Add m-esr52 at 52.6.0

1 files changed, 949 insertions, 0 deletions

diff --git a/layout/forms/nsRangeFrame.cpp b/layout/forms/nsRangeFrame.cpp
new file mode 100644
index 000000000..7590da066
--- /dev/null
+++ b/layout/forms/nsRangeFrame.cpp
@@ -0,0 +1,949 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsRangeFrame.h"
+
+#include "mozilla/EventStates.h"
+#include "mozilla/TouchEvents.h"
+
+#include "nsContentCreatorFunctions.h"
+#include "nsContentList.h"
+#include "nsContentUtils.h"
+#include "nsCSSPseudoElements.h"
+#include "nsCSSRendering.h"
+#include "nsFormControlFrame.h"
+#include "nsIContent.h"
+#include "nsIDocument.h"
+#include "nsNameSpaceManager.h"
+#include "nsIPresShell.h"
+#include "nsGkAtoms.h"
+#include "mozilla/dom/HTMLInputElement.h"
+#include "nsPresContext.h"
+#include "nsNodeInfoManager.h"
+#include "nsRenderingContext.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/StyleSetHandle.h"
+#include "mozilla/StyleSetHandleInlines.h"
+#include "nsThemeConstants.h"
+
+#ifdef ACCESSIBILITY
+#include "nsAccessibilityService.h"
+#endif
+
+#define LONG_SIDE_TO_SHORT_SIDE_RATIO 10
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::image;
+
+NS_IMPL_ISUPPORTS(nsRangeFrame::DummyTouchListener, nsIDOMEventListener)
+
+nsIFrame*
+NS_NewRangeFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsRangeFrame(aContext);
+}
+
+nsRangeFrame::nsRangeFrame(nsStyleContext* aContext)
+  : nsContainerFrame(aContext)
+{
+}
+
+nsRangeFrame::~nsRangeFrame()
+{
+#ifdef DEBUG
+  if (mOuterFocusStyle) {
+    mOuterFocusStyle->FrameRelease();
+  }
+#endif
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsRangeFrame)
+
+NS_QUERYFRAME_HEAD(nsRangeFrame)
+  NS_QUERYFRAME_ENTRY(nsRangeFrame)
+  NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+void
+nsRangeFrame::Init(nsIContent*       aContent,
+                   nsContainerFrame* aParent,
+                   nsIFrame*         aPrevInFlow)
+{
+  // With APZ enabled, touch events may be handled directly by the APZC code
+  // if the APZ knows that there is no content interested in the touch event.
+  // The range input element *is* interested in touch events, but doesn't use
+  // the usual mechanism (i.e. registering an event listener) to handle touch
+  // input. Instead, we do it here so that the APZ finds out about it, and
+  // makes sure to wait for content to run handlers before handling the touch
+  // input itself.
+  if (!mDummyTouchListener) {
+    mDummyTouchListener = new DummyTouchListener();
+  }
+  aContent->AddEventListener(NS_LITERAL_STRING("touchstart"), mDummyTouchListener, false);
+
+  StyleSetHandle styleSet = PresContext()->StyleSet();
+
+  mOuterFocusStyle =
+    styleSet->ProbePseudoElementStyle(aContent->AsElement(),
+                                      CSSPseudoElementType::mozFocusOuter,
+                                      StyleContext());
+
+  return nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+}
+
+void
+nsRangeFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(),
+               "nsRangeFrame should not have continuations; if it does we "
+               "need to call RegUnregAccessKey only for the first.");
+
+  mContent->RemoveEventListener(NS_LITERAL_STRING("touchstart"), mDummyTouchListener, false);
+
+  nsFormControlFrame::RegUnRegAccessKey(static_cast<nsIFrame*>(this), false);
+  nsContentUtils::DestroyAnonymousContent(&mTrackDiv);
+  nsContentUtils::DestroyAnonymousContent(&mProgressDiv);
+  nsContentUtils::DestroyAnonymousContent(&mThumbDiv);
+  nsContainerFrame::DestroyFrom(aDestructRoot);
+}
+
+nsresult
+nsRangeFrame::MakeAnonymousDiv(Element** aResult,
+                               CSSPseudoElementType aPseudoType,
+                               nsTArray<ContentInfo>& aElements)
+{
+  nsCOMPtr<nsIDocument> doc = mContent->GetComposedDoc();
+  RefPtr<Element> resultElement = doc->CreateHTMLElement(nsGkAtoms::div);
+
+  // Associate the pseudo-element with the anonymous child.
+  RefPtr<nsStyleContext> newStyleContext =
+    PresContext()->StyleSet()->ResolvePseudoElementStyle(mContent->AsElement(),
+                                                         aPseudoType,
+                                                         StyleContext(),
+                                                         resultElement);
+
+  if (!aElements.AppendElement(ContentInfo(resultElement, newStyleContext))) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  resultElement.forget(aResult);
+  return NS_OK;
+}
+
+nsresult
+nsRangeFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)
+{
+  nsresult rv;
+
+  // Create the ::-moz-range-track pseuto-element (a div):
+  rv = MakeAnonymousDiv(getter_AddRefs(mTrackDiv),
+                        CSSPseudoElementType::mozRangeTrack,
+                        aElements);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create the ::-moz-range-progress pseudo-element (a div):
+  rv = MakeAnonymousDiv(getter_AddRefs(mProgressDiv),
+                        CSSPseudoElementType::mozRangeProgress,
+                        aElements);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  // Create the ::-moz-range-thumb pseudo-element (a div):
+  rv = MakeAnonymousDiv(getter_AddRefs(mThumbDiv),
+                        CSSPseudoElementType::mozRangeThumb,
+                        aElements);
+  return rv;
+}
+
+void
+nsRangeFrame::AppendAnonymousContentTo(nsTArray<nsIContent*>& aElements,
+                                       uint32_t aFilter)
+{
+  if (mTrackDiv) {
+    aElements.AppendElement(mTrackDiv);
+  }
+
+  if (mProgressDiv) {
+    aElements.AppendElement(mProgressDiv);
+  }
+
+  if (mThumbDiv) {
+    aElements.AppendElement(mThumbDiv);
+  }
+}
+
+class nsDisplayRangeFocusRing : public nsDisplayItem
+{
+public:
+  nsDisplayRangeFocusRing(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)
+    : nsDisplayItem(aBuilder, aFrame) {
+    MOZ_COUNT_CTOR(nsDisplayRangeFocusRing);
+  }
+#ifdef NS_BUILD_REFCNT_LOGGING
+  virtual ~nsDisplayRangeFocusRing() {
+    MOZ_COUNT_DTOR(nsDisplayRangeFocusRing);
+  }
+#endif
+
+  nsDisplayItemGeometry* AllocateGeometry(nsDisplayListBuilder* aBuilder) override;
+  void ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,
+                                 const nsDisplayItemGeometry* aGeometry,
+                                 nsRegion *aInvalidRegion) override;
+  virtual nsRect GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) override;
+  virtual void Paint(nsDisplayListBuilder* aBuilder, nsRenderingContext* aCtx) override;
+  NS_DISPLAY_DECL_NAME("RangeFocusRing", TYPE_RANGE_FOCUS_RING)
+};
+
+nsDisplayItemGeometry*
+nsDisplayRangeFocusRing::AllocateGeometry(nsDisplayListBuilder* aBuilder)
+{
+  return new nsDisplayItemGenericImageGeometry(this, aBuilder);
+}
+
+void
+nsDisplayRangeFocusRing::ComputeInvalidationRegion(
+  nsDisplayListBuilder* aBuilder,
+  const nsDisplayItemGeometry* aGeometry,
+  nsRegion* aInvalidRegion)
+{
+  auto geometry =
+    static_cast<const nsDisplayItemGenericImageGeometry*>(aGeometry);
+
+  if (aBuilder->ShouldSyncDecodeImages() &&
+      geometry->ShouldInvalidateToSyncDecodeImages()) {
+    bool snap;
+    aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));
+  }
+
+  nsDisplayItem::ComputeInvalidationRegion(aBuilder, aGeometry, aInvalidRegion);
+}
+
+nsRect
+nsDisplayRangeFocusRing::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap)
+{
+  *aSnap = false;
+  nsRect rect(ToReferenceFrame(), Frame()->GetSize());
+
+  // We want to paint as if specifying a border for ::-moz-focus-outer
+  // specifies an outline for our frame, so inflate by the border widths:
+  nsStyleContext* styleContext =
+    static_cast<nsRangeFrame*>(mFrame)->mOuterFocusStyle;
+  MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null");
+  rect.Inflate(styleContext->StyleBorder()->GetComputedBorder());
+
+  return rect;
+}
+
+void
+nsDisplayRangeFocusRing::Paint(nsDisplayListBuilder* aBuilder,
+                               nsRenderingContext* aCtx)
+{
+  bool unused;
+  nsStyleContext* styleContext =
+    static_cast<nsRangeFrame*>(mFrame)->mOuterFocusStyle;
+  MOZ_ASSERT(styleContext, "We only exist if mOuterFocusStyle is non-null");
+
+  PaintBorderFlags flags = aBuilder->ShouldSyncDecodeImages()
+                         ? PaintBorderFlags::SYNC_DECODE_IMAGES
+                         : PaintBorderFlags();
+
+  DrawResult result =
+    nsCSSRendering::PaintBorder(mFrame->PresContext(), *aCtx, mFrame,
+                                mVisibleRect, GetBounds(aBuilder, &unused),
+                                styleContext, flags);
+
+  nsDisplayItemGenericImageGeometry::UpdateDrawResult(this, result);
+}
+
+void
+nsRangeFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                               const nsRect&           aDirtyRect,
+                               const nsDisplayListSet& aLists)
+{
+  if (IsThemed()) {
+    DisplayBorderBackgroundOutline(aBuilder, aLists);
+    // Only create items for the thumb. Specifically, we do not want
+    // the track to paint, since *our* background is used to paint
+    // the track, and we don't want the unthemed track painting over
+    // the top of the themed track.
+    // This logic is copied from
+    // nsContainerFrame::BuildDisplayListForNonBlockChildren as
+    // called by BuildDisplayListForInline.
+    nsIFrame* thumb = mThumbDiv->GetPrimaryFrame();
+    if (thumb) {
+      nsDisplayListSet set(aLists, aLists.Content());
+      BuildDisplayListForChild(aBuilder, thumb, aDirtyRect, set, DISPLAY_CHILD_INLINE);
+    }
+  } else {
+    BuildDisplayListForInline(aBuilder, aDirtyRect, aLists);
+  }
+
+  // Draw a focus outline if appropriate:
+
+  if (!aBuilder->IsForPainting() ||
+      !IsVisibleForPainting(aBuilder)) {
+    // we don't want the focus ring item for hit-testing or if the item isn't
+    // in the area being [re]painted
+    return;
+  }
+
+  EventStates eventStates = mContent->AsElement()->State();
+  if (eventStates.HasState(NS_EVENT_STATE_DISABLED) ||
+      !eventStates.HasState(NS_EVENT_STATE_FOCUSRING)) {
+    return; // can't have focus or doesn't match :-moz-focusring
+  }
+
+  if (!mOuterFocusStyle ||
+      !mOuterFocusStyle->StyleBorder()->HasBorder()) {
+    // no ::-moz-focus-outer specified border (how style specifies a focus ring
+    // for range)
+    return;
+  }
+
+  const nsStyleDisplay *disp = StyleDisplay();
+  if (IsThemed(disp) &&
+      PresContext()->GetTheme()->ThemeDrawsFocusForWidget(disp->mAppearance)) {
+    return; // the native theme displays its own visual indication of focus
+  }
+
+  aLists.Content()->AppendNewToTop(
+    new (aBuilder) nsDisplayRangeFocusRing(aBuilder, this));
+}
+
+void
+nsRangeFrame::Reflow(nsPresContext*           aPresContext,
+                     ReflowOutput&     aDesiredSize,
+                     const ReflowInput& aReflowInput,
+                     nsReflowStatus&          aStatus)
+{
+  MarkInReflow();
+  DO_GLOBAL_REFLOW_COUNT("nsRangeFrame");
+  DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus);
+
+  NS_ASSERTION(mTrackDiv, "::-moz-range-track div must exist!");
+  NS_ASSERTION(mProgressDiv, "::-moz-range-progress div must exist!");
+  NS_ASSERTION(mThumbDiv, "::-moz-range-thumb div must exist!");
+  NS_ASSERTION(!GetPrevContinuation() && !GetNextContinuation(),
+               "nsRangeFrame should not have continuations; if it does we "
+               "need to call RegUnregAccessKey only for the first.");
+
+  if (mState & NS_FRAME_FIRST_REFLOW) {
+    nsFormControlFrame::RegUnRegAccessKey(this, true);
+  }
+
+  WritingMode wm = aReflowInput.GetWritingMode();
+  nscoord computedBSize = aReflowInput.ComputedBSize();
+  if (computedBSize == NS_AUTOHEIGHT) {
+    computedBSize = 0;
+  }
+  LogicalSize
+    finalSize(wm,
+              aReflowInput.ComputedISize() +
+              aReflowInput.ComputedLogicalBorderPadding().IStartEnd(wm),
+              computedBSize +
+              aReflowInput.ComputedLogicalBorderPadding().BStartEnd(wm));
+  aDesiredSize.SetSize(wm, finalSize);
+
+  ReflowAnonymousContent(aPresContext, aDesiredSize, aReflowInput);
+
+  aDesiredSize.SetOverflowAreasToDesiredBounds();
+
+  nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
+  if (trackFrame) {
+    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, trackFrame);
+  }
+
+  nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
+  if (rangeProgressFrame) {
+    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, rangeProgressFrame);
+  }
+
+  nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
+  if (thumbFrame) {
+    ConsiderChildOverflow(aDesiredSize.mOverflowAreas, thumbFrame);
+  }
+
+  FinishAndStoreOverflow(&aDesiredSize);
+
+  aStatus = NS_FRAME_COMPLETE;
+
+  NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
+}
+
+void
+nsRangeFrame::ReflowAnonymousContent(nsPresContext*           aPresContext,
+                                     ReflowOutput&     aDesiredSize,
+                                     const ReflowInput& aReflowInput)
+{
+  // The width/height of our content box, which is the available width/height
+  // for our anonymous content:
+  nscoord rangeFrameContentBoxWidth = aReflowInput.ComputedWidth();
+  nscoord rangeFrameContentBoxHeight = aReflowInput.ComputedHeight();
+  if (rangeFrameContentBoxHeight == NS_AUTOHEIGHT) {
+    rangeFrameContentBoxHeight = 0;
+  }
+
+  nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
+
+  if (trackFrame) { // display:none?
+
+    // Position the track:
+    // The idea here is that we allow content authors to style the width,
+    // height, border and padding of the track, but we ignore margin and
+    // positioning properties and do the positioning ourself to keep the center
+    // of the track's border box on the center of the nsRangeFrame's content
+    // box.
+
+    WritingMode wm = trackFrame->GetWritingMode();
+    LogicalSize availSize = aReflowInput.ComputedSize(wm);
+    availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+    ReflowInput trackReflowInput(aPresContext, aReflowInput,
+                                       trackFrame, availSize);
+
+    // Find the x/y position of the track frame such that it will be positioned
+    // as described above. These coordinates are with respect to the
+    // nsRangeFrame's border-box.
+    nscoord trackX = rangeFrameContentBoxWidth / 2;
+    nscoord trackY = rangeFrameContentBoxHeight / 2;
+
+    // Account for the track's border and padding (we ignore its margin):
+    trackX -= trackReflowInput.ComputedPhysicalBorderPadding().left +
+                trackReflowInput.ComputedWidth() / 2;
+    trackY -= trackReflowInput.ComputedPhysicalBorderPadding().top +
+                trackReflowInput.ComputedHeight() / 2;
+
+    // Make relative to our border box instead of our content box:
+    trackX += aReflowInput.ComputedPhysicalBorderPadding().left;
+    trackY += aReflowInput.ComputedPhysicalBorderPadding().top;
+
+    nsReflowStatus frameStatus;
+    ReflowOutput trackDesiredSize(aReflowInput);
+    ReflowChild(trackFrame, aPresContext, trackDesiredSize,
+                trackReflowInput, trackX, trackY, 0, frameStatus);
+    MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
+               "We gave our child unconstrained height, so it should be complete");
+    FinishReflowChild(trackFrame, aPresContext, trackDesiredSize,
+                      &trackReflowInput, trackX, trackY, 0);
+  }
+
+  nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
+
+  if (thumbFrame) { // display:none?
+    WritingMode wm = thumbFrame->GetWritingMode();
+    LogicalSize availSize = aReflowInput.ComputedSize(wm);
+    availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+    ReflowInput thumbReflowInput(aPresContext, aReflowInput,
+                                       thumbFrame, availSize);
+
+    // Where we position the thumb depends on its size, so we first reflow
+    // the thumb at {0,0} to obtain its size, then position it afterwards.
+
+    nsReflowStatus frameStatus;
+    ReflowOutput thumbDesiredSize(aReflowInput);
+    ReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
+                thumbReflowInput, 0, 0, 0, frameStatus);
+    MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
+               "We gave our child unconstrained height, so it should be complete");
+    FinishReflowChild(thumbFrame, aPresContext, thumbDesiredSize,
+                      &thumbReflowInput, 0, 0, 0);
+    DoUpdateThumbPosition(thumbFrame, nsSize(aDesiredSize.Width(),
+                                             aDesiredSize.Height()));
+  }
+
+  nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
+
+  if (rangeProgressFrame) { // display:none?
+    WritingMode wm = rangeProgressFrame->GetWritingMode();
+    LogicalSize availSize = aReflowInput.ComputedSize(wm);
+    availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
+    ReflowInput progressReflowInput(aPresContext, aReflowInput,
+                                          rangeProgressFrame, availSize);
+
+    // We first reflow the range-progress frame at {0,0} to obtain its
+    // unadjusted dimensions, then we adjust it to so that the appropriate edge
+    // ends at the thumb.
+
+    nsReflowStatus frameStatus;
+    ReflowOutput progressDesiredSize(aReflowInput);
+    ReflowChild(rangeProgressFrame, aPresContext,
+                progressDesiredSize, progressReflowInput, 0, 0,
+                0, frameStatus);
+    MOZ_ASSERT(NS_FRAME_IS_FULLY_COMPLETE(frameStatus),
+               "We gave our child unconstrained height, so it should be complete");
+    FinishReflowChild(rangeProgressFrame, aPresContext,
+                      progressDesiredSize, &progressReflowInput, 0, 0, 0);
+    DoUpdateRangeProgressFrame(rangeProgressFrame, nsSize(aDesiredSize.Width(),
+                                                          aDesiredSize.Height()));
+  }
+}
+
+#ifdef ACCESSIBILITY
+a11y::AccType
+nsRangeFrame::AccessibleType()
+{
+  return a11y::eHTMLRangeType;
+}
+#endif
+
+double
+nsRangeFrame::GetValueAsFractionOfRange()
+{
+  MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
+  dom::HTMLInputElement* input = static_cast<dom::HTMLInputElement*>(mContent);
+
+  MOZ_ASSERT(input->GetType() == NS_FORM_INPUT_RANGE);
+
+  Decimal value = input->GetValueAsDecimal();
+  Decimal minimum = input->GetMinimum();
+  Decimal maximum = input->GetMaximum();
+
+  MOZ_ASSERT(value.isFinite() && minimum.isFinite() && maximum.isFinite(),
+             "type=range should have a default maximum/minimum");
+  
+  if (maximum <= minimum) {
+    MOZ_ASSERT(value == minimum, "Unsanitized value");
+    return 0.0;
+  }
+  
+  MOZ_ASSERT(value >= minimum && value <= maximum, "Unsanitized value");
+  
+  return ((value - minimum) / (maximum - minimum)).toDouble();
+}
+
+Decimal
+nsRangeFrame::GetValueAtEventPoint(WidgetGUIEvent* aEvent)
+{
+  MOZ_ASSERT(aEvent->mClass == eMouseEventClass ||
+             aEvent->mClass == eTouchEventClass,
+             "Unexpected event type - aEvent->mRefPoint may be meaningless");
+
+  MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
+  dom::HTMLInputElement* input = static_cast<dom::HTMLInputElement*>(mContent);
+
+  MOZ_ASSERT(input->GetType() == NS_FORM_INPUT_RANGE);
+
+  Decimal minimum = input->GetMinimum();
+  Decimal maximum = input->GetMaximum();
+  MOZ_ASSERT(minimum.isFinite() && maximum.isFinite(),
+             "type=range should have a default maximum/minimum");
+  if (maximum <= minimum) {
+    return minimum;
+  }
+  Decimal range = maximum - minimum;
+
+  LayoutDeviceIntPoint absPoint;
+  if (aEvent->mClass == eTouchEventClass) {
+    MOZ_ASSERT(aEvent->AsTouchEvent()->mTouches.Length() == 1,
+               "Unexpected number of mTouches");
+    absPoint = aEvent->AsTouchEvent()->mTouches[0]->mRefPoint;
+  } else {
+    absPoint = aEvent->mRefPoint;
+  }
+  nsPoint point =
+    nsLayoutUtils::GetEventCoordinatesRelativeTo(aEvent, absPoint, this);
+
+  if (point == nsPoint(NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE)) {
+    // We don't want to change the current value for this error state.
+    return static_cast<dom::HTMLInputElement*>(mContent)->GetValueAsDecimal();
+  }
+
+  nsRect rangeContentRect = GetContentRectRelativeToSelf();
+  nsSize thumbSize;
+
+  if (IsThemed()) {
+    // We need to get the size of the thumb from the theme.
+    nsPresContext *presContext = PresContext();
+    bool notUsedCanOverride;
+    LayoutDeviceIntSize size;
+    presContext->GetTheme()->
+      GetMinimumWidgetSize(presContext, this, NS_THEME_RANGE_THUMB, &size,
+                           &notUsedCanOverride);
+    thumbSize.width = presContext->DevPixelsToAppUnits(size.width);
+    thumbSize.height = presContext->DevPixelsToAppUnits(size.height);
+    MOZ_ASSERT(thumbSize.width > 0 && thumbSize.height > 0);
+  } else {
+    nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
+    if (thumbFrame) { // diplay:none?
+      thumbSize = thumbFrame->GetSize();
+    }
+  }
+
+  Decimal fraction;
+  if (IsHorizontal()) {
+    nscoord traversableDistance = rangeContentRect.width - thumbSize.width;
+    if (traversableDistance <= 0) {
+      return minimum;
+    }
+    nscoord posAtStart = rangeContentRect.x + thumbSize.width/2;
+    nscoord posAtEnd = posAtStart + traversableDistance;
+    nscoord posOfPoint = mozilla::clamped(point.x, posAtStart, posAtEnd);
+    fraction = Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance);
+    if (IsRightToLeft()) {
+      fraction = Decimal(1) - fraction;
+    }
+  } else {
+    nscoord traversableDistance = rangeContentRect.height - thumbSize.height;
+    if (traversableDistance <= 0) {
+      return minimum;
+    }
+    nscoord posAtStart = rangeContentRect.y + thumbSize.height/2;
+    nscoord posAtEnd = posAtStart + traversableDistance;
+    nscoord posOfPoint = mozilla::clamped(point.y, posAtStart, posAtEnd);
+    // For a vertical range, the top (posAtStart) is the highest value, so we
+    // subtract the fraction from 1.0 to get that polarity correct.
+    fraction = Decimal(1) - Decimal(posOfPoint - posAtStart) / Decimal(traversableDistance);
+  }
+
+  MOZ_ASSERT(fraction >= Decimal(0) && fraction <= Decimal(1));
+  return minimum + fraction * range;
+}
+
+void
+nsRangeFrame::UpdateForValueChange()
+{
+  if (NS_SUBTREE_DIRTY(this)) {
+    return; // we're going to be updated when we reflow
+  }
+  nsIFrame* rangeProgressFrame = mProgressDiv->GetPrimaryFrame();
+  nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
+  if (!rangeProgressFrame && !thumbFrame) {
+    return; // diplay:none?
+  }
+  if (rangeProgressFrame) {
+    DoUpdateRangeProgressFrame(rangeProgressFrame, GetSize());
+  }
+  if (thumbFrame) {
+    DoUpdateThumbPosition(thumbFrame, GetSize());
+  }
+  if (IsThemed()) {
+    // We don't know the exact dimensions or location of the thumb when native
+    // theming is applied, so we just repaint the entire range.
+    InvalidateFrame();
+  }
+
+#ifdef ACCESSIBILITY
+  nsAccessibilityService* accService = nsIPresShell::AccService();
+  if (accService) {
+    accService->RangeValueChanged(PresContext()->PresShell(), mContent);
+  }
+#endif
+
+  SchedulePaint();
+}
+
+void
+nsRangeFrame::DoUpdateThumbPosition(nsIFrame* aThumbFrame,
+                                    const nsSize& aRangeSize)
+{
+  MOZ_ASSERT(aThumbFrame);
+
+  // The idea here is that we want to position the thumb so that the center
+  // of the thumb is on an imaginary line drawn from the middle of one edge
+  // of the range frame's content box to the middle of the opposite edge of
+  // its content box (the opposite edges being the left/right edge if the
+  // range is horizontal, or else the top/bottom edges if the range is
+  // vertical). How far along this line the center of the thumb is placed
+  // depends on the value of the range.
+
+  nsMargin borderAndPadding = GetUsedBorderAndPadding();
+  nsPoint newPosition(borderAndPadding.left, borderAndPadding.top);
+
+  nsSize rangeContentBoxSize(aRangeSize);
+  rangeContentBoxSize.width -= borderAndPadding.LeftRight();
+  rangeContentBoxSize.height -= borderAndPadding.TopBottom();
+
+  nsSize thumbSize = aThumbFrame->GetSize();
+  double fraction = GetValueAsFractionOfRange();
+  MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0);
+
+  if (IsHorizontal()) {
+    if (thumbSize.width < rangeContentBoxSize.width) {
+      nscoord traversableDistance =
+        rangeContentBoxSize.width - thumbSize.width;
+      if (IsRightToLeft()) {
+        newPosition.x += NSToCoordRound((1.0 - fraction) * traversableDistance);
+      } else {
+        newPosition.x += NSToCoordRound(fraction * traversableDistance);
+      }
+      newPosition.y += (rangeContentBoxSize.height - thumbSize.height)/2;
+    }
+  } else {
+    if (thumbSize.height < rangeContentBoxSize.height) {
+      nscoord traversableDistance =
+        rangeContentBoxSize.height - thumbSize.height;
+      newPosition.x += (rangeContentBoxSize.width - thumbSize.width)/2;
+      newPosition.y += NSToCoordRound((1.0 - fraction) * traversableDistance);
+    }
+  }
+  aThumbFrame->SetPosition(newPosition);
+}
+
+void
+nsRangeFrame::DoUpdateRangeProgressFrame(nsIFrame* aRangeProgressFrame,
+                                         const nsSize& aRangeSize)
+{
+  MOZ_ASSERT(aRangeProgressFrame);
+
+  // The idea here is that we want to position the ::-moz-range-progress
+  // pseudo-element so that the center line running along its length is on the
+  // corresponding center line of the nsRangeFrame's content box. In the other
+  // dimension, we align the "start" edge of the ::-moz-range-progress
+  // pseudo-element's border-box with the corresponding edge of the
+  // nsRangeFrame's content box, and we size the progress element's border-box
+  // to have a length of GetValueAsFractionOfRange() times the nsRangeFrame's
+  // content-box size.
+
+  nsMargin borderAndPadding = GetUsedBorderAndPadding();
+  nsSize progSize = aRangeProgressFrame->GetSize();
+  nsRect progRect(borderAndPadding.left, borderAndPadding.top,
+                  progSize.width, progSize.height);
+
+  nsSize rangeContentBoxSize(aRangeSize);
+  rangeContentBoxSize.width -= borderAndPadding.LeftRight();
+  rangeContentBoxSize.height -= borderAndPadding.TopBottom();
+
+  double fraction = GetValueAsFractionOfRange();
+  MOZ_ASSERT(fraction >= 0.0 && fraction <= 1.0);
+
+  if (IsHorizontal()) {
+    nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.width);
+    if (IsRightToLeft()) {
+      progRect.x += rangeContentBoxSize.width - progLength;
+    }
+    progRect.y += (rangeContentBoxSize.height - progSize.height)/2;
+    progRect.width = progLength;
+  } else {
+    nscoord progLength = NSToCoordRound(fraction * rangeContentBoxSize.height);
+    progRect.x += (rangeContentBoxSize.width - progSize.width)/2;
+    progRect.y += rangeContentBoxSize.height - progLength;
+    progRect.height = progLength;
+  }
+  aRangeProgressFrame->SetRect(progRect);
+}
+
+nsresult
+nsRangeFrame::AttributeChanged(int32_t  aNameSpaceID,
+                               nsIAtom* aAttribute,
+                               int32_t  aModType)
+{
+  NS_ASSERTION(mTrackDiv, "The track div must exist!");
+  NS_ASSERTION(mThumbDiv, "The thumb div must exist!");
+
+  if (aNameSpaceID == kNameSpaceID_None) {
+    if (aAttribute == nsGkAtoms::value ||
+        aAttribute == nsGkAtoms::min ||
+        aAttribute == nsGkAtoms::max ||
+        aAttribute == nsGkAtoms::step) {
+      // We want to update the position of the thumb, except in one special
+      // case: If the value attribute is being set, it is possible that we are
+      // in the middle of a type change away from type=range, under the
+      // SetAttr(..., nsGkAtoms::value, ...) call in HTMLInputElement::
+      // HandleTypeChange. In that case the HTMLInputElement's type will
+      // already have changed, and if we call UpdateForValueChange()
+      // we'll fail the asserts under that call that check the type of our
+      // HTMLInputElement. Given that we're changing away from being a range
+      // and this frame will shortly be destroyed, there's no point in calling
+      // UpdateForValueChange() anyway.
+      MOZ_ASSERT(mContent->IsHTMLElement(nsGkAtoms::input), "bad cast");
+      bool typeIsRange = static_cast<dom::HTMLInputElement*>(mContent)->GetType() ==
+                           NS_FORM_INPUT_RANGE;
+      // If script changed the <input>'s type before setting these attributes
+      // then we don't need to do anything since we are going to be reframed.
+      if (typeIsRange) {
+        UpdateForValueChange();
+      }
+    } else if (aAttribute == nsGkAtoms::orient) {
+      PresContext()->PresShell()->FrameNeedsReflow(this, nsIPresShell::eResize,
+                                                   NS_FRAME_IS_DIRTY);
+    }
+  }
+
+  return nsContainerFrame::AttributeChanged(aNameSpaceID, aAttribute, aModType);
+}
+
+LogicalSize
+nsRangeFrame::ComputeAutoSize(nsRenderingContext* aRenderingContext,
+                              WritingMode         aWM,
+                              const LogicalSize&  aCBSize,
+                              nscoord             aAvailableISize,
+                              const LogicalSize&  aMargin,
+                              const LogicalSize&  aBorder,
+                              const LogicalSize&  aPadding,
+                              ComputeSizeFlags    aFlags)
+{
+  nscoord oneEm = NSToCoordRound(StyleFont()->mFont.size *
+                                 nsLayoutUtils::FontSizeInflationFor(this)); // 1em
+
+  bool isInlineOriented = IsInlineOriented();
+
+  const WritingMode wm = GetWritingMode();
+  LogicalSize autoSize(wm);
+
+  // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being
+  // given too small a size when we're natively themed. If we're themed, we set
+  // our "thickness" dimension to zero below and rely on that
+  // GetMinimumWidgetSize check to correct that dimension to the natural
+  // thickness of a slider in the current theme.
+
+  if (isInlineOriented) {
+    autoSize.ISize(wm) = LONG_SIDE_TO_SHORT_SIDE_RATIO * oneEm;
+    autoSize.BSize(wm) = IsThemed() ? 0 : oneEm;
+  } else {
+    autoSize.ISize(wm) = IsThemed() ? 0 : oneEm;
+    autoSize.BSize(wm) = LONG_SIDE_TO_SHORT_SIDE_RATIO * oneEm;
+  }
+
+  return autoSize.ConvertTo(aWM, wm);
+}
+
+nscoord
+nsRangeFrame::GetMinISize(nsRenderingContext *aRenderingContext)
+{
+  // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being
+  // given too small a size when we're natively themed. If we aren't native
+  // themed, we don't mind how small we're sized.
+  return nscoord(0);
+}
+
+nscoord
+nsRangeFrame::GetPrefISize(nsRenderingContext *aRenderingContext)
+{
+  bool isInline = IsInlineOriented();
+
+  if (!isInline && IsThemed()) {
+    // nsFrame::ComputeSize calls GetMinimumWidgetSize to prevent us from being
+    // given too small a size when we're natively themed. We return zero and
+    // depend on that correction to get our "natural" width when we're a
+    // vertical slider.
+    return 0;
+  }
+
+  nscoord prefISize = NSToCoordRound(StyleFont()->mFont.size *
+                                     nsLayoutUtils::FontSizeInflationFor(this)); // 1em
+
+  if (isInline) {
+    prefISize *= LONG_SIDE_TO_SHORT_SIDE_RATIO;
+  }
+
+  return prefISize;
+}
+
+bool
+nsRangeFrame::IsHorizontal() const
+{
+  dom::HTMLInputElement* element =
+    static_cast<dom::HTMLInputElement*>(mContent);
+  return element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
+                              nsGkAtoms::horizontal, eCaseMatters) ||
+         (!element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
+                               nsGkAtoms::vertical, eCaseMatters) &&
+          GetWritingMode().IsVertical() ==
+            element->AttrValueIs(kNameSpaceID_None, nsGkAtoms::orient,
+                                 nsGkAtoms::block, eCaseMatters));
+}
+
+double
+nsRangeFrame::GetMin() const
+{
+  return static_cast<dom::HTMLInputElement*>(mContent)->GetMinimum().toDouble();
+}
+
+double
+nsRangeFrame::GetMax() const
+{
+  return static_cast<dom::HTMLInputElement*>(mContent)->GetMaximum().toDouble();
+}
+
+double
+nsRangeFrame::GetValue() const
+{
+  return static_cast<dom::HTMLInputElement*>(mContent)->GetValueAsDecimal().toDouble();
+}
+
+nsIAtom*
+nsRangeFrame::GetType() const
+{
+  return nsGkAtoms::rangeFrame;
+}
+
+#define STYLES_DISABLING_NATIVE_THEMING \
+  NS_AUTHOR_SPECIFIED_BACKGROUND | \
+  NS_AUTHOR_SPECIFIED_PADDING | \
+  NS_AUTHOR_SPECIFIED_BORDER
+
+bool
+nsRangeFrame::ShouldUseNativeStyle() const
+{
+  nsIFrame* trackFrame = mTrackDiv->GetPrimaryFrame();
+  nsIFrame* progressFrame = mProgressDiv->GetPrimaryFrame();
+  nsIFrame* thumbFrame = mThumbDiv->GetPrimaryFrame();
+
+  return (StyleDisplay()->mAppearance == NS_THEME_RANGE) &&
+         !PresContext()->HasAuthorSpecifiedRules(this,
+                                                 (NS_AUTHOR_SPECIFIED_BORDER |
+                                                  NS_AUTHOR_SPECIFIED_BACKGROUND)) &&
+         trackFrame &&
+         !PresContext()->HasAuthorSpecifiedRules(trackFrame,
+                                                 STYLES_DISABLING_NATIVE_THEMING) &&
+         progressFrame &&
+         !PresContext()->HasAuthorSpecifiedRules(progressFrame,
+                                                 STYLES_DISABLING_NATIVE_THEMING) &&
+         thumbFrame &&
+         !PresContext()->HasAuthorSpecifiedRules(thumbFrame,
+                                                 STYLES_DISABLING_NATIVE_THEMING);
+}
+
+Element*
+nsRangeFrame::GetPseudoElement(CSSPseudoElementType aType)
+{
+  if (aType == CSSPseudoElementType::mozRangeTrack) {
+    return mTrackDiv;
+  }
+
+  if (aType == CSSPseudoElementType::mozRangeThumb) {
+    return mThumbDiv;
+  }
+
+  if (aType == CSSPseudoElementType::mozRangeProgress) {
+    return mProgressDiv;
+  }
+
+  return nsContainerFrame::GetPseudoElement(aType);
+}
+
+nsStyleContext*
+nsRangeFrame::GetAdditionalStyleContext(int32_t aIndex) const
+{
+  // We only implement this so that SetAdditionalStyleContext will be
+  // called if style changes that would change the -moz-focus-outer
+  // pseudo-element have occurred.
+  if (aIndex != 0) {
+    return nullptr;
+  }
+  return mOuterFocusStyle;
+}
+
+void
+nsRangeFrame::SetAdditionalStyleContext(int32_t aIndex,
+                                        nsStyleContext* aStyleContext)
+{
+  MOZ_ASSERT(aIndex == 0,
+             "GetAdditionalStyleContext is handling other indexes?");
+
+#ifdef DEBUG
+  if (mOuterFocusStyle) {
+    mOuterFocusStyle->FrameRelease();
+  }
+#endif
+
+  // The -moz-focus-outer pseudo-element's style has changed.
+  mOuterFocusStyle = aStyleContext;
+
+#ifdef DEBUG
+  if (mOuterFocusStyle) {
+    mOuterFocusStyle->FrameAddRef();
+  }
+#endif
+}