Add m-esr52 at 52.6.0

1 files changed, 1446 insertions, 0 deletions

diff --git a/layout/xul/nsSliderFrame.cpp b/layout/xul/nsSliderFrame.cpp
new file mode 100644
index 0000000000..8e083f20ca
--- /dev/null
+++ b/layout/xul/nsSliderFrame.cpp
@@ -0,0 +1,1446 @@
+/* -*- 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/. */
+
+//
+// Eric Vaughan
+// Netscape Communications
+//
+// See documentation in associated header file
+//
+
+#include "nsSliderFrame.h"
+
+#include "gfxPrefs.h"
+#include "nsStyleContext.h"
+#include "nsPresContext.h"
+#include "nsIContent.h"
+#include "nsCOMPtr.h"
+#include "nsNameSpaceManager.h"
+#include "nsGkAtoms.h"
+#include "nsHTMLParts.h"
+#include "nsIPresShell.h"
+#include "nsCSSRendering.h"
+#include "nsIDOMEvent.h"
+#include "nsIDOMMouseEvent.h"
+#include "nsScrollbarButtonFrame.h"
+#include "nsISliderListener.h"
+#include "nsIScrollableFrame.h"
+#include "nsIScrollbarMediator.h"
+#include "nsISupportsImpl.h"
+#include "nsScrollbarFrame.h"
+#include "nsRepeatService.h"
+#include "nsBoxLayoutState.h"
+#include "nsSprocketLayout.h"
+#include "nsIServiceManager.h"
+#include "nsContentUtils.h"
+#include "nsLayoutUtils.h"
+#include "nsDisplayList.h"
+#include "mozilla/Assertions.h"         // for MOZ_ASSERT
+#include "mozilla/Preferences.h"
+#include "mozilla/LookAndFeel.h"
+#include "mozilla/MouseEvents.h"
+#include "mozilla/Telemetry.h"
+#include "mozilla/layers/APZCCallbackHelper.h"
+#include "mozilla/layers/AsyncDragMetrics.h"
+#include "mozilla/layers/InputAPZContext.h"
+#include "mozilla/layers/ScrollInputMethods.h"
+#include <algorithm>
+
+using namespace mozilla;
+using mozilla::layers::APZCCallbackHelper;
+using mozilla::layers::AsyncDragMetrics;
+using mozilla::layers::InputAPZContext;
+using mozilla::layers::ScrollInputMethod;
+
+bool nsSliderFrame::gMiddlePref = false;
+int32_t nsSliderFrame::gSnapMultiplier;
+
+// Turn this on if you want to debug slider frames.
+#undef DEBUG_SLIDER
+
+static already_AddRefed<nsIContent>
+GetContentOfBox(nsIFrame *aBox)
+{
+  nsCOMPtr<nsIContent> content = aBox->GetContent();
+  return content.forget();
+}
+
+nsIFrame*
+NS_NewSliderFrame (nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsSliderFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsSliderFrame)
+
+NS_QUERYFRAME_HEAD(nsSliderFrame)
+  NS_QUERYFRAME_ENTRY(nsSliderFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)
+
+nsSliderFrame::nsSliderFrame(nsStyleContext* aContext):
+  nsBoxFrame(aContext),
+  mCurPos(0),
+  mChange(0),
+  mDragFinished(true),
+  mUserChanged(false),
+  mScrollingWithAPZ(false),
+  mSuppressionActive(false)
+{
+}
+
+// stop timer
+nsSliderFrame::~nsSliderFrame()
+{
+  if (mSuppressionActive) {
+    APZCCallbackHelper::SuppressDisplayport(false, PresContext() ?
+                                                   PresContext()->PresShell() :
+                                                   nullptr);
+  }
+}
+
+void
+nsSliderFrame::Init(nsIContent*       aContent,
+                    nsContainerFrame* aParent,
+                    nsIFrame*         aPrevInFlow)
+{
+  nsBoxFrame::Init(aContent, aParent, aPrevInFlow);
+
+  static bool gotPrefs = false;
+  if (!gotPrefs) {
+    gotPrefs = true;
+
+    gMiddlePref = Preferences::GetBool("middlemouse.scrollbarPosition");
+    gSnapMultiplier = Preferences::GetInt("slider.snapMultiplier");
+  }
+
+  mCurPos = GetCurrentPosition(aContent);
+}
+
+void
+nsSliderFrame::RemoveFrame(ChildListID     aListID,
+                           nsIFrame*       aOldFrame)
+{
+  nsBoxFrame::RemoveFrame(aListID, aOldFrame);
+  if (mFrames.IsEmpty())
+    RemoveListener();
+}
+
+void
+nsSliderFrame::InsertFrames(ChildListID     aListID,
+                            nsIFrame*       aPrevFrame,
+                            nsFrameList&    aFrameList)
+{
+  bool wasEmpty = mFrames.IsEmpty();
+  nsBoxFrame::InsertFrames(aListID, aPrevFrame, aFrameList);
+  if (wasEmpty)
+    AddListener();
+}
+
+void
+nsSliderFrame::AppendFrames(ChildListID     aListID,
+                            nsFrameList&    aFrameList)
+{
+  // if we have no children and on was added then make sure we add the
+  // listener
+  bool wasEmpty = mFrames.IsEmpty();
+  nsBoxFrame::AppendFrames(aListID, aFrameList);
+  if (wasEmpty)
+    AddListener();
+}
+
+int32_t
+nsSliderFrame::GetCurrentPosition(nsIContent* content)
+{
+  return GetIntegerAttribute(content, nsGkAtoms::curpos, 0);
+}
+
+int32_t
+nsSliderFrame::GetMinPosition(nsIContent* content)
+{
+  return GetIntegerAttribute(content, nsGkAtoms::minpos, 0);
+}
+
+int32_t
+nsSliderFrame::GetMaxPosition(nsIContent* content)
+{
+  return GetIntegerAttribute(content, nsGkAtoms::maxpos, 100);
+}
+
+int32_t
+nsSliderFrame::GetIncrement(nsIContent* content)
+{
+  return GetIntegerAttribute(content, nsGkAtoms::increment, 1);
+}
+
+
+int32_t
+nsSliderFrame::GetPageIncrement(nsIContent* content)
+{
+  return GetIntegerAttribute(content, nsGkAtoms::pageincrement, 10);
+}
+
+int32_t
+nsSliderFrame::GetIntegerAttribute(nsIContent* content, nsIAtom* atom, int32_t defaultValue)
+{
+    nsAutoString value;
+    content->GetAttr(kNameSpaceID_None, atom, value);
+    if (!value.IsEmpty()) {
+      nsresult error;
+
+      // convert it to an integer
+      defaultValue = value.ToInteger(&error);
+    }
+
+    return defaultValue;
+}
+
+class nsValueChangedRunnable : public Runnable
+{
+public:
+  nsValueChangedRunnable(nsISliderListener* aListener,
+                         nsIAtom* aWhich,
+                         int32_t aValue,
+                         bool aUserChanged)
+  : mListener(aListener), mWhich(aWhich),
+    mValue(aValue), mUserChanged(aUserChanged)
+  {}
+
+  NS_IMETHOD Run() override
+  {
+    return mListener->ValueChanged(nsDependentAtomString(mWhich),
+                                   mValue, mUserChanged);
+  }
+
+  nsCOMPtr<nsISliderListener> mListener;
+  nsCOMPtr<nsIAtom> mWhich;
+  int32_t mValue;
+  bool mUserChanged;
+};
+
+class nsDragStateChangedRunnable : public Runnable
+{
+public:
+  nsDragStateChangedRunnable(nsISliderListener* aListener,
+                             bool aDragBeginning)
+  : mListener(aListener),
+    mDragBeginning(aDragBeginning)
+  {}
+
+  NS_IMETHOD Run() override
+  {
+    return mListener->DragStateChanged(mDragBeginning);
+  }
+
+  nsCOMPtr<nsISliderListener> mListener;
+  bool mDragBeginning;
+};
+
+nsresult
+nsSliderFrame::AttributeChanged(int32_t aNameSpaceID,
+                                nsIAtom* aAttribute,
+                                int32_t aModType)
+{
+  nsresult rv = nsBoxFrame::AttributeChanged(aNameSpaceID, aAttribute,
+                                             aModType);
+  // if the current position changes
+  if (aAttribute == nsGkAtoms::curpos) {
+     CurrentPositionChanged();
+  } else if (aAttribute == nsGkAtoms::minpos ||
+             aAttribute == nsGkAtoms::maxpos) {
+      // bounds check it.
+
+      nsIFrame* scrollbarBox = GetScrollbar();
+      nsCOMPtr<nsIContent> scrollbar;
+      scrollbar = GetContentOfBox(scrollbarBox);
+      int32_t current = GetCurrentPosition(scrollbar);
+      int32_t min = GetMinPosition(scrollbar);
+      int32_t max = GetMaxPosition(scrollbar);
+
+      // inform the parent <scale> that the minimum or maximum changed
+      nsIFrame* parent = GetParent();
+      if (parent) {
+        nsCOMPtr<nsISliderListener> sliderListener = do_QueryInterface(parent->GetContent());
+        if (sliderListener) {
+          nsContentUtils::AddScriptRunner(
+            new nsValueChangedRunnable(sliderListener, aAttribute,
+                                       aAttribute == nsGkAtoms::minpos ? min : max, false));
+        }
+      }
+
+      if (current < min || current > max)
+      {
+        int32_t direction = 0;
+        if (current < min || max < min) {
+          current = min;
+          direction = -1;
+        } else if (current > max) {
+          current = max;
+          direction = 1;
+        }
+
+        // set the new position and notify observers
+        nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox);
+        if (scrollbarFrame) {
+          nsIScrollbarMediator* mediator = scrollbarFrame->GetScrollbarMediator();
+          scrollbarFrame->SetIncrementToWhole(direction);
+          if (mediator) {
+            mediator->ScrollByWhole(scrollbarFrame, direction,
+                                    nsIScrollbarMediator::ENABLE_SNAP);
+          }
+        }
+        // 'this' might be destroyed here
+
+        nsContentUtils::AddScriptRunner(
+          new nsSetAttrRunnable(scrollbar, nsGkAtoms::curpos, current));
+      }
+  }
+
+  if (aAttribute == nsGkAtoms::minpos ||
+      aAttribute == nsGkAtoms::maxpos ||
+      aAttribute == nsGkAtoms::pageincrement ||
+      aAttribute == nsGkAtoms::increment) {
+
+      PresContext()->PresShell()->
+        FrameNeedsReflow(this, nsIPresShell::eStyleChange, NS_FRAME_IS_DIRTY);
+  }
+
+  return rv;
+}
+
+void
+nsSliderFrame::BuildDisplayList(nsDisplayListBuilder*   aBuilder,
+                                const nsRect&           aDirtyRect,
+                                const nsDisplayListSet& aLists)
+{
+  if (aBuilder->IsForEventDelivery() && isDraggingThumb()) {
+    // This is EVIL, we shouldn't be messing with event delivery just to get
+    // thumb mouse drag events to arrive at the slider!
+    aLists.Outlines()->AppendNewToTop(new (aBuilder)
+      nsDisplayEventReceiver(aBuilder, this));
+    return;
+  }
+  
+  nsBoxFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
+}
+
+void
+nsSliderFrame::BuildDisplayListForChildren(nsDisplayListBuilder*   aBuilder,
+                                           const nsRect&           aDirtyRect,
+                                           const nsDisplayListSet& aLists)
+{
+  // if we are too small to have a thumb don't paint it.
+  nsIFrame* thumb = nsBox::GetChildXULBox(this);
+
+  if (thumb) {
+    nsRect thumbRect(thumb->GetRect());
+    nsMargin m;
+    thumb->GetXULMargin(m);
+    thumbRect.Inflate(m);
+
+    nsRect crect;
+    GetXULClientRect(crect);
+
+    if (crect.width < thumbRect.width || crect.height < thumbRect.height)
+      return;
+
+    // If this scrollbar is the scrollbar of an actively scrolled scroll frame,
+    // layerize the scrollbar thumb, wrap it in its own ContainerLayer and
+    // attach scrolling information to it.
+    // We do this here and not in the thumb's nsBoxFrame::BuildDisplayList so
+    // that the event region that gets created for the thumb is included in
+    // the nsDisplayOwnLayer contents.
+
+    uint32_t flags = 0;
+    mozilla::layers::FrameMetrics::ViewID scrollTargetId =
+      mozilla::layers::FrameMetrics::NULL_SCROLL_ID;
+    aBuilder->GetScrollbarInfo(&scrollTargetId, &flags);
+    bool thumbGetsLayer = (scrollTargetId != layers::FrameMetrics::NULL_SCROLL_ID);
+    nsLayoutUtils::SetScrollbarThumbLayerization(thumb, thumbGetsLayer);
+
+    if (thumbGetsLayer) {
+      nsDisplayListCollection tempLists;
+      nsBoxFrame::BuildDisplayListForChildren(aBuilder, aDirtyRect, tempLists);
+
+      // This is a bit of a hack. Collect up all descendant display items
+      // and merge them into a single Content() list.
+      nsDisplayList masterList;
+      masterList.AppendToTop(tempLists.BorderBackground());
+      masterList.AppendToTop(tempLists.BlockBorderBackgrounds());
+      masterList.AppendToTop(tempLists.Floats());
+      masterList.AppendToTop(tempLists.Content());
+      masterList.AppendToTop(tempLists.PositionedDescendants());
+      masterList.AppendToTop(tempLists.Outlines());
+
+      // Wrap the list to make it its own layer.
+      aLists.Content()->AppendNewToTop(new (aBuilder)
+        nsDisplayOwnLayer(aBuilder, this, &masterList, flags, scrollTargetId,
+                          GetThumbRatio()));
+
+      return;
+    }
+  }
+  
+  nsBoxFrame::BuildDisplayListForChildren(aBuilder, aDirtyRect, aLists);
+}
+
+NS_IMETHODIMP
+nsSliderFrame::DoXULLayout(nsBoxLayoutState& aState)
+{
+  // get the thumb should be our only child
+  nsIFrame* thumbBox = nsBox::GetChildXULBox(this);
+
+  if (!thumbBox) {
+    SyncLayout(aState);
+    return NS_OK;
+  }
+
+  EnsureOrient();
+
+#ifdef DEBUG_LAYOUT
+  if (mState & NS_STATE_DEBUG_WAS_SET) {
+      if (mState & NS_STATE_SET_TO_DEBUG)
+          SetXULDebug(aState, true);
+      else
+          SetXULDebug(aState, false);
+  }
+#endif
+
+  // get the content area inside our borders
+  nsRect clientRect;
+  GetXULClientRect(clientRect);
+
+  // get the scrollbar
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsCOMPtr<nsIContent> scrollbar;
+  scrollbar = GetContentOfBox(scrollbarBox);
+
+  // get the thumb's pref size
+  nsSize thumbSize = thumbBox->GetXULPrefSize(aState);
+
+  if (IsXULHorizontal())
+    thumbSize.height = clientRect.height;
+  else
+    thumbSize.width = clientRect.width;
+
+  int32_t curPos = GetCurrentPosition(scrollbar);
+  int32_t minPos = GetMinPosition(scrollbar);
+  int32_t maxPos = GetMaxPosition(scrollbar);
+  int32_t pageIncrement = GetPageIncrement(scrollbar);
+
+  maxPos = std::max(minPos, maxPos);
+  curPos = clamped(curPos, minPos, maxPos);
+
+  nscoord& availableLength = IsXULHorizontal() ? clientRect.width : clientRect.height;
+  nscoord& thumbLength = IsXULHorizontal() ? thumbSize.width : thumbSize.height;
+
+  if ((pageIncrement + maxPos - minPos) > 0 && thumbBox->GetXULFlex() > 0) {
+    float ratio = float(pageIncrement) / float(maxPos - minPos + pageIncrement);
+    thumbLength = std::max(thumbLength, NSToCoordRound(availableLength * ratio));
+  }
+
+  // Round the thumb's length to device pixels.
+  nsPresContext* presContext = PresContext();
+  thumbLength = presContext->DevPixelsToAppUnits(
+                  presContext->AppUnitsToDevPixels(thumbLength));
+
+  // mRatio translates the thumb position in app units to the value.
+  mRatio = (minPos != maxPos) ? float(availableLength - thumbLength) / float(maxPos - minPos) : 1;
+
+  // in reverse mode, curpos is reversed such that lower values are to the
+  // right or bottom and increase leftwards or upwards. In this case, use the
+  // offset from the end instead of the beginning.
+  bool reverse = mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                                         nsGkAtoms::reverse, eCaseMatters);
+  nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
+
+  // set the thumb's coord to be the current pos * the ratio.
+  nsRect thumbRect(clientRect.x, clientRect.y, thumbSize.width, thumbSize.height);
+  int32_t& thumbPos = (IsXULHorizontal() ? thumbRect.x : thumbRect.y);
+  thumbPos += NSToCoordRound(pos * mRatio);
+
+  nsRect oldThumbRect(thumbBox->GetRect());
+  LayoutChildAt(aState, thumbBox, thumbRect);
+
+  SyncLayout(aState);
+
+  // Redraw only if thumb changed size.
+  if (!oldThumbRect.IsEqualInterior(thumbRect))
+    XULRedraw(aState);
+
+  return NS_OK;
+}
+
+
+nsresult
+nsSliderFrame::HandleEvent(nsPresContext* aPresContext,
+                           WidgetGUIEvent* aEvent,
+                           nsEventStatus* aEventStatus)
+{
+  NS_ENSURE_ARG_POINTER(aEventStatus);
+
+  // If a web page calls event.preventDefault() we still want to
+  // scroll when scroll arrow is clicked. See bug 511075.
+  if (!mContent->IsInNativeAnonymousSubtree() &&
+      nsEventStatus_eConsumeNoDefault == *aEventStatus) {
+    return NS_OK;
+  }
+
+  if (!mDragFinished && !isDraggingThumb()) {
+    StopDrag();
+    return NS_OK;
+  }
+
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsCOMPtr<nsIContent> scrollbar;
+  scrollbar = GetContentOfBox(scrollbarBox);
+  bool isHorizontal = IsXULHorizontal();
+
+  if (isDraggingThumb())
+  {
+    switch (aEvent->mMessage) {
+    case eTouchMove:
+    case eMouseMove: {
+      if (mScrollingWithAPZ) {
+        break;
+      }
+      nsPoint eventPoint;
+      if (!GetEventPoint(aEvent, eventPoint)) {
+        break;
+      }
+      if (mChange) {
+        // On Linux the destination point is determined by the initial click
+        // on the scrollbar track and doesn't change until the mouse button
+        // is released.
+#ifndef MOZ_WIDGET_GTK
+        // On the other platforms we need to update the destination point now.
+        mDestinationPoint = eventPoint;
+        StopRepeat();
+        StartRepeat();
+#endif
+        break;
+      }
+
+      nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
+
+      nsIFrame* thumbFrame = mFrames.FirstChild();
+      if (!thumbFrame) {
+        return NS_OK;
+      }
+
+      mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
+          (uint32_t) ScrollInputMethod::MainThreadScrollbarDrag);
+
+      // take our current position and subtract the start location
+      pos -= mDragStart;
+      bool isMouseOutsideThumb = false;
+      if (gSnapMultiplier) {
+        nsSize thumbSize = thumbFrame->GetSize();
+        if (isHorizontal) {
+          // horizontal scrollbar - check if mouse is above or below thumb
+          // XXXbz what about looking at the .y of the thumb's rect?  Is that
+          // always zero here?
+          if (eventPoint.y < -gSnapMultiplier * thumbSize.height ||
+              eventPoint.y > thumbSize.height +
+                               gSnapMultiplier * thumbSize.height)
+            isMouseOutsideThumb = true;
+        }
+        else {
+          // vertical scrollbar - check if mouse is left or right of thumb
+          if (eventPoint.x < -gSnapMultiplier * thumbSize.width ||
+              eventPoint.x > thumbSize.width +
+                               gSnapMultiplier * thumbSize.width)
+            isMouseOutsideThumb = true;
+        }
+      }
+      if (aEvent->mClass == eTouchEventClass) {
+        *aEventStatus = nsEventStatus_eConsumeNoDefault;
+      }
+      if (isMouseOutsideThumb)
+      {
+        SetCurrentThumbPosition(scrollbar, mThumbStart, false, false);
+        return NS_OK;
+      }
+
+      // set it
+      SetCurrentThumbPosition(scrollbar, pos, false, true); // with snapping
+    }
+    break;
+
+    case eTouchEnd:
+    case eMouseUp:
+      if (ShouldScrollForEvent(aEvent)) {
+        StopDrag();
+        //we MUST call nsFrame HandleEvent for mouse ups to maintain the selection state and capture state.
+        return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+      }
+      break;
+
+    default:
+      break;
+    }
+
+    //return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+    return NS_OK;
+  } else if (ShouldScrollToClickForEvent(aEvent)) {
+    nsPoint eventPoint;
+    if (!GetEventPoint(aEvent, eventPoint)) {
+      return NS_OK;
+    }
+    nscoord pos = isHorizontal ? eventPoint.x : eventPoint.y;
+
+    // adjust so that the middle of the thumb is placed under the click
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      return NS_OK;
+    }
+    nsSize thumbSize = thumbFrame->GetSize();
+    nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
+
+    mozilla::Telemetry::Accumulate(mozilla::Telemetry::SCROLL_INPUT_METHODS,
+        (uint32_t) ScrollInputMethod::MainThreadScrollbarTrackClick);
+
+    // set it
+    nsWeakFrame weakFrame(this);
+    // should aMaySnap be true here?
+    SetCurrentThumbPosition(scrollbar, pos - thumbLength/2, false, false);
+    NS_ENSURE_TRUE(weakFrame.IsAlive(), NS_OK);
+
+    DragThumb(true);
+
+#ifdef MOZ_WIDGET_GTK
+    nsCOMPtr<nsIContent> thumb = thumbFrame->GetContent();
+    thumb->SetAttr(kNameSpaceID_None, nsGkAtoms::active, NS_LITERAL_STRING("true"), true);
+#endif
+
+    if (aEvent->mClass == eTouchEventClass) {
+      *aEventStatus = nsEventStatus_eConsumeNoDefault;
+    }
+
+    if (isHorizontal)
+      mThumbStart = thumbFrame->GetPosition().x;
+    else
+      mThumbStart = thumbFrame->GetPosition().y;
+
+    mDragStart = pos - mThumbStart;
+  }
+#ifdef MOZ_WIDGET_GTK
+  else if (ShouldScrollForEvent(aEvent) &&
+           aEvent->mClass == eMouseEventClass &&
+           aEvent->AsMouseEvent()->button == WidgetMouseEvent::eRightButton) {
+    // HandlePress and HandleRelease are usually called via
+    // nsFrame::HandleEvent, but only for the left mouse button.
+    if (aEvent->mMessage == eMouseDown) {
+      HandlePress(aPresContext, aEvent, aEventStatus);
+    } else if (aEvent->mMessage == eMouseUp) {
+      HandleRelease(aPresContext, aEvent, aEventStatus);
+    }
+
+    return NS_OK;
+  }
+#endif
+
+  // XXX hack until handle release is actually called in nsframe.
+  //  if (aEvent->mMessage == eMouseOut ||
+  //      aEvent->mMessage == NS_MOUSE_RIGHT_BUTTON_UP ||
+  //      aEvent->mMessage == NS_MOUSE_LEFT_BUTTON_UP) {
+  //    HandleRelease(aPresContext, aEvent, aEventStatus);
+  //  }
+
+  if (aEvent->mMessage == eMouseOut && mChange)
+     HandleRelease(aPresContext, aEvent, aEventStatus);
+
+  return nsFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
+}
+
+// Helper function to collect the "scroll to click" metric. Beware of
+// caching this, users expect to be able to change the system preference
+// and see the browser change its behavior immediately.
+bool
+nsSliderFrame::GetScrollToClick()
+{
+  if (GetScrollbar() != this) {
+    return LookAndFeel::GetInt(LookAndFeel::eIntID_ScrollToClick, false);
+  }
+
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::movetoclick,
+                            nsGkAtoms::_true, eCaseMatters)) {
+    return true;
+  }
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::movetoclick,
+                            nsGkAtoms::_false, eCaseMatters)) {
+    return false;
+  }
+
+#ifdef XP_MACOSX
+  return true;
+#else
+  return false;
+#endif
+}
+
+nsIFrame*
+nsSliderFrame::GetScrollbar()
+{
+  // if we are in a scrollbar then return the scrollbar's content node
+  // if we are not then return ours.
+   nsIFrame* scrollbar;
+   nsScrollbarButtonFrame::GetParentWithTag(nsGkAtoms::scrollbar, this, scrollbar);
+
+   if (scrollbar == nullptr)
+       return this;
+
+   return scrollbar->IsXULBoxFrame() ? scrollbar : this;
+}
+
+void
+nsSliderFrame::PageUpDown(nscoord change)
+{
+  // on a page up or down get our page increment. We get this by getting the scrollbar we are in and
+  // asking it for the current position and the page increment. If we are not in a scrollbar we will
+  // get the values from our own node.
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsCOMPtr<nsIContent> scrollbar;
+  scrollbar = GetContentOfBox(scrollbarBox);
+
+  nscoord pageIncrement = GetPageIncrement(scrollbar);
+  int32_t curpos = GetCurrentPosition(scrollbar);
+  int32_t minpos = GetMinPosition(scrollbar);
+  int32_t maxpos = GetMaxPosition(scrollbar);
+
+  // get the new position and make sure it is in bounds
+  int32_t newpos = curpos + change * pageIncrement;
+  if (newpos < minpos || maxpos < minpos)
+    newpos = minpos;
+  else if (newpos > maxpos)
+    newpos = maxpos;
+
+  SetCurrentPositionInternal(scrollbar, newpos, true);
+}
+
+// called when the current position changed and we need to update the thumb's location
+void
+nsSliderFrame::CurrentPositionChanged()
+{
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsCOMPtr<nsIContent> scrollbar;
+  scrollbar = GetContentOfBox(scrollbarBox);
+
+  // get the current position
+  int32_t curPos = GetCurrentPosition(scrollbar);
+
+  // do nothing if the position did not change
+  if (mCurPos == curPos)
+    return;
+
+  // get our current min and max position from our content node
+  int32_t minPos = GetMinPosition(scrollbar);
+  int32_t maxPos = GetMaxPosition(scrollbar);
+
+  maxPos = std::max(minPos, maxPos);
+  curPos = clamped(curPos, minPos, maxPos);
+
+  // get the thumb's rect
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame)
+    return; // The thumb may stream in asynchronously via XBL.
+
+  nsRect thumbRect = thumbFrame->GetRect();
+
+  nsRect clientRect;
+  GetXULClientRect(clientRect);
+
+  // figure out the new rect
+  nsRect newThumbRect(thumbRect);
+
+  bool reverse = mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                                         nsGkAtoms::reverse, eCaseMatters);
+  nscoord pos = reverse ? (maxPos - curPos) : (curPos - minPos);
+
+  if (IsXULHorizontal())
+     newThumbRect.x = clientRect.x + NSToCoordRound(pos * mRatio);
+  else
+     newThumbRect.y = clientRect.y + NSToCoordRound(pos * mRatio);
+
+  // avoid putting the scroll thumb at subpixel positions which cause needless invalidations
+  nscoord appUnitsPerPixel = PresContext()->AppUnitsPerDevPixel();
+  nsPoint snappedThumbLocation = ToAppUnits(
+      newThumbRect.TopLeft().ToNearestPixels(appUnitsPerPixel),
+      appUnitsPerPixel);
+  if (IsXULHorizontal()) {
+    newThumbRect.x = snappedThumbLocation.x;
+  } else {
+    newThumbRect.y = snappedThumbLocation.y;
+  }
+
+  // set the rect
+  thumbFrame->SetRect(newThumbRect);
+
+  // Request a repaint of the scrollbar
+  nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox);
+  nsIScrollbarMediator* mediator = scrollbarFrame
+      ? scrollbarFrame->GetScrollbarMediator() : nullptr;
+  if (!mediator || !mediator->ShouldSuppressScrollbarRepaints()) {
+    SchedulePaint();
+  }
+
+  mCurPos = curPos;
+
+  // inform the parent <scale> if it exists that the value changed
+  nsIFrame* parent = GetParent();
+  if (parent) {
+    nsCOMPtr<nsISliderListener> sliderListener = do_QueryInterface(parent->GetContent());
+    if (sliderListener) {
+      nsContentUtils::AddScriptRunner(
+        new nsValueChangedRunnable(sliderListener, nsGkAtoms::curpos, mCurPos, mUserChanged));
+    }
+  }
+}
+
+static void UpdateAttribute(nsIContent* aScrollbar, nscoord aNewPos, bool aNotify, bool aIsSmooth) {
+  nsAutoString str;
+  str.AppendInt(aNewPos);
+  
+  if (aIsSmooth) {
+    aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::smooth, NS_LITERAL_STRING("true"), false);
+  }
+  aScrollbar->SetAttr(kNameSpaceID_None, nsGkAtoms::curpos, str, aNotify);
+  if (aIsSmooth) {
+    aScrollbar->UnsetAttr(kNameSpaceID_None, nsGkAtoms::smooth, false);
+  }
+}
+
+// Use this function when you want to set the scroll position via the position
+// of the scrollbar thumb, e.g. when dragging the slider. This function scrolls
+// the content in such a way that thumbRect.x/.y becomes aNewThumbPos.
+void
+nsSliderFrame::SetCurrentThumbPosition(nsIContent* aScrollbar, nscoord aNewThumbPos,
+                                       bool aIsSmooth, bool aMaySnap)
+{
+  nsRect crect;
+  GetXULClientRect(crect);
+  nscoord offset = IsXULHorizontal() ? crect.x : crect.y;
+  int32_t newPos = NSToIntRound((aNewThumbPos - offset) / mRatio);
+  
+  if (aMaySnap && mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::snap,
+                                        nsGkAtoms::_true, eCaseMatters)) {
+    // If snap="true", then the slider may only be set to min + (increment * x).
+    // Otherwise, the slider may be set to any positive integer.
+    int32_t increment = GetIncrement(aScrollbar);
+    newPos = NSToIntRound(newPos / float(increment)) * increment;
+  }
+  
+  SetCurrentPosition(aScrollbar, newPos, aIsSmooth);
+}
+
+// Use this function when you know the target scroll position of the scrolled content.
+// aNewPos should be passed to this function as a position as if the minpos is 0.
+// That is, the minpos will be added to the position by this function. In a reverse
+// direction slider, the newpos should be the distance from the end.
+void
+nsSliderFrame::SetCurrentPosition(nsIContent* aScrollbar, int32_t aNewPos,
+                                  bool aIsSmooth)
+{
+   // get min and max position from our content node
+  int32_t minpos = GetMinPosition(aScrollbar);
+  int32_t maxpos = GetMaxPosition(aScrollbar);
+
+  // in reverse direction sliders, flip the value so that it goes from
+  // right to left, or bottom to top.
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                            nsGkAtoms::reverse, eCaseMatters))
+    aNewPos = maxpos - aNewPos;
+  else
+    aNewPos += minpos;
+
+  // get the new position and make sure it is in bounds
+  if (aNewPos < minpos || maxpos < minpos)
+    aNewPos = minpos;
+  else if (aNewPos > maxpos)
+    aNewPos = maxpos;
+
+  SetCurrentPositionInternal(aScrollbar, aNewPos, aIsSmooth);
+}
+
+void
+nsSliderFrame::SetCurrentPositionInternal(nsIContent* aScrollbar, int32_t aNewPos,
+                                          bool aIsSmooth)
+{
+  nsCOMPtr<nsIContent> scrollbar = aScrollbar;
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsWeakFrame weakFrame(this);
+
+  mUserChanged = true;
+
+  nsScrollbarFrame* scrollbarFrame = do_QueryFrame(scrollbarBox);
+  if (scrollbarFrame) {
+    // See if we have a mediator.
+    nsIScrollbarMediator* mediator = scrollbarFrame->GetScrollbarMediator();
+    if (mediator) {
+      nscoord oldPos = nsPresContext::CSSPixelsToAppUnits(GetCurrentPosition(scrollbar));
+      nscoord newPos = nsPresContext::CSSPixelsToAppUnits(aNewPos);
+      mediator->ThumbMoved(scrollbarFrame, oldPos, newPos);
+      if (!weakFrame.IsAlive()) {
+        return;
+      }
+      UpdateAttribute(scrollbar, aNewPos, /* aNotify */false, aIsSmooth);
+      CurrentPositionChanged();
+      mUserChanged = false;
+      return;
+    }
+  }
+
+  UpdateAttribute(scrollbar, aNewPos, true, aIsSmooth);
+  if (!weakFrame.IsAlive()) {
+    return;
+  }
+  mUserChanged = false;
+
+#ifdef DEBUG_SLIDER
+  printf("Current Pos=%d\n",aNewPos);
+#endif
+
+}
+
+nsIAtom*
+nsSliderFrame::GetType() const
+{
+  return nsGkAtoms::sliderFrame;
+}
+
+void
+nsSliderFrame::SetInitialChildList(ChildListID     aListID,
+                                   nsFrameList&    aChildList)
+{
+  nsBoxFrame::SetInitialChildList(aListID, aChildList);
+  if (aListID == kPrincipalList) {
+    AddListener();
+  }
+}
+
+nsresult
+nsSliderMediator::HandleEvent(nsIDOMEvent* aEvent)
+{
+  // Only process the event if the thumb is not being dragged.
+  if (mSlider && !mSlider->isDraggingThumb())
+    return mSlider->StartDrag(aEvent);
+
+  return NS_OK;
+}
+
+bool
+nsSliderFrame::StartAPZDrag()
+{
+  if (!gfxPlatform::GetPlatform()->SupportsApzDragInput()) {
+    return false;
+  }
+
+  nsContainerFrame* cf = GetScrollbar()->GetParent();
+  if (!cf) {
+    return false;
+  }
+
+  nsIContent* scrollableContent = cf->GetContent();
+  if (!scrollableContent) {
+    return false;
+  }
+
+  mozilla::layers::FrameMetrics::ViewID scrollTargetId;
+  bool hasID = nsLayoutUtils::FindIDFor(scrollableContent, &scrollTargetId);
+  bool hasAPZView = hasID && (scrollTargetId != layers::FrameMetrics::NULL_SCROLL_ID);
+
+  if (!hasAPZView) {
+    return false;
+  }
+
+  nsIFrame* scrollbarBox = GetScrollbar();
+  nsCOMPtr<nsIContent> scrollbar = GetContentOfBox(scrollbarBox);
+
+  // This rect is the range in which the scroll thumb can slide in.
+  nsRect sliderTrack = GetRect() - scrollbarBox->GetPosition();
+  CSSIntRect sliderTrackCSS = CSSIntRect::FromAppUnitsRounded(sliderTrack);
+
+  uint64_t inputblockId = InputAPZContext::GetInputBlockId();
+  uint32_t presShellId = PresContext()->PresShell()->GetPresShellId();
+  AsyncDragMetrics dragMetrics(scrollTargetId, presShellId, inputblockId,
+                               NSAppUnitsToIntPixels(mDragStart,
+                                 float(AppUnitsPerCSSPixel())),
+                               sliderTrackCSS,
+                               IsXULHorizontal() ? AsyncDragMetrics::HORIZONTAL :
+                                                   AsyncDragMetrics::VERTICAL);
+
+  if (!nsLayoutUtils::HasDisplayPort(scrollableContent)) {
+    return false;
+  }
+
+  // When we start an APZ drag, we wont get mouse events for the drag.
+  // APZ will consume them all and only notify us of the new scroll position.
+  this->GetNearestWidget()->StartAsyncScrollbarDrag(dragMetrics);
+  return true;
+}
+
+nsresult
+nsSliderFrame::StartDrag(nsIDOMEvent* aEvent)
+{
+#ifdef DEBUG_SLIDER
+  printf("Begin dragging\n");
+#endif
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                            nsGkAtoms::_true, eCaseMatters))
+    return NS_OK;
+
+  WidgetGUIEvent* event = aEvent->WidgetEventPtr()->AsGUIEvent();
+
+  if (!ShouldScrollForEvent(event)) {
+    return NS_OK;
+  }
+
+  nsPoint pt;
+  if (!GetEventPoint(event, pt)) {
+    return NS_OK;
+  }
+  bool isHorizontal = IsXULHorizontal();
+  nscoord pos = isHorizontal ? pt.x : pt.y;
+
+  // If we should scroll-to-click, first place the middle of the slider thumb
+  // under the mouse.
+  nsCOMPtr<nsIContent> scrollbar;
+  nscoord newpos = pos;
+  bool scrollToClick = ShouldScrollToClickForEvent(event);
+  if (scrollToClick) {
+    // adjust so that the middle of the thumb is placed under the click
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      return NS_OK;
+    }
+    nsSize thumbSize = thumbFrame->GetSize();
+    nscoord thumbLength = isHorizontal ? thumbSize.width : thumbSize.height;
+
+    newpos -= (thumbLength/2);
+
+    nsIFrame* scrollbarBox = GetScrollbar();
+    scrollbar = GetContentOfBox(scrollbarBox);
+  }
+
+  DragThumb(true);
+
+  if (scrollToClick) {
+    // should aMaySnap be true here?
+    SetCurrentThumbPosition(scrollbar, newpos, false, false);
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return NS_OK;
+  }
+
+#ifdef MOZ_WIDGET_GTK
+  nsCOMPtr<nsIContent> thumb = thumbFrame->GetContent();
+  thumb->SetAttr(kNameSpaceID_None, nsGkAtoms::active, NS_LITERAL_STRING("true"), true);
+#endif
+
+  if (isHorizontal)
+    mThumbStart = thumbFrame->GetPosition().x;
+  else
+    mThumbStart = thumbFrame->GetPosition().y;
+
+  mDragStart = pos - mThumbStart;
+
+  mScrollingWithAPZ = StartAPZDrag();
+
+#ifdef DEBUG_SLIDER
+  printf("Pressed mDragStart=%d\n",mDragStart);
+#endif
+
+  if (!mScrollingWithAPZ && !mSuppressionActive) {
+    MOZ_ASSERT(PresContext()->PresShell());
+    APZCCallbackHelper::SuppressDisplayport(true, PresContext()->PresShell());
+    mSuppressionActive = true;
+  }
+
+  return NS_OK;
+}
+
+nsresult
+nsSliderFrame::StopDrag()
+{
+  AddListener();
+  DragThumb(false);
+
+  mScrollingWithAPZ = false;
+
+  if (mSuppressionActive) {
+    MOZ_ASSERT(PresContext()->PresShell());
+    APZCCallbackHelper::SuppressDisplayport(false, PresContext()->PresShell());
+    mSuppressionActive = false;
+  }
+
+#ifdef MOZ_WIDGET_GTK
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (thumbFrame) {
+    nsCOMPtr<nsIContent> thumb = thumbFrame->GetContent();
+    thumb->UnsetAttr(kNameSpaceID_None, nsGkAtoms::active, true);
+  }
+#endif
+
+  if (mChange) {
+    StopRepeat();
+    mChange = 0;
+  }
+  return NS_OK;
+}
+
+void
+nsSliderFrame::DragThumb(bool aGrabMouseEvents)
+{
+  mDragFinished = !aGrabMouseEvents;
+
+  // inform the parent <scale> that a drag is beginning or ending
+  nsIFrame* parent = GetParent();
+  if (parent) {
+    nsCOMPtr<nsISliderListener> sliderListener = do_QueryInterface(parent->GetContent());
+    if (sliderListener) {
+      nsContentUtils::AddScriptRunner(
+        new nsDragStateChangedRunnable(sliderListener, aGrabMouseEvents));
+    }
+  }
+
+  nsIPresShell::SetCapturingContent(aGrabMouseEvents ? GetContent() : nullptr,
+                                    aGrabMouseEvents ? CAPTURE_IGNOREALLOWED : 0);
+}
+
+bool
+nsSliderFrame::isDraggingThumb()
+{
+  return (nsIPresShell::GetCapturingContent() == GetContent());
+}
+
+void
+nsSliderFrame::AddListener()
+{
+  if (!mMediator) {
+    mMediator = new nsSliderMediator(this);
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return;
+  }
+  thumbFrame->GetContent()->
+    AddSystemEventListener(NS_LITERAL_STRING("mousedown"), mMediator,
+                           false, false);
+  thumbFrame->GetContent()->
+    AddSystemEventListener(NS_LITERAL_STRING("touchstart"), mMediator,
+                           false, false);
+}
+
+void
+nsSliderFrame::RemoveListener()
+{
+  NS_ASSERTION(mMediator, "No listener was ever added!!");
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame)
+    return;
+
+  thumbFrame->GetContent()->
+    RemoveSystemEventListener(NS_LITERAL_STRING("mousedown"), mMediator, false);
+}
+
+bool
+nsSliderFrame::ShouldScrollForEvent(WidgetGUIEvent* aEvent)
+{
+  switch (aEvent->mMessage) {
+    case eTouchStart:
+    case eTouchEnd:
+      return true;
+    case eMouseDown:
+    case eMouseUp: {
+      uint16_t button = aEvent->AsMouseEvent()->button;
+#ifdef MOZ_WIDGET_GTK
+      return (button == WidgetMouseEvent::eLeftButton) ||
+             (button == WidgetMouseEvent::eRightButton && GetScrollToClick()) ||
+             (button == WidgetMouseEvent::eMiddleButton && gMiddlePref && !GetScrollToClick());
+#else
+      return (button == WidgetMouseEvent::eLeftButton) ||
+             (button == WidgetMouseEvent::eMiddleButton && gMiddlePref);
+#endif
+    }
+    default:
+      return false;
+  }
+}
+
+bool
+nsSliderFrame::ShouldScrollToClickForEvent(WidgetGUIEvent* aEvent)
+{
+  if (!ShouldScrollForEvent(aEvent)) {
+    return false;
+  }
+
+  if (aEvent->mMessage == eTouchStart) {
+    return GetScrollToClick();
+  }
+
+  if (aEvent->mMessage != eMouseDown) {
+    return false;
+  }
+
+#if defined(XP_MACOSX) || defined(MOZ_WIDGET_GTK)
+  // On Mac and Linux, clicking the scrollbar thumb should never scroll to click.
+  if (IsEventOverThumb(aEvent)) {
+    return false;
+  }
+#endif
+
+  WidgetMouseEvent* mouseEvent = aEvent->AsMouseEvent();
+  if (mouseEvent->button == WidgetMouseEvent::eLeftButton) {
+#ifdef XP_MACOSX
+    bool invertPref = mouseEvent->IsAlt();
+#else
+    bool invertPref = mouseEvent->IsShift();
+#endif
+    return GetScrollToClick() != invertPref;
+  }
+
+#ifdef MOZ_WIDGET_GTK
+  if (mouseEvent->button == WidgetMouseEvent::eRightButton) {
+    return !GetScrollToClick();
+  }
+#endif
+
+  return true;
+}
+
+bool
+nsSliderFrame::IsEventOverThumb(WidgetGUIEvent* aEvent)
+{
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) {
+    return false;
+  }
+
+  nsPoint eventPoint;
+  if (!GetEventPoint(aEvent, eventPoint)) {
+    return false;
+  }
+
+  nsRect thumbRect = thumbFrame->GetRect();
+#if defined(MOZ_WIDGET_GTK)
+  /* Scrollbar track can have padding, so it's better to check that eventPoint
+   * is inside of actual thumb, not just its one axis. The part of the scrollbar
+   * track adjacent to thumb can actually receive events in GTK3 */
+  return eventPoint.x >= thumbRect.x && eventPoint.x < thumbRect.XMost() &&
+         eventPoint.y >= thumbRect.y && eventPoint.y < thumbRect.YMost();
+#else
+  bool isHorizontal = IsXULHorizontal();
+  nscoord eventPos = isHorizontal ? eventPoint.x : eventPoint.y;
+  nscoord thumbStart = isHorizontal ? thumbRect.x : thumbRect.y;
+  nscoord thumbEnd = isHorizontal ? thumbRect.XMost() : thumbRect.YMost();
+
+  return eventPos >= thumbStart && eventPos < thumbEnd;
+#endif
+}
+
+NS_IMETHODIMP
+nsSliderFrame::HandlePress(nsPresContext* aPresContext,
+                           WidgetGUIEvent* aEvent,
+                           nsEventStatus* aEventStatus)
+{
+  if (!ShouldScrollForEvent(aEvent) || ShouldScrollToClickForEvent(aEvent)) {
+    return NS_OK;
+  }
+
+  if (IsEventOverThumb(aEvent)) {
+    return NS_OK;
+  }
+
+  nsIFrame* thumbFrame = mFrames.FirstChild();
+  if (!thumbFrame) // display:none?
+    return NS_OK;
+
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::disabled,
+                            nsGkAtoms::_true, eCaseMatters))
+    return NS_OK;
+  
+  nsRect thumbRect = thumbFrame->GetRect();
+  
+  nscoord change = 1;
+  nsPoint eventPoint;
+  if (!GetEventPoint(aEvent, eventPoint)) {
+    return NS_OK;
+  }
+  if (IsXULHorizontal() ? eventPoint.x < thumbRect.x 
+                        : eventPoint.y < thumbRect.y)
+    change = -1;
+
+  mChange = change;
+  DragThumb(true);
+  // On Linux we want to keep scrolling in the direction indicated by |change|
+  // until the mouse is released. On the other platforms we want to stop
+  // scrolling as soon as the scrollbar thumb has reached the current mouse
+  // position.
+#ifdef MOZ_WIDGET_GTK
+  nsRect clientRect;
+  GetXULClientRect(clientRect);
+
+  // Set the destination point to the very end of the scrollbar so that
+  // scrolling doesn't stop halfway through.
+  if (change > 0) {
+    mDestinationPoint = nsPoint(clientRect.width, clientRect.height);
+  }
+  else {
+    mDestinationPoint = nsPoint(0, 0);
+  }
+#else
+  mDestinationPoint = eventPoint;
+#endif
+  StartRepeat();
+  PageScroll(change);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsSliderFrame::HandleRelease(nsPresContext* aPresContext,
+                             WidgetGUIEvent* aEvent,
+                             nsEventStatus* aEventStatus)
+{
+  StopRepeat();
+
+  nsIFrame* scrollbar = GetScrollbar();
+  nsScrollbarFrame* sb = do_QueryFrame(scrollbar);
+  if (sb) {
+    nsIScrollbarMediator* m = sb->GetScrollbarMediator();
+    if (m) {
+      m->ScrollbarReleased(sb);
+    }
+  }
+  return NS_OK;
+}
+
+void
+nsSliderFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  // tell our mediator if we have one we are gone.
+  if (mMediator) {
+    mMediator->SetSlider(nullptr);
+    mMediator = nullptr;
+  }
+  StopRepeat();
+
+  // call base class Destroy()
+  nsBoxFrame::DestroyFrom(aDestructRoot);
+}
+
+nsSize
+nsSliderFrame::GetXULPrefSize(nsBoxLayoutState& aState)
+{
+  EnsureOrient();
+  return nsBoxFrame::GetXULPrefSize(aState);
+}
+
+nsSize
+nsSliderFrame::GetXULMinSize(nsBoxLayoutState& aState)
+{
+  EnsureOrient();
+
+  // our min size is just our borders and padding
+  return nsBox::GetXULMinSize(aState);
+}
+
+nsSize
+nsSliderFrame::GetXULMaxSize(nsBoxLayoutState& aState)
+{
+  EnsureOrient();
+  return nsBoxFrame::GetXULMaxSize(aState);
+}
+
+void
+nsSliderFrame::EnsureOrient()
+{
+  nsIFrame* scrollbarBox = GetScrollbar();
+
+  bool isHorizontal = (scrollbarBox->GetStateBits() & NS_STATE_IS_HORIZONTAL) != 0;
+  if (isHorizontal)
+      mState |= NS_STATE_IS_HORIZONTAL;
+  else
+      mState &= ~NS_STATE_IS_HORIZONTAL;
+}
+
+
+void
+nsSliderFrame::Notify(void)
+{
+    bool stop = false;
+
+    nsIFrame* thumbFrame = mFrames.FirstChild();
+    if (!thumbFrame) {
+      StopRepeat();
+      return;
+    }
+    nsRect thumbRect = thumbFrame->GetRect();
+
+    bool isHorizontal = IsXULHorizontal();
+
+    // See if the thumb has moved past our destination point.
+    // if it has we want to stop.
+    if (isHorizontal) {
+        if (mChange < 0) {
+            if (thumbRect.x < mDestinationPoint.x)
+                stop = true;
+        } else {
+            if (thumbRect.x + thumbRect.width > mDestinationPoint.x)
+                stop = true;
+        }
+    } else {
+         if (mChange < 0) {
+            if (thumbRect.y < mDestinationPoint.y)
+                stop = true;
+        } else {
+            if (thumbRect.y + thumbRect.height > mDestinationPoint.y)
+                stop = true;
+        }
+    }
+
+
+    if (stop) {
+      StopRepeat();
+    } else {
+      PageScroll(mChange);
+    }
+}
+
+void
+nsSliderFrame::PageScroll(nscoord aChange)
+{
+  if (mContent->AttrValueIs(kNameSpaceID_None, nsGkAtoms::dir,
+                            nsGkAtoms::reverse, eCaseMatters)) {
+    aChange = -aChange;
+  }
+  nsIFrame* scrollbar = GetScrollbar();
+  nsScrollbarFrame* sb = do_QueryFrame(scrollbar);
+  if (sb) {
+    nsIScrollbarMediator* m = sb->GetScrollbarMediator();
+    sb->SetIncrementToPage(aChange);
+    if (m) {
+      m->ScrollByPage(sb, aChange, nsIScrollbarMediator::ENABLE_SNAP);
+      return;
+    }
+  }
+  PageUpDown(aChange);
+}
+
+float
+nsSliderFrame::GetThumbRatio() const
+{
+  // mRatio is in thumb app units per scrolled css pixels. Convert it to a
+  // ratio of the thumb's CSS pixels per scrolled CSS pixels. (Note the thumb
+  // is in the scrollframe's parent's space whereas the scrolled CSS pixels
+  // are in the scrollframe's space).
+  return mRatio / mozilla::AppUnitsPerCSSPixel();
+}
+
+NS_IMPL_ISUPPORTS(nsSliderMediator,
+                  nsIDOMEventListener)