The Tor Browser / file revision

 /* -*- 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/. */

 /* rendering object to wrap rendering objects that should be scrollable */

 #include "nsGfxScrollFrame.h"

 #include "base/compiler_specific.h"

 #include "DisplayItemClip.h"

 #include "nsCOMPtr.h"

 #include "nsPresContext.h"

 #include "nsView.h"

 #include "nsIScrollable.h"

 #include "nsContainerFrame.h"

 #include "nsGkAtoms.h"

 #include "nsNameSpaceManager.h"

 #include "nsContentList.h"

 #include "nsIDocumentInlines.h"

 #include "nsFontMetrics.h"

 #include "nsBoxLayoutState.h"

 #include "nsINodeInfo.h"

 #include "nsScrollbarFrame.h"

 #include "nsIScrollbarMediator.h"

 #include "nsITextControlFrame.h"

 #include "nsIDOMHTMLTextAreaElement.h"

 #include "nsNodeInfoManager.h"

 #include "nsContentCreatorFunctions.h"

 #include "nsAutoPtr.h"

 #include "nsPresState.h"

 #include "nsIHTMLDocument.h"

 #include "nsContentUtils.h"

 #include "nsLayoutUtils.h"

 #include "nsBidiUtils.h"

 #include "mozilla/ContentEvents.h"

 #include "mozilla/EventDispatcher.h"

 #include "mozilla/Preferences.h"

 #include "mozilla/LookAndFeel.h"

 #include "mozilla/dom/Element.h"

 #include <stdint.h>

 #include "mozilla/MathAlgorithms.h"

 #include "FrameLayerBuilder.h"

 #include "nsSMILKeySpline.h"

 #include "nsSubDocumentFrame.h"

 #include "nsSVGOuterSVGFrame.h"

 #include "mozilla/Attributes.h"

 #include "ScrollbarActivity.h"

 #include "nsRefreshDriver.h"

 #include "nsThemeConstants.h"

 #include "nsSVGIntegrationUtils.h"

 #include "nsIScrollPositionListener.h"

 #include "StickyScrollContainer.h"

 #include "nsIFrameInlines.h"

 #include "gfxPrefs.h"

 #include <algorithm>

 #include <cstdlib> // for std::abs(int/long)

 #include <cmath> // for std::abs(float/double)

 using namespace mozilla;

 using namespace mozilla::dom;

 using namespace mozilla::layout;

 //----------------------------------------------------------------------

 //----------nsHTMLScrollFrame-------------------------------------------

 nsIFrame*

 NS_NewHTMLScrollFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, bool aIsRoot)

 {

   return new (aPresShell) nsHTMLScrollFrame(aPresShell, aContext, aIsRoot);

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsHTMLScrollFrame)

 nsHTMLScrollFrame::nsHTMLScrollFrame(nsIPresShell* aShell, nsStyleContext* aContext, bool aIsRoot)

   : nsContainerFrame(aContext),

     mHelper(ALLOW_THIS_IN_INITIALIZER_LIST(this), aIsRoot)

 {

 }

 void

 nsHTMLScrollFrame::ScrollbarActivityStarted() const

 {

   if (mHelper.mScrollbarActivity) {

     mHelper.mScrollbarActivity->ActivityStarted();

   }

 }

 void

 nsHTMLScrollFrame::ScrollbarActivityStopped() const

 {

   if (mHelper.mScrollbarActivity) {

     mHelper.mScrollbarActivity->ActivityStopped();

   }

 }

 nsresult

 nsHTMLScrollFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)

 {

   return mHelper.CreateAnonymousContent(aElements);

 }

 void

 nsHTMLScrollFrame::AppendAnonymousContentTo(nsBaseContentList& aElements,

                                             uint32_t aFilter)

 {

   mHelper.AppendAnonymousContentTo(aElements, aFilter);

 }

 void

 nsHTMLScrollFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   DestroyAbsoluteFrames(aDestructRoot);

   mHelper.Destroy();

   nsContainerFrame::DestroyFrom(aDestructRoot);

 }

 nsresult

 nsHTMLScrollFrame::SetInitialChildList(ChildListID  aListID,

                                        nsFrameList& aChildList)

 {

   nsresult rv = nsContainerFrame::SetInitialChildList(aListID, aChildList);

   mHelper.ReloadChildFrames();

   return rv;

 }

 nsresult

 nsHTMLScrollFrame::AppendFrames(ChildListID  aListID,

                                 nsFrameList& aFrameList)

 {

   NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");

   mFrames.AppendFrames(nullptr, aFrameList);

   mHelper.ReloadChildFrames();

   return NS_OK;

 }

 nsresult

 nsHTMLScrollFrame::InsertFrames(ChildListID aListID,

                                 nsIFrame* aPrevFrame,

                                 nsFrameList& aFrameList)

 {

   NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");

   NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,

                "inserting after sibling frame with different parent");

   mFrames.InsertFrames(nullptr, aPrevFrame, aFrameList);

   mHelper.ReloadChildFrames();

   return NS_OK;

 }

 nsresult

 nsHTMLScrollFrame::RemoveFrame(ChildListID aListID,

                                nsIFrame* aOldFrame)

 {

   NS_ASSERTION(aListID == kPrincipalList, "Only main list supported");

   mFrames.DestroyFrame(aOldFrame);

   mHelper.ReloadChildFrames();

   return NS_OK;

 }

 nsSplittableType

 nsHTMLScrollFrame::GetSplittableType() const

 {

   return NS_FRAME_NOT_SPLITTABLE;

 }

 nsIAtom*

 nsHTMLScrollFrame::GetType() const

 {

   return nsGkAtoms::scrollFrame;

 }

 /**

  HTML scrolling implementation

  All other things being equal, we prefer layouts with fewer scrollbars showing.

 */

 struct MOZ_STACK_CLASS ScrollReflowState {

   const nsHTMLReflowState& mReflowState;

   nsBoxLayoutState mBoxState;

   ScrollbarStyles mStyles;

   nsMargin mComputedBorder;

   // === Filled in by ReflowScrolledFrame ===

   nsOverflowAreas mContentsOverflowAreas;

   bool mReflowedContentsWithHScrollbar;

   bool mReflowedContentsWithVScrollbar;

   // === Filled in when TryLayout succeeds ===

   // The size of the inside-border area

   nsSize mInsideBorderSize;

   // Whether we decided to show the horizontal scrollbar

   bool mShowHScrollbar;

   // Whether we decided to show the vertical scrollbar

   bool mShowVScrollbar;

   ScrollReflowState(nsIScrollableFrame* aFrame,

                     const nsHTMLReflowState& aState) :

     mReflowState(aState),

     // mBoxState is just used for scrollbars so we don't need to

     // worry about the reflow depth here

     mBoxState(aState.frame->PresContext(), aState.rendContext, 0),

     mStyles(aFrame->GetScrollbarStyles()) {

   }

 };

 // XXXldb Can this go away?

 static nsSize ComputeInsideBorderSize(ScrollReflowState* aState,

                                       const nsSize& aDesiredInsideBorderSize)

 {

   // aDesiredInsideBorderSize is the frame size; i.e., it includes

   // borders and padding (but the scrolled child doesn't have

   // borders). The scrolled child has the same padding as us.

   nscoord contentWidth = aState->mReflowState.ComputedWidth();

   if (contentWidth == NS_UNCONSTRAINEDSIZE) {

     contentWidth = aDesiredInsideBorderSize.width -

       aState->mReflowState.ComputedPhysicalPadding().LeftRight();

   }

   nscoord contentHeight = aState->mReflowState.ComputedHeight();

   if (contentHeight == NS_UNCONSTRAINEDSIZE) {

     contentHeight = aDesiredInsideBorderSize.height -

       aState->mReflowState.ComputedPhysicalPadding().TopBottom();

   }

   contentWidth  = aState->mReflowState.ApplyMinMaxWidth(contentWidth);

   contentHeight = aState->mReflowState.ApplyMinMaxHeight(contentHeight);

   return nsSize(contentWidth + aState->mReflowState.ComputedPhysicalPadding().LeftRight(),

                 contentHeight + aState->mReflowState.ComputedPhysicalPadding().TopBottom());

 }

 static void

 GetScrollbarMetrics(nsBoxLayoutState& aState, nsIFrame* aBox, nsSize* aMin,

                     nsSize* aPref, bool aVertical)

 {

   NS_ASSERTION(aState.GetRenderingContext(),

                "Must have rendering context in layout state for size "

                "computations");

   if (aMin) {

     *aMin = aBox->GetMinSize(aState);

     nsBox::AddMargin(aBox, *aMin);

     if (aMin->width < 0) {

       aMin->width = 0;

     }

     if (aMin->height < 0) {

       aMin->height = 0;

     }

   }

   if (aPref) {

     *aPref = aBox->GetPrefSize(aState);

     nsBox::AddMargin(aBox, *aPref);

     if (aPref->width < 0) {

       aPref->width = 0;

     }

     if (aPref->height < 0) {

       aPref->height = 0;

     }

   }

 }

 /**

  * Assuming that we know the metrics for our wrapped frame and

  * whether the horizontal and/or vertical scrollbars are present,

  * compute the resulting layout and return true if the layout is

  * consistent. If the layout is consistent then we fill in the

  * computed fields of the ScrollReflowState.

  *

  * The layout is consistent when both scrollbars are showing if and only

  * if they should be showing. A horizontal scrollbar should be showing if all

  * following conditions are met:

  * 1) the style is not HIDDEN

  * 2) our inside-border height is at least the scrollbar height (i.e., the

  * scrollbar fits vertically)

  * 3) our scrollport width (the inside-border width minus the width allocated for a

  * vertical scrollbar, if showing) is at least the scrollbar's min-width

  * (i.e., the scrollbar fits horizontally)

  * 4) the style is SCROLL, or the kid's overflow-area XMost is

  * greater than the scrollport width

  *

  * @param aForce if true, then we just assume the layout is consistent.

  */

 bool

 nsHTMLScrollFrame::TryLayout(ScrollReflowState* aState,

                              nsHTMLReflowMetrics* aKidMetrics,

                              bool aAssumeHScroll, bool aAssumeVScroll,

                              bool aForce, nsresult* aResult)

 {

   *aResult = NS_OK;

   if ((aState->mStyles.mVertical == NS_STYLE_OVERFLOW_HIDDEN && aAssumeVScroll) ||

       (aState->mStyles.mHorizontal == NS_STYLE_OVERFLOW_HIDDEN && aAssumeHScroll)) {

     NS_ASSERTION(!aForce, "Shouldn't be forcing a hidden scrollbar to show!");

     return false;

   }

   if (aAssumeVScroll != aState->mReflowedContentsWithVScrollbar ||

       (aAssumeHScroll != aState->mReflowedContentsWithHScrollbar &&

        ScrolledContentDependsOnHeight(aState))) {

     nsresult rv = ReflowScrolledFrame(aState, aAssumeHScroll, aAssumeVScroll,

                                       aKidMetrics, false);

     if (NS_FAILED(rv)) {

       *aResult = rv;

       return false;

     }

   }

   nsSize vScrollbarMinSize(0, 0);

   nsSize vScrollbarPrefSize(0, 0);

   if (mHelper.mVScrollbarBox) {

     GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox,

                         &vScrollbarMinSize,

                         aAssumeVScroll ? &vScrollbarPrefSize : nullptr, true);

   }

   nscoord vScrollbarDesiredWidth = aAssumeVScroll ? vScrollbarPrefSize.width : 0;

   nscoord vScrollbarMinHeight = aAssumeVScroll ? vScrollbarMinSize.height : 0;

   nsSize hScrollbarMinSize(0, 0);

   nsSize hScrollbarPrefSize(0, 0);

   if (mHelper.mHScrollbarBox) {

     GetScrollbarMetrics(aState->mBoxState, mHelper.mHScrollbarBox,

                         &hScrollbarMinSize,

                         aAssumeHScroll ? &hScrollbarPrefSize : nullptr, false);

   }

   nscoord hScrollbarDesiredHeight = aAssumeHScroll ? hScrollbarPrefSize.height : 0;

   nscoord hScrollbarMinWidth = aAssumeHScroll ? hScrollbarMinSize.width : 0;

   // First, compute our inside-border size and scrollport size

   // XXXldb Can we depend more on ComputeSize here?

   nsSize desiredInsideBorderSize;

   desiredInsideBorderSize.width = vScrollbarDesiredWidth +

     std::max(aKidMetrics->Width(), hScrollbarMinWidth);

   desiredInsideBorderSize.height = hScrollbarDesiredHeight +

     std::max(aKidMetrics->Height(), vScrollbarMinHeight);

   aState->mInsideBorderSize =

     ComputeInsideBorderSize(aState, desiredInsideBorderSize);

   nsSize scrollPortSize = nsSize(std::max(0, aState->mInsideBorderSize.width - vScrollbarDesiredWidth),

                                  std::max(0, aState->mInsideBorderSize.height - hScrollbarDesiredHeight));

   if (!aForce) {

     nsRect scrolledRect =

       mHelper.GetScrolledRectInternal(aState->mContentsOverflowAreas.ScrollableOverflow(),

                                      scrollPortSize);

     nscoord oneDevPixel = aState->mBoxState.PresContext()->DevPixelsToAppUnits(1);

     // If the style is HIDDEN then we already know that aAssumeHScroll is false

     if (aState->mStyles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN) {

       bool wantHScrollbar =

         aState->mStyles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL ||

         scrolledRect.XMost() >= scrollPortSize.width + oneDevPixel ||

         scrolledRect.x <= -oneDevPixel;

       if (scrollPortSize.width < hScrollbarMinSize.width)

         wantHScrollbar = false;

       if (wantHScrollbar != aAssumeHScroll)

         return false;

     }

     // If the style is HIDDEN then we already know that aAssumeVScroll is false

     if (aState->mStyles.mVertical != NS_STYLE_OVERFLOW_HIDDEN) {

       bool wantVScrollbar =

         aState->mStyles.mVertical == NS_STYLE_OVERFLOW_SCROLL ||

         scrolledRect.YMost() >= scrollPortSize.height + oneDevPixel ||

         scrolledRect.y <= -oneDevPixel;

       if (scrollPortSize.height < vScrollbarMinSize.height)

         wantVScrollbar = false;

       if (wantVScrollbar != aAssumeVScroll)

         return false;

     }

   }

   nscoord vScrollbarActualWidth = aState->mInsideBorderSize.width - scrollPortSize.width;

   aState->mShowHScrollbar = aAssumeHScroll;

   aState->mShowVScrollbar = aAssumeVScroll;

   nsPoint scrollPortOrigin(aState->mComputedBorder.left,

                            aState->mComputedBorder.top);

   if (!mHelper.IsScrollbarOnRight()) {

     scrollPortOrigin.x += vScrollbarActualWidth;

   }

   mHelper.mScrollPort = nsRect(scrollPortOrigin, scrollPortSize);

   return true;

 }

 bool

 nsHTMLScrollFrame::ScrolledContentDependsOnHeight(ScrollReflowState* aState)

 {

   // Return true if ReflowScrolledFrame is going to do something different

   // based on the presence of a horizontal scrollbar.

   return (mHelper.mScrolledFrame->GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT) ||

     aState->mReflowState.ComputedHeight() != NS_UNCONSTRAINEDSIZE ||

     aState->mReflowState.ComputedMinHeight() > 0 ||

     aState->mReflowState.ComputedMaxHeight() != NS_UNCONSTRAINEDSIZE;

 }

 nsresult

 nsHTMLScrollFrame::ReflowScrolledFrame(ScrollReflowState* aState,

                                        bool aAssumeHScroll,

                                        bool aAssumeVScroll,

                                        nsHTMLReflowMetrics* aMetrics,

                                        bool aFirstPass)

 {

   // these could be NS_UNCONSTRAINEDSIZE ... std::min arithmetic should

   // be OK

   const nsMargin& padding = aState->mReflowState.ComputedPhysicalPadding();

   nscoord availWidth = aState->mReflowState.ComputedWidth() + padding.LeftRight();

   nscoord computedHeight = aState->mReflowState.ComputedHeight();

   nscoord computedMinHeight = aState->mReflowState.ComputedMinHeight();

   nscoord computedMaxHeight = aState->mReflowState.ComputedMaxHeight();

   if (!ShouldPropagateComputedHeightToScrolledContent()) {

     computedHeight = NS_UNCONSTRAINEDSIZE;

     computedMinHeight = 0;

     computedMaxHeight = NS_UNCONSTRAINEDSIZE;

   }

   if (aAssumeHScroll) {

     nsSize hScrollbarPrefSize;

     GetScrollbarMetrics(aState->mBoxState, mHelper.mHScrollbarBox,

                         nullptr, &hScrollbarPrefSize, false);

     if (computedHeight != NS_UNCONSTRAINEDSIZE) {

       computedHeight = std::max(0, computedHeight - hScrollbarPrefSize.height);

     }

     computedMinHeight = std::max(0, computedMinHeight - hScrollbarPrefSize.height);

     if (computedMaxHeight != NS_UNCONSTRAINEDSIZE) {

       computedMaxHeight = std::max(0, computedMaxHeight - hScrollbarPrefSize.height);

     }

   }

   if (aAssumeVScroll) {

     nsSize vScrollbarPrefSize;

     GetScrollbarMetrics(aState->mBoxState, mHelper.mVScrollbarBox,

                         nullptr, &vScrollbarPrefSize, true);

     availWidth = std::max(0, availWidth - vScrollbarPrefSize.width);

   }

   nsPresContext* presContext = PresContext();

   // Pass false for aInit so we can pass in the correct padding.

   nsHTMLReflowState kidReflowState(presContext, aState->mReflowState,

                                    mHelper.mScrolledFrame,

                                    nsSize(availWidth, NS_UNCONSTRAINEDSIZE),

                                    -1, -1, nsHTMLReflowState::CALLER_WILL_INIT);

   kidReflowState.Init(presContext, -1, -1, nullptr,

                       &padding);

   kidReflowState.mFlags.mAssumingHScrollbar = aAssumeHScroll;

   kidReflowState.mFlags.mAssumingVScrollbar = aAssumeVScroll;

   kidReflowState.SetComputedHeight(computedHeight);

   kidReflowState.ComputedMinHeight() = computedMinHeight;

   kidReflowState.ComputedMaxHeight() = computedMaxHeight;

   // Temporarily set mHasHorizontalScrollbar/mHasVerticalScrollbar to

   // reflect our assumptions while we reflow the child.

   bool didHaveHorizontalScrollbar = mHelper.mHasHorizontalScrollbar;

   bool didHaveVerticalScrollbar = mHelper.mHasVerticalScrollbar;

   mHelper.mHasHorizontalScrollbar = aAssumeHScroll;

   mHelper.mHasVerticalScrollbar = aAssumeVScroll;

   nsReflowStatus status;

   nsresult rv = ReflowChild(mHelper.mScrolledFrame, presContext, *aMetrics,

                             kidReflowState, 0, 0,

                             NS_FRAME_NO_MOVE_FRAME, status);

   mHelper.mHasHorizontalScrollbar = didHaveHorizontalScrollbar;

   mHelper.mHasVerticalScrollbar = didHaveVerticalScrollbar;

   // Don't resize or position the view (if any) because we're going to resize

   // it to the correct size anyway in PlaceScrollArea. Allowing it to

   // resize here would size it to the natural height of the frame,

   // which will usually be different from the scrollport height;

   // invalidating the difference will cause unnecessary repainting.

   FinishReflowChild(mHelper.mScrolledFrame, presContext,

                     *aMetrics, &kidReflowState, 0, 0,

                     NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_SIZE_VIEW);

   // XXX Some frames (e.g., nsObjectFrame, nsFrameFrame, nsTextFrame) don't bother

   // setting their mOverflowArea. This is wrong because every frame should

   // always set mOverflowArea. In fact nsObjectFrame and nsFrameFrame don't

   // support the 'outline' property because of this. Rather than fix the world

   // right now, just fix up the overflow area if necessary. Note that we don't

   // check HasOverflowRect() because it could be set even though the

   // overflow area doesn't include the frame bounds.

   aMetrics->UnionOverflowAreasWithDesiredBounds();

   if (MOZ_UNLIKELY(StyleDisplay()->mOverflowClipBox ==

                      NS_STYLE_OVERFLOW_CLIP_BOX_CONTENT_BOX)) {

     nsOverflowAreas childOverflow;

     nsLayoutUtils::UnionChildOverflow(mHelper.mScrolledFrame, childOverflow);

     nsRect childScrollableOverflow = childOverflow.ScrollableOverflow();

     childScrollableOverflow.Inflate(padding);

     nsRect contentArea = nsRect(0, 0, availWidth, computedHeight);

     if (!contentArea.Contains(childScrollableOverflow)) {

       aMetrics->mOverflowAreas.ScrollableOverflow() = childScrollableOverflow;

     }

   }

   aState->mContentsOverflowAreas = aMetrics->mOverflowAreas;

   aState->mReflowedContentsWithHScrollbar = aAssumeHScroll;

   aState->mReflowedContentsWithVScrollbar = aAssumeVScroll;

   return rv;

 }

 bool

 nsHTMLScrollFrame::GuessHScrollbarNeeded(const ScrollReflowState& aState)

 {

   if (aState.mStyles.mHorizontal != NS_STYLE_OVERFLOW_AUTO)

     // no guessing required

     return aState.mStyles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL;

   return mHelper.mHasHorizontalScrollbar;

 }

 bool

 nsHTMLScrollFrame::GuessVScrollbarNeeded(const ScrollReflowState& aState)

 {

   if (aState.mStyles.mVertical != NS_STYLE_OVERFLOW_AUTO)

     // no guessing required

     return aState.mStyles.mVertical == NS_STYLE_OVERFLOW_SCROLL;

   // If we've had at least one non-initial reflow, then just assume

   // the state of the vertical scrollbar will be what we determined

   // last time.

   if (mHelper.mHadNonInitialReflow) {

     return mHelper.mHasVerticalScrollbar;

   }

   // If this is the initial reflow, guess false because usually

   // we have very little content by then.

   if (InInitialReflow())

     return false;

   if (mHelper.mIsRoot) {

     nsIFrame *f = mHelper.mScrolledFrame->GetFirstPrincipalChild();

     if (f && f->GetType() == nsGkAtoms::svgOuterSVGFrame &&

         static_cast<nsSVGOuterSVGFrame*>(f)->VerticalScrollbarNotNeeded()) {

       // Common SVG case - avoid a bad guess.

       return false;

     }

     // Assume that there will be a scrollbar; it seems to me

     // that 'most pages' do have a scrollbar, and anyway, it's cheaper

     // to do an extra reflow for the pages that *don't* need a

     // scrollbar (because on average they will have less content).

     return true;

   }

   // For non-viewports, just guess that we don't need a scrollbar.

   // XXX I wonder if statistically this is the right idea; I'm

   // basically guessing that there are a lot of overflow:auto DIVs

   // that get their intrinsic size and don't overflow

   return false;

 }

 bool

 nsHTMLScrollFrame::InInitialReflow() const

 {

   // We're in an initial reflow if NS_FRAME_FIRST_REFLOW is set, unless we're a

   // root scrollframe.  In that case we want to skip this clause altogether.

   // The guess here is that there are lots of overflow:auto divs out there that

   // end up auto-sizing so they don't overflow, and that the root basically

   // always needs a scrollbar if it did last time we loaded this page (good

   // assumption, because our initial reflow is no longer synchronous).

   return !mHelper.mIsRoot && (GetStateBits() & NS_FRAME_FIRST_REFLOW);

 }

 nsresult

 nsHTMLScrollFrame::ReflowContents(ScrollReflowState* aState,

                                   const nsHTMLReflowMetrics& aDesiredSize)

 {

   nsHTMLReflowMetrics kidDesiredSize(aDesiredSize.GetWritingMode(), aDesiredSize.mFlags);

   nsresult rv = ReflowScrolledFrame(aState, GuessHScrollbarNeeded(*aState),

       GuessVScrollbarNeeded(*aState), &kidDesiredSize, true);

   NS_ENSURE_SUCCESS(rv, rv);

   // There's an important special case ... if the child appears to fit

   // in the inside-border rect (but overflows the scrollport), we

   // should try laying it out without a vertical scrollbar. It will

   // usually fit because making the available-width wider will not

   // normally make the child taller. (The only situation I can think

   // of is when you have a line containing %-width inline replaced

   // elements whose percentages sum to more than 100%, so increasing

   // the available width makes the line break where it was fitting

   // before.) If we don't treat this case specially, then we will

   // decide that showing scrollbars is OK because the content

   // overflows when we're showing scrollbars and we won't try to

   // remove the vertical scrollbar.

   // Detecting when we enter this special case is important for when

   // people design layouts that exactly fit the container "most of the

   // time".

   // XXX Is this check really sufficient to catch all the incremental cases

   // where the ideal case doesn't have a scrollbar?

   if ((aState->mReflowedContentsWithHScrollbar || aState->mReflowedContentsWithVScrollbar) &&

       aState->mStyles.mVertical != NS_STYLE_OVERFLOW_SCROLL &&

       aState->mStyles.mHorizontal != NS_STYLE_OVERFLOW_SCROLL) {

     nsSize insideBorderSize =

       ComputeInsideBorderSize(aState,

                               nsSize(kidDesiredSize.Width(), kidDesiredSize.Height()));

     nsRect scrolledRect =

       mHelper.GetScrolledRectInternal(kidDesiredSize.ScrollableOverflow(),

                                      insideBorderSize);

     if (nsRect(nsPoint(0, 0), insideBorderSize).Contains(scrolledRect)) {

       // Let's pretend we had no scrollbars coming in here

       rv = ReflowScrolledFrame(aState, false, false,

                                &kidDesiredSize, false);

       NS_ENSURE_SUCCESS(rv, rv);

     }

   }

   // Try vertical scrollbar settings that leave the vertical scrollbar unchanged.

   // Do this first because changing the vertical scrollbar setting is expensive,

   // forcing a reflow always.

   // Try leaving the horizontal scrollbar unchanged first. This will be more

   // efficient.

   if (TryLayout(aState, &kidDesiredSize, aState->mReflowedContentsWithHScrollbar,

                 aState->mReflowedContentsWithVScrollbar, false, &rv))

     return NS_OK;

   if (TryLayout(aState, &kidDesiredSize, !aState->mReflowedContentsWithHScrollbar,

                 aState->mReflowedContentsWithVScrollbar, false, &rv))

     return NS_OK;

   // OK, now try toggling the vertical scrollbar. The performance advantage

   // of trying the status-quo horizontal scrollbar state

   // does not exist here (we'll have to reflow due to the vertical scrollbar

   // change), so always try no horizontal scrollbar first.

   bool newVScrollbarState = !aState->mReflowedContentsWithVScrollbar;

   if (TryLayout(aState, &kidDesiredSize, false, newVScrollbarState, false, &rv))

     return NS_OK;

   if (TryLayout(aState, &kidDesiredSize, true, newVScrollbarState, false, &rv))

     return NS_OK;

   // OK, we're out of ideas. Try again enabling whatever scrollbars we can

   // enable and force the layout to stick even if it's inconsistent.

   // This just happens sometimes.

   TryLayout(aState, &kidDesiredSize,

             aState->mStyles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN,

             aState->mStyles.mVertical != NS_STYLE_OVERFLOW_HIDDEN,

             true, &rv);

   return rv;

 }

 void

 nsHTMLScrollFrame::PlaceScrollArea(const ScrollReflowState& aState,

                                    const nsPoint& aScrollPosition)

 {

   nsIFrame *scrolledFrame = mHelper.mScrolledFrame;

   // Set the x,y of the scrolled frame to the correct value

   scrolledFrame->SetPosition(mHelper.mScrollPort.TopLeft() - aScrollPosition);

   nsRect scrolledArea;

   // Preserve the width or height of empty rects

   nsSize portSize = mHelper.mScrollPort.Size();

   nsRect scrolledRect =

     mHelper.GetScrolledRectInternal(aState.mContentsOverflowAreas.ScrollableOverflow(),

                                    portSize);

   scrolledArea.UnionRectEdges(scrolledRect,

                               nsRect(nsPoint(0,0), portSize));

   // Store the new overflow area. Note that this changes where an outline

   // of the scrolled frame would be painted, but scrolled frames can't have

   // outlines (the outline would go on this scrollframe instead).

   // Using FinishAndStoreOverflow is needed so the overflow rect

   // gets set correctly.  It also messes with the overflow rect in the

   // -moz-hidden-unscrollable case, but scrolled frames can't have

   // 'overflow' either.

   // This needs to happen before SyncFrameViewAfterReflow so

   // HasOverflowRect() will return the correct value.

   nsOverflowAreas overflow(scrolledArea, scrolledArea);

   scrolledFrame->FinishAndStoreOverflow(overflow,

                                         scrolledFrame->GetSize());

   // Note that making the view *exactly* the size of the scrolled area

   // is critical, since the view scrolling code uses the size of the

   // scrolled view to clamp scroll requests.

   // Normally the scrolledFrame won't have a view but in some cases it

   // might create its own.

   nsContainerFrame::SyncFrameViewAfterReflow(scrolledFrame->PresContext(),

                                              scrolledFrame,

                                              scrolledFrame->GetView(),

                                              scrolledArea,

                                              0);

 }

 nscoord

 nsHTMLScrollFrame::GetIntrinsicVScrollbarWidth(nsRenderingContext *aRenderingContext)

 {

   ScrollbarStyles ss = GetScrollbarStyles();

   if (ss.mVertical != NS_STYLE_OVERFLOW_SCROLL || !mHelper.mVScrollbarBox)

     return 0;

   // Don't need to worry about reflow depth here since it's

   // just for scrollbars

   nsBoxLayoutState bls(PresContext(), aRenderingContext, 0);

   nsSize vScrollbarPrefSize(0, 0);

   GetScrollbarMetrics(bls, mHelper.mVScrollbarBox,

                       nullptr, &vScrollbarPrefSize, true);

   return vScrollbarPrefSize.width;

 }

 /* virtual */ nscoord

 nsHTMLScrollFrame::GetMinWidth(nsRenderingContext *aRenderingContext)

 {

   nscoord result = mHelper.mScrolledFrame->GetMinWidth(aRenderingContext);

   DISPLAY_MIN_WIDTH(this, result);

   return result + GetIntrinsicVScrollbarWidth(aRenderingContext);

 }

 /* virtual */ nscoord

 nsHTMLScrollFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)

 {

   nscoord result = mHelper.mScrolledFrame->GetPrefWidth(aRenderingContext);

   DISPLAY_PREF_WIDTH(this, result);

   return NSCoordSaturatingAdd(result, GetIntrinsicVScrollbarWidth(aRenderingContext));

 }

 nsresult

 nsHTMLScrollFrame::GetPadding(nsMargin& aMargin)

 {

   // Our padding hangs out on the inside of the scrollframe, but XUL doesn't

   // reaize that.  If we're stuck inside a XUL box, we need to claim no

   // padding.

   // @see also nsXULScrollFrame::GetPadding.

   aMargin.SizeTo(0,0,0,0);

   return NS_OK;

 }

 bool

 nsHTMLScrollFrame::IsCollapsed()

 {

   // We're never collapsed in the box sense.

   return false;

 }

 // Return the <browser> if the scrollframe is for the root frame directly

 // inside a <browser>.

 static nsIContent*

 GetBrowserRoot(nsIContent* aContent)

 {

   if (aContent) {

     nsIDocument* doc = aContent->GetCurrentDoc();

     nsPIDOMWindow* win = doc->GetWindow();

     if (win) {

       nsCOMPtr<nsIContent> frameContent =

         do_QueryInterface(win->GetFrameElementInternal());

       if (frameContent &&

           frameContent->NodeInfo()->Equals(nsGkAtoms::browser, kNameSpaceID_XUL))

         return frameContent;

     }

   }

   return nullptr;

 }

 nsresult

 nsHTMLScrollFrame::Reflow(nsPresContext*           aPresContext,

                           nsHTMLReflowMetrics&     aDesiredSize,

                           const nsHTMLReflowState& aReflowState,

                           nsReflowStatus&          aStatus)

 {

   DO_GLOBAL_REFLOW_COUNT("nsHTMLScrollFrame");

   DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);

   mHelper.HandleScrollbarStyleSwitching();

   ScrollReflowState state(this, aReflowState);

   // sanity check: ensure that if we have no scrollbar, we treat it

   // as hidden.

   if (!mHelper.mVScrollbarBox || mHelper.mNeverHasVerticalScrollbar)

     state.mStyles.mVertical = NS_STYLE_OVERFLOW_HIDDEN;

   if (!mHelper.mHScrollbarBox || mHelper.mNeverHasHorizontalScrollbar)

     state.mStyles.mHorizontal = NS_STYLE_OVERFLOW_HIDDEN;

   //------------ Handle Incremental Reflow -----------------

   bool reflowHScrollbar = true;

   bool reflowVScrollbar = true;

   bool reflowScrollCorner = true;

   if (!aReflowState.ShouldReflowAllKids()) {

     #define NEEDS_REFLOW(frame_) \

       ((frame_) && NS_SUBTREE_DIRTY(frame_))

     reflowHScrollbar = NEEDS_REFLOW(mHelper.mHScrollbarBox);

     reflowVScrollbar = NEEDS_REFLOW(mHelper.mVScrollbarBox);

     reflowScrollCorner = NEEDS_REFLOW(mHelper.mScrollCornerBox) ||

                          NEEDS_REFLOW(mHelper.mResizerBox);

     #undef NEEDS_REFLOW

   }

   if (mHelper.mIsRoot) {

     mHelper.mCollapsedResizer = true;

     nsIContent* browserRoot = GetBrowserRoot(mContent);

     if (browserRoot) {

       bool showResizer = browserRoot->HasAttr(kNameSpaceID_None, nsGkAtoms::showresizer);

       reflowScrollCorner = showResizer == mHelper.mCollapsedResizer;

       mHelper.mCollapsedResizer = !showResizer;

     }

   }

   nsRect oldScrollAreaBounds = mHelper.mScrollPort;

   nsRect oldScrolledAreaBounds =

     mHelper.mScrolledFrame->GetScrollableOverflowRectRelativeToParent();

   nsPoint oldScrollPosition = mHelper.GetScrollPosition();

   state.mComputedBorder = aReflowState.ComputedPhysicalBorderPadding() -

     aReflowState.ComputedPhysicalPadding();

   nsresult rv = ReflowContents(&state, aDesiredSize);

   if (NS_FAILED(rv))

     return rv;

   // Restore the old scroll position, for now, even if that's not valid anymore

   // because we changed size. We'll fix it up in a post-reflow callback, because

   // our current size may only be temporary (e.g. we're compute XUL desired sizes).

   PlaceScrollArea(state, oldScrollPosition);

   if (!mHelper.mPostedReflowCallback) {

     // Make sure we'll try scrolling to restored position

     PresContext()->PresShell()->PostReflowCallback(&mHelper);

     mHelper.mPostedReflowCallback = true;

   }

   bool didHaveHScrollbar = mHelper.mHasHorizontalScrollbar;

   bool didHaveVScrollbar = mHelper.mHasVerticalScrollbar;

   mHelper.mHasHorizontalScrollbar = state.mShowHScrollbar;

   mHelper.mHasVerticalScrollbar = state.mShowVScrollbar;

   nsRect newScrollAreaBounds = mHelper.mScrollPort;

   nsRect newScrolledAreaBounds =

     mHelper.mScrolledFrame->GetScrollableOverflowRectRelativeToParent();

   if (mHelper.mSkippedScrollbarLayout ||

       reflowHScrollbar || reflowVScrollbar || reflowScrollCorner ||

       (GetStateBits() & NS_FRAME_IS_DIRTY) ||

       didHaveHScrollbar != state.mShowHScrollbar ||

       didHaveVScrollbar != state.mShowVScrollbar ||

       !oldScrollAreaBounds.IsEqualEdges(newScrollAreaBounds) ||

       !oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {

     if (!mHelper.mSupppressScrollbarUpdate) {

       mHelper.mSkippedScrollbarLayout = false;

       mHelper.SetScrollbarVisibility(mHelper.mHScrollbarBox, state.mShowHScrollbar);

       mHelper.SetScrollbarVisibility(mHelper.mVScrollbarBox, state.mShowVScrollbar);

       // place and reflow scrollbars

       nsRect insideBorderArea =

         nsRect(nsPoint(state.mComputedBorder.left, state.mComputedBorder.top),

                state.mInsideBorderSize);

       mHelper.LayoutScrollbars(state.mBoxState, insideBorderArea,

                               oldScrollAreaBounds);

     } else {

       mHelper.mSkippedScrollbarLayout = true;

     }

   }

   aDesiredSize.Width() = state.mInsideBorderSize.width +

     state.mComputedBorder.LeftRight();

   aDesiredSize.Height() = state.mInsideBorderSize.height +

     state.mComputedBorder.TopBottom();

   aDesiredSize.SetOverflowAreasToDesiredBounds();

   if (mHelper.IsIgnoringViewportClipping()) {

     aDesiredSize.mOverflowAreas.UnionWith(

       state.mContentsOverflowAreas + mHelper.mScrolledFrame->GetPosition());

   }

   mHelper.UpdateSticky();

   FinishReflowWithAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, aStatus);

   if (!InInitialReflow() && !mHelper.mHadNonInitialReflow) {

     mHelper.mHadNonInitialReflow = true;

   }

   if (mHelper.mIsRoot && !oldScrolledAreaBounds.IsEqualEdges(newScrolledAreaBounds)) {

     mHelper.PostScrolledAreaEvent();

   }

   aStatus = NS_FRAME_COMPLETE;

   NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);

   mHelper.PostOverflowEvent();

   return rv;

 }

 ////////////////////////////////////////////////////////////////////////////////

 #ifdef DEBUG_FRAME_DUMP

 nsresult

 nsHTMLScrollFrame::GetFrameName(nsAString& aResult) const

 {

   return MakeFrameName(NS_LITERAL_STRING("HTMLScroll"), aResult);

 }

 #endif

 #ifdef ACCESSIBILITY

 a11y::AccType

 nsHTMLScrollFrame::AccessibleType()

 {

   // Create an accessible regardless of focusable state because the state can be

   // changed during frame life cycle without any notifications to accessibility.

   if (mContent->IsRootOfNativeAnonymousSubtree() ||

       GetScrollbarStyles() ==

         ScrollbarStyles(NS_STYLE_OVERFLOW_HIDDEN, NS_STYLE_OVERFLOW_HIDDEN) ) {

     return a11y::eNoType;

   }

   return a11y::eHyperTextType;

 }

 #endif

 NS_QUERYFRAME_HEAD(nsHTMLScrollFrame)

   NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)

   NS_QUERYFRAME_ENTRY(nsIScrollbarOwner)

   NS_QUERYFRAME_ENTRY(nsIScrollableFrame)

   NS_QUERYFRAME_ENTRY(nsIStatefulFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)

 //----------nsXULScrollFrame-------------------------------------------

 nsIFrame*

 NS_NewXULScrollFrame(nsIPresShell* aPresShell, nsStyleContext* aContext,

                      bool aIsRoot, bool aClipAllDescendants)

 {

   return new (aPresShell) nsXULScrollFrame(aPresShell, aContext, aIsRoot,

                                            aClipAllDescendants);

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsXULScrollFrame)

 nsXULScrollFrame::nsXULScrollFrame(nsIPresShell* aShell, nsStyleContext* aContext,

                                    bool aIsRoot, bool aClipAllDescendants)

   : nsBoxFrame(aShell, aContext, aIsRoot),

     mHelper(ALLOW_THIS_IN_INITIALIZER_LIST(this), aIsRoot)

 {

   SetLayoutManager(nullptr);

   mHelper.mClipAllDescendants = aClipAllDescendants;

 }

 void

 nsXULScrollFrame::ScrollbarActivityStarted() const

 {

   if (mHelper.mScrollbarActivity) {

     mHelper.mScrollbarActivity->ActivityStarted();

   }

 }

 void

 nsXULScrollFrame::ScrollbarActivityStopped() const

 {

   if (mHelper.mScrollbarActivity) {

     mHelper.mScrollbarActivity->ActivityStopped();

   }

 }

 nsMargin

 ScrollFrameHelper::GetDesiredScrollbarSizes(nsBoxLayoutState* aState)

 {

   NS_ASSERTION(aState && aState->GetRenderingContext(),

                "Must have rendering context in layout state for size "

                "computations");

   nsMargin result(0, 0, 0, 0);

   if (mVScrollbarBox) {

     nsSize size = mVScrollbarBox->GetPrefSize(*aState);

     nsBox::AddMargin(mVScrollbarBox, size);

     if (IsScrollbarOnRight())

       result.left = size.width;

     else

       result.right = size.width;

   }

   if (mHScrollbarBox) {

     nsSize size = mHScrollbarBox->GetPrefSize(*aState);

     nsBox::AddMargin(mHScrollbarBox, size);

     // We don't currently support any scripts that would require a scrollbar

     // at the top. (Are there any?)

     result.bottom = size.height;

   }

   return result;

 }

 nscoord

 ScrollFrameHelper::GetNondisappearingScrollbarWidth(nsBoxLayoutState* aState)

 {

   NS_ASSERTION(aState && aState->GetRenderingContext(),

                "Must have rendering context in layout state for size "

                "computations");

   if (LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0) {

     // We're using overlay scrollbars, so we need to get the width that

     // non-disappearing scrollbars would have.

     nsITheme* theme = aState->PresContext()->GetTheme();

     if (theme &&

         theme->ThemeSupportsWidget(aState->PresContext(),

                                    mVScrollbarBox,

                                    NS_THEME_SCROLLBAR_NON_DISAPPEARING)) {

       nsIntSize size;

       nsRenderingContext* rendContext = aState->GetRenderingContext();

       if (rendContext) {

         bool canOverride = true;

         theme->GetMinimumWidgetSize(rendContext,

                                     mVScrollbarBox,

                                     NS_THEME_SCROLLBAR_NON_DISAPPEARING,

                                     &size,

                                     &canOverride);

         if (size.width) {

           return aState->PresContext()->DevPixelsToAppUnits(size.width);

         }

       }

     }

   }

   return GetDesiredScrollbarSizes(aState).LeftRight();

 }

 void

 ScrollFrameHelper::HandleScrollbarStyleSwitching()

 {

   // Check if we switched between scrollbar styles.

   if (mScrollbarActivity &&

       LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) == 0) {

     mScrollbarActivity->Destroy();

     mScrollbarActivity = nullptr;

     mOuter->PresContext()->ThemeChanged();

   }

   else if (!mScrollbarActivity &&

            LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0) {

     mScrollbarActivity = new ScrollbarActivity(do_QueryFrame(mOuter));

     mOuter->PresContext()->ThemeChanged();

   }

 }

 static bool IsFocused(nsIContent* aContent)

 {

   // Some content elements, like the GetContent() of a scroll frame

   // for a text input field, are inside anonymous subtrees, but the focus

   // manager always reports a non-anonymous element as the focused one, so

   // walk up the tree until we reach a non-anonymous element.

   while (aContent && aContent->IsInAnonymousSubtree()) {

     aContent = aContent->GetParent();

   }

   return aContent ? nsContentUtils::IsFocusedContent(aContent) : false;

 }

 bool

 ScrollFrameHelper::WantAsyncScroll() const

 {

   nsRect scrollRange = GetScrollRange();

   ScrollbarStyles styles = GetScrollbarStylesFromFrame();

   bool isFocused = IsFocused(mOuter->GetContent());

   bool isVScrollable = (scrollRange.height > 0)

                     && (styles.mVertical != NS_STYLE_OVERFLOW_HIDDEN);

   bool isHScrollable = (scrollRange.width > 0)

                     && (styles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN);

   // The check for scroll bars was added in bug 825692 to prevent layerization

   // of text inputs for performance reasons. However, if a text input is

   // focused we want to layerize it so we can async scroll it (bug 946408).

   bool isVAsyncScrollable = isVScrollable && (mVScrollbarBox || isFocused);

   bool isHAsyncScrollable = isHScrollable && (mHScrollbarBox || isFocused);

   return isVAsyncScrollable || isHAsyncScrollable;

 }

 nsresult

 nsXULScrollFrame::CreateAnonymousContent(nsTArray<ContentInfo>& aElements)

 {

   return mHelper.CreateAnonymousContent(aElements);

 }

 void

 nsXULScrollFrame::AppendAnonymousContentTo(nsBaseContentList& aElements,

                                            uint32_t aFilter)

 {

   mHelper.AppendAnonymousContentTo(aElements, aFilter);

 }

 void

 nsXULScrollFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   mHelper.Destroy();

   nsBoxFrame::DestroyFrom(aDestructRoot);

 }

 nsresult

 nsXULScrollFrame::SetInitialChildList(ChildListID     aListID,

                                       nsFrameList&    aChildList)

 {

   nsresult rv = nsBoxFrame::SetInitialChildList(aListID, aChildList);

   mHelper.ReloadChildFrames();

   return rv;

 }

 nsresult

 nsXULScrollFrame::AppendFrames(ChildListID     aListID,

                                nsFrameList&    aFrameList)

 {

   nsresult rv = nsBoxFrame::AppendFrames(aListID, aFrameList);

   mHelper.ReloadChildFrames();

   return rv;

 }

 nsresult

 nsXULScrollFrame::InsertFrames(ChildListID     aListID,

                                nsIFrame*       aPrevFrame,

                                nsFrameList&    aFrameList)

 {

   nsresult rv = nsBoxFrame::InsertFrames(aListID, aPrevFrame, aFrameList);

   mHelper.ReloadChildFrames();

   return rv;

 }

 nsresult

 nsXULScrollFrame::RemoveFrame(ChildListID     aListID,

                               nsIFrame*       aOldFrame)

 {

   nsresult rv = nsBoxFrame::RemoveFrame(aListID, aOldFrame);

   mHelper.ReloadChildFrames();

   return rv;

 }

 nsSplittableType

 nsXULScrollFrame::GetSplittableType() const

 {

   return NS_FRAME_NOT_SPLITTABLE;

 }

 nsresult

 nsXULScrollFrame::GetPadding(nsMargin& aMargin)

 {

   aMargin.SizeTo(0,0,0,0);

   return NS_OK;

 }

 nsIAtom*

 nsXULScrollFrame::GetType() const

 {

   return nsGkAtoms::scrollFrame;

 }

 nscoord

 nsXULScrollFrame::GetBoxAscent(nsBoxLayoutState& aState)

 {

   if (!mHelper.mScrolledFrame)

     return 0;

   nscoord ascent = mHelper.mScrolledFrame->GetBoxAscent(aState);

   nsMargin m(0,0,0,0);

   GetBorderAndPadding(m);

   ascent += m.top;

   GetMargin(m);

   ascent += m.top;

   return ascent;

 }

 nsSize

 nsXULScrollFrame::GetPrefSize(nsBoxLayoutState& aState)

 {

 #ifdef DEBUG_LAYOUT

   PropagateDebug(aState);

 #endif

   nsSize pref = mHelper.mScrolledFrame->GetPrefSize(aState);

   ScrollbarStyles styles = GetScrollbarStyles();

   // scrolled frames don't have their own margins

   if (mHelper.mVScrollbarBox &&

       styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {

     nsSize vSize = mHelper.mVScrollbarBox->GetPrefSize(aState);

     nsBox::AddMargin(mHelper.mVScrollbarBox, vSize);

     pref.width += vSize.width;

   }

   if (mHelper.mHScrollbarBox &&

       styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {

     nsSize hSize = mHelper.mHScrollbarBox->GetPrefSize(aState);

     nsBox::AddMargin(mHelper.mHScrollbarBox, hSize);

     pref.height += hSize.height;

   }

   AddBorderAndPadding(pref);

   bool widthSet, heightSet;

   nsIFrame::AddCSSPrefSize(this, pref, widthSet, heightSet);

   return pref;

 }

 nsSize

 nsXULScrollFrame::GetMinSize(nsBoxLayoutState& aState)

 {

 #ifdef DEBUG_LAYOUT

   PropagateDebug(aState);

 #endif

   nsSize min = mHelper.mScrolledFrame->GetMinSizeForScrollArea(aState);

   ScrollbarStyles styles = GetScrollbarStyles();

   if (mHelper.mVScrollbarBox &&

       styles.mVertical == NS_STYLE_OVERFLOW_SCROLL) {

      nsSize vSize = mHelper.mVScrollbarBox->GetMinSize(aState);

      AddMargin(mHelper.mVScrollbarBox, vSize);

      min.width += vSize.width;

      if (min.height < vSize.height)

         min.height = vSize.height;

   }

   if (mHelper.mHScrollbarBox &&

       styles.mHorizontal == NS_STYLE_OVERFLOW_SCROLL) {

      nsSize hSize = mHelper.mHScrollbarBox->GetMinSize(aState);

      AddMargin(mHelper.mHScrollbarBox, hSize);

      min.height += hSize.height;

      if (min.width < hSize.width)

         min.width = hSize.width;

   }

   AddBorderAndPadding(min);

   bool widthSet, heightSet;

   nsIFrame::AddCSSMinSize(aState, this, min, widthSet, heightSet);

   return min;

 }

 nsSize

 nsXULScrollFrame::GetMaxSize(nsBoxLayoutState& aState)

 {

 #ifdef DEBUG_LAYOUT

   PropagateDebug(aState);

 #endif

   nsSize maxSize(NS_INTRINSICSIZE, NS_INTRINSICSIZE);

   AddBorderAndPadding(maxSize);

   bool widthSet, heightSet;

   nsIFrame::AddCSSMaxSize(this, maxSize, widthSet, heightSet);

   return maxSize;

 }

 #ifdef DEBUG_FRAME_DUMP

 nsresult

 nsXULScrollFrame::GetFrameName(nsAString& aResult) const

 {

   return MakeFrameName(NS_LITERAL_STRING("XULScroll"), aResult);

 }

 #endif

 NS_IMETHODIMP

 nsXULScrollFrame::DoLayout(nsBoxLayoutState& aState)

 {

   uint32_t flags = aState.LayoutFlags();

   nsresult rv = Layout(aState);

   aState.SetLayoutFlags(flags);

   nsBox::DoLayout(aState);

   return rv;

 }

 NS_QUERYFRAME_HEAD(nsXULScrollFrame)

   NS_QUERYFRAME_ENTRY(nsIAnonymousContentCreator)

   NS_QUERYFRAME_ENTRY(nsIScrollbarOwner)

   NS_QUERYFRAME_ENTRY(nsIScrollableFrame)

   NS_QUERYFRAME_ENTRY(nsIStatefulFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsBoxFrame)

 //-------------------- Helper ----------------------

 #define SMOOTH_SCROLL_PREF_NAME "general.smoothScroll"

 const double kCurrentVelocityWeighting = 0.25;

 const double kStopDecelerationWeighting = 0.4;

 // AsyncScroll has ref counting.

 class ScrollFrameHelper::AsyncScroll MOZ_FINAL : public nsARefreshObserver {

 public:

   typedef mozilla::TimeStamp TimeStamp;

   typedef mozilla::TimeDuration TimeDuration;

   AsyncScroll(nsPoint aStartPos)

     : mIsFirstIteration(true)

     , mStartPos(aStartPos)

     , mCallee(nullptr)

   {}

 private:

   // Private destructor, to discourage deletion outside of Release():

   ~AsyncScroll() {

     RemoveObserver();

   }

 public:

   nsPoint PositionAt(TimeStamp aTime);

   nsSize VelocityAt(TimeStamp aTime); // In nscoords per second

   void InitSmoothScroll(TimeStamp aTime, nsPoint aDestination,

                         nsIAtom *aOrigin, const nsRect& aRange);

   void Init(const nsRect& aRange) {

     mRange = aRange;

   }

   bool IsFinished(TimeStamp aTime) {

     return aTime > mStartTime + mDuration; // XXX or if we've hit the wall

   }

   TimeStamp mStartTime;

   // mPrevEventTime holds previous 3 timestamps for intervals averaging (to

   // reduce duration fluctuations). When AsyncScroll is constructed and no

   // previous timestamps are available (indicated with mIsFirstIteration),

   // initialize mPrevEventTime using imaginary previous timestamps with maximum

   // relevant intervals between them.

   TimeStamp mPrevEventTime[3];

   bool mIsFirstIteration;

   // Cached Preferences values to avoid re-reading them when extending an existing

   // animation for the same event origin (can be as frequent as every 10(!)ms for

   // a quick roll of the mouse wheel).

   // These values are minimum and maximum animation duration per event origin,

   // and a global ratio which defines how longer is the animation's duration

   // compared to the average recent events intervals (such that for a relatively

   // consistent events rate, the next event arrives before current animation ends)

   nsCOMPtr<nsIAtom> mOrigin;

   int32_t mOriginMinMS;

   int32_t mOriginMaxMS;

   double  mIntervalRatio;

   TimeDuration mDuration;

   nsPoint mStartPos;

   nsPoint mDestination;

   // Allowed destination positions around mDestination

   nsRect mRange;

   nsSMILKeySpline mTimingFunctionX;

   nsSMILKeySpline mTimingFunctionY;

   bool mIsSmoothScroll;

 protected:

   double ProgressAt(TimeStamp aTime) {

     return clamped((aTime - mStartTime) / mDuration, 0.0, 1.0);

   }

   nscoord VelocityComponent(double aTimeProgress,

                             nsSMILKeySpline& aTimingFunction,

                             nscoord aStart, nscoord aDestination);

   // Initializes the timing function in such a way that the current velocity is

   // preserved.

   void InitTimingFunction(nsSMILKeySpline& aTimingFunction,

                           nscoord aCurrentPos, nscoord aCurrentVelocity,

                           nscoord aDestination);

   TimeDuration CalcDurationForEventTime(TimeStamp aTime, nsIAtom *aOrigin);

 // The next section is observer/callback management

 // Bodies of WillRefresh and RefreshDriver contain ScrollFrameHelper specific code.

 public:

   NS_INLINE_DECL_REFCOUNTING(AsyncScroll)

   /*

    * Set a refresh observer for smooth scroll iterations (and start observing).

    * Should be used at most once during the lifetime of this object.

    * Return value: true on success, false otherwise.

    */

   bool SetRefreshObserver(ScrollFrameHelper *aCallee) {

     NS_ASSERTION(aCallee && !mCallee, "AsyncScroll::SetRefreshObserver - Invalid usage.");

     if (!RefreshDriver(aCallee)->AddRefreshObserver(this, Flush_Style)) {

       return false;

     }

     mCallee = aCallee;

     return true;

   }

   virtual void WillRefresh(mozilla::TimeStamp aTime) MOZ_OVERRIDE {

     // The callback may release "this".

     // We don't access members after returning, so no need for KungFuDeathGrip.

     ScrollFrameHelper::AsyncScrollCallback(mCallee, aTime);

   }

 private:

   ScrollFrameHelper *mCallee;

   nsRefreshDriver* RefreshDriver(ScrollFrameHelper* aCallee) {

     return aCallee->mOuter->PresContext()->RefreshDriver();

   }

   /*

    * The refresh driver doesn't hold a reference to its observers,

    *   so releasing this object can (and is) used to remove the observer on DTOR.

    * Currently, this object is released once the scrolling ends.

    */

   void RemoveObserver() {

     if (mCallee) {

       RefreshDriver(mCallee)->RemoveRefreshObserver(this, Flush_Style);

     }

   }

 };

 nsPoint

 ScrollFrameHelper::AsyncScroll::PositionAt(TimeStamp aTime) {

   double progressX = mTimingFunctionX.GetSplineValue(ProgressAt(aTime));

   double progressY = mTimingFunctionY.GetSplineValue(ProgressAt(aTime));

   return nsPoint(NSToCoordRound((1 - progressX) * mStartPos.x + progressX * mDestination.x),

                  NSToCoordRound((1 - progressY) * mStartPos.y + progressY * mDestination.y));

 }

 nsSize

 ScrollFrameHelper::AsyncScroll::VelocityAt(TimeStamp aTime) {

   double timeProgress = ProgressAt(aTime);

   return nsSize(VelocityComponent(timeProgress, mTimingFunctionX,

                                   mStartPos.x, mDestination.x),

                 VelocityComponent(timeProgress, mTimingFunctionY,

                                   mStartPos.y, mDestination.y));

 }

 /*

  * Calculate duration, possibly dynamically according to events rate and event origin.

  * (also maintain previous timestamps - which are only used here).

  */

 TimeDuration

 ScrollFrameHelper::

 AsyncScroll::CalcDurationForEventTime(TimeStamp aTime, nsIAtom *aOrigin) {

   if (!aOrigin){

     aOrigin = nsGkAtoms::other;

   }

   // Read preferences only on first iteration or for a different event origin.

   if (mIsFirstIteration || aOrigin != mOrigin) {

     mOrigin = aOrigin;

     mOriginMinMS = mOriginMaxMS = 0;

     bool isOriginSmoothnessEnabled = false;

     mIntervalRatio = 1;

     // Default values for all preferences are defined in all.js

     static const int32_t kDefaultMinMS = 150, kDefaultMaxMS = 150;

     static const bool kDefaultIsSmoothEnabled = true;

     nsAutoCString originName;

     aOrigin->ToUTF8String(originName);

     nsAutoCString prefBase = NS_LITERAL_CSTRING("general.smoothScroll.") + originName;

     isOriginSmoothnessEnabled = Preferences::GetBool(prefBase.get(), kDefaultIsSmoothEnabled);

     if (isOriginSmoothnessEnabled) {

       nsAutoCString prefMin = prefBase + NS_LITERAL_CSTRING(".durationMinMS");

       nsAutoCString prefMax = prefBase + NS_LITERAL_CSTRING(".durationMaxMS");

       mOriginMinMS = Preferences::GetInt(prefMin.get(), kDefaultMinMS);

       mOriginMaxMS = Preferences::GetInt(prefMax.get(), kDefaultMaxMS);

       static const int32_t kSmoothScrollMaxAllowedAnimationDurationMS = 10000;

       mOriginMaxMS = clamped(mOriginMaxMS, 0, kSmoothScrollMaxAllowedAnimationDurationMS);

       mOriginMinMS = clamped(mOriginMinMS, 0, mOriginMaxMS);

     }

     // Keep the animation duration longer than the average event intervals

     //   (to "connect" consecutive scroll animations before the scroll comes to a stop).

     static const double kDefaultDurationToIntervalRatio = 2; // Duplicated at all.js

     mIntervalRatio = Preferences::GetInt("general.smoothScroll.durationToIntervalRatio",

                                          kDefaultDurationToIntervalRatio * 100) / 100.0;

     // Duration should be at least as long as the intervals -> ratio is at least 1

     mIntervalRatio = std::max(1.0, mIntervalRatio);

     if (mIsFirstIteration) {

       // Starting a new scroll (i.e. not when extending an existing scroll animation),

       //   create imaginary prev timestamps with maximum relevant intervals between them.

       // Longest relevant interval (which results in maximum duration)

       TimeDuration maxDelta = TimeDuration::FromMilliseconds(mOriginMaxMS / mIntervalRatio);

       mPrevEventTime[0] = aTime              - maxDelta;

       mPrevEventTime[1] = mPrevEventTime[0]  - maxDelta;

       mPrevEventTime[2] = mPrevEventTime[1]  - maxDelta;

     }

   }

   // Average last 3 delta durations (rounding errors up to 2ms are negligible for us)

   int32_t eventsDeltaMs = (aTime - mPrevEventTime[2]).ToMilliseconds() / 3;

   mPrevEventTime[2] = mPrevEventTime[1];

   mPrevEventTime[1] = mPrevEventTime[0];

   mPrevEventTime[0] = aTime;

   // Modulate duration according to events rate (quicker events -> shorter durations).

   // The desired effect is to use longer duration when scrolling slowly, such that

   // it's easier to follow, but reduce the duration to make it feel more snappy when

   // scrolling quickly. To reduce fluctuations of the duration, we average event

   // intervals using the recent 4 timestamps (now + three prev -> 3 intervals).

   int32_t durationMS = clamped<int32_t>(eventsDeltaMs * mIntervalRatio, mOriginMinMS, mOriginMaxMS);

   return TimeDuration::FromMilliseconds(durationMS);

 }

 void

 ScrollFrameHelper::AsyncScroll::InitSmoothScroll(TimeStamp aTime,

                                                      nsPoint aDestination,

                                                      nsIAtom *aOrigin,

                                                      const nsRect& aRange) {

   mRange = aRange;

   TimeDuration duration = CalcDurationForEventTime(aTime, aOrigin);

   nsSize currentVelocity(0, 0);

   if (!mIsFirstIteration) {

     // If an additional event has not changed the destination, then do not let

     // another minimum duration reset slow things down.  If it would then

     // instead continue with the existing timing function.

     if (aDestination == mDestination &&

         aTime + duration > mStartTime + mDuration)

       return;

     currentVelocity = VelocityAt(aTime);

     mStartPos = PositionAt(aTime);

   }

   mStartTime = aTime;

   mDuration = duration;

   mDestination = aDestination;

   InitTimingFunction(mTimingFunctionX, mStartPos.x, currentVelocity.width,

                      aDestination.x);

   InitTimingFunction(mTimingFunctionY, mStartPos.y, currentVelocity.height,

                      aDestination.y);

   mIsFirstIteration = false;

 }

 nscoord

 ScrollFrameHelper::AsyncScroll::VelocityComponent(double aTimeProgress,

                                                       nsSMILKeySpline& aTimingFunction,

                                                       nscoord aStart,

                                                       nscoord aDestination)

 {

   double dt, dxy;

   aTimingFunction.GetSplineDerivativeValues(aTimeProgress, dt, dxy);

   if (dt == 0)

     return dxy >= 0 ? nscoord_MAX : nscoord_MIN;

   const TimeDuration oneSecond = TimeDuration::FromSeconds(1);

   double slope = dxy / dt;

   return NSToCoordRound(slope * (aDestination - aStart) / (mDuration / oneSecond));

 }

 void

 ScrollFrameHelper::AsyncScroll::InitTimingFunction(nsSMILKeySpline& aTimingFunction,

                                                        nscoord aCurrentPos,

                                                        nscoord aCurrentVelocity,

                                                        nscoord aDestination)

 {

   if (aDestination == aCurrentPos || kCurrentVelocityWeighting == 0) {

     aTimingFunction.Init(0, 0, 1 - kStopDecelerationWeighting, 1);

     return;

   }

   const TimeDuration oneSecond = TimeDuration::FromSeconds(1);

   double slope = aCurrentVelocity * (mDuration / oneSecond) / (aDestination - aCurrentPos);

   double normalization = sqrt(1.0 + slope * slope);

   double dt = 1.0 / normalization * kCurrentVelocityWeighting;

   double dxy = slope / normalization * kCurrentVelocityWeighting;

   aTimingFunction.Init(dt, dxy, 1 - kStopDecelerationWeighting, 1);

 }

 static bool

 IsSmoothScrollingEnabled()

 {

   return Preferences::GetBool(SMOOTH_SCROLL_PREF_NAME, false);

 }

 class ScrollFrameActivityTracker MOZ_FINAL : public nsExpirationTracker<ScrollFrameHelper,4> {

 public:

   // Wait for 3-4s between scrolls before we remove our layers.

   // That's 4 generations of 1s each.

   enum { TIMEOUT_MS = 1000 };

   ScrollFrameActivityTracker()

     : nsExpirationTracker<ScrollFrameHelper,4>(TIMEOUT_MS) {}

   ~ScrollFrameActivityTracker() {

     AgeAllGenerations();

   }

   virtual void NotifyExpired(ScrollFrameHelper *aObject) {

     RemoveObject(aObject);

     aObject->MarkInactive();

   }

 };

 static ScrollFrameActivityTracker *gScrollFrameActivityTracker = nullptr;

 // There are situations when a scroll frame is destroyed and then re-created

 // for the same content element. In this case we want to increment the scroll

 // generation between the old and new scrollframes. If the new one knew about

 // the old one then it could steal the old generation counter and increment it

 // but it doesn't have that reference so instead we use a static global to

 // ensure the new one gets a fresh value.

 static uint32_t sScrollGenerationCounter = 0;

 ScrollFrameHelper::ScrollFrameHelper(nsContainerFrame* aOuter,

                                              bool aIsRoot)

   : mHScrollbarBox(nullptr)

   , mVScrollbarBox(nullptr)

   , mScrolledFrame(nullptr)

   , mScrollCornerBox(nullptr)

   , mResizerBox(nullptr)

   , mOuter(aOuter)

   , mAsyncScroll(nullptr)

   , mOriginOfLastScroll(nsGkAtoms::other)

   , mScrollGeneration(++sScrollGenerationCounter)

   , mDestination(0, 0)

   , mScrollPosAtLastPaint(0, 0)

   , mRestorePos(-1, -1)

   , mLastPos(-1, -1)

   , mResolution(1.0, 1.0)

   , mScrollPosForLayerPixelAlignment(-1, -1)

   , mLastUpdateImagesPos(-1, -1)

   , mNeverHasVerticalScrollbar(false)

   , mNeverHasHorizontalScrollbar(false)

   , mHasVerticalScrollbar(false)

   , mHasHorizontalScrollbar(false)

   , mFrameIsUpdatingScrollbar(false)

   , mDidHistoryRestore(false)

   , mIsRoot(aIsRoot)

   , mClipAllDescendants(aIsRoot)

   , mSupppressScrollbarUpdate(false)

   , mSkippedScrollbarLayout(false)

   , mHadNonInitialReflow(false)

   , mHorizontalOverflow(false)

   , mVerticalOverflow(false)

   , mPostedReflowCallback(false)

   , mMayHaveDirtyFixedChildren(false)

   , mUpdateScrollbarAttributes(false)

   , mCollapsedResizer(false)

   , mShouldBuildScrollableLayer(false)

   , mHasBeenScrolled(false)

   , mIsResolutionSet(false)

 {

   mScrollingActive = IsAlwaysActive();

   if (LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0) {

     mScrollbarActivity = new ScrollbarActivity(do_QueryFrame(aOuter));

   }

   EnsureImageVisPrefsCached();

 }

 ScrollFrameHelper::~ScrollFrameHelper()

 {

   if (mActivityExpirationState.IsTracked()) {

     gScrollFrameActivityTracker->RemoveObject(this);

   }

   if (gScrollFrameActivityTracker &&

       gScrollFrameActivityTracker->IsEmpty()) {

     delete gScrollFrameActivityTracker;

     gScrollFrameActivityTracker = nullptr;

   }

   if (mScrollActivityTimer) {

     mScrollActivityTimer->Cancel();

     mScrollActivityTimer = nullptr;

   }

 }

 /*

  * Callback function from AsyncScroll, used in ScrollFrameHelper::ScrollTo

  */

 void

 ScrollFrameHelper::AsyncScrollCallback(void* anInstance, mozilla::TimeStamp aTime)

 {

   ScrollFrameHelper* self = static_cast<ScrollFrameHelper*>(anInstance);

   if (!self || !self->mAsyncScroll)

     return;

   nsRect range = self->mAsyncScroll->mRange;

   if (self->mAsyncScroll->mIsSmoothScroll) {

     if (!self->mAsyncScroll->IsFinished(aTime)) {

       nsPoint destination = self->mAsyncScroll->PositionAt(aTime);

       // Allow this scroll operation to land on any pixel boundary between the

       // current position and the final allowed range.  (We don't want

       // intermediate steps to be more constrained than the final step!)

       nsRect intermediateRange =

         nsRect(self->GetScrollPosition(), nsSize()).UnionEdges(range);

       self->ScrollToImpl(destination, intermediateRange);

       // 'self' might be destroyed here

       return;

     }

   }

   // Apply desired destination range since this is the last step of scrolling.

   self->mAsyncScroll = nullptr;

   nsWeakFrame weakFrame(self->mOuter);

   self->ScrollToImpl(self->mDestination, range);

   if (!weakFrame.IsAlive()) {

     return;

   }

   // We are done scrolling, set our destination to wherever we actually ended

   // up scrolling to.

   self->mDestination = self->GetScrollPosition();

 }

 void

 ScrollFrameHelper::ScrollToCSSPixels(const CSSIntPoint& aScrollPosition)

 {

   nsPoint current = GetScrollPosition();

   CSSIntPoint currentCSSPixels = GetScrollPositionCSSPixels();

   nsPoint pt = CSSPoint::ToAppUnits(aScrollPosition);

   nscoord halfPixel = nsPresContext::CSSPixelsToAppUnits(0.5f);

   nsRect range(pt.x - halfPixel, pt.y - halfPixel, 2*halfPixel - 1, 2*halfPixel - 1);

   // XXX I don't think the following blocks are needed anymore, now that

   // ScrollToImpl simply tries to scroll an integer number of layer

   // pixels from the current position

   if (currentCSSPixels.x == aScrollPosition.x) {

     pt.x = current.x;

     range.x = pt.x;

     range.width = 0;

   }

   if (currentCSSPixels.y == aScrollPosition.y) {

     pt.y = current.y;

     range.y = pt.y;

     range.height = 0;

   }

   ScrollTo(pt, nsIScrollableFrame::INSTANT, &range);

   // 'this' might be destroyed here

 }

 void

 ScrollFrameHelper::ScrollToCSSPixelsApproximate(const CSSPoint& aScrollPosition,

                                                 nsIAtom *aOrigin)

 {

   nsPoint pt = CSSPoint::ToAppUnits(aScrollPosition);

   nscoord halfRange = nsPresContext::CSSPixelsToAppUnits(1000);

   nsRect range(pt.x - halfRange, pt.y - halfRange, 2*halfRange - 1, 2*halfRange - 1);

   ScrollToWithOrigin(pt, nsIScrollableFrame::INSTANT, aOrigin, &range);

   // 'this' might be destroyed here

 }

 CSSIntPoint

 ScrollFrameHelper::GetScrollPositionCSSPixels()

 {

   return CSSIntPoint::FromAppUnitsRounded(GetScrollPosition());

 }

 /*

  * this method wraps calls to ScrollToImpl(), either in one shot or incrementally,

  *  based on the setting of the smoothness scroll pref

  */

 void

 ScrollFrameHelper::ScrollToWithOrigin(nsPoint aScrollPosition,

                                           nsIScrollableFrame::ScrollMode aMode,

                                           nsIAtom *aOrigin,

                                           const nsRect* aRange)

 {

   nsRect scrollRange = GetScrollRangeForClamping();

   mDestination = scrollRange.ClampPoint(aScrollPosition);

   nsRect range = aRange ? *aRange : nsRect(aScrollPosition, nsSize(0, 0));

   if (aMode == nsIScrollableFrame::INSTANT) {

     // Asynchronous scrolling is not allowed, so we'll kill any existing

     // async-scrolling process and do an instant scroll.

     mAsyncScroll = nullptr;

     nsWeakFrame weakFrame(mOuter);

     ScrollToImpl(mDestination, range, aOrigin);

     if (!weakFrame.IsAlive()) {

       return;

     }

     // We are done scrolling, set our destination to wherever we actually ended

     // up scrolling to.

     mDestination = GetScrollPosition();

     return;

   }

   TimeStamp now = TimeStamp::Now();

   bool isSmoothScroll = (aMode == nsIScrollableFrame::SMOOTH) &&

                           IsSmoothScrollingEnabled();

   if (!mAsyncScroll) {

     mAsyncScroll = new AsyncScroll(GetScrollPosition());

     if (!mAsyncScroll->SetRefreshObserver(this)) {

       mAsyncScroll = nullptr;

       // Observer setup failed. Scroll the normal way.

       nsWeakFrame weakFrame(mOuter);

       ScrollToImpl(mDestination, range, aOrigin);

       if (!weakFrame.IsAlive()) {

         return;

       }

       // We are done scrolling, set our destination to wherever we actually

       // ended up scrolling to.

       mDestination = GetScrollPosition();

       return;

     }

   }

   mAsyncScroll->mIsSmoothScroll = isSmoothScroll;

   if (isSmoothScroll) {

     mAsyncScroll->InitSmoothScroll(now, mDestination, aOrigin, range);

   } else {

     mAsyncScroll->Init(range);

   }

 }

 // We can't use nsContainerFrame::PositionChildViews here because

 // we don't want to invalidate views that have moved.

 static void AdjustViews(nsIFrame* aFrame)

 {

   nsView* view = aFrame->GetView();

   if (view) {

     nsPoint pt;

     aFrame->GetParent()->GetClosestView(&pt);

     pt += aFrame->GetPosition();

     view->SetPosition(pt.x, pt.y);

     return;

   }

   if (!(aFrame->GetStateBits() & NS_FRAME_HAS_CHILD_WITH_VIEW)) {

     return;

   }

   // Call AdjustViews recursively for all child frames except the popup list as

   // the views for popups are not scrolled.

   nsIFrame::ChildListIterator lists(aFrame);

   for (; !lists.IsDone(); lists.Next()) {

     if (lists.CurrentID() == nsIFrame::kPopupList) {

       continue;

     }

     nsFrameList::Enumerator childFrames(lists.CurrentList());

     for (; !childFrames.AtEnd(); childFrames.Next()) {

       AdjustViews(childFrames.get());

     }

   }

 }

 static bool

 CanScrollWithBlitting(nsIFrame* aFrame)

 {

   if (aFrame->GetStateBits() & NS_SCROLLFRAME_INVALIDATE_CONTENTS_ON_SCROLL)

     return false;

   for (nsIFrame* f = aFrame; f;

        f = nsLayoutUtils::GetCrossDocParentFrame(f)) {

     if (nsSVGIntegrationUtils::UsingEffectsForFrame(f) ||

         f->IsFrameOfType(nsIFrame::eSVG) ||

         f->GetStateBits() & NS_FRAME_NO_COMPONENT_ALPHA) {

       return false;

     }

     if (nsLayoutUtils::IsPopup(f))

       break;

   }

   return true;

 }

 bool ScrollFrameHelper::IsIgnoringViewportClipping() const

 {

   if (!mIsRoot)

     return false;

   nsSubDocumentFrame* subdocFrame = static_cast<nsSubDocumentFrame*>

     (nsLayoutUtils::GetCrossDocParentFrame(mOuter->PresContext()->PresShell()->GetRootFrame()));

   return subdocFrame && !subdocFrame->ShouldClipSubdocument();

 }

 bool ScrollFrameHelper::ShouldClampScrollPosition() const

 {

   if (!mIsRoot)

     return true;

   nsSubDocumentFrame* subdocFrame = static_cast<nsSubDocumentFrame*>

     (nsLayoutUtils::GetCrossDocParentFrame(mOuter->PresContext()->PresShell()->GetRootFrame()));

   return !subdocFrame || subdocFrame->ShouldClampScrollPosition();

 }

 bool ScrollFrameHelper::IsAlwaysActive() const

 {

   if (nsDisplayItem::ForceActiveLayers()) {

     return true;

   }

   const nsStyleDisplay* disp = mOuter->StyleDisplay();

   if (disp && (disp->mWillChangeBitField & NS_STYLE_WILL_CHANGE_SCROLL)) {

     return true;

   }

   // Unless this is the root scrollframe for a non-chrome document

   // which is the direct child of a chrome document, we default to not

   // being "active".

   if (!(mIsRoot && mOuter->PresContext()->IsRootContentDocument())) {

      return false;

   }

   // If we have scrolled before, then we should stay active.

   if (mHasBeenScrolled) {

     return true;

   }

   // If we're overflow:hidden, then start as inactive until

   // we get scrolled manually.

   ScrollbarStyles styles = GetScrollbarStylesFromFrame();

   return (styles.mHorizontal != NS_STYLE_OVERFLOW_HIDDEN &&

           styles.mVertical != NS_STYLE_OVERFLOW_HIDDEN);

 }

 void ScrollFrameHelper::MarkInactive()

 {

   if (IsAlwaysActive() || !mScrollingActive)

     return;

   mScrollingActive = false;

   mOuter->InvalidateFrameSubtree();

 }

 void ScrollFrameHelper::MarkActive()

 {

   mScrollingActive = true;

   if (IsAlwaysActive())

     return;

   if (mActivityExpirationState.IsTracked()) {

     gScrollFrameActivityTracker->MarkUsed(this);

   } else {

     if (!gScrollFrameActivityTracker) {

       gScrollFrameActivityTracker = new ScrollFrameActivityTracker();

     }

     gScrollFrameActivityTracker->AddObject(this);

   }

 }

 void ScrollFrameHelper::ScrollVisual(nsPoint aOldScrolledFramePos)

 {

   // Mark this frame as having been scrolled. If this is the root

   // scroll frame of a content document, then IsAlwaysActive()

   // will return true from now on and MarkInactive() won't

   // have any effect.

   mHasBeenScrolled = true;

   AdjustViews(mScrolledFrame);

   // We need to call this after fixing up the view positions

   // to be consistent with the frame hierarchy.

   bool canScrollWithBlitting = CanScrollWithBlitting(mOuter);

   mOuter->RemoveStateBits(NS_SCROLLFRAME_INVALIDATE_CONTENTS_ON_SCROLL);

   if (IsScrollingActive()) {

     if (!canScrollWithBlitting) {

       MarkInactive();

     }

   }

   if (canScrollWithBlitting) {

     MarkActive();

   }

   mOuter->SchedulePaint();

 }

 /**

  * Clamp desired scroll position aDesired and range [aDestLower, aDestUpper]

  * to [aBoundLower, aBoundUpper] and then select the appunit value from among

  * aBoundLower, aBoundUpper and those such that (aDesired - aCurrent) *

  * aRes/aAppUnitsPerPixel is an integer (or as close as we can get

  * modulo rounding to appunits) that is in [aDestLower, aDestUpper] and

  * closest to aDesired.  If no such value exists, return the nearest in

  * [aDestLower, aDestUpper].

  */

 static nscoord

 ClampAndAlignWithPixels(nscoord aDesired,

                         nscoord aBoundLower, nscoord aBoundUpper,

                         nscoord aDestLower, nscoord aDestUpper,

                         nscoord aAppUnitsPerPixel, double aRes,

                         nscoord aCurrent)

 {

   // Intersect scroll range with allowed range, by clamping the ends

   // of aRange to be within bounds

   nscoord destLower = clamped(aDestLower, aBoundLower, aBoundUpper);

   nscoord destUpper = clamped(aDestUpper, aBoundLower, aBoundUpper);

   nscoord desired = clamped(aDesired, destLower, destUpper);

   double currentLayerVal = (aRes*aCurrent)/aAppUnitsPerPixel;

   double desiredLayerVal = (aRes*desired)/aAppUnitsPerPixel;

   double delta = desiredLayerVal - currentLayerVal;

   double nearestLayerVal = NS_round(delta) + currentLayerVal;

   // Convert back from ThebesLayer space to appunits relative to the top-left

   // of the scrolled frame.

   nscoord aligned =

     NSToCoordRoundWithClamp(nearestLayerVal*aAppUnitsPerPixel/aRes);

   // Use a bound if it is within the allowed range and closer to desired than

   // the nearest pixel-aligned value.

   if (aBoundUpper == destUpper &&

       static_cast<decltype(Abs(desired))>(aBoundUpper - desired) <

       Abs(desired - aligned))

     return aBoundUpper;

   if (aBoundLower == destLower &&

       static_cast<decltype(Abs(desired))>(desired - aBoundLower) <

       Abs(aligned - desired))

     return aBoundLower;

   // Accept the nearest pixel-aligned value if it is within the allowed range. 

   if (aligned >= destLower && aligned <= destUpper)

     return aligned;

   // Check if opposite pixel boundary fits into allowed range.

   double oppositeLayerVal =

     nearestLayerVal + ((nearestLayerVal < desiredLayerVal) ? 1.0 : -1.0);

   nscoord opposite =

     NSToCoordRoundWithClamp(oppositeLayerVal*aAppUnitsPerPixel/aRes);

   if (opposite >= destLower && opposite <= destUpper) {

     return opposite;

   }

   // No alignment available.

   return desired;

 }

 /**

  * Clamp desired scroll position aPt to aBounds and then snap

  * it to the same layer pixel edges as aCurrent, keeping it within aRange

  * during snapping. aCurrent is the current scroll position.

  */

 static nsPoint

 ClampAndAlignWithLayerPixels(const nsPoint& aPt,

                              const nsRect& aBounds,

                              const nsRect& aRange,

                              const nsPoint& aCurrent,

                              nscoord aAppUnitsPerPixel,

                              const gfxSize& aScale)

 {

   return nsPoint(ClampAndAlignWithPixels(aPt.x, aBounds.x, aBounds.XMost(),

                                          aRange.x, aRange.XMost(),

                                          aAppUnitsPerPixel, aScale.width,

                                          aCurrent.x),

                  ClampAndAlignWithPixels(aPt.y, aBounds.y, aBounds.YMost(),

                                          aRange.y, aRange.YMost(),

                                          aAppUnitsPerPixel, aScale.height,

                                          aCurrent.y));

 }

 /* static */ void

 ScrollFrameHelper::ScrollActivityCallback(nsITimer *aTimer, void* anInstance)

 {

   ScrollFrameHelper* self = static_cast<ScrollFrameHelper*>(anInstance);

   // Fire the synth mouse move.

   self->mScrollActivityTimer->Cancel();

   self->mScrollActivityTimer = nullptr;

   self->mOuter->PresContext()->PresShell()->SynthesizeMouseMove(true);

 }

 void

 ScrollFrameHelper::ScheduleSyntheticMouseMove()

 {

   if (!mScrollActivityTimer) {

     mScrollActivityTimer = do_CreateInstance("@mozilla.org/timer;1");

     if (!mScrollActivityTimer)

       return;

   }

   mScrollActivityTimer->InitWithFuncCallback(

         ScrollActivityCallback, this, 100, nsITimer::TYPE_ONE_SHOT);

 }

 void

 ScrollFrameHelper::ScrollToImpl(nsPoint aPt, const nsRect& aRange, nsIAtom* aOrigin)

 {

   if (aOrigin == nullptr) {

     // If no origin was specified, we still want to set it to something that's

     // non-null, so that we can use nullness to distinguish if the frame was scrolled

     // at all. Default it to some generic placeholder.

     aOrigin = nsGkAtoms::other;

   }

   nsPresContext* presContext = mOuter->PresContext();

   nscoord appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();

   // 'scale' is our estimate of the scale factor that will be applied

   // when rendering the scrolled content to its own ThebesLayer.

   gfxSize scale = FrameLayerBuilder::GetThebesLayerScaleForFrame(mScrolledFrame);

   nsPoint curPos = GetScrollPosition();

   nsPoint alignWithPos = mScrollPosForLayerPixelAlignment == nsPoint(-1,-1)

       ? curPos : mScrollPosForLayerPixelAlignment;

   // Try to align aPt with curPos so they have an integer number of layer

   // pixels between them. This gives us the best chance of scrolling without

   // having to invalidate due to changes in subpixel rendering.

   // Note that when we actually draw into a ThebesLayer, the coordinates

   // that get mapped onto the layer buffer pixels are from the display list,

   // which are relative to the display root frame's top-left increasing down,

   // whereas here our coordinates are scroll positions which increase upward

   // and are relative to the scrollport top-left. This difference doesn't actually

   // matter since all we are about is that there be an integer number of

   // layer pixels between pt and curPos.

   nsPoint pt =

     ClampAndAlignWithLayerPixels(aPt,

                                  GetScrollRangeForClamping(),

                                  aRange,

                                  alignWithPos,

                                  appUnitsPerDevPixel,

                                  scale);

   if (pt == curPos) {

     return;

   }

   bool needImageVisibilityUpdate = (mLastUpdateImagesPos == nsPoint(-1,-1));

   nsPoint dist(std::abs(pt.x - mLastUpdateImagesPos.x),

                std::abs(pt.y - mLastUpdateImagesPos.y));

   nsSize scrollPortSize = GetScrollPositionClampingScrollPortSize();

   nscoord horzAllowance = std::max(scrollPortSize.width / std::max(sHorzScrollFraction, 1),

                                    nsPresContext::AppUnitsPerCSSPixel());

   nscoord vertAllowance = std::max(scrollPortSize.height / std::max(sVertScrollFraction, 1),

                                    nsPresContext::AppUnitsPerCSSPixel());

   if (dist.x >= horzAllowance || dist.y >= vertAllowance) {

     needImageVisibilityUpdate = true;

   }

   if (needImageVisibilityUpdate) {

     presContext->PresShell()->ScheduleImageVisibilityUpdate();

   }

   // notify the listeners.

   for (uint32_t i = 0; i < mListeners.Length(); i++) {

     mListeners[i]->ScrollPositionWillChange(pt.x, pt.y);

   }

   nsPoint oldScrollFramePos = mScrolledFrame->GetPosition();

   // Update frame position for scrolling

   mScrolledFrame->SetPosition(mScrollPort.TopLeft() - pt);

   mOriginOfLastScroll = aOrigin;

   mScrollGeneration = ++sScrollGenerationCounter;

   // We pass in the amount to move visually

   ScrollVisual(oldScrollFramePos);

   ScheduleSyntheticMouseMove();

   nsWeakFrame weakFrame(mOuter);

   UpdateScrollbarPosition();

   if (!weakFrame.IsAlive()) {

     return;

   }

   PostScrollEvent();

   // notify the listeners.

   for (uint32_t i = 0; i < mListeners.Length(); i++) {

     mListeners[i]->ScrollPositionDidChange(pt.x, pt.y);

   }

   nsCOMPtr<nsIDocShell> docShell = presContext->GetDocShell();

   if (docShell) {

     docShell->NotifyScrollObservers();

   }

 }

 static int32_t

 MaxZIndexInList(nsDisplayList* aList, nsDisplayListBuilder* aBuilder)

 {

   int32_t maxZIndex = 0;

   for (nsDisplayItem* item = aList->GetBottom(); item; item = item->GetAbove()) {

     maxZIndex = std::max(maxZIndex, item->ZIndex());

   }

   return maxZIndex;

 }

 static void

 AppendToTop(nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists,

             nsDisplayList* aSource, nsIFrame* aSourceFrame, bool aOwnLayer,

             uint32_t aFlags, mozilla::layers::FrameMetrics::ViewID aScrollTargetId,

             bool aPositioned)

 {

   if (aSource->IsEmpty())

     return;

   nsDisplayWrapList* newItem = aOwnLayer?

     new (aBuilder) nsDisplayOwnLayer(aBuilder, aSourceFrame, aSource,

                                      aFlags, aScrollTargetId) :

     new (aBuilder) nsDisplayWrapList(aBuilder, aSourceFrame, aSource);

   if (aPositioned) {

     // We want overlay scrollbars to always be on top of the scrolled content,

     // but we don't want them to unnecessarily cover overlapping elements from

     // outside our scroll frame.

     nsDisplayList* positionedDescendants = aLists.PositionedDescendants();

     if (!positionedDescendants->IsEmpty()) {

       newItem->SetOverrideZIndex(MaxZIndexInList(positionedDescendants, aBuilder));

       positionedDescendants->AppendNewToTop(newItem);

     } else {

       aLists.Outlines()->AppendNewToTop(newItem);

     }

   } else {

     aLists.BorderBackground()->AppendNewToTop(newItem);

   }

 }

 struct HoveredStateComparator

 {

   bool Equals(nsIFrame* A, nsIFrame* B) const {

     bool aHovered = A->GetContent()->HasAttr(kNameSpaceID_None,

                                              nsGkAtoms::hover);

     bool bHovered = B->GetContent()->HasAttr(kNameSpaceID_None,

                                              nsGkAtoms::hover);

     return aHovered == bHovered;

   }

   bool LessThan(nsIFrame* A, nsIFrame* B) const {

     bool aHovered = A->GetContent()->HasAttr(kNameSpaceID_None,

                                              nsGkAtoms::hover);

     bool bHovered = B->GetContent()->HasAttr(kNameSpaceID_None,

                                              nsGkAtoms::hover);

     return !aHovered && bHovered;

   }

 };

 void

 ScrollFrameHelper::AppendScrollPartsTo(nsDisplayListBuilder*   aBuilder,

                                            const nsRect&           aDirtyRect,

                                            const nsDisplayListSet& aLists,

                                            bool&                   aCreateLayer,

                                            bool                    aPositioned)

 {

   nsITheme* theme = mOuter->PresContext()->GetTheme();

   if (theme &&

       theme->ShouldHideScrollbars()) {

     return;

   }

   bool overlayScrollbars =

     LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars) != 0;

   nsAutoTArray<nsIFrame*, 3> scrollParts;

   for (nsIFrame* kid = mOuter->GetFirstPrincipalChild(); kid; kid = kid->GetNextSibling()) {

     if (kid == mScrolledFrame ||

         (kid->IsPositioned() || overlayScrollbars) != aPositioned)

       continue;

     scrollParts.AppendElement(kid);

   }

   mozilla::layers::FrameMetrics::ViewID scrollTargetId = aCreateLayer

     ? nsLayoutUtils::FindOrCreateIDFor(mScrolledFrame->GetContent())

     : mozilla::layers::FrameMetrics::NULL_SCROLL_ID;

   scrollParts.Sort(HoveredStateComparator());

   for (uint32_t i = 0; i < scrollParts.Length(); ++i) {

     nsDisplayListCollection partList;

     mOuter->BuildDisplayListForChild(

       aBuilder, scrollParts[i], aDirtyRect, partList,

       nsIFrame::DISPLAY_CHILD_FORCE_STACKING_CONTEXT);

     uint32_t flags = 0;

     if (scrollParts[i] == mVScrollbarBox) {

       flags |= nsDisplayOwnLayer::VERTICAL_SCROLLBAR;

     }

     if (scrollParts[i] == mHScrollbarBox) {

       flags |= nsDisplayOwnLayer::HORIZONTAL_SCROLLBAR;

     }

     // DISPLAY_CHILD_FORCE_STACKING_CONTEXT put everything into

     // partList.PositionedDescendants().

     ::AppendToTop(aBuilder, aLists,

                   partList.PositionedDescendants(), scrollParts[i],

                   aCreateLayer, flags, scrollTargetId, aPositioned);

   }

 }

 class ScrollLayerWrapper : public nsDisplayWrapper

 {

 public:

   ScrollLayerWrapper(nsIFrame* aScrollFrame, nsIFrame* aScrolledFrame)

     : mCount(0)

     , mProps(aScrolledFrame->Properties())

     , mScrollFrame(aScrollFrame)

     , mScrolledFrame(aScrolledFrame)

   {

     SetCount(0);

   }

   virtual nsDisplayItem* WrapList(nsDisplayListBuilder* aBuilder,

                                   nsIFrame* aFrame,

                                   nsDisplayList* aList) MOZ_OVERRIDE {

     SetCount(++mCount);

     return new (aBuilder) nsDisplayScrollLayer(aBuilder, aList, mScrolledFrame, mScrolledFrame, mScrollFrame);

   }

   virtual nsDisplayItem* WrapItem(nsDisplayListBuilder* aBuilder,

                                   nsDisplayItem* aItem) MOZ_OVERRIDE {

     SetCount(++mCount);

     return new (aBuilder) nsDisplayScrollLayer(aBuilder, aItem, aItem->Frame(), mScrolledFrame, mScrollFrame);

   }

 protected:

   void SetCount(intptr_t aCount) {

     mProps.Set(nsIFrame::ScrollLayerCount(), reinterpret_cast<void*>(aCount));

   }

   intptr_t mCount;

   FrameProperties mProps;

   nsIFrame* mScrollFrame;

   nsIFrame* mScrolledFrame;

 };

 /* static */ bool ScrollFrameHelper::sImageVisPrefsCached = false;

 /* static */ uint32_t ScrollFrameHelper::sHorzExpandScrollPort = 0;

 /* static */ uint32_t ScrollFrameHelper::sVertExpandScrollPort = 1;

 /* static */ int32_t ScrollFrameHelper::sHorzScrollFraction = 2;

 /* static */ int32_t ScrollFrameHelper::sVertScrollFraction = 2;

 /* static */ void

 ScrollFrameHelper::EnsureImageVisPrefsCached()

 {

   if (!sImageVisPrefsCached) {

     Preferences::AddUintVarCache(&sHorzExpandScrollPort,

       "layout.imagevisibility.numscrollportwidths", (uint32_t)0);

     Preferences::AddUintVarCache(&sVertExpandScrollPort,

       "layout.imagevisibility.numscrollportheights", 1);

     Preferences::AddIntVarCache(&sHorzScrollFraction,

       "layout.imagevisibility.amountscrollbeforeupdatehorizontal", 2);

     Preferences::AddIntVarCache(&sVertScrollFraction,

       "layout.imagevisibility.amountscrollbeforeupdatevertical", 2);

     sImageVisPrefsCached = true;

   }

 }

 nsRect

 ScrollFrameHelper::ExpandRect(const nsRect& aRect) const

 {

   // We don't want to expand a rect in a direction that we can't scroll, so we

   // check the scroll range.

   nsRect scrollRange = GetScrollRangeForClamping();

   nsPoint scrollPos = GetScrollPosition();

   nsMargin expand(0, 0, 0, 0);

   nscoord vertShift = sVertExpandScrollPort * aRect.height;

   if (scrollRange.y < scrollPos.y) {

     expand.top = vertShift;

   }

   if (scrollPos.y < scrollRange.YMost()) {

     expand.bottom = vertShift;

   }

   nscoord horzShift = sHorzExpandScrollPort * aRect.width;

   if (scrollRange.x < scrollPos.x) {

     expand.left = horzShift;

   }

   if (scrollPos.x < scrollRange.XMost()) {

     expand.right = horzShift;

   }

   nsRect rect = aRect;

   rect.Inflate(expand);

   return rect;

 }

 static bool

 ShouldBeClippedByFrame(nsIFrame* aClipFrame, nsIFrame* aClippedFrame)

 {

   return nsLayoutUtils::IsProperAncestorFrame(aClipFrame, aClippedFrame);

 }

 static void

 ClipItemsExceptCaret(nsDisplayList* aList, nsDisplayListBuilder* aBuilder,

                      nsIFrame* aClipFrame, const DisplayItemClip& aClip)

 {

   nsDisplayItem* i = aList->GetBottom();

   for (; i; i = i->GetAbove()) {

     if (!::ShouldBeClippedByFrame(aClipFrame, i->Frame())) {

       continue;

     }

     bool unused;

     nsRect bounds = i->GetBounds(aBuilder, &unused);

     bool isAffectedByClip = aClip.IsRectAffectedByClip(bounds);

     if (isAffectedByClip && nsDisplayItem::TYPE_CARET == i->GetType()) {

       // Don't clip the caret if it overflows vertically only, and by half

       // its height at most.  This is to avoid clipping it when the line-height

       // is small.

       auto half = bounds.height / 2;

       bounds.y += half;

       bounds.height -= half;

       isAffectedByClip = aClip.IsRectAffectedByClip(bounds);

       if (isAffectedByClip) {

         // Don't clip the caret if it's just outside on the right side.

         nsRect rightSide(bounds.x - 1, bounds.y, 1, bounds.height);

         isAffectedByClip = aClip.IsRectAffectedByClip(rightSide);

         // Also, avoid clipping it in a zero-height line box (heuristic only).

         if (isAffectedByClip) {

           isAffectedByClip = i->Frame()->GetRect().height != 0;

         }

       }

     }

     if (isAffectedByClip) {

       DisplayItemClip newClip;

       newClip.IntersectWith(i->GetClip());

       newClip.IntersectWith(aClip);

       i->SetClip(aBuilder, newClip);

     }

     nsDisplayList* children = i->GetSameCoordinateSystemChildren();

     if (children) {

       ClipItemsExceptCaret(children, aBuilder, aClipFrame, aClip);

     }

   }

 }

 static void

 ClipListsExceptCaret(nsDisplayListCollection* aLists,

                      nsDisplayListBuilder* aBuilder,

                      nsIFrame* aClipFrame,

                      const DisplayItemClip& aClip)

 {

   ::ClipItemsExceptCaret(aLists->BorderBackground(), aBuilder, aClipFrame, aClip);

   ::ClipItemsExceptCaret(aLists->BlockBorderBackgrounds(), aBuilder, aClipFrame, aClip);

   ::ClipItemsExceptCaret(aLists->Floats(), aBuilder, aClipFrame, aClip);

   ::ClipItemsExceptCaret(aLists->PositionedDescendants(), aBuilder, aClipFrame, aClip);

   ::ClipItemsExceptCaret(aLists->Outlines(), aBuilder, aClipFrame, aClip);

   ::ClipItemsExceptCaret(aLists->Content(), aBuilder, aClipFrame, aClip);

 }

 static bool

 DisplayportExceedsMaxTextureSize(nsPresContext* aPresContext, const nsRect& aDisplayPort)

 {

 #ifdef MOZ_WIDGET_GONK

   // On B2G we actively run into max texture size limits because the displayport-sizing code

   // in the AsyncPanZoomController code is slightly busted (bug 957668 will fix it properly).

   // We sometimes end up requesting displayports for which the corresponding layer will be

   // larger than the max GL texture size (which we assume to be 4096 here).

   // If we run into this case, we should just not use the displayport at all and fall back to

   // just making a ScrollInfoLayer so that we use the APZC's synchronous scrolling fallback

   // mechanism.

   // Note also that if we don't do this here, it is quite likely that the parent B2G process

   // will kill this child process to prevent OOMs (see the patch that landed as part of bug

   // 965945 for details).

   gfxSize resolution = aPresContext->PresShell()->GetCumulativeResolution();

   return (aPresContext->AppUnitsToDevPixels(aDisplayPort.width) * resolution.width > 4096) ||

          (aPresContext->AppUnitsToDevPixels(aDisplayPort.height) * resolution.height > 4096);

 #else

   return false;

 #endif

 }

 void

 ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder*   aBuilder,

                                     const nsRect&           aDirtyRect,

                                     const nsDisplayListSet& aLists)

 {

   if (aBuilder->IsForImageVisibility()) {

     mLastUpdateImagesPos = GetScrollPosition();

   }

   mOuter->DisplayBorderBackgroundOutline(aBuilder, aLists);

   if (aBuilder->IsPaintingToWindow()) {

     mScrollPosAtLastPaint = GetScrollPosition();

     if (IsScrollingActive() && !CanScrollWithBlitting(mOuter)) {

       MarkInactive();

     }

     if (IsScrollingActive()) {

       if (mScrollPosForLayerPixelAlignment == nsPoint(-1,-1)) {

         mScrollPosForLayerPixelAlignment = mScrollPosAtLastPaint;

       }

     } else {

       mScrollPosForLayerPixelAlignment = nsPoint(-1,-1);

     }

   }

   // We put scrollbars in their own layers when this is the root scroll

   // frame and we are a toplevel content document. In this situation, the

   // scrollbar(s) would normally be assigned their own layer anyway, since

   // they're not scrolled with the rest of the document. But when both

   // scrollbars are visible, the layer's visible rectangle would be the size

   // of the viewport, so most layer implementations would create a layer buffer

   // that's much larger than necessary. Creating independent layers for each

   // scrollbar works around the problem.

   bool createLayersForScrollbars = mIsRoot &&

     mOuter->PresContext()->IsRootContentDocument();

   if (aBuilder->GetIgnoreScrollFrame() == mOuter || IsIgnoringViewportClipping()) {

     // If we are a root scroll frame that has a display port we want to add

     // scrollbars, they will be children of the scrollable layer, but they get

     // adjusted by the APZC automatically.

     bool addScrollBars = mIsRoot &&

       nsLayoutUtils::GetDisplayPort(mOuter->GetContent()) &&

       !aBuilder->IsForEventDelivery();

     // For now, don't add them for display root documents, cause we've never

     // had them there.

     if (aBuilder->RootReferenceFrame()->PresContext() == mOuter->PresContext()) {

       addScrollBars = false;

     }

     if (addScrollBars) {

       // Add classic scrollbars.

       AppendScrollPartsTo(aBuilder, aDirtyRect, aLists, createLayersForScrollbars,

                           false);

     }

     // Don't clip the scrolled child, and don't paint scrollbars/scrollcorner.

     // The scrolled frame shouldn't have its own background/border, so we

     // can just pass aLists directly.

     mOuter->BuildDisplayListForChild(aBuilder, mScrolledFrame,

                                      aDirtyRect, aLists);

 #ifdef MOZ_WIDGET_GONK

     // TODO: only layerize the overlay scrollbars if this scrollframe can be

     // panned asynchronously. For now just always layerize on B2G because.

     // that's where we want the layerized scrollbars

     createLayersForScrollbars = true;

 #endif

     if (addScrollBars) {

       // Add overlay scrollbars.

       AppendScrollPartsTo(aBuilder, aDirtyRect, aLists, createLayersForScrollbars,

                           true);

     }

     return;

   }

   // Now display the scrollbars and scrollcorner. These parts are drawn

   // in the border-background layer, on top of our own background and

   // borders and underneath borders and backgrounds of later elements

   // in the tree.

   // Note that this does not apply for overlay scrollbars; those are drawn

   // in the positioned-elements layer on top of everything else by the call

   // to AppendScrollPartsTo(..., true) further down.

   AppendScrollPartsTo(aBuilder, aDirtyRect, aLists, createLayersForScrollbars,

                       false);

   // Overflow clipping can never clip frames outside our subtree, so there

   // is no need to worry about whether we are a moving frame that might clip

   // non-moving frames.

   // Not all our descendants will be clipped by overflow clipping, but all

   // the ones that aren't clipped will be out of flow frames that have already

   // had dirty rects saved for them by their parent frames calling

   // MarkOutOfFlowChildrenForDisplayList, so it's safe to restrict our

   // dirty rect here.

   nsRect dirtyRect = aDirtyRect.Intersect(mScrollPort);

   nsRect displayPort;

   bool usingDisplayport = false;

   if (!aBuilder->IsForEventDelivery()) {

     if (!mIsRoot) {

       // For a non-root scroll frame, override the value of the display port

       // base rect, and possibly create a display port if there isn't one

       // already. For root scroll frame, nsLayoutUtils::PaintFrame or

       // nsSubDocumentFrame::BuildDisplayList takes care of this.

       nsRect displayportBase = dirtyRect;

       usingDisplayport = nsLayoutUtils::GetOrMaybeCreateDisplayPort(

           *aBuilder, mOuter, displayportBase, &displayPort);

     } else {

       // For a root frmae, just get the value of the existing of the display

       // port, if any.

       usingDisplayport = nsLayoutUtils::GetDisplayPort(mOuter->GetContent(), &displayPort);

     }

     if (usingDisplayport && DisplayportExceedsMaxTextureSize(mOuter->PresContext(), displayPort)) {

       usingDisplayport = false;

     }

     // Override the dirty rectangle if the displayport has been set.

     if (usingDisplayport) {

       dirtyRect = displayPort;

     }

   }

   if (aBuilder->IsForImageVisibility()) {

     // We expand the dirty rect to catch images just outside of the scroll port.

     // We use the dirty rect instead of the whole scroll port to prevent

     // too much expansion in the presence of very large (bigger than the

     // viewport) scroll ports.

     dirtyRect = ExpandRect(dirtyRect);

   }

   // Since making new layers is expensive, only use nsDisplayScrollLayer

   // if the area is scrollable and we're the content process (unless we're on

   // B2G, where we support async scrolling for scrollable elements in the

   // parent process as well).

   // When a displayport is being used, force building of a layer so that

   // CompositorParent can always find the scrollable layer for the root content

   // document.

   // If the element is marked 'scrollgrab', also force building of a layer

   // so that APZ can implement scroll grabbing.

   mShouldBuildScrollableLayer = usingDisplayport || nsContentUtils::HasScrollgrab(mOuter->GetContent());

   bool shouldBuildLayer = false;

   if (mShouldBuildScrollableLayer) {

     shouldBuildLayer = true;

   } else {

     shouldBuildLayer =

       nsLayoutUtils::WantSubAPZC() &&

       WantAsyncScroll() &&

       // If we are the root scroll frame for the display root then we don't need a scroll

       // info layer to make a RecordFrameMetrics call for us as

       // nsDisplayList::PaintForFrame already calls RecordFrameMetrics for us.

       (!mIsRoot || aBuilder->RootReferenceFrame()->PresContext() != mOuter->PresContext());

   }

   nsDisplayListCollection scrolledContent;

   {

     // Note that setting the current scroll parent id here means that positioned children

     // of this scroll info layer will pick up the scroll info layer as their scroll handoff

     // parent. This is intentional because that is what happens for positioned children

     // of scroll layers, and we want to maintain consistent behaviour between scroll layers

     // and scroll info layers.

     nsDisplayListBuilder::AutoCurrentScrollParentIdSetter idSetter(

         aBuilder,

         shouldBuildLayer && mScrolledFrame->GetContent()

             ? nsLayoutUtils::FindOrCreateIDFor(mScrolledFrame->GetContent())

             : aBuilder->GetCurrentScrollParentId());

     DisplayListClipState::AutoSaveRestore clipState(aBuilder);

     if (usingDisplayport) {

       nsRect clip = displayPort + aBuilder->ToReferenceFrame(mOuter);

       // If we are using a display port, then ignore any pre-existing clip

       // passed down from our parents, and use only the clip computed here

       // based on the display port. The pre-existing clip would just defeat

       // the purpose of a display port which is to paint regions that are not

       // currently visible so that they can be brought into view asynchronously.

       // Notes:

       //   - The pre-existing clip state will be restored when the

       //     AutoSaveRestore goes out of scope, so there is no permanent change

       //     to this clip state.

       //   - We still set a clip to the scroll port further below where we

       //     build the scroll wrapper. This doesn't prevent us from painting

       //     the entire displayport, but it lets the compositor know to

       //     clip to the scroll port after compositing.

       clipState.Clear();

       if (mClipAllDescendants) {

         clipState.ClipContentDescendants(clip);

       } else {

         clipState.ClipContainingBlockDescendants(clip, nullptr);

       }

     } else {

       nsRect clip = mScrollPort + aBuilder->ToReferenceFrame(mOuter);

       nscoord radii[8];

       bool haveRadii = mOuter->GetPaddingBoxBorderRadii(radii);

       // Our override of GetBorderRadii ensures we never have a radius at

       // the corners where we have a scrollbar.

       if (mClipAllDescendants) {

         clipState.ClipContentDescendants(clip, haveRadii ? radii : nullptr);

       } else {

         clipState.ClipContainingBlockDescendants(clip, haveRadii ? radii : nullptr);

       }

     }

     mOuter->BuildDisplayListForChild(aBuilder, mScrolledFrame, dirtyRect, scrolledContent);

   }

   if (MOZ_UNLIKELY(mOuter->StyleDisplay()->mOverflowClipBox ==

                      NS_STYLE_OVERFLOW_CLIP_BOX_CONTENT_BOX)) {

     // We only clip if there is *scrollable* overflow, to avoid clipping

     // *visual* overflow unnecessarily.

     nsRect clipRect = mScrollPort + aBuilder->ToReferenceFrame(mOuter);

     nsRect so = mScrolledFrame->GetScrollableOverflowRect();

     if (clipRect.width != so.width || clipRect.height != so.height ||

         so.x < 0 || so.y < 0) {

       // The 'scrolledContent' items are clipped to the padding-box at this point.

       // Now clip them again to the content-box, except the nsDisplayCaret item

       // which we allow to overflow the content-box in various situations --

       // see ::ClipItemsExceptCaret.