The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

  * vim: set ts=2 sw=2 et tw=78:

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

  */

 /*

  * structures that represent things to be painted (ordered in z-order),

  * used during painting and hit testing

  */

 #include "mozilla/dom/TabChild.h"

 #include "mozilla/layers/PLayerTransaction.h"

 #include "nsDisplayList.h"

 #include "nsCSSRendering.h"

 #include "nsRenderingContext.h"

 #include "nsISelectionController.h"

 #include "nsIPresShell.h"

 #include "nsRegion.h"

 #include "nsStyleStructInlines.h"

 #include "nsStyleTransformMatrix.h"

 #include "gfxMatrix.h"

 #include "nsSVGIntegrationUtils.h"

 #include "nsLayoutUtils.h"

 #include "nsIScrollableFrame.h"

 #include "nsIFrameInlines.h"

 #include "nsThemeConstants.h"

 #include "LayerTreeInvalidation.h"

 #include "imgIContainer.h"

 #include "BasicLayers.h"

 #include "nsBoxFrame.h"

 #include "nsViewportFrame.h"

 #include "nsSubDocumentFrame.h"

 #include "nsSVGEffects.h"

 #include "nsSVGElement.h"

 #include "nsSVGClipPathFrame.h"

 #include "GeckoProfiler.h"

 #include "nsAnimationManager.h"

 #include "nsTransitionManager.h"

 #include "nsViewManager.h"

 #include "ImageLayers.h"

 #include "ImageContainer.h"

 #include "nsCanvasFrame.h"

 #include "StickyScrollContainer.h"

 #include "mozilla/EventStates.h"

 #include "mozilla/LookAndFeel.h"

 #include "mozilla/Preferences.h"

 #include "ActiveLayerTracker.h"

 #include "nsContentUtils.h"

 #include "nsPrintfCString.h"

 #include "UnitTransforms.h"

 #include <stdint.h>

 #include <algorithm>

 using namespace mozilla;

 using namespace mozilla::css;

 using namespace mozilla::layers;

 using namespace mozilla::dom;

 typedef FrameMetrics::ViewID ViewID;

 static inline nsIFrame*

 GetTransformRootFrame(nsIFrame* aFrame)

 {

   return nsLayoutUtils::GetTransformRootFrame(aFrame);

 }

 static void AddTransformFunctions(nsCSSValueList* aList,

                                   nsStyleContext* aContext,

                                   nsPresContext* aPresContext,

                                   nsRect& aBounds,

                                   float aAppUnitsPerPixel,

                                   InfallibleTArray<TransformFunction>& aFunctions)

 {

   if (aList->mValue.GetUnit() == eCSSUnit_None) {

     return;

   }

   for (const nsCSSValueList* curr = aList; curr; curr = curr->mNext) {

     const nsCSSValue& currElem = curr->mValue;

     NS_ASSERTION(currElem.GetUnit() == eCSSUnit_Function,

                  "Stream should consist solely of functions!");

     nsCSSValue::Array* array = currElem.GetArrayValue();

     bool canStoreInRuleTree = true;

     switch (nsStyleTransformMatrix::TransformFunctionOf(array)) {

       case eCSSKeyword_rotatex:

       {

         double theta = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(RotationX(theta));

         break;

       }

       case eCSSKeyword_rotatey:

       {

         double theta = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(RotationY(theta));

         break;

       }

       case eCSSKeyword_rotatez:

       {

         double theta = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(RotationZ(theta));

         break;

       }

       case eCSSKeyword_rotate:

       {

         double theta = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(Rotation(theta));

         break;

       }

       case eCSSKeyword_rotate3d:

       {

         double x = array->Item(1).GetFloatValue();

         double y = array->Item(2).GetFloatValue();

         double z = array->Item(3).GetFloatValue();

         double theta = array->Item(4).GetAngleValueInRadians();

         aFunctions.AppendElement(Rotation3D(x, y, z, theta));

         break;

       }

       case eCSSKeyword_scalex:

       {

         double x = array->Item(1).GetFloatValue();

         aFunctions.AppendElement(Scale(x, 1, 1));

         break;

       }

       case eCSSKeyword_scaley:

       {

         double y = array->Item(1).GetFloatValue();

         aFunctions.AppendElement(Scale(1, y, 1));

         break;

       }

       case eCSSKeyword_scalez:

       {

         double z = array->Item(1).GetFloatValue();

         aFunctions.AppendElement(Scale(1, 1, z));

         break;

       }

       case eCSSKeyword_scale:

       {

         double x = array->Item(1).GetFloatValue();

         // scale(x) is shorthand for scale(x, x);

         double y = array->Count() == 2 ? x : array->Item(2).GetFloatValue();

         aFunctions.AppendElement(Scale(x, y, 1));

         break;

       }

       case eCSSKeyword_scale3d:

       {

         double x = array->Item(1).GetFloatValue();

         double y = array->Item(2).GetFloatValue();

         double z = array->Item(3).GetFloatValue();

         aFunctions.AppendElement(Scale(x, y, z));

         break;

       }

       case eCSSKeyword_translatex:

       {

         double x = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(1), aContext, aPresContext, canStoreInRuleTree,

           aBounds.Width(), aAppUnitsPerPixel);

         aFunctions.AppendElement(Translation(x, 0, 0));

         break;

       }

       case eCSSKeyword_translatey:

       {

         double y = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(1), aContext, aPresContext, canStoreInRuleTree,

           aBounds.Height(), aAppUnitsPerPixel);

         aFunctions.AppendElement(Translation(0, y, 0));

         break;

       }

       case eCSSKeyword_translatez:

       {

         double z = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(1), aContext, aPresContext, canStoreInRuleTree,

           0, aAppUnitsPerPixel);

         aFunctions.AppendElement(Translation(0, 0, z));

         break;

       }

       case eCSSKeyword_translate:

       {

         double x = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(1), aContext, aPresContext, canStoreInRuleTree,

           aBounds.Width(), aAppUnitsPerPixel);

         // translate(x) is shorthand for translate(x, 0)

         double y = 0;

         if (array->Count() == 3) {

            y = nsStyleTransformMatrix::ProcessTranslatePart(

             array->Item(2), aContext, aPresContext, canStoreInRuleTree,

             aBounds.Height(), aAppUnitsPerPixel);

         }

         aFunctions.AppendElement(Translation(x, y, 0));

         break;

       }

       case eCSSKeyword_translate3d:

       {

         double x = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(1), aContext, aPresContext, canStoreInRuleTree,

           aBounds.Width(), aAppUnitsPerPixel);

         double y = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(2), aContext, aPresContext, canStoreInRuleTree,

           aBounds.Height(), aAppUnitsPerPixel);

         double z = nsStyleTransformMatrix::ProcessTranslatePart(

           array->Item(3), aContext, aPresContext, canStoreInRuleTree,

           0, aAppUnitsPerPixel);

         aFunctions.AppendElement(Translation(x, y, z));

         break;

       }

       case eCSSKeyword_skewx:

       {

         double x = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(SkewX(x));

         break;

       }

       case eCSSKeyword_skewy:

       {

         double y = array->Item(1).GetAngleValueInRadians();

         aFunctions.AppendElement(SkewY(y));

         break;

       }

       case eCSSKeyword_skew:

       {

         double x = array->Item(1).GetAngleValueInRadians();

         // skew(x) is shorthand for skew(x, 0)

         double y = 0;

         if (array->Count() == 3) {

           y = array->Item(2).GetAngleValueInRadians();

         }

         aFunctions.AppendElement(Skew(x, y));

         break;

       }

       case eCSSKeyword_matrix:

       {

         gfx::Matrix4x4 matrix;

         matrix._11 = array->Item(1).GetFloatValue();

         matrix._12 = array->Item(2).GetFloatValue();

         matrix._13 = 0;

         matrix._14 = 0;

         matrix._21 = array->Item(3).GetFloatValue();

         matrix._22 = array->Item(4).GetFloatValue();

         matrix._23 = 0;

         matrix._24 = 0;

         matrix._31 = 0;

         matrix._32 = 0;

         matrix._33 = 1;

         matrix._34 = 0;

         matrix._41 = array->Item(5).GetFloatValue();

         matrix._42 = array->Item(6).GetFloatValue();

         matrix._43 = 0;

         matrix._44 = 1;

         aFunctions.AppendElement(TransformMatrix(matrix));

         break;

       }

       case eCSSKeyword_matrix3d:

       {

         gfx::Matrix4x4 matrix;

         matrix._11 = array->Item(1).GetFloatValue();

         matrix._12 = array->Item(2).GetFloatValue();

         matrix._13 = array->Item(3).GetFloatValue();

         matrix._14 = array->Item(4).GetFloatValue();

         matrix._21 = array->Item(5).GetFloatValue();

         matrix._22 = array->Item(6).GetFloatValue();

         matrix._23 = array->Item(7).GetFloatValue();

         matrix._24 = array->Item(8).GetFloatValue();

         matrix._31 = array->Item(9).GetFloatValue();

         matrix._32 = array->Item(10).GetFloatValue();

         matrix._33 = array->Item(11).GetFloatValue();

         matrix._34 = array->Item(12).GetFloatValue();

         matrix._41 = array->Item(13).GetFloatValue();

         matrix._42 = array->Item(14).GetFloatValue();

         matrix._43 = array->Item(15).GetFloatValue();

         matrix._44 = array->Item(16).GetFloatValue();

         aFunctions.AppendElement(TransformMatrix(matrix));

         break;

       }

       case eCSSKeyword_interpolatematrix:

       {

         gfx3DMatrix matrix;

         nsStyleTransformMatrix::ProcessInterpolateMatrix(matrix, array,

                                                          aContext,

                                                          aPresContext,

                                                          canStoreInRuleTree,

                                                          aBounds,

                                                          aAppUnitsPerPixel);

         gfx::Matrix4x4 transform;

         gfx::ToMatrix4x4(matrix, transform);

         aFunctions.AppendElement(TransformMatrix(transform));

         break;

       }

       case eCSSKeyword_perspective:

       {

         aFunctions.AppendElement(Perspective(array->Item(1).GetFloatValue()));

         break;

       }

       default:

         NS_ERROR("Function not handled yet!");

     }

   }

 }

 static TimingFunction

 ToTimingFunction(css::ComputedTimingFunction& aCTF)

 {

   if (aCTF.GetType() == nsTimingFunction::Function) {

     const nsSMILKeySpline* spline = aCTF.GetFunction();

     return TimingFunction(CubicBezierFunction(spline->X1(), spline->Y1(),

                                               spline->X2(), spline->Y2()));

   }

   uint32_t type = aCTF.GetType() == nsTimingFunction::StepStart ? 1 : 2;

   return TimingFunction(StepFunction(aCTF.GetSteps(), type));

 }

 static void

 AddAnimationForProperty(nsIFrame* aFrame, nsCSSProperty aProperty,

                         mozilla::StyleAnimation* ea, Layer* aLayer,

                         AnimationData& aData, bool aPending)

 {

   NS_ASSERTION(aLayer->AsContainerLayer(), "Should only animate ContainerLayer");

   nsStyleContext* styleContext = aFrame->StyleContext();

   nsPresContext* presContext = aFrame->PresContext();

   nsRect bounds = nsDisplayTransform::GetFrameBoundsForTransform(aFrame);

   // all data passed directly to the compositor should be in css pixels

   float scale = nsDeviceContext::AppUnitsPerCSSPixel();

   mozilla::layers::Animation* animation =

     aPending ?

     aLayer->AddAnimationForNextTransaction() :

     aLayer->AddAnimation();

   animation->startTime() = ea->mStartTime + ea->mDelay;

   animation->duration() = ea->mIterationDuration;

   animation->numIterations() =

     ea->mIterationCount != NS_IEEEPositiveInfinity() ? ea->mIterationCount : -1;

   animation->direction() = ea->mDirection;

   animation->property() = aProperty;

   animation->data() = aData;

   for (uint32_t propIdx = 0; propIdx < ea->mProperties.Length(); propIdx++) {

     AnimationProperty* property = &ea->mProperties[propIdx];

     if (aProperty != property->mProperty) {

       continue;

     }

     for (uint32_t segIdx = 0; segIdx < property->mSegments.Length(); segIdx++) {

       AnimationPropertySegment* segment = &property->mSegments[segIdx];

       AnimationSegment* animSegment = animation->segments().AppendElement();

       if (aProperty == eCSSProperty_transform) {

         animSegment->startState() = InfallibleTArray<TransformFunction>();

         animSegment->endState() = InfallibleTArray<TransformFunction>();

         nsCSSValueSharedList* list = segment->mFromValue.GetCSSValueSharedListValue();

         AddTransformFunctions(list->mHead, styleContext, presContext, bounds, scale,

                               animSegment->startState().get_ArrayOfTransformFunction());

         list = segment->mToValue.GetCSSValueSharedListValue();

         AddTransformFunctions(list->mHead, styleContext, presContext, bounds, scale,

                               animSegment->endState().get_ArrayOfTransformFunction());

       } else if (aProperty == eCSSProperty_opacity) {

         animSegment->startState() = segment->mFromValue.GetFloatValue();

         animSegment->endState() = segment->mToValue.GetFloatValue();

       }

       animSegment->startPortion() = segment->mFromKey;

       animSegment->endPortion() = segment->mToKey;

       animSegment->sampleFn() = ToTimingFunction(segment->mTimingFunction);

     }

   }

 }

 template<class T>

 static void

 AddAnimationsForProperty(nsIFrame* aFrame, nsCSSProperty aProperty,

                          nsTArray<T>& aAnimations,

                          Layer* aLayer, AnimationData& aData,

                          bool aPending) {

   mozilla::TimeStamp currentTime =

     aFrame->PresContext()->RefreshDriver()->MostRecentRefresh();

   for (uint32_t animIdx = 0; animIdx < aAnimations.Length(); animIdx++) {

     mozilla::StyleAnimation* anim = &aAnimations[animIdx];

     if (!(anim->HasAnimationOfProperty(aProperty) &&

           anim->IsRunningAt(currentTime))) {

       continue;

     }

     AddAnimationForProperty(aFrame, aProperty, anim, aLayer, aData, aPending);

     anim->mIsRunningOnCompositor = true;

   }

 }

 /* static */ void

 nsDisplayListBuilder::AddAnimationsAndTransitionsToLayer(Layer* aLayer,

                                                          nsDisplayListBuilder* aBuilder,

                                                          nsDisplayItem* aItem,

                                                          nsIFrame* aFrame,

                                                          nsCSSProperty aProperty)

 {

   // This function can be called in two ways:  from

   // nsDisplay*::BuildLayer while constructing a layer (with all

   // pointers non-null), or from RestyleManager's handling of

   // UpdateOpacityLayer/UpdateTransformLayer hints.

   MOZ_ASSERT(!aBuilder == !aItem,

              "should only be called in two configurations, with both "

              "aBuilder and aItem, or with neither");

   MOZ_ASSERT(!aItem || aFrame == aItem->Frame(), "frame mismatch");

   bool pending = !aBuilder;

   if (pending) {

     aLayer->ClearAnimationsForNextTransaction();

   } else {

     aLayer->ClearAnimations();

   }

   nsIContent* content = aFrame->GetContent();

   if (!content) {

     return;

   }

   ElementTransitions* et =

     nsTransitionManager::GetTransitionsForCompositor(content, aProperty);

   ElementAnimations* ea =

     nsAnimationManager::GetAnimationsForCompositor(content, aProperty);

   if (!ea && !et) {

     return;

   }

   // If the frame is not prerendered, bail out.

   // Do this check only during layer construction; during updating the

   // caller is required to check it appropriately.

   if (aItem && !aItem->CanUseAsyncAnimations(aBuilder)) {

     // AnimationManager or TransitionManager need to know that we refused to

     // run this animation asynchronously so that they will not throttle the

     // main thread animation.

     aFrame->Properties().Set(nsIFrame::RefusedAsyncAnimation(),

                             reinterpret_cast<void*>(intptr_t(true)));

     // We need to schedule another refresh driver run so that AnimationManager

     // or TransitionManager get a chance to unthrottle the animation.

     aFrame->SchedulePaint();

     return;

   }

   AnimationData data;

   if (aProperty == eCSSProperty_transform) {

     nsRect bounds = nsDisplayTransform::GetFrameBoundsForTransform(aFrame);

     // all data passed directly to the compositor should be in css pixels

     float scale = nsDeviceContext::AppUnitsPerCSSPixel();

     gfxPoint3D offsetToTransformOrigin =

       nsDisplayTransform::GetDeltaToTransformOrigin(aFrame, scale, &bounds);

     gfxPoint3D offsetToPerspectiveOrigin =

       nsDisplayTransform::GetDeltaToPerspectiveOrigin(aFrame, scale);

     nscoord perspective = 0.0;

     nsStyleContext* parentStyleContext = aFrame->StyleContext()->GetParent();

     if (parentStyleContext) {

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

       if (disp && disp->mChildPerspective.GetUnit() == eStyleUnit_Coord) {

         perspective = disp->mChildPerspective.GetCoordValue();

       }

     }

     nsPoint origin;

     if (aItem) {

       origin = aItem->ToReferenceFrame();

     } else {

       // transform display items used a reference frame computed from

       // their GetTransformRootFrame().

       nsIFrame* referenceFrame =

         nsLayoutUtils::GetReferenceFrame(GetTransformRootFrame(aFrame));

       origin = aFrame->GetOffsetToCrossDoc(referenceFrame);

     }

     data = TransformData(origin, offsetToTransformOrigin,

                          offsetToPerspectiveOrigin, bounds, perspective,

                          aFrame->PresContext()->AppUnitsPerDevPixel());

   } else if (aProperty == eCSSProperty_opacity) {

     data = null_t();

   }

   if (et) {

     AddAnimationsForProperty(aFrame, aProperty, et->mPropertyTransitions,

                              aLayer, data, pending);

     aLayer->SetAnimationGeneration(et->mAnimationGeneration);

   }

   if (ea) {

     AddAnimationsForProperty(aFrame, aProperty, ea->mAnimations,

                              aLayer, data, pending);

     aLayer->SetAnimationGeneration(ea->mAnimationGeneration);

   }

 }

 nsDisplayListBuilder::nsDisplayListBuilder(nsIFrame* aReferenceFrame,

     Mode aMode, bool aBuildCaret)

     : mReferenceFrame(aReferenceFrame),

       mIgnoreScrollFrame(nullptr),

       mLayerEventRegions(nullptr),

       mCurrentTableItem(nullptr),

       mFinalTransparentRegion(nullptr),

       mCachedOffsetFrame(aReferenceFrame),

       mCachedReferenceFrame(aReferenceFrame),

       mCachedOffset(0, 0),

       mGlassDisplayItem(nullptr),

       mMode(aMode),

       mCurrentScrollParentId(FrameMetrics::NULL_SCROLL_ID),

       mBuildCaret(aBuildCaret),

       mIgnoreSuppression(false),

       mHadToIgnoreSuppression(false),

       mIsAtRootOfPseudoStackingContext(false),

       mIncludeAllOutOfFlows(false),

       mDescendIntoSubdocuments(true),

       mSelectedFramesOnly(false),

       mAccurateVisibleRegions(false),

       mAllowMergingAndFlattening(true),

       mWillComputePluginGeometry(false),

       mInTransform(false),

       mInFixedPos(false),

       mSyncDecodeImages(false),

       mIsPaintingToWindow(false),

       mIsCompositingCheap(false),

       mContainsPluginItem(false),

       mContainsBlendMode(false),

       mAncestorHasTouchEventHandler(false),

       mHaveScrollableDisplayPort(false)

 {

   MOZ_COUNT_CTOR(nsDisplayListBuilder);

   PL_InitArenaPool(&mPool, "displayListArena", 1024,

                    std::max(NS_ALIGNMENT_OF(void*),NS_ALIGNMENT_OF(double))-1);

   nsPresContext* pc = aReferenceFrame->PresContext();

   nsIPresShell *shell = pc->PresShell();

   if (pc->IsRenderingOnlySelection()) {

     nsCOMPtr<nsISelectionController> selcon(do_QueryInterface(shell));

     if (selcon) {

       selcon->GetSelection(nsISelectionController::SELECTION_NORMAL,

                            getter_AddRefs(mBoundingSelection));

     }

   }

   nsCSSRendering::BeginFrameTreesLocked();

   PR_STATIC_ASSERT(nsDisplayItem::TYPE_MAX < (1 << nsDisplayItem::TYPE_BITS));

 }

 static void MarkFrameForDisplay(nsIFrame* aFrame, nsIFrame* aStopAtFrame) {

   for (nsIFrame* f = aFrame; f;

        f = nsLayoutUtils::GetParentOrPlaceholderFor(f)) {

     if (f->GetStateBits() & NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO)

       return;

     f->AddStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO);

     if (f == aStopAtFrame) {

       // we've reached a frame that we know will be painted, so we can stop.

       break;

     }

   }

 }

 void nsDisplayListBuilder::MarkOutOfFlowFrameForDisplay(nsIFrame* aDirtyFrame,

                                                         nsIFrame* aFrame,

                                                         const nsRect& aDirtyRect)

 {

   nsRect dirtyRectRelativeToDirtyFrame = aDirtyRect;

   if (nsLayoutUtils::IsFixedPosFrameInDisplayPort(aFrame)) {

     NS_ASSERTION(aDirtyFrame == aFrame->GetParent(), "Dirty frame should be viewport frame");

     // position: fixed items are reflowed into and only drawn inside the

     // viewport, or the scroll position clamping scrollport size, if one is

     // set.

     nsIPresShell* ps = aFrame->PresContext()->PresShell();

     dirtyRectRelativeToDirtyFrame.MoveTo(0, 0);

     if (ps->IsScrollPositionClampingScrollPortSizeSet()) {

       dirtyRectRelativeToDirtyFrame.SizeTo(ps->GetScrollPositionClampingScrollPortSize());

     } else {

       dirtyRectRelativeToDirtyFrame.SizeTo(aDirtyFrame->GetSize());

     }

   }

   nsRect dirty = dirtyRectRelativeToDirtyFrame - aFrame->GetOffsetTo(aDirtyFrame);

   nsRect overflowRect = aFrame->GetVisualOverflowRect();

   if (aFrame->IsTransformed() &&

       nsLayoutUtils::HasAnimationsForCompositor(aFrame->GetContent(),

                                                 eCSSProperty_transform)) {

    /**

     * Add a fuzz factor to the overflow rectangle so that elements only just

     * out of view are pulled into the display list, so they can be

     * prerendered if necessary.

     */

     overflowRect.Inflate(nsPresContext::CSSPixelsToAppUnits(32));

   }

   if (!dirty.IntersectRect(dirty, overflowRect))

     return;

   const DisplayItemClip* clip = mClipState.GetClipForContainingBlockDescendants();

   OutOfFlowDisplayData* data = clip ? new OutOfFlowDisplayData(*clip, dirty)

     : new OutOfFlowDisplayData(dirty);

   aFrame->Properties().Set(nsDisplayListBuilder::OutOfFlowDisplayDataProperty(), data);

   MarkFrameForDisplay(aFrame, aDirtyFrame);

 }

 static void UnmarkFrameForDisplay(nsIFrame* aFrame) {

   nsPresContext* presContext = aFrame->PresContext();

   presContext->PropertyTable()->

     Delete(aFrame, nsDisplayListBuilder::OutOfFlowDisplayDataProperty());

   for (nsIFrame* f = aFrame; f;

        f = nsLayoutUtils::GetParentOrPlaceholderFor(f)) {

     if (!(f->GetStateBits() & NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO))

       return;

     f->RemoveStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO);

   }

 }

 static bool gPrintApzcTree = false;

 static bool GetApzcTreePrintPref() {

   static bool initialized = false;

   if (!initialized) {

     Preferences::AddBoolVarCache(&gPrintApzcTree, "apz.printtree", gPrintApzcTree);

     initialized = true;

   }

   return gPrintApzcTree;

 }

 static void RecordFrameMetrics(nsIFrame* aForFrame,

                                nsIFrame* aScrollFrame,

                                const nsIFrame* aReferenceFrame,

                                ContainerLayer* aRoot,

                                const nsRect& aVisibleRect,

                                const nsRect& aViewport,

                                nsRect* aDisplayPort,

                                nsRect* aCriticalDisplayPort,

                                ViewID aScrollId,

                                bool aIsRoot,

                                const ContainerLayerParameters& aContainerParameters) {

   nsPresContext* presContext = aForFrame->PresContext();

   int32_t auPerDevPixel = presContext->AppUnitsPerDevPixel();

   LayoutDeviceToLayerScale resolution(aContainerParameters.mXScale, aContainerParameters.mYScale);

   nsIntRect visible = aVisibleRect.ScaleToNearestPixels(

     resolution.scale, resolution.scale, auPerDevPixel);

   aRoot->SetVisibleRegion(visible);

   FrameMetrics metrics;

   metrics.mViewport = CSSRect::FromAppUnits(aViewport);

   if (aDisplayPort) {

     metrics.mDisplayPort = CSSRect::FromAppUnits(*aDisplayPort);

     if (aCriticalDisplayPort) {

       metrics.mCriticalDisplayPort = CSSRect::FromAppUnits(*aCriticalDisplayPort);

     }

   }

   nsIScrollableFrame* scrollableFrame = nullptr;

   if (aScrollFrame)

     scrollableFrame = aScrollFrame->GetScrollTargetFrame();

   metrics.mScrollableRect = CSSRect::FromAppUnits(

     nsLayoutUtils::CalculateScrollableRectForFrame(scrollableFrame, aForFrame));

   if (scrollableFrame) {

     nsPoint scrollPosition = scrollableFrame->GetScrollPosition();

     metrics.SetScrollOffset(CSSPoint::FromAppUnits(scrollPosition));

     // If the frame was scrolled since the last layers update, and by

     // something other than the APZ code, we want to tell the APZ to update

     // its scroll offset.

     nsIAtom* originOfLastScroll = scrollableFrame->OriginOfLastScroll();

     if (originOfLastScroll && originOfLastScroll != nsGkAtoms::apz) {

       metrics.SetScrollOffsetUpdated(scrollableFrame->CurrentScrollGeneration());

     }

   }

   metrics.SetScrollId(aScrollId);

   metrics.mIsRoot = aIsRoot;

   // Only the root scrollable frame for a given presShell should pick up

   // the presShell's resolution. All the other frames are 1.0.

   nsIPresShell* presShell = presContext->GetPresShell();

   if (aScrollFrame == presShell->GetRootScrollFrame()) {

     metrics.mResolution = ParentLayerToLayerScale(presShell->GetXResolution(),

                                                   presShell->GetYResolution());

   } else {

     metrics.mResolution = ParentLayerToLayerScale(1.0f);

   }

   // For the cumulateive resolution, multiply the resolutions of all the

   // presShells back up to the root

   metrics.mCumulativeResolution = LayoutDeviceToLayerScale(1.0f);

   nsIPresShell* curPresShell = presShell;

   while (curPresShell != nullptr) {

     ParentLayerToLayerScale presShellResolution(curPresShell->GetXResolution(),

                                                 curPresShell->GetYResolution());

     metrics.mCumulativeResolution.scale *= presShellResolution.scale;

     nsPresContext* parentContext = curPresShell->GetPresContext()->GetParentPresContext();

     curPresShell = parentContext ? parentContext->GetPresShell() : nullptr;

   }

   metrics.mDevPixelsPerCSSPixel = CSSToLayoutDeviceScale(

     (float)nsPresContext::AppUnitsPerCSSPixel() / auPerDevPixel);

   // Initially, AsyncPanZoomController should render the content to the screen

   // at the painted resolution.

   const LayerToScreenScale layerToScreenScale(1.0f);

   metrics.SetZoom(metrics.mCumulativeResolution * metrics.mDevPixelsPerCSSPixel

                   * layerToScreenScale);

   if (presShell) {

     nsIDocument* document = nullptr;

     document = presShell->GetDocument();

     if (document) {

       nsCOMPtr<nsPIDOMWindow> innerWin(document->GetInnerWindow());

       if (innerWin) {

         metrics.mMayHaveTouchListeners = innerWin->HasTouchEventListeners();

       }

     }

   }

   LayoutDeviceToParentLayerScale layoutToParentLayerScale =

     // The ScreenToParentLayerScale should be mTransformScale which is not calculated yet,

     // but we don't yet handle CSS transforms, so we assume it's 1 here.

     metrics.mCumulativeResolution * LayerToScreenScale(1.0) * ScreenToParentLayerScale(1.0);

   // Calculate the composition bounds as the size of the scroll frame and

   // its origin relative to the reference frame.

   // If aScrollFrame is null, we are in a document without a root scroll frame,

   // so it's a xul document. In this case, use the size of the viewport frame.

   nsIFrame* frameForCompositionBoundsCalculation = aScrollFrame ? aScrollFrame : aForFrame;

   nsRect compositionBounds(frameForCompositionBoundsCalculation->GetOffsetToCrossDoc(aReferenceFrame),

                            frameForCompositionBoundsCalculation->GetSize());

   metrics.mCompositionBounds = RoundedToInt(LayoutDeviceRect::FromAppUnits(compositionBounds, auPerDevPixel)

                                             * layoutToParentLayerScale);

   // For the root scroll frame of the root content document, the above calculation

   // will yield the size of the viewport frame as the composition bounds, which

   // doesn't actually correspond to what is visible when

   // nsIDOMWindowUtils::setCSSViewport has been called to modify the visible area of

   // the prescontext that the viewport frame is reflowed into. In that case if our

   // document has a widget then the widget's bounds will correspond to what is

   // visible. If we don't have a widget the root view's bounds correspond to what

   // would be visible because they don't get modified by setCSSViewport.

   bool isRootContentDocRootScrollFrame = presContext->IsRootContentDocument()

                                       && aScrollFrame == presShell->GetRootScrollFrame();

   if (isRootContentDocRootScrollFrame) {

     if (nsIFrame* rootFrame = presShell->GetRootFrame()) {

       if (nsView* view = rootFrame->GetView()) {

         nsRect viewBoundsAppUnits = view->GetBounds() + rootFrame->GetOffsetToCrossDoc(aReferenceFrame);

         ParentLayerIntRect viewBounds = RoundedToInt(LayoutDeviceRect::FromAppUnits(viewBoundsAppUnits, auPerDevPixel)

                                                      * layoutToParentLayerScale);

         // On Android, we need to do things a bit differently to get things

         // right (see bug 983208, bug 988882). We use the bounds of the nearest

         // widget, but clamp the height to the view bounds height. This clamping

         // is done to get correct results for a page where the page is sized to

         // the screen and thus the dynamic toolbar never disappears. In such a

         // case, we want the composition bounds to exclude the toolbar height,

         // but the widget bounds includes it. We don't currently have a good way

         // of knowing about the toolbar height, but clamping to the view bounds

         // height gives the correct answer in the cases we care about.

         nsIWidget* widget =

 #ifdef MOZ_WIDGET_ANDROID

             rootFrame->GetNearestWidget();

 #else

             view->GetWidget();

 #endif

         if (widget) {

           nsIntRect widgetBounds;

           widget->GetBounds(widgetBounds);

           metrics.mCompositionBounds = ViewAs<ParentLayerPixel>(widgetBounds);

 #ifdef MOZ_WIDGET_ANDROID

           if (viewBounds.height < metrics.mCompositionBounds.height) {

             metrics.mCompositionBounds.height = viewBounds.height;

           }

 #endif

         } else {

           metrics.mCompositionBounds = viewBounds;

         }

       }

     }

   }

   // Adjust composition bounds for the size of scroll bars.

   if (scrollableFrame && !LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars)) {

     nsMargin sizes = scrollableFrame->GetActualScrollbarSizes();

     // Scrollbars are not subject to scaling, so CSS pixels = layer pixels for them.

     ParentLayerIntMargin boundMargins = RoundedToInt(CSSMargin::FromAppUnits(sizes) * CSSToParentLayerScale(1.0f));

     metrics.mCompositionBounds.Deflate(boundMargins);

   }

   metrics.SetRootCompositionSize(

     nsLayoutUtils::CalculateRootCompositionSize(aScrollFrame ? aScrollFrame : aForFrame,

                                                 isRootContentDocRootScrollFrame, metrics));

   if (GetApzcTreePrintPref()) {

     if (nsIContent* content = frameForCompositionBoundsCalculation->GetContent()) {

       nsAutoString contentDescription;

       content->Describe(contentDescription);

       metrics.SetContentDescription(NS_LossyConvertUTF16toASCII(contentDescription).get());

     }

   }

   metrics.mPresShellId = presShell->GetPresShellId();

   // If the scroll frame's content is marked 'scrollgrab', record this

   // in the FrameMetrics so APZ knows to provide the scroll grabbing

   // behaviour.

   if (aScrollFrame && nsContentUtils::HasScrollgrab(aScrollFrame->GetContent())) {

     metrics.mHasScrollgrab = true;

   }

   aRoot->SetFrameMetrics(metrics);

 }

 nsDisplayListBuilder::~nsDisplayListBuilder() {

   NS_ASSERTION(mFramesMarkedForDisplay.Length() == 0,

                "All frames should have been unmarked");

   NS_ASSERTION(mPresShellStates.Length() == 0,

                "All presshells should have been exited");

   NS_ASSERTION(!mCurrentTableItem, "No table item should be active");

   nsCSSRendering::EndFrameTreesLocked();

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

     mDisplayItemClipsToDestroy[i]->DisplayItemClip::~DisplayItemClip();

   }

   PL_FinishArenaPool(&mPool);

   MOZ_COUNT_DTOR(nsDisplayListBuilder);

 }

 uint32_t

 nsDisplayListBuilder::GetBackgroundPaintFlags() {

   uint32_t flags = 0;

   if (mSyncDecodeImages) {

     flags |= nsCSSRendering::PAINTBG_SYNC_DECODE_IMAGES;

   }

   if (mIsPaintingToWindow) {

     flags |= nsCSSRendering::PAINTBG_TO_WINDOW;

   }

   return flags;

 }

 void

 nsDisplayListBuilder::SubtractFromVisibleRegion(nsRegion* aVisibleRegion,

                                                 const nsRegion& aRegion)

 {

   if (aRegion.IsEmpty())

     return;

   nsRegion tmp;

   tmp.Sub(*aVisibleRegion, aRegion);

   // Don't let *aVisibleRegion get too complex, but don't let it fluff out

   // to its bounds either, which can be very bad (see bug 516740).

   // Do let aVisibleRegion get more complex if by doing so we reduce its

   // area by at least half.

   if (GetAccurateVisibleRegions() || tmp.GetNumRects() <= 15 ||

       tmp.Area() <= aVisibleRegion->Area()/2) {

     *aVisibleRegion = tmp;

   }

 }

 nsCaret *

 nsDisplayListBuilder::GetCaret() {

   nsRefPtr<nsCaret> caret = CurrentPresShellState()->mPresShell->GetCaret();

   return caret;

 }

 void

 nsDisplayListBuilder::EnterPresShell(nsIFrame* aReferenceFrame,

                                      const nsRect& aDirtyRect) {

   PresShellState* state = mPresShellStates.AppendElement();

   if (!state)

     return;

   state->mPresShell = aReferenceFrame->PresContext()->PresShell();

   state->mCaretFrame = nullptr;

   state->mFirstFrameMarkedForDisplay = mFramesMarkedForDisplay.Length();

   state->mPresShell->UpdateCanvasBackground();

   if (mIsPaintingToWindow) {

     mReferenceFrame->AddPaintedPresShell(state->mPresShell);

     state->mPresShell->IncrementPaintCount();

   }

   bool buildCaret = mBuildCaret;

   if (mIgnoreSuppression || !state->mPresShell->IsPaintingSuppressed()) {

     if (state->mPresShell->IsPaintingSuppressed()) {

       mHadToIgnoreSuppression = true;

     }

     state->mIsBackgroundOnly = false;

   } else {

     state->mIsBackgroundOnly = true;

     buildCaret = false;

   }

   if (!buildCaret)

     return;

   nsRefPtr<nsCaret> caret = state->mPresShell->GetCaret();

   state->mCaretFrame = caret->GetCaretFrame();

   NS_ASSERTION(state->mCaretFrame == caret->GetCaretFrame(),

                "GetCaretFrame() is unstable");

   if (state->mCaretFrame) {

     // Check if the dirty rect intersects with the caret's dirty rect.

     nsRect caretRect =

       caret->GetCaretRect() + state->mCaretFrame->GetOffsetTo(aReferenceFrame);

     if (caretRect.Intersects(aDirtyRect)) {

       // Okay, our rects intersect, let's mark the frame and all of its ancestors.

       mFramesMarkedForDisplay.AppendElement(state->mCaretFrame);

       MarkFrameForDisplay(state->mCaretFrame, nullptr);

     }

   }

 }

 void

 nsDisplayListBuilder::LeavePresShell(nsIFrame* aReferenceFrame,

                                      const nsRect& aDirtyRect) {

   if (CurrentPresShellState()->mPresShell != aReferenceFrame->PresContext()->PresShell()) {

     // Must have not allocated a state for this presshell, presumably due

     // to OOM.

     return;

   }

   ResetMarkedFramesForDisplayList();

   mPresShellStates.SetLength(mPresShellStates.Length() - 1);

 }

 void

 nsDisplayListBuilder::ResetMarkedFramesForDisplayList()

 {

   // Unmark and pop off the frames marked for display in this pres shell.

   uint32_t firstFrameForShell = CurrentPresShellState()->mFirstFrameMarkedForDisplay;

   for (uint32_t i = firstFrameForShell;

        i < mFramesMarkedForDisplay.Length(); ++i) {

     UnmarkFrameForDisplay(mFramesMarkedForDisplay[i]);

   }

   mFramesMarkedForDisplay.SetLength(firstFrameForShell);

 }

 void

 nsDisplayListBuilder::MarkFramesForDisplayList(nsIFrame* aDirtyFrame,

                                                const nsFrameList& aFrames,

                                                const nsRect& aDirtyRect) {

   mFramesMarkedForDisplay.SetCapacity(mFramesMarkedForDisplay.Length() + aFrames.GetLength());

   for (nsFrameList::Enumerator e(aFrames); !e.AtEnd(); e.Next()) {

     mFramesMarkedForDisplay.AppendElement(e.get());

     MarkOutOfFlowFrameForDisplay(aDirtyFrame, e.get(), aDirtyRect);

   }

 }

 void

 nsDisplayListBuilder::MarkPreserve3DFramesForDisplayList(nsIFrame* aDirtyFrame, const nsRect& aDirtyRect)

 {

   nsAutoTArray<nsIFrame::ChildList,4> childListArray;

   aDirtyFrame->GetChildLists(&childListArray);

   nsIFrame::ChildListArrayIterator lists(childListArray);

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

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

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

       nsIFrame *child = childFrames.get();

       if (child->Preserves3D()) {

         mFramesMarkedForDisplay.AppendElement(child);

         nsRect dirty = aDirtyRect - child->GetOffsetTo(aDirtyFrame);

         child->Properties().Set(nsDisplayListBuilder::Preserve3DDirtyRectProperty(),

                            new nsRect(dirty));

         MarkFrameForDisplay(child, aDirtyFrame);

       }

     }

   }

 }

 void*

 nsDisplayListBuilder::Allocate(size_t aSize) {

   void *tmp;

   PL_ARENA_ALLOCATE(tmp, &mPool, aSize);

   if (!tmp) {

     NS_RUNTIMEABORT("out of memory");

   }

   return tmp;

 }

 const DisplayItemClip*

 nsDisplayListBuilder::AllocateDisplayItemClip(const DisplayItemClip& aOriginal)

 {

   void* p = Allocate(sizeof(DisplayItemClip));

   if (!aOriginal.GetRoundedRectCount()) {

     memcpy(p, &aOriginal, sizeof(DisplayItemClip));

     return static_cast<DisplayItemClip*>(p);

   }

   DisplayItemClip* c = new (p) DisplayItemClip(aOriginal);

   mDisplayItemClipsToDestroy.AppendElement(c);

   return c;

 }

 void nsDisplayListSet::MoveTo(const nsDisplayListSet& aDestination) const

 {

   aDestination.BorderBackground()->AppendToTop(BorderBackground());

   aDestination.BlockBorderBackgrounds()->AppendToTop(BlockBorderBackgrounds());

   aDestination.Floats()->AppendToTop(Floats());

   aDestination.Content()->AppendToTop(Content());

   aDestination.PositionedDescendants()->AppendToTop(PositionedDescendants());

   aDestination.Outlines()->AppendToTop(Outlines());

 }

 void

 nsDisplayList::FlattenTo(nsTArray<nsDisplayItem*>* aElements) {

   nsDisplayItem* item;

   while ((item = RemoveBottom()) != nullptr) {

     if (item->GetType() == nsDisplayItem::TYPE_WRAP_LIST) {

       item->GetSameCoordinateSystemChildren()->FlattenTo(aElements);

       item->~nsDisplayItem();

     } else {

       aElements->AppendElement(item);

     }

   }

 }

 nsRect

 nsDisplayList::GetBounds(nsDisplayListBuilder* aBuilder) const {

   nsRect bounds;

   for (nsDisplayItem* i = GetBottom(); i != nullptr; i = i->GetAbove()) {

     bounds.UnionRect(bounds, i->GetClippedBounds(aBuilder));

   }

   return bounds;

 }

 bool

 nsDisplayList::ComputeVisibilityForRoot(nsDisplayListBuilder* aBuilder,

                                         nsRegion* aVisibleRegion,

                                         nsIFrame* aDisplayPortFrame) {

   PROFILER_LABEL("nsDisplayList", "ComputeVisibilityForRoot");

   nsRegion r;

   r.And(*aVisibleRegion, GetBounds(aBuilder));

   return ComputeVisibilityForSublist(aBuilder, aVisibleRegion,

                                      r.GetBounds(), r.GetBounds(),

                                      aDisplayPortFrame);

 }

 static nsRegion

 TreatAsOpaque(nsDisplayItem* aItem, nsDisplayListBuilder* aBuilder)

 {

   bool snap;

   nsRegion opaque = aItem->GetOpaqueRegion(aBuilder, &snap);

   if (aBuilder->IsForPluginGeometry()) {

     // Treat all leaf chrome items as opaque, unless their frames are opacity:0.

     // Since opacity:0 frames generate an nsDisplayOpacity, that item will

     // not be treated as opaque here, so opacity:0 chrome content will be

     // effectively ignored, as it should be.

     // We treat leaf chrome items as opaque to ensure that they cover

     // content plugins, for security reasons.

     // Non-leaf chrome items don't render contents of their own so shouldn't

     // be treated as opaque (and their bounds is just the union of their

     // children, which might be a large area their contents don't really cover).

     nsIFrame* f = aItem->Frame();

     if (f->PresContext()->IsChrome() && !aItem->GetChildren() &&

         f->StyleDisplay()->mOpacity != 0.0) {

       opaque = aItem->GetBounds(aBuilder, &snap);

     }

   }

   if (opaque.IsEmpty()) {

     return opaque;

   }

   nsRegion opaqueClipped;

   nsRegionRectIterator iter(opaque);

   for (const nsRect* r = iter.Next(); r; r = iter.Next()) {

     opaqueClipped.Or(opaqueClipped, aItem->GetClip().ApproximateIntersectInward(*r));

   }

   return opaqueClipped;

 }

 /* Checks if aPotentialScrollItem is a scroll layer item and aPotentialScrollbarItem

  * is an overlay scrollbar item for the same scroll frame.

  */

 static bool

 IsScrollLayerItemAndOverlayScrollbarForScrollFrame(

   nsDisplayItem* aPotentialScrollItem, nsDisplayItem* aPotentialScrollbarItem)

 {

   if (aPotentialScrollItem->GetType() == nsDisplayItem::TYPE_SCROLL_LAYER &&

       aPotentialScrollbarItem &&

       aPotentialScrollbarItem->GetType() == nsDisplayItem::TYPE_OWN_LAYER &&

       LookAndFeel::GetInt(LookAndFeel::eIntID_UseOverlayScrollbars)) {

     nsDisplayScrollLayer* scrollItem =

       static_cast<nsDisplayScrollLayer*>(aPotentialScrollItem);

     nsDisplayOwnLayer* layerItem =

       static_cast<nsDisplayOwnLayer*>(aPotentialScrollbarItem);

     if ((layerItem->GetFlags() &

          (nsDisplayOwnLayer::VERTICAL_SCROLLBAR |

           nsDisplayOwnLayer::HORIZONTAL_SCROLLBAR)) &&

         layerItem->Frame()->GetParent() == scrollItem->GetScrollFrame()) {

       return true;

     }

   }

   return false;

 }

 bool

 nsDisplayList::ComputeVisibilityForSublist(nsDisplayListBuilder* aBuilder,

                                            nsRegion* aVisibleRegion,

                                            const nsRect& aListVisibleBounds,

                                            const nsRect& aAllowVisibleRegionExpansion,

                                            nsIFrame* aDisplayPortFrame) {

 #ifdef DEBUG

   nsRegion r;

   r.And(*aVisibleRegion, GetBounds(aBuilder));

   NS_ASSERTION(r.GetBounds().IsEqualInterior(aListVisibleBounds),

                "bad aListVisibleBounds");

 #endif

   mVisibleRect = aListVisibleBounds;

   bool anyVisible = false;

   nsAutoTArray<nsDisplayItem*, 512> elements;

   FlattenTo(&elements);

   bool forceTransparentSurface = false;

   for (int32_t i = elements.Length() - 1; i >= 0; --i) {

     nsDisplayItem* item = elements[i];

     nsDisplayItem* belowItem = i < 1 ? nullptr : elements[i - 1];

     nsDisplayList* list = item->GetSameCoordinateSystemChildren();

     if (aBuilder->AllowMergingAndFlattening()) {

       if (belowItem && item->TryMerge(aBuilder, belowItem)) {

         belowItem->~nsDisplayItem();

         elements.ReplaceElementsAt(i - 1, 1, item);

         continue;

       }

       // If an overlay scrollbar item is between a scroll layer item and the

       // other scroll layer items that we need to merge with just move the

       // scrollbar item up, that way it will be on top of the scrolled content

       // and we can try to merge all the scroll layer items.

       if (IsScrollLayerItemAndOverlayScrollbarForScrollFrame(item, belowItem)) {

         elements[i] = belowItem;

         elements[i-1] = item;

         i++;

         continue;

       }

       if (list && item->ShouldFlattenAway(aBuilder)) {

         // The elements on the list >= i no longer serve any use.

         elements.SetLength(i);

         list->FlattenTo(&elements);

         i = elements.Length();

         item->~nsDisplayItem();

         continue;

       }

     }

     nsRect bounds = item->GetClippedBounds(aBuilder);

     nsRegion itemVisible;

     itemVisible.And(*aVisibleRegion, bounds);

     item->mVisibleRect = itemVisible.GetBounds();

     if (item->ComputeVisibility(aBuilder, aVisibleRegion,

                                 aAllowVisibleRegionExpansion.Intersect(bounds))) {

       anyVisible = true;

       // If we're in a displayport, we need to make sure that fixed position

       // items do not subtract from the visible region, as async scrolling

       // may expose these occluded areas.

       // If the item is fixed pos in the same document as the displayport

       // then don't let it occlude this list. The only other case possible

       // is that the fixed pos content is in a child document, in which it

       // would scroll with the rest of the content.

       bool occlude = true;

       if (aDisplayPortFrame && item->IsInFixedPos()) {

         if (item->Frame()->PresContext() == aDisplayPortFrame->PresContext()) {

           occlude = false;

         }

       }

       if (occlude) {

         nsRegion opaque = TreatAsOpaque(item, aBuilder);

         // Subtract opaque item from the visible region

         aBuilder->SubtractFromVisibleRegion(aVisibleRegion, opaque);

       }

       if (aBuilder->NeedToForceTransparentSurfaceForItem(item) ||

           (list && list->NeedsTransparentSurface())) {

         forceTransparentSurface = true;

       }

     }

     AppendToBottom(item);

   }

   mIsOpaque = !aVisibleRegion->Intersects(mVisibleRect);

   mForceTransparentSurface = forceTransparentSurface;

 #if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)

   mDidComputeVisibility = true;

 #endif

   return anyVisible;

 }

 void nsDisplayList::PaintRoot(nsDisplayListBuilder* aBuilder,

                               nsRenderingContext* aCtx,

                               uint32_t aFlags) const {

   PROFILER_LABEL("nsDisplayList", "PaintRoot");

   PaintForFrame(aBuilder, aCtx, aBuilder->RootReferenceFrame(), aFlags);

 }

 /**

  * We paint by executing a layer manager transaction, constructing a

  * single layer representing the display list, and then making it the

  * root of the layer manager, drawing into the ThebesLayers.

  */

 void nsDisplayList::PaintForFrame(nsDisplayListBuilder* aBuilder,

                                   nsRenderingContext* aCtx,

                                   nsIFrame* aForFrame,

                                   uint32_t aFlags) const {

   NS_ASSERTION(mDidComputeVisibility,

                "Must call ComputeVisibility before calling Paint");

   nsRefPtr<LayerManager> layerManager;

   bool widgetTransaction = false;

   bool allowRetaining = false;

   bool doBeginTransaction = true;

   nsView *view = nullptr;

   if (aFlags & PAINT_USE_WIDGET_LAYERS) {

     nsIFrame* rootReferenceFrame = aBuilder->RootReferenceFrame();

     view = rootReferenceFrame->GetView();

     NS_ASSERTION(rootReferenceFrame == nsLayoutUtils::GetDisplayRootFrame(rootReferenceFrame),

                  "Reference frame must be a display root for us to use the layer manager");

     nsIWidget* window = rootReferenceFrame->GetNearestWidget();

     if (window) {

       layerManager = window->GetLayerManager(&allowRetaining);

       if (layerManager) {

         doBeginTransaction = !(aFlags & PAINT_EXISTING_TRANSACTION);

         widgetTransaction = true;

       }

     }

   }

   if (!layerManager) {

     if (!aCtx) {

       NS_WARNING("Nowhere to paint into");

       return;

     }

     layerManager = new BasicLayerManager();

   }

   // Store the existing layer builder to reinstate it on return.

   FrameLayerBuilder *oldBuilder = layerManager->GetLayerBuilder();

   FrameLayerBuilder *layerBuilder = new FrameLayerBuilder();

   layerBuilder->Init(aBuilder, layerManager);

   if (aFlags & PAINT_COMPRESSED) {

     layerBuilder->SetLayerTreeCompressionMode();

   }

   if (aFlags & PAINT_FLUSH_LAYERS) {

     FrameLayerBuilder::InvalidateAllLayers(layerManager);

   }

   if (doBeginTransaction) {

     if (aCtx) {

       layerManager->BeginTransactionWithTarget(aCtx->ThebesContext());

     } else {

       layerManager->BeginTransaction();

     }

   }

   if (widgetTransaction) {

     layerBuilder->DidBeginRetainedLayerTransaction(layerManager);

   }

   nsPresContext* presContext = aForFrame->PresContext();

   nsIPresShell* presShell = presContext->GetPresShell();

   NotifySubDocInvalidationFunc computeInvalidFunc =

     presContext->MayHavePaintEventListenerInSubDocument() ? nsPresContext::NotifySubDocInvalidation : 0;

   bool computeInvalidRect = (computeInvalidFunc ||

                              (!layerManager->IsCompositingCheap() && layerManager->NeedsWidgetInvalidation())) &&

                             widgetTransaction;

   nsAutoPtr<LayerProperties> props(computeInvalidRect ? 

                                      LayerProperties::CloneFrom(layerManager->GetRoot()) : 

                                      nullptr);

   ContainerLayerParameters containerParameters

     (presShell->GetXResolution(), presShell->GetYResolution());

   nsRefPtr<ContainerLayer> root = layerBuilder->

     BuildContainerLayerFor(aBuilder, layerManager, aForFrame, nullptr, *this,

                            containerParameters, nullptr);

   nsIDocument* document = nullptr;

   if (presShell) {

     document = presShell->GetDocument();

   }

   if (widgetTransaction ||

       // SVG-as-an-image docs don't paint as part of the retained layer tree,

       // but they still need the invalidation state bits cleared in order for

       // invalidation for CSS/SMIL animation to work properly.

       (document && document->IsBeingUsedAsImage())) {

     aForFrame->ClearInvalidationStateBits();

   }

   if (!root) {

     layerManager->SetUserData(&gLayerManagerLayerBuilder, oldBuilder);

     return;

   }

   // Root is being scaled up by the X/Y resolution. Scale it back down.

   root->SetPostScale(1.0f/containerParameters.mXScale,

                      1.0f/containerParameters.mYScale);

   ViewID id = FrameMetrics::NULL_SCROLL_ID;

   bool isRoot = presContext->IsRootContentDocument();

   nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();

   nsRect displayport, criticalDisplayport;

   bool usingDisplayport = false;

   bool usingCriticalDisplayport = false;

   if (rootScrollFrame) {

     nsIContent* content = rootScrollFrame->GetContent();

     if (content) {

       usingDisplayport = nsLayoutUtils::GetDisplayPort(content, &displayport);

       usingCriticalDisplayport =

         nsLayoutUtils::GetCriticalDisplayPort(content, &criticalDisplayport);

       // If this is the root content document, we want it to have a scroll id.

       if (isRoot) {

         id = nsLayoutUtils::FindOrCreateIDFor(content);

       }

     }

   }

   nsRect viewport(aBuilder->ToReferenceFrame(aForFrame), aForFrame->GetSize());

   RecordFrameMetrics(aForFrame, rootScrollFrame,

                      aBuilder->FindReferenceFrameFor(aForFrame),

                      root, mVisibleRect, viewport,

                      (usingDisplayport ? &displayport : nullptr),

                      (usingCriticalDisplayport ? &criticalDisplayport : nullptr),

                      id, isRoot, containerParameters);

   if (usingDisplayport &&

       !(root->GetContentFlags() & Layer::CONTENT_OPAQUE)) {

     // See bug 693938, attachment 567017

     NS_WARNING("Transparent content with displayports can be expensive.");

   }

   layerManager->SetRoot(root);

   layerBuilder->WillEndTransaction();

   bool temp = aBuilder->SetIsCompositingCheap(layerManager->IsCompositingCheap());

   LayerManager::EndTransactionFlags flags = LayerManager::END_DEFAULT;

   if (layerManager->NeedsWidgetInvalidation()) {

     if (aFlags & PAINT_NO_COMPOSITE) {

       flags = LayerManager::END_NO_COMPOSITE;

     }

   } else {

     // Client layer managers never composite directly, so

     // we don't need to worry about END_NO_COMPOSITE.

     if (aBuilder->WillComputePluginGeometry()) {

       flags = LayerManager::END_NO_REMOTE_COMPOSITE;

     }

   }

   layerManager->EndTransaction(FrameLayerBuilder::DrawThebesLayer,

                                aBuilder, flags);

   aBuilder->SetIsCompositingCheap(temp);

   layerBuilder->DidEndTransaction();

   nsIntRegion invalid;

   if (props) {

     invalid = props->ComputeDifferences(root, computeInvalidFunc);

   } else if (widgetTransaction) {

     LayerProperties::ClearInvalidations(root);

   }

   bool shouldInvalidate = layerManager->NeedsWidgetInvalidation();

   if (view) {

     if (props) {

       if (!invalid.IsEmpty()) {

         nsIntRect bounds = invalid.GetBounds();

         nsRect rect(presContext->DevPixelsToAppUnits(bounds.x),

                     presContext->DevPixelsToAppUnits(bounds.y),

                     presContext->DevPixelsToAppUnits(bounds.width),

                     presContext->DevPixelsToAppUnits(bounds.height));

         if (shouldInvalidate) {

           view->GetViewManager()->InvalidateViewNoSuppression(view, rect);

         }

         presContext->NotifyInvalidation(bounds, 0);

       }

     } else if (shouldInvalidate) {

       view->GetViewManager()->InvalidateView(view);

     }

   }

   if (aFlags & PAINT_FLUSH_LAYERS) {

     FrameLayerBuilder::InvalidateAllLayers(layerManager);

   }

   layerManager->SetUserData(&gLayerManagerLayerBuilder, oldBuilder);

 }

 uint32_t nsDisplayList::Count() const {

   uint32_t count = 0;

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

     ++count;

   }

   return count;

 }

 nsDisplayItem* nsDisplayList::RemoveBottom() {

   nsDisplayItem* item = mSentinel.mAbove;

   if (!item)

     return nullptr;

   mSentinel.mAbove = item->mAbove;

   if (item == mTop) {

     // must have been the only item

     mTop = &mSentinel;

   }

   item->mAbove = nullptr;

   return item;

 }

 void nsDisplayList::DeleteAll() {

   nsDisplayItem* item;

   while ((item = RemoveBottom()) != nullptr) {

     item->~nsDisplayItem();

   }

 }

 static bool

 GetMouseThrough(const nsIFrame* aFrame)

 {

   if (!aFrame->IsBoxFrame())

     return false;

   const nsIFrame* frame = aFrame;

   while (frame) {

     if (frame->GetStateBits() & NS_FRAME_MOUSE_THROUGH_ALWAYS) {

       return true;

     } else if (frame->GetStateBits() & NS_FRAME_MOUSE_THROUGH_NEVER) {

       return false;

     }

     frame = frame->GetParentBox();

   }

   return false;

 }

 static bool

 IsFrameReceivingPointerEvents(nsIFrame* aFrame)

 {

   nsSubDocumentFrame* frame = do_QueryFrame(aFrame);

   if (frame && frame->PassPointerEventsToChildren()) {

     return true;

   }

   return NS_STYLE_POINTER_EVENTS_NONE !=

     aFrame->StyleVisibility()->GetEffectivePointerEvents(aFrame);

 }

 // A list of frames, and their z depth. Used for sorting

 // the results of hit testing.

 struct FramesWithDepth

 {

   FramesWithDepth(float aDepth) :

     mDepth(aDepth)

   {}

   bool operator<(const FramesWithDepth& aOther) const {

     if (mDepth != aOther.mDepth) {

       // We want to sort so that the shallowest item (highest depth value) is first

       return mDepth > aOther.mDepth;

     }

     return this < &aOther;

   }

   bool operator==(const FramesWithDepth& aOther) const {

     return this == &aOther;

   }

   float mDepth;

   nsTArray<nsIFrame*> mFrames;

 };

 // Sort the frames by depth and then moves all the contained frames to the destination

 void FlushFramesArray(nsTArray<FramesWithDepth>& aSource, nsTArray<nsIFrame*>* aDest)

 {

   if (aSource.IsEmpty()) {

     return;

   }

   aSource.Sort();

   uint32_t length = aSource.Length();

   for (uint32_t i = 0; i < length; i++) {

     aDest->MoveElementsFrom(aSource[i].mFrames);

   }

   aSource.Clear();

 }

 void nsDisplayList::HitTest(nsDisplayListBuilder* aBuilder, const nsRect& aRect,

                             nsDisplayItem::HitTestState* aState,

                             nsTArray<nsIFrame*> *aOutFrames) const {

   int32_t itemBufferStart = aState->mItemBuffer.Length();

   nsDisplayItem* item;

   for (item = GetBottom(); item; item = item->GetAbove()) {

     aState->mItemBuffer.AppendElement(item);

   }

   nsAutoTArray<FramesWithDepth, 16> temp;

   for (int32_t i = aState->mItemBuffer.Length() - 1; i >= itemBufferStart; --i) {

     // Pop element off the end of the buffer. We want to shorten the buffer

     // so that recursive calls to HitTest have more buffer space.

     item = aState->mItemBuffer[i];

     aState->mItemBuffer.SetLength(i);

     bool snap;

     nsRect r = item->GetBounds(aBuilder, &snap).Intersect(aRect);

     if (item->GetClip().MayIntersect(r)) {

       nsAutoTArray<nsIFrame*, 16> outFrames;

       item->HitTest(aBuilder, aRect, aState, &outFrames);

       // For 3d transforms with preserve-3d we add hit frames into the temp list

       // so we can sort them later, otherwise we add them directly to the output list.

       nsTArray<nsIFrame*> *writeFrames = aOutFrames;

       if (item->GetType() == nsDisplayItem::TYPE_TRANSFORM &&

           item->Frame()->Preserves3D()) {

         if (outFrames.Length()) {

           nsDisplayTransform *transform = static_cast<nsDisplayTransform*>(item);

           nsPoint point = aRect.TopLeft();

           // A 1x1 rect means a point, otherwise use the center of the rect

           if (aRect.width != 1 || aRect.height != 1) {

             point = aRect.Center();

           }

           temp.AppendElement(FramesWithDepth(transform->GetHitDepthAtPoint(aBuilder, point)));

           writeFrames = &temp[temp.Length() - 1].mFrames;

         }

       } else {

         // We may have just finished a run of consecutive preserve-3d transforms,

         // so flush these into the destination array before processing our frame list.

         FlushFramesArray(temp, aOutFrames);

       }

       for (uint32_t j = 0; j < outFrames.Length(); j++) {

         nsIFrame *f = outFrames.ElementAt(j);

         // Handle the XUL 'mousethrough' feature and 'pointer-events'.

         if (!GetMouseThrough(f) && IsFrameReceivingPointerEvents(f)) {

           writeFrames->AppendElement(f);

         }

       }

     }

   }

   // Clear any remaining preserve-3d transforms.

   FlushFramesArray(temp, aOutFrames);

   NS_ASSERTION(aState->mItemBuffer.Length() == uint32_t(itemBufferStart),

                "How did we forget to pop some elements?");

 }

 static void Sort(nsDisplayList* aList, int32_t aCount, nsDisplayList::SortLEQ aCmp,

                  void* aClosure) {

   if (aCount < 2)

     return;

   nsDisplayList list1;

   nsDisplayList list2;

   int i;

   int32_t half = aCount/2;

   bool sorted = true;

   nsDisplayItem* prev = nullptr;

   for (i = 0; i < aCount; ++i) {

     nsDisplayItem* item = aList->RemoveBottom();

     (i < half ? &list1 : &list2)->AppendToTop(item);

     if (sorted && prev && !aCmp(prev, item, aClosure)) {

       sorted = false;

     }

     prev = item;

   }

   if (sorted) {

     aList->AppendToTop(&list1);

     aList->AppendToTop(&list2);

     return;

   }

   Sort(&list1, half, aCmp, aClosure);

   Sort(&list2, aCount - half, aCmp, aClosure);

   for (i = 0; i < aCount; ++i) {

     if (list1.GetBottom() &&

         (!list2.GetBottom() ||

          aCmp(list1.GetBottom(), list2.GetBottom(), aClosure))) {

       aList->AppendToTop(list1.RemoveBottom());

     } else {

       aList->AppendToTop(list2.RemoveBottom());

     }

   }

 }

 static nsIContent* FindContentInDocument(nsDisplayItem* aItem, nsIDocument* aDoc) {

   nsIFrame* f = aItem->Frame();

   while (f) {

     nsPresContext* pc = f->PresContext();

     if (pc->Document() == aDoc) {

       return f->GetContent();

     }

     f = nsLayoutUtils::GetCrossDocParentFrame(pc->PresShell()->GetRootFrame());

   }

   return nullptr;

 }

 static bool IsContentLEQ(nsDisplayItem* aItem1, nsDisplayItem* aItem2,

                          void* aClosure) {

   nsIContent* commonAncestor = static_cast<nsIContent*>(aClosure);

   // It's possible that the nsIContent for aItem1 or aItem2 is in a subdocument

   // of commonAncestor, because display items for subdocuments have been

   // mixed into the same list. Ensure that we're looking at content

   // in commonAncestor's document.

   nsIDocument* commonAncestorDoc = commonAncestor->OwnerDoc();

   nsIContent* content1 = FindContentInDocument(aItem1, commonAncestorDoc);

   nsIContent* content2 = FindContentInDocument(aItem2, commonAncestorDoc);

   if (!content1 || !content2) {

     NS_ERROR("Document trees are mixed up!");

     // Something weird going on

     return true;

   }

   return nsLayoutUtils::CompareTreePosition(content1, content2, commonAncestor) <= 0;

 }

 static bool IsZOrderLEQ(nsDisplayItem* aItem1, nsDisplayItem* aItem2,

                         void* aClosure) {

   // Note that we can't just take the difference of the two

   // z-indices here, because that might overflow a 32-bit int.

   return aItem1->ZIndex() <= aItem2->ZIndex();

 }

 void nsDisplayList::SortByZOrder(nsDisplayListBuilder* aBuilder,

                                  nsIContent* aCommonAncestor) {

   Sort(aBuilder, IsZOrderLEQ, aCommonAncestor);

 }

 void nsDisplayList::SortByContentOrder(nsDisplayListBuilder* aBuilder,

                                        nsIContent* aCommonAncestor) {

   Sort(aBuilder, IsContentLEQ, aCommonAncestor);

 }

 void nsDisplayList::Sort(nsDisplayListBuilder* aBuilder,

                          SortLEQ aCmp, void* aClosure) {

   ::Sort(this, Count(), aCmp, aClosure);

 }

 void

 nsDisplayItem::AddInvalidRegionForSyncDecodeBackgroundImages(

   nsDisplayListBuilder* aBuilder,

   const nsDisplayItemGeometry* aGeometry,

   nsRegion* aInvalidRegion)

 {

   if (aBuilder->ShouldSyncDecodeImages()) {

     if (!nsCSSRendering::AreAllBackgroundImagesDecodedForFrame(mFrame)) {

       bool snap;

       aInvalidRegion->Or(*aInvalidRegion, GetBounds(aBuilder, &snap));

     }

   }

 }

 /* static */ bool

 nsDisplayItem::ForceActiveLayers()

 {

   static bool sForce = false;

   static bool sForceCached = false;

   if (!sForceCached) {

     Preferences::AddBoolVarCache(&sForce, "layers.force-active", false);

     sForceCached = true;

   }

   return sForce;

 }

 /* static */ int32_t

 nsDisplayItem::MaxActiveLayers()

 {

   static int32_t sMaxLayers = false;

   static bool sMaxLayersCached = false;

   if (!sMaxLayersCached) {

     Preferences::AddIntVarCache(&sMaxLayers, "layers.max-active", -1);

     sMaxLayersCached = true;

   }

   return sMaxLayers;

 }

 int32_t

 nsDisplayItem::ZIndex() const

 {

   if (!mFrame->IsPositioned() && !mFrame->IsFlexItem())

     return 0;

   const nsStylePosition* position = mFrame->StylePosition();

   if (position->mZIndex.GetUnit() == eStyleUnit_Integer)

     return position->mZIndex.GetIntValue();

   // sort the auto and 0 elements together

   return 0;

 }

 bool

 nsDisplayItem::RecomputeVisibility(nsDisplayListBuilder* aBuilder,

                                    nsRegion* aVisibleRegion) {

   nsRect bounds = GetClippedBounds(aBuilder);

   nsRegion itemVisible;

   itemVisible.And(*aVisibleRegion, bounds);

   mVisibleRect = itemVisible.GetBounds();

   // When we recompute visibility within layers we don't need to

   // expand the visible region for content behind plugins (the plugin

   // is not in the layer).

   if (!ComputeVisibility(aBuilder, aVisibleRegion, nsRect()))

     return false;

   nsRegion opaque = TreatAsOpaque(this, aBuilder);

   aBuilder->SubtractFromVisibleRegion(aVisibleRegion, opaque);

   return true;

 }

 nsRect

 nsDisplayItem::GetClippedBounds(nsDisplayListBuilder* aBuilder)

 {

   bool snap;

   nsRect r = GetBounds(aBuilder, &snap);

   return GetClip().ApplyNonRoundedIntersection(r);

 }

 nsRect

 nsDisplaySolidColor::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap)

 {

   *aSnap = true;

   return mBounds;

 }

 void

 nsDisplaySolidColor::Paint(nsDisplayListBuilder* aBuilder,

                            nsRenderingContext* aCtx)

 {

   aCtx->SetColor(mColor);

   aCtx->FillRect(mVisibleRect);

 }

 #ifdef MOZ_DUMP_PAINTING

 void

 nsDisplaySolidColor::WriteDebugInfo(nsACString& aTo)

 {

   aTo += nsPrintfCString(" (rgba %d,%d,%d,%d)",

                  NS_GET_R(mColor), NS_GET_G(mColor),

                  NS_GET_B(mColor), NS_GET_A(mColor));

 }

 #endif

 static void

 RegisterThemeGeometry(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame)

 {

   nsIFrame* displayRoot = nsLayoutUtils::GetDisplayRootFrame(aFrame);

   for (nsIFrame* f = aFrame; f; f = f->GetParent()) {

     // Bail out if we're in a transformed subtree

     if (f->IsTransformed())

       return;

     // Bail out if we're not in the displayRoot's document

     if (!f->GetParent() && f != displayRoot)

       return;

   }

   nsRect borderBox(aFrame->GetOffsetTo(displayRoot), aFrame->GetSize());

   aBuilder->RegisterThemeGeometry(aFrame->StyleDisplay()->mAppearance,

       borderBox.ToNearestPixels(aFrame->PresContext()->AppUnitsPerDevPixel()));

 }

 nsDisplayBackgroundImage::nsDisplayBackgroundImage(nsDisplayListBuilder* aBuilder,

                                                    nsIFrame* aFrame,

                                                    uint32_t aLayer,

                                                    const nsStyleBackground* aBackgroundStyle)

   : nsDisplayImageContainer(aBuilder, aFrame)

   , mBackgroundStyle(aBackgroundStyle)

   , mLayer(aLayer)

 {

   MOZ_COUNT_CTOR(nsDisplayBackgroundImage);

   mBounds = GetBoundsInternal(aBuilder);

 }

 nsDisplayBackgroundImage::~nsDisplayBackgroundImage()

 {

 #ifdef NS_BUILD_REFCNT_LOGGING

   MOZ_COUNT_DTOR(nsDisplayBackgroundImage);

 #endif

 }

 static nsStyleContext* GetBackgroundStyleContext(nsIFrame* aFrame)

 {

   nsStyleContext *sc;

   if (!nsCSSRendering::FindBackground(aFrame, &sc)) {

     // We don't want to bail out if moz-appearance is set on a root

     // node. If it has a parent content node, bail because it's not

     // a root, other wise keep going in order to let the theme stuff

     // draw the background. The canvas really should be drawing the

     // bg, but there's no way to hook that up via css.

     if (!aFrame->StyleDisplay()->mAppearance) {

       return nullptr;

     }

     nsIContent* content = aFrame->GetContent();

     if (!content || content->GetParent()) {

       return nullptr;

     }

     sc = aFrame->StyleContext();

   }

   return sc;

 }

 /*static*/ bool

 nsDisplayBackgroundImage::AppendBackgroundItemsToTop(nsDisplayListBuilder* aBuilder,

                                                      nsIFrame* aFrame,

                                                      nsDisplayList* aList)

 {

   nsStyleContext* bgSC = nullptr;

   const nsStyleBackground* bg = nullptr;

   nsPresContext* presContext = aFrame->PresContext();

   bool isThemed = aFrame->IsThemed();

   if (!isThemed) {

     bgSC = GetBackgroundStyleContext(aFrame);

     if (bgSC) {

       bg = bgSC->StyleBackground();

     }

   }

   bool drawBackgroundColor = false;

   nscolor color;

   if (!nsCSSRendering::IsCanvasFrame(aFrame) && bg) {

     bool drawBackgroundImage;

     color =

       nsCSSRendering::DetermineBackgroundColor(presContext, bgSC, aFrame,

                                                drawBackgroundImage, drawBackgroundColor);

   }

   // An auxiliary list is necessary in case we have background blending; if that

   // is the case, background items need to be wrapped by a blend container to

   // isolate blending to the background

   nsDisplayList bgItemList;

   // Even if we don't actually have a background color to paint, we may still need

   // to create an item for hit testing.

   if ((drawBackgroundColor && color != NS_RGBA(0,0,0,0)) ||

       aBuilder->IsForEventDelivery()) {

     bgItemList.AppendNewToTop(

         new (aBuilder) nsDisplayBackgroundColor(aBuilder, aFrame, bg,

                                                 drawBackgroundColor ? color : NS_RGBA(0, 0, 0, 0)));

   }

   if (isThemed) {

     nsDisplayThemedBackground* bgItem =

       new (aBuilder) nsDisplayThemedBackground(aBuilder, aFrame);

     bgItemList.AppendNewToTop(bgItem);

     aList->AppendToTop(&bgItemList);

     return true;

   }

   if (!bg) {

     aList->AppendToTop(&bgItemList);

     return false;

   }

   bool needBlendContainer = false;

   // Passing bg == nullptr in this macro will result in one iteration with

   // i = 0.

   NS_FOR_VISIBLE_BACKGROUND_LAYERS_BACK_TO_FRONT(i, bg) {

     if (bg->mLayers[i].mImage.IsEmpty()) {

       continue;

     }

     if (bg->mLayers[i].mBlendMode != NS_STYLE_BLEND_NORMAL) {

       needBlendContainer = true;

     }

     nsDisplayBackgroundImage* bgItem =

       new (aBuilder) nsDisplayBackgroundImage(aBuilder, aFrame, i, bg);

     bgItemList.AppendNewToTop(bgItem);

   }

   if (needBlendContainer) {

     bgItemList.AppendNewToTop(

       new (aBuilder) nsDisplayBlendContainer(aBuilder, aFrame, &bgItemList));

   }

   aList->AppendToTop(&bgItemList);

   return false;

 }

 // Check that the rounded border of aFrame, added to aToReferenceFrame,

 // intersects aRect.  Assumes that the unrounded border has already

 // been checked for intersection.

 static bool

 RoundedBorderIntersectsRect(nsIFrame* aFrame,

                             const nsPoint& aFrameToReferenceFrame,

                             const nsRect& aTestRect)

 {

   if (!nsRect(aFrameToReferenceFrame, aFrame->GetSize()).Intersects(aTestRect))

     return false;

   nscoord radii[8];

   return !aFrame->GetBorderRadii(radii) ||

          nsLayoutUtils::RoundedRectIntersectsRect(nsRect(aFrameToReferenceFrame,

                                                   aFrame->GetSize()),

                                                   radii, aTestRect);

 }

 // Returns TRUE if aContainedRect is guaranteed to be contained in

 // the rounded rect defined by aRoundedRect and aRadii. Complex cases are

 // handled conservatively by returning FALSE in some situations where

 // a more thorough analysis could return TRUE.

 //

 // See also RoundedRectIntersectsRect.

 static bool RoundedRectContainsRect(const nsRect& aRoundedRect,

                                     const nscoord aRadii[8],

                                     const nsRect& aContainedRect) {

   nsRegion rgn = nsLayoutUtils::RoundedRectIntersectRect(aRoundedRect, aRadii, aContainedRect);

   return rgn.Contains(aContainedRect);

 }

 bool

 nsDisplayBackgroundImage::IsSingleFixedPositionImage(nsDisplayListBuilder* aBuilder,

                                                      const nsRect& aClipRect,

                                                      gfxRect* aDestRect)

 {

   if (!mBackgroundStyle)

     return false;

   if (mBackgroundStyle->mLayers.Length() != 1)

     return false;

   nsPresContext* presContext = mFrame->PresContext();

   uint32_t flags = aBuilder->GetBackgroundPaintFlags();

   nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());

   const nsStyleBackground::Layer &layer = mBackgroundStyle->mLayers[mLayer];

   if (layer.mAttachment != NS_STYLE_BG_ATTACHMENT_FIXED)

     return false;

   nsBackgroundLayerState state =

     nsCSSRendering::PrepareBackgroundLayer(presContext,

                                            mFrame,

                                            flags,

                                            borderArea,

                                            aClipRect,

                                            *mBackgroundStyle,

                                            layer);

   nsImageRenderer* imageRenderer = &state.mImageRenderer;

   // We only care about images here, not gradients.

   if (!imageRenderer->IsRasterImage())

     return false;

   int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();

   *aDestRect = nsLayoutUtils::RectToGfxRect(state.mFillArea, appUnitsPerDevPixel);

   return true;

 }

 bool

 nsDisplayBackgroundImage::TryOptimizeToImageLayer(LayerManager* aManager,

                                                   nsDisplayListBuilder* aBuilder)

 {

   if (!mBackgroundStyle)

     return false;

   nsPresContext* presContext = mFrame->PresContext();

   uint32_t flags = aBuilder->GetBackgroundPaintFlags();

   nsRect borderArea = nsRect(ToReferenceFrame(), mFrame->GetSize());

   const nsStyleBackground::Layer &layer = mBackgroundStyle->mLayers[mLayer];

   if (layer.mClip != NS_STYLE_BG_CLIP_BORDER) {

     return false;

   }

   nscoord radii[8];

   if (mFrame->GetBorderRadii(radii)) {

     return false;

   }

   nsBackgroundLayerState state =

     nsCSSRendering::PrepareBackgroundLayer(presContext,

                                            mFrame,

                                            flags,

                                            borderArea,

                                            borderArea,

                                            *mBackgroundStyle,

                                            layer);

   nsImageRenderer* imageRenderer = &state.mImageRenderer;

   // We only care about images here, not gradients.

   if (!imageRenderer->IsRasterImage())

     return false;

   nsRefPtr<ImageContainer> imageContainer = imageRenderer->GetContainer(aManager);

   // Image is not ready to be made into a layer yet

   if (!imageContainer)

     return false;

   // We currently can't handle tiled or partial backgrounds.

   if (!state.mDestArea.IsEqualEdges(state.mFillArea)) {

     return false;

   }

   // XXX Ignoring state.mAnchor. ImageLayer drawing snaps mDestArea edges to

   // layer pixel boundaries. This should be OK for now.

   int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel();

   mDestRect = nsLayoutUtils::RectToGfxRect(state.mDestArea, appUnitsPerDevPixel);

   mImageContainer = imageContainer;

   // Ok, we can turn this into a layer if needed.

   return true;

 }

 already_AddRefed<ImageContainer>

 nsDisplayBackgroundImage::GetContainer(LayerManager* aManager,

                                        nsDisplayListBuilder *aBuilder)

 {

   if (!TryOptimizeToImageLayer(aManager, aBuilder)) {

     return nullptr;

   }

   nsRefPtr<ImageContainer> container = mImageContainer;

   return container.forget();

 }

 LayerState

 nsDisplayBackgroundImage::GetLayerState(nsDisplayListBuilder* aBuilder,

                                         LayerManager* aManager,

                                         const ContainerLayerParameters& aParameters)

 {

   bool animated = false;

   if (mBackgroundStyle) {

     const nsStyleBackground::Layer &layer = mBackgroundStyle->mLayers[mLayer];

     const nsStyleImage* image = &layer.mImage;

     if (image->GetType() == eStyleImageType_Image) {

       imgIRequest* imgreq = image->GetImageData();

       nsCOMPtr<imgIContainer> image;

       if (NS_SUCCEEDED(imgreq->GetImage(getter_AddRefs(image))) && image) {

         if (NS_FAILED(image->GetAnimated(&animated))) {

           animated = false;

         }

       }

     }

   }

   if (!animated ||

       !nsLayoutUtils::AnimatedImageLayersEnabled()) {

     if (!aManager->IsCompositingCheap() ||

         !nsLayoutUtils::GPUImageScalingEnabled()) {

       return LAYER_NONE;

     }

   }

   if (!TryOptimizeToImageLayer(aManager, aBuilder)) {

     return LAYER_NONE;

   }

   if (!animated) {

     mozilla::gfx::IntSize imageSize = mImageContainer->GetCurrentSize();

     NS_ASSERTION(imageSize.width != 0 && imageSize.height != 0, "Invalid image size!");

     gfxRect destRect = mDestRect;

     destRect.width *= aParameters.mXScale;

     destRect.height *= aParameters.mYScale;

     // Calculate the scaling factor for the frame.

     gfxSize scale = gfxSize(destRect.width / imageSize.width, destRect.height / imageSize.height);

     // If we are not scaling at all, no point in separating this into a layer.

     if (scale.width == 1.0f && scale.height == 1.0f) {

       return LAYER_NONE;

     }

     // If the target size is pretty small, no point in using a layer.

     if (destRect.width * destRect.height < 64 * 64) {

       return LAYER_NONE;

     }

   }

   return LAYER_ACTIVE;

 }

 already_AddRefed<Layer>

 nsDisplayBackgroundImage::BuildLayer(nsDisplayListBuilder* aBuilder,

                                      LayerManager* aManager,

                                      const ContainerLayerParameters& aParameters)

 {

   nsRefPtr<ImageLayer> layer = static_cast<ImageLayer*>

     (aManager->GetLayerBuilder()->GetLeafLayerFor(aBuilder, this));

   if (!layer) {

     layer = aManager->CreateImageLayer();

     if (!layer)

       return nullptr;

   }

   layer->SetContainer(mImageContainer);

   ConfigureLayer(layer, aParameters.mOffset);

   return layer.forget();

 }

 void

 nsDisplayBackgroundImage::ConfigureLayer(ImageLayer* aLayer, const nsIntPoint& aOffset)

 {

   aLayer->SetFilter(nsLayoutUtils::GetGraphicsFilterForFrame(mFrame));

   mozilla::gfx::IntSize imageSize = mImageContainer->GetCurrentSize();

   NS_ASSERTION(imageSize.width != 0 && imageSize.height != 0, "Invalid image size!");

   gfxPoint p = mDestRect.TopLeft() + aOffset;

   gfx::Matrix transform;

   transform.Translate(p.x, p.y);

   transform.Scale(mDestRect.width/imageSize.width,

                   mDestRect.height/imageSize.height);

   aLayer->SetBaseTransform(gfx::Matrix4x4::From2D(transform));

   aLayer->SetVisibleRegion(nsIntRect(0, 0, imageSize.width, imageSize.height));

 }

 void

 nsDisplayBackgroundImage::HitTest(nsDisplayListBuilder* aBuilder,

                                   const nsRect& aRect,

                                   HitTestState* aState,

                                   nsTArray<nsIFrame*> *aOutFrames)

 {

   if (RoundedBorderIntersectsRect(mFrame, ToReferenceFrame(), aRect)) {

     aOutFrames->AppendElement(mFrame);

   }

 }

 bool

 nsDisplayBackgroundImage::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                             nsRegion* aVisibleRegion,

                                             const nsRect& aAllowVisibleRegionExpansion)

 {

   if (!nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion,

                                         aAllowVisibleRegionExpansion)) {

     return false;

   }

   // Return false if the background was propagated away from this

   // frame. We don't want this display item to show up and confuse

   // anything.

   return mBackgroundStyle;

 }

 /* static */ nsRegion

 nsDisplayBackgroundImage::GetInsideClipRegion(nsDisplayItem* aItem,

                                               nsPresContext* aPresContext,

                                               uint8_t aClip, const nsRect& aRect,

                                               bool* aSnap)

 {

   nsRegion result;

   if (aRect.IsEmpty())

     return result;

   nsIFrame *frame = aItem->Frame();

   nscoord radii[8];

   nsRect clipRect;

   bool haveRadii;

   switch (aClip) {

   case NS_STYLE_BG_CLIP_BORDER:

     haveRadii = frame->GetBorderRadii(radii);

     clipRect = nsRect(aItem->ToReferenceFrame(), frame->GetSize());

     break;

   case NS_STYLE_BG_CLIP_PADDING:

     haveRadii = frame->GetPaddingBoxBorderRadii(radii);

     clipRect = frame->GetPaddingRect() - frame->GetPosition() + aItem->ToReferenceFrame();

     break;

   case NS_STYLE_BG_CLIP_CONTENT:

     haveRadii = frame->GetContentBoxBorderRadii(radii);

     clipRect = frame->GetContentRect() - frame->GetPosition() + aItem->ToReferenceFrame();

     break;

   default:

     NS_NOTREACHED("Unknown clip type");

     return result;

   }

   if (haveRadii) {

     *aSnap = false;

     result = nsLayoutUtils::RoundedRectIntersectRect(clipRect, radii, aRect);

   } else {

     result = clipRect.Intersect(aRect);

   }

   return result;

 }

 nsRegion

 nsDisplayBackgroundImage::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                                           bool* aSnap) {

   nsRegion result;

   *aSnap = false;

   if (!mBackgroundStyle)

     return result;

   *aSnap = true;

   // For policies other than EACH_BOX, don't try to optimize here, since

   // this could easily lead to O(N^2) behavior inside InlineBackgroundData,

   // which expects frames to be sent to it in content order, not reverse

   // content order which we'll produce here.

   // Of course, if there's only one frame in the flow, it doesn't matter.

   if (mBackgroundStyle->mBackgroundInlinePolicy == NS_STYLE_BG_INLINE_POLICY_EACH_BOX ||

       (!mFrame->GetPrevContinuation() && !mFrame->GetNextContinuation())) {

     const nsStyleBackground::Layer& layer = mBackgroundStyle->mLayers[mLayer];

     if (layer.mImage.IsOpaque() && layer.mBlendMode == NS_STYLE_BLEND_NORMAL) {

       nsPresContext* presContext = mFrame->PresContext();

       result = GetInsideClipRegion(this, presContext, layer.mClip, mBounds, aSnap);

     }

   }

   return result;

 }

 bool

 nsDisplayBackgroundImage::IsUniform(nsDisplayListBuilder* aBuilder, nscolor* aColor) {

   if (!mBackgroundStyle) {

     *aColor = NS_RGBA(0,0,0,0);

     return true;

   }

   return false;

 }

 bool

 nsDisplayBackgroundImage::IsVaryingRelativeToMovingFrame(nsDisplayListBuilder* aBuilder,

                                                          nsIFrame* aFrame)

 {

   if (!mBackgroundStyle)

     return false;

   if (!mBackgroundStyle->HasFixedBackground())

     return false;

   // If aFrame is mFrame or an ancestor in this document, and aFrame is

   // not the viewport frame, then moving aFrame will move mFrame

   // relative to the viewport, so our fixed-pos background will change.

   return aFrame->GetParent() &&

     (aFrame == mFrame ||

      nsLayoutUtils::IsProperAncestorFrame(aFrame, mFrame));

 }

 nsRect

 nsDisplayBackgroundImage::GetPositioningArea()

 {

   if (!mBackgroundStyle) {

     return nsRect();

   }

   nsIFrame* attachedToFrame;

   return nsCSSRendering::ComputeBackgroundPositioningArea(

       mFrame->PresContext(), mFrame,

       nsRect(ToReferenceFrame(), mFrame->GetSize()),

       *mBackgroundStyle, mBackgroundStyle->mLayers[mLayer],

       &attachedToFrame) + ToReferenceFrame();

 }

 bool

 nsDisplayBackgroundImage::RenderingMightDependOnPositioningAreaSizeChange()

 {

   if (!mBackgroundStyle)

     return false;

   nscoord radii[8];

   if (mFrame->GetBorderRadii(radii)) {

     // A change in the size of the positioning area might change the position

     // of the rounded corners.

     return true;

   }

   const nsStyleBackground::Layer &layer = mBackgroundStyle->mLayers[mLayer];

   if (layer.RenderingMightDependOnPositioningAreaSizeChange()) {

     return true;

   }

   return false;

 }

 static void CheckForBorderItem(nsDisplayItem *aItem, uint32_t& aFlags)

 {

   nsDisplayItem* nextItem = aItem->GetAbove();

   while (nextItem && nextItem->GetType() == nsDisplayItem::TYPE_BACKGROUND) {

     nextItem = nextItem->GetAbove();

   }

   if (nextItem && 

       nextItem->Frame() == aItem->Frame() &&

       nextItem->GetType() == nsDisplayItem::TYPE_BORDER) {

     aFlags |= nsCSSRendering::PAINTBG_WILL_PAINT_BORDER;

   }

 }

 void

 nsDisplayBackgroundImage::Paint(nsDisplayListBuilder* aBuilder,

                                 nsRenderingContext* aCtx) {

   PaintInternal(aBuilder, aCtx, mVisibleRect, nullptr);

 }

 void

 nsDisplayBackgroundImage::PaintInternal(nsDisplayListBuilder* aBuilder,

                                         nsRenderingContext* aCtx, const nsRect& aBounds,

                                         nsRect* aClipRect) {

   nsPoint offset = ToReferenceFrame();

   uint32_t flags = aBuilder->GetBackgroundPaintFlags();

   CheckForBorderItem(this, flags);

   nsCSSRendering::PaintBackground(mFrame->PresContext(), *aCtx, mFrame,

                                   aBounds,

                                   nsRect(offset, mFrame->GetSize()),

                                   flags, aClipRect, mLayer);

 }

 void nsDisplayBackgroundImage::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                                          const nsDisplayItemGeometry* aGeometry,

                                                          nsRegion* aInvalidRegion)

 {

   if (!mBackgroundStyle) {

     return;

   }

   const nsDisplayBackgroundGeometry* geometry = static_cast<const nsDisplayBackgroundGeometry*>(aGeometry);

   bool snap;

   nsRect bounds = GetBounds(aBuilder, &snap);

   nsRect positioningArea = GetPositioningArea();

   if (positioningArea.TopLeft() != geometry->mPositioningArea.TopLeft() ||

       (positioningArea.Size() != geometry->mPositioningArea.Size() &&

        RenderingMightDependOnPositioningAreaSizeChange())) {

     // Positioning area changed in a way that could cause everything to change,

     // so invalidate everything (both old and new painting areas).

     aInvalidRegion->Or(bounds, geometry->mBounds);

     if (positioningArea.Size() != geometry->mPositioningArea.Size()) {

       NotifyRenderingChanged();

     }

     return;

   }

   if (aBuilder->ShouldSyncDecodeImages()) {

     if (mBackgroundStyle &&

         !nsCSSRendering::IsBackgroundImageDecodedForStyleContextAndLayer(mBackgroundStyle, mLayer)) {

       aInvalidRegion->Or(*aInvalidRegion, bounds);

       NotifyRenderingChanged();

     }

   }

   if (!bounds.IsEqualInterior(geometry->mBounds)) {

     // Positioning area is unchanged, so invalidate just the change in the

     // painting area.

     aInvalidRegion->Xor(bounds, geometry->mBounds);

     NotifyRenderingChanged();

   }

 }

 nsRect

 nsDisplayBackgroundImage::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {

   *aSnap = true;

   return mBounds;

 }

 nsRect

 nsDisplayBackgroundImage::GetBoundsInternal(nsDisplayListBuilder* aBuilder) {

   nsPresContext* presContext = mFrame->PresContext();

   if (!mBackgroundStyle) {

     return nsRect();

   }

   nsRect borderBox = nsRect(ToReferenceFrame(), mFrame->GetSize());

   nsRect clipRect = borderBox;

   if (mFrame->GetType() == nsGkAtoms::canvasFrame) {

     nsCanvasFrame* frame = static_cast<nsCanvasFrame*>(mFrame);

     clipRect = frame->CanvasArea() + ToReferenceFrame();

   }

   const nsStyleBackground::Layer& layer = mBackgroundStyle->mLayers[mLayer];

   return nsCSSRendering::GetBackgroundLayerRect(presContext, mFrame,

                                                 borderBox, clipRect,

                                                 *mBackgroundStyle, layer,

                                                 aBuilder->GetBackgroundPaintFlags());

 }

 uint32_t

 nsDisplayBackgroundImage::GetPerFrameKey()

 {

   return (mLayer << nsDisplayItem::TYPE_BITS) |

     nsDisplayItem::GetPerFrameKey();

 }

 nsDisplayThemedBackground::nsDisplayThemedBackground(nsDisplayListBuilder* aBuilder,

                                                      nsIFrame* aFrame)

   : nsDisplayItem(aBuilder, aFrame)

 {

   MOZ_COUNT_CTOR(nsDisplayThemedBackground);

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

   mAppearance = disp->mAppearance;

   mFrame->IsThemed(disp, &mThemeTransparency);

   // Perform necessary RegisterThemeGeometry

   switch (disp->mAppearance) {

     case NS_THEME_MOZ_MAC_UNIFIED_TOOLBAR:

     case NS_THEME_TOOLBAR:

     case NS_THEME_WINDOW_TITLEBAR:

     case NS_THEME_WINDOW_BUTTON_BOX:

     case NS_THEME_MOZ_MAC_FULLSCREEN_BUTTON:

     case NS_THEME_WINDOW_BUTTON_BOX_MAXIMIZED:

       RegisterThemeGeometry(aBuilder, aFrame);

       break;

     case NS_THEME_WIN_BORDERLESS_GLASS:

     case NS_THEME_WIN_GLASS:

       aBuilder->SetGlassDisplayItem(this);

       break;

   }

   mBounds = GetBoundsInternal();

 }

 nsDisplayThemedBackground::~nsDisplayThemedBackground()

 {

 #ifdef NS_BUILD_REFCNT_LOGGING

   MOZ_COUNT_DTOR(nsDisplayThemedBackground);

 #endif

 }

 #ifdef MOZ_DUMP_PAINTING

 void

 nsDisplayThemedBackground::WriteDebugInfo(nsACString& aTo)

 {

   aTo += nsPrintfCString(" (themed, appearance:%d)", mAppearance);

 }

 #endif

 void

 nsDisplayThemedBackground::HitTest(nsDisplayListBuilder* aBuilder,

                                   const nsRect& aRect,

                                   HitTestState* aState,

                                   nsTArray<nsIFrame*> *aOutFrames)

 {

   // Assume that any point in our border rect is a hit.

   if (nsRect(ToReferenceFrame(), mFrame->GetSize()).Intersects(aRect)) {

     aOutFrames->AppendElement(mFrame);

   }

 }

 nsRegion

 nsDisplayThemedBackground::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                                            bool* aSnap) {

   nsRegion result;

   *aSnap = false;

   if (mThemeTransparency == nsITheme::eOpaque) {

     result = nsRect(ToReferenceFrame(), mFrame->GetSize());

   }

   return result;

 }

 bool

 nsDisplayThemedBackground::IsUniform(nsDisplayListBuilder* aBuilder, nscolor* aColor) {

   if (mAppearance == NS_THEME_WIN_BORDERLESS_GLASS ||

       mAppearance == NS_THEME_WIN_GLASS) {

     *aColor = NS_RGBA(0,0,0,0);

     return true;

   }

   return false;

 }

 nsRect

 nsDisplayThemedBackground::GetPositioningArea()

 {

   return nsRect(ToReferenceFrame(), mFrame->GetSize());

 }

 void

 nsDisplayThemedBackground::Paint(nsDisplayListBuilder* aBuilder,

                                  nsRenderingContext* aCtx)

 {

   PaintInternal(aBuilder, aCtx, mVisibleRect, nullptr);

 }

 void

 nsDisplayThemedBackground::PaintInternal(nsDisplayListBuilder* aBuilder,

                                          nsRenderingContext* aCtx, const nsRect& aBounds,

                                          nsRect* aClipRect)

 {

   // XXXzw this ignores aClipRect.

   nsPresContext* presContext = mFrame->PresContext();

   nsITheme *theme = presContext->GetTheme();

   nsRect borderArea(ToReferenceFrame(), mFrame->GetSize());

   nsRect drawing(borderArea);

   theme->GetWidgetOverflow(presContext->DeviceContext(), mFrame, mAppearance,

                            &drawing);

   drawing.IntersectRect(drawing, aBounds);

   theme->DrawWidgetBackground(aCtx, mFrame, mAppearance, borderArea, drawing);

 }

 bool nsDisplayThemedBackground::IsWindowActive()

 {

   EventStates docState = mFrame->GetContent()->OwnerDoc()->GetDocumentState();

   return !docState.HasState(NS_DOCUMENT_STATE_WINDOW_INACTIVE);

 }

 void nsDisplayThemedBackground::ComputeInvalidationRegion(nsDisplayListBuilder* aBuilder,

                                                           const nsDisplayItemGeometry* aGeometry,

                                                           nsRegion* aInvalidRegion)

 {

   const nsDisplayThemedBackgroundGeometry* geometry = static_cast<const nsDisplayThemedBackgroundGeometry*>(aGeometry);

   bool snap;

   nsRect bounds = GetBounds(aBuilder, &snap);

   nsRect positioningArea = GetPositioningArea();

   if (!positioningArea.IsEqualInterior(geometry->mPositioningArea)) {

     // Invalidate everything (both old and new painting areas).

     aInvalidRegion->Or(bounds, geometry->mBounds);

     return;

   }

   if (!bounds.IsEqualInterior(geometry->mBounds)) {

     // Positioning area is unchanged, so invalidate just the change in the

     // painting area.

     aInvalidRegion->Xor(bounds, geometry->mBounds);

   }

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

   if (theme->WidgetAppearanceDependsOnWindowFocus(mAppearance) &&

       IsWindowActive() != geometry->mWindowIsActive) {

     aInvalidRegion->Or(*aInvalidRegion, bounds);

   }

 }

 nsRect

 nsDisplayThemedBackground::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {

   *aSnap = true;

   return mBounds;

 }

 nsRect

 nsDisplayThemedBackground::GetBoundsInternal() {

   nsPresContext* presContext = mFrame->PresContext();

   nsRect r(nsPoint(0,0), mFrame->GetSize());

   presContext->GetTheme()->

       GetWidgetOverflow(presContext->DeviceContext(), mFrame,

                         mFrame->StyleDisplay()->mAppearance, &r);

 #ifdef XP_MACOSX

   // Bug 748219

   r.Inflate(mFrame->PresContext()->AppUnitsPerDevPixel());

 #endif

   return r + ToReferenceFrame();

 }

 void

 nsDisplayBackgroundColor::Paint(nsDisplayListBuilder* aBuilder,

                                 nsRenderingContext* aCtx) 

 {

   if (mColor == NS_RGBA(0, 0, 0, 0)) {

     return;

   }

   nsPoint offset = ToReferenceFrame();

   uint32_t flags = aBuilder->GetBackgroundPaintFlags();

   CheckForBorderItem(this, flags);

   nsCSSRendering::PaintBackgroundColor(mFrame->PresContext(), *aCtx, mFrame,

                                        mVisibleRect,

                                        nsRect(offset, mFrame->GetSize()),

                                        flags);

 }

 nsRegion

 nsDisplayBackgroundColor::GetOpaqueRegion(nsDisplayListBuilder* aBuilder,

                                           bool* aSnap) 

 {

   if (NS_GET_A(mColor) != 255) {

     return nsRegion();

   }

   if (!mBackgroundStyle)

     return nsRegion();

   *aSnap = true;

   const nsStyleBackground::Layer& bottomLayer = mBackgroundStyle->BottomLayer();

   nsRect borderBox = nsRect(ToReferenceFrame(), mFrame->GetSize());

   nsPresContext* presContext = mFrame->PresContext();

   return nsDisplayBackgroundImage::GetInsideClipRegion(this, presContext, bottomLayer.mClip, borderBox, aSnap);

 }

 bool

 nsDisplayBackgroundColor::IsUniform(nsDisplayListBuilder* aBuilder, nscolor* aColor) 

 {

   *aColor = mColor;

   if (!mBackgroundStyle)

     return true;

   return (!nsLayoutUtils::HasNonZeroCorner(mFrame->StyleBorder()->mBorderRadius) &&

           mBackgroundStyle->BottomLayer().mClip == NS_STYLE_BG_CLIP_BORDER);

 }

 void

 nsDisplayBackgroundColor::HitTest(nsDisplayListBuilder* aBuilder,

                                   const nsRect& aRect,

                                   HitTestState* aState,

                                   nsTArray<nsIFrame*> *aOutFrames)

 {

   if (!RoundedBorderIntersectsRect(mFrame, ToReferenceFrame(), aRect)) {

     // aRect doesn't intersect our border-radius curve.

     return;

   }

   aOutFrames->AppendElement(mFrame);

 }

 #ifdef MOZ_DUMP_PAINTING

 void

 nsDisplayBackgroundColor::WriteDebugInfo(nsACString& aTo)

 {

   aTo += nsPrintfCString(" (rgba %d,%d,%d,%d)", 

           NS_GET_R(mColor), NS_GET_G(mColor),

           NS_GET_B(mColor), NS_GET_A(mColor));

 }

 #endif

 nsRect

 nsDisplayOutline::GetBounds(nsDisplayListBuilder* aBuilder, bool* aSnap) {

   *aSnap = false;

   return mFrame->GetVisualOverflowRectRelativeToSelf() + ToReferenceFrame();

 }

 void

 nsDisplayOutline::Paint(nsDisplayListBuilder* aBuilder,

                         nsRenderingContext* aCtx) {

   // TODO join outlines together

   nsPoint offset = ToReferenceFrame();

   nsCSSRendering::PaintOutline(mFrame->PresContext(), *aCtx, mFrame,

                                mVisibleRect,

                                nsRect(offset, mFrame->GetSize()),

                                mFrame->StyleContext());

 }

 bool

 nsDisplayOutline::ComputeVisibility(nsDisplayListBuilder* aBuilder,

                                     nsRegion* aVisibleRegion,

                                     const nsRect& aAllowVisibleRegionExpansion) {

   if (!nsDisplayItem::ComputeVisibility(aBuilder, aVisibleRegion,