diff options
Diffstat (limited to 'layout/base/FrameLayerBuilder.cpp')
| -rw-r--r-- | layout/base/FrameLayerBuilder.cpp | 6378 |
1 files changed, 6378 insertions, 0 deletions
diff --git a/layout/base/FrameLayerBuilder.cpp b/layout/base/FrameLayerBuilder.cpp new file mode 100644 index 000000000..9269c2ab6 --- /dev/null +++ b/layout/base/FrameLayerBuilder.cpp @@ -0,0 +1,6378 @@ +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "mozilla/DebugOnly.h" + +#include "FrameLayerBuilder.h" + +#include "mozilla/LookAndFeel.h" +#include "mozilla/Maybe.h" +#include "mozilla/dom/ProfileTimelineMarkerBinding.h" +#include "mozilla/gfx/Matrix.h" +#include "ActiveLayerTracker.h" +#include "BasicLayers.h" +#include "DisplayItemScrollClip.h" +#include "ImageContainer.h" +#include "ImageLayers.h" +#include "LayerTreeInvalidation.h" +#include "Layers.h" +#include "LayerUserData.h" +#include "MaskLayerImageCache.h" +#include "UnitTransforms.h" +#include "Units.h" +#include "gfx2DGlue.h" +#include "gfxEnv.h" +#include "gfxUtils.h" +#include "nsAutoPtr.h" +#include "nsAnimationManager.h" +#include "nsDisplayList.h" +#include "nsDocShell.h" +#include "nsIScrollableFrame.h" +#include "nsImageFrame.h" +#include "nsLayoutUtils.h" +#include "nsPresContext.h" +#include "nsPrintfCString.h" +#include "nsRenderingContext.h" +#include "nsSVGIntegrationUtils.h" +#include "nsTransitionManager.h" +#include "mozilla/LayerTimelineMarker.h" + +#include "mozilla/EffectCompositor.h" +#include "mozilla/Move.h" +#include "mozilla/ReverseIterator.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Tools.h" +#include "mozilla/layers/ShadowLayers.h" +#include "mozilla/layers/TextureClient.h" +#include "mozilla/layers/TextureWrapperImage.h" +#include "mozilla/Unused.h" +#include "GeckoProfiler.h" +#include "LayersLogging.h" +#include "gfxPrefs.h" + +#include <algorithm> + +using namespace mozilla::layers; +using namespace mozilla::gfx; + +namespace mozilla { + +class PaintedDisplayItemLayerUserData; + +static nsTHashtable<nsPtrHashKey<FrameLayerBuilder::DisplayItemData>>* sAliveDisplayItemDatas; + +/** + * The address of gPaintedDisplayItemLayerUserData is used as the user + * data key for PaintedLayers created by FrameLayerBuilder. + * It identifies PaintedLayers used to draw non-layer content, which are + * therefore eligible for recycling. We want display items to be able to + * create their own dedicated PaintedLayers in BuildLayer, if necessary, + * and we wouldn't want to accidentally recycle those. + * The user data is a PaintedDisplayItemLayerUserData. + */ +uint8_t gPaintedDisplayItemLayerUserData; +/** + * The address of gColorLayerUserData is used as the user + * data key for ColorLayers created by FrameLayerBuilder. + * The user data is null. + */ +uint8_t gColorLayerUserData; +/** + * The address of gImageLayerUserData is used as the user + * data key for ImageLayers created by FrameLayerBuilder. + * The user data is null. + */ +uint8_t gImageLayerUserData; +/** + * The address of gLayerManagerUserData is used as the user + * data key for retained LayerManagers managed by FrameLayerBuilder. + * The user data is a LayerManagerData. + */ +uint8_t gLayerManagerUserData; +/** + * The address of gMaskLayerUserData is used as the user + * data key for mask layers managed by FrameLayerBuilder. + * The user data is a MaskLayerUserData. + */ +uint8_t gMaskLayerUserData; +/** + * The address of gCSSMaskLayerUserData is used as the user + * data key for mask layers of css masking managed by FrameLayerBuilder. + * The user data is a CSSMaskLayerUserData. + */ +uint8_t gCSSMaskLayerUserData; + +// a global cache of image containers used for mask layers +static MaskLayerImageCache* gMaskLayerImageCache = nullptr; + +static inline MaskLayerImageCache* GetMaskLayerImageCache() +{ + if (!gMaskLayerImageCache) { + gMaskLayerImageCache = new MaskLayerImageCache(); + } + + return gMaskLayerImageCache; +} + +FrameLayerBuilder::FrameLayerBuilder() + : mRetainingManager(nullptr) + , mDetectedDOMModification(false) + , mInvalidateAllLayers(false) + , mInLayerTreeCompressionMode(false) + , mContainerLayerGeneration(0) + , mMaxContainerLayerGeneration(0) +{ + MOZ_COUNT_CTOR(FrameLayerBuilder); +} + +FrameLayerBuilder::~FrameLayerBuilder() +{ + GetMaskLayerImageCache()->Sweep(); + MOZ_COUNT_DTOR(FrameLayerBuilder); +} + +FrameLayerBuilder::DisplayItemData::DisplayItemData(LayerManagerData* aParent, uint32_t aKey, + Layer* aLayer, nsIFrame* aFrame) + + : mParent(aParent) + , mLayer(aLayer) + , mDisplayItemKey(aKey) + , mItem(nullptr) + , mUsed(true) + , mIsInvalid(false) +{ + MOZ_COUNT_CTOR(FrameLayerBuilder::DisplayItemData); + + if (!sAliveDisplayItemDatas) { + sAliveDisplayItemDatas = new nsTHashtable<nsPtrHashKey<FrameLayerBuilder::DisplayItemData>>(); + } + MOZ_RELEASE_ASSERT(!sAliveDisplayItemDatas->Contains(this)); + sAliveDisplayItemDatas->PutEntry(this); + + MOZ_RELEASE_ASSERT(mLayer); + if (aFrame) { + AddFrame(aFrame); + } + +} + +void +FrameLayerBuilder::DisplayItemData::AddFrame(nsIFrame* aFrame) +{ + MOZ_RELEASE_ASSERT(mLayer); + mFrameList.AppendElement(aFrame); + + nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(FrameLayerBuilder::LayerManagerDataProperty()); + if (!array) { + array = new nsTArray<DisplayItemData*>(); + aFrame->Properties().Set(FrameLayerBuilder::LayerManagerDataProperty(), array); + } + array->AppendElement(this); +} + +void +FrameLayerBuilder::DisplayItemData::RemoveFrame(nsIFrame* aFrame) +{ + MOZ_RELEASE_ASSERT(mLayer); + bool result = mFrameList.RemoveElement(aFrame); + MOZ_RELEASE_ASSERT(result, "Can't remove a frame that wasn't added!"); + + nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(FrameLayerBuilder::LayerManagerDataProperty()); + MOZ_RELEASE_ASSERT(array, "Must be already stored on the frame!"); + array->RemoveElement(this); +} + +void +FrameLayerBuilder::DisplayItemData::EndUpdate() +{ + MOZ_RELEASE_ASSERT(mLayer); + MOZ_ASSERT(!mItem); + mIsInvalid = false; + mUsed = false; +} + +void +FrameLayerBuilder::DisplayItemData::EndUpdate(nsAutoPtr<nsDisplayItemGeometry> aGeometry) +{ + MOZ_RELEASE_ASSERT(mLayer); + MOZ_ASSERT(mItem); + MOZ_ASSERT(mGeometry || aGeometry); + + if (aGeometry) { + mGeometry = aGeometry; + } + mClip = mItem->GetClip(); + mFrameListChanges.Clear(); + + mItem = nullptr; + EndUpdate(); +} + +void +FrameLayerBuilder::DisplayItemData::BeginUpdate(Layer* aLayer, LayerState aState, + uint32_t aContainerLayerGeneration, + nsDisplayItem* aItem /* = nullptr */) +{ + MOZ_RELEASE_ASSERT(mLayer); + MOZ_RELEASE_ASSERT(aLayer); + mLayer = aLayer; + mOptLayer = nullptr; + mInactiveManager = nullptr; + mLayerState = aState; + mContainerLayerGeneration = aContainerLayerGeneration; + mUsed = true; + + if (aLayer->AsPaintedLayer()) { + mItem = aItem; + } + + if (!aItem) { + return; + } + + // We avoid adding or removing element unnecessarily + // since we have to modify userdata each time + AutoTArray<nsIFrame*, 4> copy(mFrameList); + if (!copy.RemoveElement(aItem->Frame())) { + AddFrame(aItem->Frame()); + mFrameListChanges.AppendElement(aItem->Frame()); + } + + AutoTArray<nsIFrame*,4> mergedFrames; + aItem->GetMergedFrames(&mergedFrames); + for (uint32_t i = 0; i < mergedFrames.Length(); ++i) { + if (!copy.RemoveElement(mergedFrames[i])) { + AddFrame(mergedFrames[i]); + mFrameListChanges.AppendElement(mergedFrames[i]); + } + } + + for (uint32_t i = 0; i < copy.Length(); i++) { + RemoveFrame(copy[i]); + mFrameListChanges.AppendElement(copy[i]); + } +} + +static const nsIFrame* sDestroyedFrame = nullptr; +FrameLayerBuilder::DisplayItemData::~DisplayItemData() +{ + MOZ_COUNT_DTOR(FrameLayerBuilder::DisplayItemData); + MOZ_RELEASE_ASSERT(mLayer); + for (uint32_t i = 0; i < mFrameList.Length(); i++) { + nsIFrame* frame = mFrameList[i]; + if (frame == sDestroyedFrame) { + continue; + } + nsTArray<DisplayItemData*> *array = + reinterpret_cast<nsTArray<DisplayItemData*>*>(frame->Properties().Get(LayerManagerDataProperty())); + array->RemoveElement(this); + } + + MOZ_RELEASE_ASSERT(sAliveDisplayItemDatas && sAliveDisplayItemDatas->Contains(this)); + sAliveDisplayItemDatas->RemoveEntry(this); + if (sAliveDisplayItemDatas->Count() == 0) { + delete sAliveDisplayItemDatas; + sAliveDisplayItemDatas = nullptr; + } +} + +void +FrameLayerBuilder::DisplayItemData::ClearAnimationCompositorState() +{ + if (mDisplayItemKey != nsDisplayItem::TYPE_TRANSFORM && + mDisplayItemKey != nsDisplayItem::TYPE_OPACITY) { + return; + } + + for (nsIFrame* frame : mFrameList) { + nsCSSPropertyID prop = mDisplayItemKey == nsDisplayItem::TYPE_TRANSFORM ? + eCSSProperty_transform : eCSSProperty_opacity; + EffectCompositor::ClearIsRunningOnCompositor(frame, prop); + } +} + +const nsTArray<nsIFrame*>& +FrameLayerBuilder::DisplayItemData::GetFrameListChanges() +{ + return mFrameListChanges; +} + +/** + * This is the userdata we associate with a layer manager. + */ +class LayerManagerData : public LayerUserData { +public: + explicit LayerManagerData(LayerManager *aManager) + : mLayerManager(aManager) +#ifdef DEBUG_DISPLAY_ITEM_DATA + , mParent(nullptr) +#endif + , mInvalidateAllLayers(false) + { + MOZ_COUNT_CTOR(LayerManagerData); + } + ~LayerManagerData() { + MOZ_COUNT_DTOR(LayerManagerData); + } + +#ifdef DEBUG_DISPLAY_ITEM_DATA + void Dump(const char *aPrefix = "") { + printf_stderr("%sLayerManagerData %p\n", aPrefix, this); + + for (auto iter = mDisplayItems.Iter(); !iter.Done(); iter.Next()) { + FrameLayerBuilder::DisplayItemData* data = iter.Get()->GetKey(); + + nsAutoCString prefix; + prefix += aPrefix; + prefix += " "; + + const char* layerState; + switch (data->mLayerState) { + case LAYER_NONE: + layerState = "LAYER_NONE"; break; + case LAYER_INACTIVE: + layerState = "LAYER_INACTIVE"; break; + case LAYER_ACTIVE: + layerState = "LAYER_ACTIVE"; break; + case LAYER_ACTIVE_FORCE: + layerState = "LAYER_ACTIVE_FORCE"; break; + case LAYER_ACTIVE_EMPTY: + layerState = "LAYER_ACTIVE_EMPTY"; break; + case LAYER_SVG_EFFECTS: + layerState = "LAYER_SVG_EFFECTS"; break; + } + uint32_t mask = (1 << nsDisplayItem::TYPE_BITS) - 1; + + nsAutoCString str; + str += prefix; + str += nsPrintfCString("Frame %p ", data->mFrameList[0]); + str += nsDisplayItem::DisplayItemTypeName(static_cast<nsDisplayItem::Type>(data->mDisplayItemKey & mask)); + if ((data->mDisplayItemKey >> nsDisplayItem::TYPE_BITS)) { + str += nsPrintfCString("(%i)", data->mDisplayItemKey >> nsDisplayItem::TYPE_BITS); + } + str += nsPrintfCString(", %s, Layer %p", layerState, data->mLayer.get()); + if (data->mOptLayer) { + str += nsPrintfCString(", OptLayer %p", data->mOptLayer.get()); + } + if (data->mInactiveManager) { + str += nsPrintfCString(", InactiveLayerManager %p", data->mInactiveManager.get()); + } + str += "\n"; + + printf_stderr("%s", str.get()); + + if (data->mInactiveManager) { + prefix += " "; + printf_stderr("%sDumping inactive layer info:\n", prefix.get()); + LayerManagerData* lmd = static_cast<LayerManagerData*> + (data->mInactiveManager->GetUserData(&gLayerManagerUserData)); + lmd->Dump(prefix.get()); + } + } + } +#endif + + /** + * Tracks which frames have layers associated with them. + */ + LayerManager *mLayerManager; +#ifdef DEBUG_DISPLAY_ITEM_DATA + LayerManagerData *mParent; +#endif + nsTHashtable<nsRefPtrHashKey<FrameLayerBuilder::DisplayItemData> > mDisplayItems; + bool mInvalidateAllLayers; +}; + +/* static */ void +FrameLayerBuilder::DestroyDisplayItemDataFor(nsIFrame* aFrame) +{ + FrameProperties props = aFrame->Properties(); + props.Delete(LayerManagerDataProperty()); +} + +struct AssignedDisplayItem +{ + AssignedDisplayItem(nsDisplayItem* aItem, + const DisplayItemClip& aClip, + LayerState aLayerState) + : mItem(aItem) + , mClip(aClip) + , mLayerState(aLayerState) + {} + + nsDisplayItem* mItem; + DisplayItemClip mClip; + LayerState mLayerState; +}; + +/** + * We keep a stack of these to represent the PaintedLayers that are + * currently available to have display items added to. + * We use a stack here because as much as possible we want to + * assign display items to existing PaintedLayers, and to the lowest + * PaintedLayer in z-order. This reduces the number of layers and + * makes it more likely a display item will be rendered to an opaque + * layer, giving us the best chance of getting subpixel AA. + */ +class PaintedLayerData { +public: + PaintedLayerData() : + mAnimatedGeometryRoot(nullptr), + mScrollClip(nullptr), + mReferenceFrame(nullptr), + mLayer(nullptr), + mSolidColor(NS_RGBA(0, 0, 0, 0)), + mIsSolidColorInVisibleRegion(false), + mFontSmoothingBackgroundColor(NS_RGBA(0,0,0,0)), + mSingleItemFixedToViewport(false), + mNeedComponentAlpha(false), + mForceTransparentSurface(false), + mHideAllLayersBelow(false), + mOpaqueForAnimatedGeometryRootParent(false), + mDisableFlattening(false), + mBackfaceHidden(false), + mImage(nullptr), + mCommonClipCount(-1), + mNewChildLayersIndex(-1) + {} + +#ifdef MOZ_DUMP_PAINTING + /** + * Keep track of important decisions for debugging. + */ + nsCString mLog; + + #define FLB_LOG_PAINTED_LAYER_DECISION(pld, ...) \ + if (gfxPrefs::LayersDumpDecision()) { \ + pld->mLog.AppendPrintf("\t\t\t\t"); \ + pld->mLog.AppendPrintf(__VA_ARGS__); \ + } +#else + #define FLB_LOG_PAINTED_LAYER_DECISION(...) +#endif + + /** + * Record that an item has been added to the PaintedLayer, so we + * need to update our regions. + * @param aVisibleRect the area of the item that's visible + * @param aSolidColor if non-null, the visible area of the item is + * a constant color given by *aSolidColor + */ + void Accumulate(ContainerState* aState, + nsDisplayItem* aItem, + const nsIntRegion& aClippedOpaqueRegion, + const nsIntRect& aVisibleRect, + const DisplayItemClip& aClip, + LayerState aLayerState); + AnimatedGeometryRoot* GetAnimatedGeometryRoot() { return mAnimatedGeometryRoot; } + + /** + * A region including the horizontal pan, vertical pan, and no action regions. + */ + nsRegion CombinedTouchActionRegion(); + + /** + * Add the given hit regions to the hit regions to the hit retions for this + * PaintedLayer. + */ + void AccumulateEventRegions(ContainerState* aState, nsDisplayLayerEventRegions* aEventRegions); + + /** + * If this represents only a nsDisplayImage, and the image type supports being + * optimized to an ImageLayer, returns true. + */ + bool CanOptimizeToImageLayer(nsDisplayListBuilder* aBuilder); + + /** + * If this represents only a nsDisplayImage, and the image type supports being + * optimized to an ImageLayer, returns an ImageContainer for the underlying + * image if one is available. + */ + already_AddRefed<ImageContainer> GetContainerForImageLayer(nsDisplayListBuilder* aBuilder); + + bool VisibleAboveRegionIntersects(const nsIntRegion& aRegion) const + { return !mVisibleAboveRegion.Intersect(aRegion).IsEmpty(); } + bool VisibleRegionIntersects(const nsIntRegion& aRegion) const + { return !mVisibleRegion.Intersect(aRegion).IsEmpty(); } + + /** + * The region of visible content in the layer, relative to the + * container layer (which is at the snapped top-left of the display + * list reference frame). + */ + nsIntRegion mVisibleRegion; + /** + * The region of visible content in the layer that is opaque. + * Same coordinate system as mVisibleRegion. + */ + nsIntRegion mOpaqueRegion; + /** + * The definitely-hit region for this PaintedLayer. + */ + nsRegion mHitRegion; + /** + * The maybe-hit region for this PaintedLayer. + */ + nsRegion mMaybeHitRegion; + /** + * The dispatch-to-content hit region for this PaintedLayer. + */ + nsRegion mDispatchToContentHitRegion; + /** + * The region for this PaintedLayer that is sensitive to events + * but disallows panning and zooming. This is an approximation + * and any deviation from the true region will be part of the + * mDispatchToContentHitRegion. + */ + nsRegion mNoActionRegion; + /** + * The region for this PaintedLayer that is sensitive to events and + * allows horizontal panning but not zooming. This is an approximation + * and any deviation from the true region will be part of the + * mDispatchToContentHitRegion. + */ + nsRegion mHorizontalPanRegion; + /** + * The region for this PaintedLayer that is sensitive to events and + * allows vertical panning but not zooming. This is an approximation + * and any deviation from the true region will be part of the + * mDispatchToContentHitRegion. + */ + nsRegion mVerticalPanRegion; + /** + * Scaled versions of the bounds of mHitRegion and mMaybeHitRegion. + * We store these because FindPaintedLayerFor() needs to consume them + * in this form, and it's a hot code path so we don't want to scale + * them inside that function. + */ + nsIntRect mScaledHitRegionBounds; + nsIntRect mScaledMaybeHitRegionBounds; + /** + * The "active scrolled root" for all content in the layer. Must + * be non-null; all content in a PaintedLayer must have the same + * active scrolled root. + */ + AnimatedGeometryRoot* mAnimatedGeometryRoot; + /** + * The scroll clip for this layer. + */ + const DisplayItemScrollClip* mScrollClip; + /** + * The offset between mAnimatedGeometryRoot and the reference frame. + */ + nsPoint mAnimatedGeometryRootOffset; + /** + * If non-null, the frame from which we'll extract "fixed positioning" + * metadata for this layer. This can be a position:fixed frame or a viewport + * frame; the latter case is used for background-attachment:fixed content. + */ + const nsIFrame* mReferenceFrame; + PaintedLayer* mLayer; + /** + * If mIsSolidColorInVisibleRegion is true, this is the color of the visible + * region. + */ + nscolor mSolidColor; + /** + * True if every pixel in mVisibleRegion will have color mSolidColor. + */ + bool mIsSolidColorInVisibleRegion; + /** + * The target background color for smoothing fonts that are drawn on top of + * transparent parts of the layer. + */ + nscolor mFontSmoothingBackgroundColor; + /** + * True if the layer contains exactly one item that returned true for + * ShouldFixToViewport. + */ + bool mSingleItemFixedToViewport; + /** + * True if there is any text visible in the layer that's over + * transparent pixels in the layer. + */ + bool mNeedComponentAlpha; + /** + * Set if the layer should be treated as transparent, even if its entire + * area is covered by opaque display items. For example, this needs to + * be set if something is going to "punch holes" in the layer by clearing + * part of its surface. + */ + bool mForceTransparentSurface; + /** + * Set if all layers below this PaintedLayer should be hidden. + */ + bool mHideAllLayersBelow; + /** + * Set if the opaque region for this layer can be applied to the parent + * animated geometry root of this layer's animated geometry root. + * We set this when a PaintedLayer's animated geometry root is a scrollframe + * and the PaintedLayer completely fills the displayport of the scrollframe. + */ + bool mOpaqueForAnimatedGeometryRootParent; + /** + * Set if there is content in the layer that must avoid being flattened. + */ + bool mDisableFlattening; + /** + * Set if the backface of this region is hidden to the user. + * Content that backface is hidden should not be draw on the layer + * with visible backface. + */ + bool mBackfaceHidden; + /** + * Stores the pointer to the nsDisplayImage if we want to + * convert this to an ImageLayer. + */ + nsDisplayImageContainer* mImage; + /** + * Stores the clip that we need to apply to the image or, if there is no + * image, a clip for SOME item in the layer. There is no guarantee which + * item's clip will be stored here and mItemClip should not be used to clip + * the whole layer - only some part of the clip should be used, as determined + * by PaintedDisplayItemLayerUserData::GetCommonClipCount() - which may even be + * no part at all. + */ + DisplayItemClip mItemClip; + /** + * The first mCommonClipCount rounded rectangle clips are identical for + * all items in the layer. + * -1 if there are no items in the layer; must be >=0 by the time that this + * data is popped from the stack. + */ + int32_t mCommonClipCount; + /** + * Index of this layer in mNewChildLayers. + */ + int32_t mNewChildLayersIndex; + /* + * Updates mCommonClipCount by checking for rounded rect clips in common + * between the clip on a new item (aCurrentClip) and the common clips + * on items already in the layer (the first mCommonClipCount rounded rects + * in mItemClip). + */ + void UpdateCommonClipCount(const DisplayItemClip& aCurrentClip); + /** + * The union of all the bounds of the display items in this layer. + */ + nsIntRect mBounds; + /** + * The region of visible content above the layer and below the + * next PaintedLayerData currently in the stack, if any. + * This is a conservative approximation: it contains the true region. + */ + nsIntRegion mVisibleAboveRegion; + /** + * All the display items that have been assigned to this painted layer. + * These items get added by Accumulate(). + */ + nsTArray<AssignedDisplayItem> mAssignedDisplayItems; + +}; + +struct NewLayerEntry { + NewLayerEntry() + : mAnimatedGeometryRoot(nullptr) + , mScrollClip(nullptr) + , mLayerContentsVisibleRect(0, 0, -1, -1) + , mLayerState(LAYER_INACTIVE) + , mHideAllLayersBelow(false) + , mOpaqueForAnimatedGeometryRootParent(false) + , mPropagateComponentAlphaFlattening(true) + , mUntransformedVisibleRegion(false) + {} + // mLayer is null if the previous entry is for a PaintedLayer that hasn't + // been optimized to some other form (yet). + RefPtr<Layer> mLayer; + AnimatedGeometryRoot* mAnimatedGeometryRoot; + const DisplayItemScrollClip* mScrollClip; + // If non-null, this ScrollMetadata is set to the be the first ScrollMetadata + // on the layer. + UniquePtr<ScrollMetadata> mBaseScrollMetadata; + // The following are only used for retained layers (for occlusion + // culling of those layers). These regions are all relative to the + // container reference frame. + nsIntRegion mVisibleRegion; + nsIntRegion mOpaqueRegion; + // This rect is in the layer's own coordinate space. The computed visible + // region for the layer cannot extend beyond this rect. + nsIntRect mLayerContentsVisibleRect; + LayerState mLayerState; + bool mHideAllLayersBelow; + // When mOpaqueForAnimatedGeometryRootParent is true, the opaque region of + // this layer is opaque in the same position even subject to the animation of + // geometry of mAnimatedGeometryRoot. For example when mAnimatedGeometryRoot + // is a scrolled frame and the scrolled content is opaque everywhere in the + // displayport, we can set this flag. + // When this flag is set, we can treat this opaque region as covering + // content whose animated geometry root is the animated geometry root for + // mAnimatedGeometryRoot->GetParent(). + bool mOpaqueForAnimatedGeometryRootParent; + + // If true, then the content flags for this layer should contribute + // to our decision to flatten component alpha layers, false otherwise. + bool mPropagateComponentAlphaFlattening; + // mVisibleRegion is relative to the associated frame before + // transform. + bool mUntransformedVisibleRegion; +}; + +class PaintedLayerDataTree; + +/** + * This is tree node type for PaintedLayerDataTree. + * Each node corresponds to a different animated geometry root, and contains + * a stack of PaintedLayerDatas, in bottom-to-top order. + * There is at most one node per animated geometry root. The ancestor and + * descendant relations in PaintedLayerDataTree tree mirror those in the frame + * tree. + * Each node can have clip that describes the potential extents that items in + * this node can cover. If mHasClip is false, it means that the node's contents + * can move anywhere. + * Testing against the clip instead of the node's actual contents has the + * advantage that the node's contents can move or animate without affecting + * content in other nodes. So we don't need to re-layerize during animations + * (sync or async), and during async animations everything is guaranteed to + * look correct. + * The contents of a node's PaintedLayerData stack all share the node's + * animated geometry root. The child nodes are on top of the PaintedLayerData + * stack, in z-order, and the clip rects of the child nodes are allowed to + * intersect with the visible region or visible above region of their parent + * node's PaintedLayerDatas. + */ +class PaintedLayerDataNode { +public: + PaintedLayerDataNode(PaintedLayerDataTree& aTree, + PaintedLayerDataNode* aParent, + AnimatedGeometryRoot* aAnimatedGeometryRoot); + ~PaintedLayerDataNode(); + + AnimatedGeometryRoot* GetAnimatedGeometryRoot() const { return mAnimatedGeometryRoot; } + + /** + * Whether this node's contents can potentially intersect aRect. + * aRect is in our tree's ContainerState's coordinate space. + */ + bool Intersects(const nsIntRect& aRect) const + { return !mHasClip || mClipRect.Intersects(aRect); } + + /** + * Create a PaintedLayerDataNode for aAnimatedGeometryRoot, add it to our + * children, and return it. + */ + PaintedLayerDataNode* AddChildNodeFor(AnimatedGeometryRoot* aAnimatedGeometryRoot); + + /** + * Find a PaintedLayerData in our mPaintedLayerDataStack that aItem can be + * added to. Creates a new PaintedLayerData by calling + * aNewPaintedLayerCallback if necessary. + */ + template<typename NewPaintedLayerCallbackType> + PaintedLayerData* FindPaintedLayerFor(const nsIntRect& aVisibleRect, + bool aBackfaceHidden, + const DisplayItemScrollClip* aScrollClip, + NewPaintedLayerCallbackType aNewPaintedLayerCallback); + + /** + * Find an opaque background color for aRegion. Pulls a color from the parent + * geometry root if appropriate, but only if that color is present underneath + * the whole clip of this node, so that this node's contents can animate or + * move (possibly async) without having to change the background color. + * @param aUnderIndex Searching will start in mPaintedLayerDataStack right + * below aUnderIndex. + */ + enum { ABOVE_TOP = -1 }; + nscolor FindOpaqueBackgroundColor(const nsIntRegion& aRegion, + int32_t aUnderIndex = ABOVE_TOP) const; + /** + * Same as FindOpaqueBackgroundColor, but only returns a color if absolutely + * nothing is in between, so that it can be used for a layer that can move + * anywhere inside our clip. + */ + nscolor FindOpaqueBackgroundColorCoveringEverything() const; + + /** + * Adds aRect to this node's top PaintedLayerData's mVisibleAboveRegion, + * or mVisibleAboveBackgroundRegion if mPaintedLayerDataStack is empty. + */ + void AddToVisibleAboveRegion(const nsIntRect& aRect); + /** + * Call this if all of our existing content can potentially be covered, so + * nothing can merge with it and all new content needs to create new items + * on top. This will finish all of our children and pop our whole + * mPaintedLayerDataStack. + */ + void SetAllDrawingAbove(); + + /** + * Finish this node: Finish all children, finish our PaintedLayer contents, + * and (if requested) adjust our parent's visible above region to include + * our clip. + */ + void Finish(bool aParentNeedsAccurateVisibleAboveRegion); + + /** + * Finish any children that intersect aRect. + */ + void FinishChildrenIntersecting(const nsIntRect& aRect); + + /** + * Finish all children. + */ + void FinishAllChildren() { FinishAllChildren(true); } + +protected: + /** + * Finish the topmost item in mPaintedLayerDataStack and pop it from the + * stack. + */ + void PopPaintedLayerData(); + /** + * Finish all items in mPaintedLayerDataStack and clear the stack. + */ + void PopAllPaintedLayerData(); + /** + * Finish all of our child nodes, but don't touch mPaintedLayerDataStack. + */ + void FinishAllChildren(bool aThisNodeNeedsAccurateVisibleAboveRegion); + /** + * Pass off opaque background color searching to our parent node, if we have + * one. + */ + nscolor FindOpaqueBackgroundColorInParentNode() const; + + PaintedLayerDataTree& mTree; + PaintedLayerDataNode* mParent; + AnimatedGeometryRoot* mAnimatedGeometryRoot; + + /** + * Our contents: a PaintedLayerData stack and our child nodes. + */ + nsTArray<PaintedLayerData> mPaintedLayerDataStack; + + /** + * UniquePtr is used here in the sense of "unique ownership", i.e. there is + * only one owner. Not in the sense of "this is the only pointer to the + * node": There are two other, non-owning, pointers to our child nodes: The + * node's respective children point to their parent node with their mParent + * pointer, and the tree keeps a map of animated geometry root to node in its + * mNodes member. These outside pointers are the reason that mChildren isn't + * just an nsTArray<PaintedLayerDataNode> (since the pointers would become + * invalid whenever the array expands its capacity). + */ + nsTArray<UniquePtr<PaintedLayerDataNode>> mChildren; + + /** + * The region that's covered between our "background" and the bottom of + * mPaintedLayerDataStack. This is used to indicate whether we can pull + * a background color from our parent node. If mVisibleAboveBackgroundRegion + * should be considered infinite, mAllDrawingAboveBackground will be true and + * the value of mVisibleAboveBackgroundRegion will be meaningless. + */ + nsIntRegion mVisibleAboveBackgroundRegion; + + /** + * Our clip, if we have any. If not, that means we can move anywhere, and + * mHasClip will be false and mClipRect will be meaningless. + */ + nsIntRect mClipRect; + bool mHasClip; + + /** + * Whether mVisibleAboveBackgroundRegion should be considered infinite. + */ + bool mAllDrawingAboveBackground; +}; + +class ContainerState; + +/** + * A tree of PaintedLayerDataNodes. At any point in time, the tree only + * contains nodes for animated geometry roots that new items can potentially + * merge into. Any time content is added on top that overlaps existing things + * in such a way that we no longer want to merge new items with some existing + * content, that existing content gets "finished". + * The public-facing methods of this class are FindPaintedLayerFor, + * AddingOwnLayer, and Finish. The other public methods are for + * PaintedLayerDataNode. + * The tree calls out to its containing ContainerState for some things. + * All coordinates / rects in the tree or the tree nodes are in the + * ContainerState's coordinate space, i.e. relative to the reference frame and + * in layer pixels. + * The clip rects of sibling nodes never overlap. This is ensured by finishing + * existing nodes before adding new ones, if this property were to be violated. + * The root tree node doesn't get finished until the ContainerState is + * finished. + * The tree's root node is always the root reference frame of the builder. We + * don't stop at the container state's mContainerAnimatedGeometryRoot because + * some of our contents can have animated geometry roots that are not + * descendants of the container's animated geometry root. Every animated + * geometry root we encounter for our contents needs to have a defined place in + * the tree. + */ +class PaintedLayerDataTree { +public: + PaintedLayerDataTree(ContainerState& aContainerState, + nscolor& aBackgroundColor) + : mContainerState(aContainerState) + , mContainerUniformBackgroundColor(aBackgroundColor) + {} + + ~PaintedLayerDataTree() + { + MOZ_ASSERT(!mRoot); + MOZ_ASSERT(mNodes.Count() == 0); + } + + /** + * Notify our contents that some non-PaintedLayer content has been added. + * *aRect needs to be a rectangle that doesn't move with respect to + * aAnimatedGeometryRoot and that contains the added item. + * If aRect is null, the extents will be considered infinite. + * If aOutUniformBackgroundColor is non-null, it will be set to an opaque + * color that can be pulled into the background of the added content, or + * transparent if that is not possible. + */ + void AddingOwnLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIntRect* aRect, + nscolor* aOutUniformBackgroundColor); + + /** + * Find a PaintedLayerData for aItem. This can either be an existing + * PaintedLayerData from inside a node in our tree, or a new one that gets + * created by a call out to aNewPaintedLayerCallback. + */ + template<typename NewPaintedLayerCallbackType> + PaintedLayerData* FindPaintedLayerFor(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemScrollClip* aScrollClip, + const nsIntRect& aVisibleRect, + bool aBackfaceidden, + NewPaintedLayerCallbackType aNewPaintedLayerCallback); + + /** + * Finish everything. + */ + void Finish(); + + /** + * Get the parent animated geometry root of aAnimatedGeometryRoot. + * That's either aAnimatedGeometryRoot's animated geometry root, or, if + * that's aAnimatedGeometryRoot itself, then it's the animated geometry + * root for aAnimatedGeometryRoot's cross-doc parent frame. + */ + AnimatedGeometryRoot* GetParentAnimatedGeometryRoot(AnimatedGeometryRoot* aAnimatedGeometryRoot); + + /** + * Whether aAnimatedGeometryRoot has an intrinsic clip that doesn't move with + * respect to aAnimatedGeometryRoot's parent animated geometry root. + * If aAnimatedGeometryRoot is a scroll frame, this will be the scroll frame's + * scroll port, otherwise there is no clip. + * This method doesn't have much to do with PaintedLayerDataTree, but this is + * where we have easy access to a display list builder, which we use to get + * the clip rect result into the right coordinate space. + */ + bool IsClippedWithRespectToParentAnimatedGeometryRoot(AnimatedGeometryRoot* aAnimatedGeometryRoot, + nsIntRect* aOutClip); + + /** + * Called by PaintedLayerDataNode when it is finished, so that we can drop + * our pointers to it. + */ + void NodeWasFinished(AnimatedGeometryRoot* aAnimatedGeometryRoot); + + nsDisplayListBuilder* Builder() const; + ContainerState& ContState() const { return mContainerState; } + nscolor UniformBackgroundColor() const { return mContainerUniformBackgroundColor; } + +protected: + /** + * Finish all nodes that potentially intersect *aRect, where *aRect is a rect + * that doesn't move with respect to aAnimatedGeometryRoot. + * If aRect is null, *aRect will be considered infinite. + */ + void FinishPotentiallyIntersectingNodes(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIntRect* aRect); + + /** + * Make sure that there is a node for aAnimatedGeometryRoot and all of its + * ancestor geometry roots. Return the node for aAnimatedGeometryRoot. + */ + PaintedLayerDataNode* EnsureNodeFor(AnimatedGeometryRoot* aAnimatedGeometryRoot); + + /** + * Find an existing node in the tree for an ancestor of aAnimatedGeometryRoot. + * *aOutAncestorChild will be set to the last ancestor that was encountered + * in the search up from aAnimatedGeometryRoot; it will be a child animated + * geometry root of the result, if neither are null. + */ + PaintedLayerDataNode* + FindNodeForAncestorAnimatedGeometryRoot(AnimatedGeometryRoot* aAnimatedGeometryRoot, + AnimatedGeometryRoot** aOutAncestorChild); + + ContainerState& mContainerState; + UniquePtr<PaintedLayerDataNode> mRoot; + + /** + * The uniform opaque color from behind this container layer, or + * NS_RGBA(0,0,0,0) if the background behind this container layer is not + * uniform and opaque. This color can be pulled into PaintedLayers that are + * directly above the background. + */ + nscolor mContainerUniformBackgroundColor; + + /** + * A hash map for quick access the node belonging to a particular animated + * geometry root. + */ + nsDataHashtable<nsPtrHashKey<AnimatedGeometryRoot>, PaintedLayerDataNode*> mNodes; +}; + +/** + * This is a helper object used to build up the layer children for + * a ContainerLayer. + */ +class ContainerState { +public: + ContainerState(nsDisplayListBuilder* aBuilder, + LayerManager* aManager, + FrameLayerBuilder* aLayerBuilder, + nsIFrame* aContainerFrame, + nsDisplayItem* aContainerItem, + const nsRect& aContainerBounds, + ContainerLayer* aContainerLayer, + const ContainerLayerParameters& aParameters, + bool aFlattenToSingleLayer, + nscolor aBackgroundColor, + const DisplayItemScrollClip* aContainerScrollClip) : + mBuilder(aBuilder), mManager(aManager), + mLayerBuilder(aLayerBuilder), + mContainerFrame(aContainerFrame), + mContainerLayer(aContainerLayer), + mContainerBounds(aContainerBounds), + mContainerScrollClip(aContainerScrollClip), + mScrollClipForPerspectiveChild(aParameters.mScrollClipForPerspectiveChild), + mParameters(aParameters), + mPaintedLayerDataTree(*this, aBackgroundColor), + mFlattenToSingleLayer(aFlattenToSingleLayer) + { + nsPresContext* presContext = aContainerFrame->PresContext(); + mAppUnitsPerDevPixel = presContext->AppUnitsPerDevPixel(); + mContainerReferenceFrame = + const_cast<nsIFrame*>(aContainerItem ? aContainerItem->ReferenceFrameForChildren() : + mBuilder->FindReferenceFrameFor(mContainerFrame)); + bool isAtRoot = !aContainerItem || (aContainerItem->Frame() == mBuilder->RootReferenceFrame()); + MOZ_ASSERT_IF(isAtRoot, mContainerReferenceFrame == mBuilder->RootReferenceFrame()); + mContainerAnimatedGeometryRoot = isAtRoot + ? aBuilder->GetRootAnimatedGeometryRoot() + : aContainerItem->GetAnimatedGeometryRoot(); + MOZ_ASSERT(!mBuilder->IsPaintingToWindow() || + nsLayoutUtils::IsAncestorFrameCrossDoc(mBuilder->RootReferenceFrame(), + *mContainerAnimatedGeometryRoot)); + // When AllowResidualTranslation is false, display items will be drawn + // scaled with a translation by integer pixels, so we know how the snapping + // will work. + mSnappingEnabled = aManager->IsSnappingEffectiveTransforms() && + !mParameters.AllowResidualTranslation(); + CollectOldLayers(); + } + + /** + * This is the method that actually walks a display list and builds + * the child layers. + */ + void ProcessDisplayItems(nsDisplayList* aList); + /** + * This finalizes all the open PaintedLayers by popping every element off + * mPaintedLayerDataStack, then sets the children of the container layer + * to be all the layers in mNewChildLayers in that order and removes any + * layers as children of the container that aren't in mNewChildLayers. + * @param aTextContentFlags if any child layer has CONTENT_COMPONENT_ALPHA, + * set *aTextContentFlags to CONTENT_COMPONENT_ALPHA + */ + void Finish(uint32_t *aTextContentFlags, + const nsIntRect& aContainerPixelBounds, + nsDisplayList* aChildItems, bool* aHasComponentAlphaChildren); + + nscoord GetAppUnitsPerDevPixel() { return mAppUnitsPerDevPixel; } + + nsIntRect ScaleToNearestPixels(const nsRect& aRect) const + { + return aRect.ScaleToNearestPixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + nsIntRegion ScaleRegionToNearestPixels(const nsRegion& aRegion) const + { + return aRegion.ScaleToNearestPixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + nsIntRect ScaleToOutsidePixels(const nsRect& aRect, bool aSnap = false) const + { + if (aSnap && mSnappingEnabled) { + return ScaleToNearestPixels(aRect); + } + return aRect.ScaleToOutsidePixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + nsIntRect ScaleToInsidePixels(const nsRect& aRect, bool aSnap = false) const + { + if (aSnap && mSnappingEnabled) { + return ScaleToNearestPixels(aRect); + } + return aRect.ScaleToInsidePixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + + nsIntRegion ScaleRegionToInsidePixels(const nsRegion& aRegion, bool aSnap = false) const + { + if (aSnap && mSnappingEnabled) { + return ScaleRegionToNearestPixels(aRegion); + } + return aRegion.ScaleToInsidePixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + + nsIntRegion ScaleRegionToOutsidePixels(const nsRegion& aRegion, bool aSnap = false) const + { + if (aSnap && mSnappingEnabled) { + return ScaleRegionToNearestPixels(aRegion); + } + return aRegion.ScaleToOutsidePixels(mParameters.mXScale, mParameters.mYScale, + mAppUnitsPerDevPixel); + } + + nsIFrame* GetContainerFrame() const { return mContainerFrame; } + nsDisplayListBuilder* Builder() const { return mBuilder; } + + /** + * Check if we are currently inside an inactive layer. + */ + bool IsInInactiveLayer() const { + return mLayerBuilder->GetContainingPaintedLayerData(); + } + + /** + * Sets aOuterVisibleRegion as aLayer's visible region. + * @param aOuterVisibleRegion + * is in the coordinate space of the container reference frame. + * @param aLayerContentsVisibleRect, if non-null, is in the layer's own + * coordinate system. + * @param aOuterUntransformed is true if the given aOuterVisibleRegion + * is already untransformed with the matrix of the layer. + */ + void SetOuterVisibleRegionForLayer(Layer* aLayer, + const nsIntRegion& aOuterVisibleRegion, + const nsIntRect* aLayerContentsVisibleRect = nullptr, + bool aOuterUntransformed = false) const; + + /** + * Try to determine whether the PaintedLayer aData has a single opaque color + * covering aRect. If successful, return that color, otherwise return + * NS_RGBA(0,0,0,0). + * If aRect turns out not to intersect any content in the layer, + * *aOutIntersectsLayer will be set to false. + */ + nscolor FindOpaqueBackgroundColorInLayer(const PaintedLayerData* aData, + const nsIntRect& aRect, + bool* aOutIntersectsLayer) const; + + /** + * Indicate that we are done adding items to the PaintedLayer represented by + * aData. Make sure that a real PaintedLayer exists for it, and set the final + * visible region and opaque-content. + */ + template<typename FindOpaqueBackgroundColorCallbackType> + void FinishPaintedLayerData(PaintedLayerData& aData, FindOpaqueBackgroundColorCallbackType aFindOpaqueBackgroundColor); + +protected: + friend class PaintedLayerData; + + LayerManager::PaintedLayerCreationHint + GetLayerCreationHint(AnimatedGeometryRoot* aAnimatedGeometryRoot); + + /** + * Creates a new PaintedLayer and sets up the transform on the PaintedLayer + * to account for scrolling. + */ + already_AddRefed<PaintedLayer> CreatePaintedLayer(PaintedLayerData* aData); + + /** + * Find a PaintedLayer for recycling, recycle it and prepare it for use, or + * return null if no suitable layer was found. + */ + already_AddRefed<PaintedLayer> AttemptToRecyclePaintedLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot, + nsDisplayItem* aItem, + const nsPoint& aTopLeft); + /** + * Recycle aLayer and do any necessary invalidation. + */ + PaintedDisplayItemLayerUserData* RecyclePaintedLayer(PaintedLayer* aLayer, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + bool& didResetScrollPositionForLayerPixelAlignment); + + /** + * Perform the last step of CreatePaintedLayer / AttemptToRecyclePaintedLayer: + * Initialize aData, set up the layer's transform for scrolling, and + * invalidate the layer for layer pixel alignment changes if necessary. + */ + void PreparePaintedLayerForUse(PaintedLayer* aLayer, + PaintedDisplayItemLayerUserData* aData, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIFrame* aReferenceFrame, + const nsPoint& aTopLeft, + bool aDidResetScrollPositionForLayerPixelAlignment); + + /** + * Attempt to prepare an ImageLayer based upon the provided PaintedLayerData. + * Returns nullptr on failure. + */ + already_AddRefed<Layer> PrepareImageLayer(PaintedLayerData* aData); + + /** + * Attempt to prepare a ColorLayer based upon the provided PaintedLayerData. + * Returns nullptr on failure. + */ + already_AddRefed<Layer> PrepareColorLayer(PaintedLayerData* aData); + + /** + * Grab the next recyclable ColorLayer, or create one if there are no + * more recyclable ColorLayers. + */ + already_AddRefed<ColorLayer> CreateOrRecycleColorLayer(PaintedLayer* aPainted); + /** + * Grab the next recyclable ImageLayer, or create one if there are no + * more recyclable ImageLayers. + */ + already_AddRefed<ImageLayer> CreateOrRecycleImageLayer(PaintedLayer* aPainted); + /** + * Grab a recyclable ImageLayer for use as a mask layer for aLayer (that is a + * mask layer which has been used for aLayer before), or create one if such + * a layer doesn't exist. + * + * Since mask layers can exist either on the layer directly, or as a side- + * attachment to FrameMetrics (for ancestor scrollframe clips), we key the + * recycle operation on both the originating layer and the mask layer's + * index in the layer, if any. + */ + struct MaskLayerKey; + already_AddRefed<ImageLayer> + CreateOrRecycleMaskImageLayerFor(const MaskLayerKey& aKey, + mozilla::function<void(Layer* aLayer)> aSetUserData); + /** + * Grabs all PaintedLayers and ColorLayers from the ContainerLayer and makes them + * available for recycling. + */ + void CollectOldLayers(); + /** + * If aItem used to belong to a PaintedLayer, invalidates the area of + * aItem in that layer. If aNewLayer is a PaintedLayer, invalidates the area of + * aItem in that layer. + */ + void InvalidateForLayerChange(nsDisplayItem* aItem, + PaintedLayer* aNewLayer); + /** + * Returns true if aItem's opaque area (in aOpaque) covers the entire + * scrollable area of its presshell. + */ + bool ItemCoversScrollableArea(nsDisplayItem* aItem, const nsRegion& aOpaque); + + /** + * Set FrameMetrics and scroll-induced clipping on aEntry's layer. + */ + void SetupScrollingMetadata(NewLayerEntry* aEntry); + + /** + * Applies occlusion culling. + * For each layer in mNewChildLayers, remove from its visible region the + * opaque regions of the layers at higher z-index, but only if they have + * the same animated geometry root and fixed-pos frame ancestor. + * The opaque region for the child layers that share the same animated + * geometry root as the container frame is returned in + * *aOpaqueRegionForContainer. + * + * Also sets scroll metadata on the layers. + */ + void PostprocessRetainedLayers(nsIntRegion* aOpaqueRegionForContainer); + + /** + * Computes the snapped opaque area of aItem. Sets aList's opaque flag + * if it covers the entire list bounds. Sets *aHideAllLayersBelow to true + * this item covers the entire viewport so that all layers below are + * permanently invisible. + */ + nsIntRegion ComputeOpaqueRect(nsDisplayItem* aItem, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemClip& aClip, + nsDisplayList* aList, + bool* aHideAllLayersBelow, + bool* aOpaqueForAnimatedGeometryRootParent); + + /** + * Return a PaintedLayerData object that is initialized for a layer that + * aItem will be assigned to. + * @param aItem The item that is going to be added. + * @param aVisibleRect The visible rect of the item. + * @param aAnimatedGeometryRoot The item's animated geometry root. + * @param aScrollClip The scroll clip for this PaintedLayer. + * @param aTopLeft The offset between aAnimatedGeometryRoot and + * the reference frame. + * @param aShouldFixToViewport If true, aAnimatedGeometryRoot is the + * viewport and we will be adding fixed-pos + * metadata for this layer because the display + * item returned true from ShouldFixToViewport. + */ + PaintedLayerData NewPaintedLayerData(nsDisplayItem* aItem, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemScrollClip* aScrollClip, + const nsPoint& aTopLeft, + bool aShouldFixToViewport); + + /* Build a mask layer to represent the clipping region. Will return null if + * there is no clipping specified or a mask layer cannot be built. + * Builds an ImageLayer for the appropriate backend; the mask is relative to + * aLayer's visible region. + * aLayer is the layer to be clipped. + * relative to the container reference frame + * aRoundedRectClipCount is used when building mask layers for PaintedLayers, + * SetupMaskLayer will build a mask layer for only the first + * aRoundedRectClipCount rounded rects in aClip + */ + void SetupMaskLayer(Layer *aLayer, const DisplayItemClip& aClip, + uint32_t aRoundedRectClipCount = UINT32_MAX); + + /** + * If |aClip| has rounded corners, create a mask layer for them, and + * add it to |aLayer|'s ancestor mask layers, returning an index into + * the array of ancestor mask layers. Returns an empty Maybe if + * |aClip| does not have rounded corners, or if no mask layer could + * be created. + */ + Maybe<size_t> SetupMaskLayerForScrolledClip(Layer* aLayer, + const DisplayItemClip& aClip); + + /* + * Create/find a mask layer with suitable size for aMaskItem to paint + * css-positioned-masking onto. + */ + void SetupMaskLayerForCSSMask(Layer* aLayer, nsDisplayMask* aMaskItem); + + already_AddRefed<Layer> CreateMaskLayer( + Layer *aLayer, const DisplayItemClip& aClip, + const Maybe<size_t>& aForAncestorMaskLayer, + uint32_t aRoundedRectClipCount = UINT32_MAX); + + bool ChooseAnimatedGeometryRoot(const nsDisplayList& aList, + AnimatedGeometryRoot **aAnimatedGeometryRoot); + + nsDisplayListBuilder* mBuilder; + LayerManager* mManager; + FrameLayerBuilder* mLayerBuilder; + nsIFrame* mContainerFrame; + nsIFrame* mContainerReferenceFrame; + AnimatedGeometryRoot* mContainerAnimatedGeometryRoot; + ContainerLayer* mContainerLayer; + nsRect mContainerBounds; + const DisplayItemScrollClip* mContainerScrollClip; + const DisplayItemScrollClip* mScrollClipForPerspectiveChild; +#ifdef DEBUG + nsRect mAccumulatedChildBounds; +#endif + ContainerLayerParameters mParameters; + /** + * The region of PaintedLayers that should be invalidated every time + * we recycle one. + */ + nsIntRegion mInvalidPaintedContent; + PaintedLayerDataTree mPaintedLayerDataTree; + /** + * We collect the list of children in here. During ProcessDisplayItems, + * the layers in this array either have mContainerLayer as their parent, + * or no parent. + * PaintedLayers have two entries in this array: the second one is used only if + * the PaintedLayer is optimized away to a ColorLayer or ImageLayer. + * It's essential that this array is only appended to, since PaintedLayerData + * records the index of its PaintedLayer in this array. + */ + typedef AutoTArray<NewLayerEntry,1> AutoLayersArray; + AutoLayersArray mNewChildLayers; + nsTHashtable<nsRefPtrHashKey<PaintedLayer>> mPaintedLayersAvailableForRecycling; + nscoord mAppUnitsPerDevPixel; + bool mSnappingEnabled; + bool mFlattenToSingleLayer; + + struct MaskLayerKey { + MaskLayerKey() : mLayer(nullptr) {} + MaskLayerKey(Layer* aLayer, const Maybe<size_t>& aAncestorIndex) + : mLayer(aLayer), + mAncestorIndex(aAncestorIndex) + {} + + PLDHashNumber Hash() const { + // Hash the layer and add the layer index to the hash. + return (NS_PTR_TO_UINT32(mLayer) >> 2) + + (mAncestorIndex ? (*mAncestorIndex + 1) : 0); + } + bool operator ==(const MaskLayerKey& aOther) const { + return mLayer == aOther.mLayer && + mAncestorIndex == aOther.mAncestorIndex; + } + + Layer* mLayer; + Maybe<size_t> mAncestorIndex; + }; + + nsDataHashtable<nsGenericHashKey<MaskLayerKey>, RefPtr<ImageLayer>> + mRecycledMaskImageLayers; +}; + +class PaintedDisplayItemLayerUserData : public LayerUserData +{ +public: + PaintedDisplayItemLayerUserData() : + mMaskClipCount(0), + mForcedBackgroundColor(NS_RGBA(0,0,0,0)), + mFontSmoothingBackgroundColor(NS_RGBA(0,0,0,0)), + mXScale(1.f), mYScale(1.f), + mAppUnitsPerDevPixel(0), + mTranslation(0, 0), + mAnimatedGeometryRootPosition(0, 0) {} + + /** + * Record the number of clips in the PaintedLayer's mask layer. + * Should not be reset when the layer is recycled since it is used to track + * changes in the use of mask layers. + */ + uint32_t mMaskClipCount; + + /** + * A color that should be painted over the bounds of the layer's visible + * region before any other content is painted. + */ + nscolor mForcedBackgroundColor; + + /** + * The target background color for smoothing fonts that are drawn on top of + * transparent parts of the layer. + */ + nscolor mFontSmoothingBackgroundColor; + + /** + * The resolution scale used. + */ + float mXScale, mYScale; + + /** + * The appunits per dev pixel for the items in this layer. + */ + nscoord mAppUnitsPerDevPixel; + + /** + * The offset from the PaintedLayer's 0,0 to the + * reference frame. This isn't necessarily the same as the transform + * set on the PaintedLayer since we might also be applying an extra + * offset specified by the parent ContainerLayer/ + */ + nsIntPoint mTranslation; + + /** + * We try to make 0,0 of the PaintedLayer be the top-left of the + * border-box of the "active scrolled root" frame (i.e. the nearest ancestor + * frame for the display items that is being actively scrolled). But + * we force the PaintedLayer transform to be an integer translation, and we may + * have a resolution scale, so we have to snap the PaintedLayer transform, so + * 0,0 may not be exactly the top-left of the active scrolled root. Here we + * store the coordinates in PaintedLayer space of the top-left of the + * active scrolled root. + */ + gfxPoint mAnimatedGeometryRootPosition; + + nsIntRegion mRegionToInvalidate; + + // The offset between the active scrolled root of this layer + // and the root of the container for the previous and current + // paints respectively. + nsPoint mLastAnimatedGeometryRootOrigin; + nsPoint mAnimatedGeometryRootOrigin; + + RefPtr<ColorLayer> mColorLayer; + RefPtr<ImageLayer> mImageLayer; + + // The region for which display item visibility for this layer has already + // been calculated. Used to reduce the number of calls to + // RecomputeVisibilityForItems if it is known in advance that a larger + // region will be painted during a transaction than in a single call to + // DrawPaintedLayer, for example when progressive paint is enabled. + nsIntRegion mVisibilityComputedRegion; +}; + +/* + * User data for layers which will be used as masks. + */ +struct MaskLayerUserData : public LayerUserData +{ + MaskLayerUserData() + : mScaleX(-1.0f) + , mScaleY(-1.0f) + , mAppUnitsPerDevPixel(-1) + { } + MaskLayerUserData(const DisplayItemClip& aClip, + uint32_t aRoundedRectClipCount, + int32_t aAppUnitsPerDevPixel, + const ContainerLayerParameters& aParams) + : mScaleX(aParams.mXScale) + , mScaleY(aParams.mYScale) + , mOffset(aParams.mOffset) + , mAppUnitsPerDevPixel(aAppUnitsPerDevPixel) + { + aClip.AppendRoundedRects(&mRoundedClipRects, aRoundedRectClipCount); + } + + void operator=(MaskLayerUserData&& aOther) + { + mScaleX = aOther.mScaleX; + mScaleY = aOther.mScaleY; + mOffset = aOther.mOffset; + mAppUnitsPerDevPixel = aOther.mAppUnitsPerDevPixel; + mRoundedClipRects.SwapElements(aOther.mRoundedClipRects); + } + + bool + operator== (const MaskLayerUserData& aOther) const + { + return mRoundedClipRects == aOther.mRoundedClipRects && + mScaleX == aOther.mScaleX && + mScaleY == aOther.mScaleY && + mOffset == aOther.mOffset && + mAppUnitsPerDevPixel == aOther.mAppUnitsPerDevPixel; + } + + // Keeps a MaskLayerImageKey alive by managing its mLayerCount member-var + MaskLayerImageCache::MaskLayerImageKeyRef mImageKey; + // properties of the mask layer; the mask layer may be re-used if these + // remain unchanged. + nsTArray<DisplayItemClip::RoundedRect> mRoundedClipRects; + // scale from the masked layer which is applied to the mask + float mScaleX, mScaleY; + // The ContainerLayerParameters offset which is applied to the mask's transform. + nsIntPoint mOffset; + int32_t mAppUnitsPerDevPixel; +}; + +/* + * User data for layers which will be used as masks for css positioned mask. + */ +struct CSSMaskLayerUserData : public LayerUserData +{ + CSSMaskLayerUserData() + : mImageLayers(nsStyleImageLayers::LayerType::Mask) + { } + + CSSMaskLayerUserData(nsIFrame* aFrame, const nsIntRect& aBounds) + : mImageLayers(aFrame->StyleSVGReset()->mMask), + mContentRect(aFrame->GetContentRectRelativeToSelf()), + mPaddingRect(aFrame->GetPaddingRectRelativeToSelf()), + mBorderRect(aFrame->GetRectRelativeToSelf()), + mMarginRect(aFrame->GetMarginRectRelativeToSelf()), + mBounds(aBounds) + { + Hash(aFrame); + } + + CSSMaskLayerUserData& operator=(const CSSMaskLayerUserData& aOther) + { + mImageLayers = aOther.mImageLayers; + + mContentRect = aOther.mContentRect; + mPaddingRect = aOther.mPaddingRect; + mBorderRect = aOther.mBorderRect; + mMarginRect = aOther.mMarginRect; + + mBounds = aOther.mBounds; + + mHash = aOther.mHash; + + return *this; + } + + bool + operator==(const CSSMaskLayerUserData& aOther) const + { + if (mHash != aOther.mHash) { + return false; + } + + if (mImageLayers.mLayers != aOther.mImageLayers.mLayers) { + return false; + } + + if (!mContentRect.IsEqualEdges(aOther.mContentRect) || + !mPaddingRect.IsEqualEdges(aOther.mPaddingRect) || + !mBorderRect.IsEqualEdges(aOther.mBorderRect) || + !mMarginRect.IsEqualEdges(aOther.mMarginRect)) { + return false; + } + + if (!mBounds.IsEqualEdges(aOther.mBounds)) { + return false; + } + + return true; + } + +private: + void Hash(nsIFrame* aFrame) + { + uint32_t hash = 0; + + const nsStyleImageLayers& imageLayers = aFrame->StyleSVGReset()->mMask; + for (uint32_t i = 0; i < imageLayers.mLayers.Length(); i++) { + const nsStyleImageLayers::Layer& newLayer = imageLayers.mLayers[i]; + hash = AddToHash(hash, HashBytes(&newLayer, sizeof(newLayer))); + } + + hash = AddToHash(hash, HashBytes(&mContentRect, sizeof(mContentRect))); + hash = AddToHash(hash, HashBytes(&mPaddingRect, sizeof(mPaddingRect))); + hash = AddToHash(hash, HashBytes(&mBorderRect, sizeof(mBorderRect))); + hash = AddToHash(hash, HashBytes(&mMarginRect, sizeof(mMarginRect))); + + hash = AddToHash(hash, HashBytes(&mBounds, sizeof(mBounds))); + + mHash = hash; + } + + nsStyleImageLayers mImageLayers; + + nsRect mContentRect; + nsRect mPaddingRect; + nsRect mBorderRect; + nsRect mMarginRect; + + nsIntRect mBounds; + + uint32_t mHash; +}; + +/* + * A helper object to create a draw target for painting mask and create a + * image container to hold the drawing result. The caller can then bind this + * image container with a image mask layer via ImageLayer::SetContainer. + */ +class MaskImageData +{ +public: + MaskImageData(const gfx::IntSize& aSize, LayerManager* aLayerManager) + : mTextureClientLocked(false) + , mSize(aSize) + , mLayerManager(aLayerManager) + { + MOZ_ASSERT(!mSize.IsEmpty()); + MOZ_ASSERT(mLayerManager); + } + + ~MaskImageData() + { + if (mTextureClientLocked) { + MOZ_ASSERT(mTextureClient); + // Clear DrawTarget before Unlock. + mDrawTarget = nullptr; + mTextureClient->Unlock(); + } + } + + gfx::DrawTarget* CreateDrawTarget() + { + if (mDrawTarget) { + return mDrawTarget; + } + + if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC) { + mDrawTarget = mLayerManager->CreateOptimalMaskDrawTarget(mSize); + return mDrawTarget; + } + + MOZ_ASSERT(mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT); + + ShadowLayerForwarder* fwd = mLayerManager->AsShadowForwarder(); + if (!fwd) { + return nullptr; + } + mTextureClient = + TextureClient::CreateForDrawing(fwd, + SurfaceFormat::A8, + mSize, + BackendSelector::Content, + TextureFlags::DISALLOW_BIGIMAGE, + TextureAllocationFlags::ALLOC_CLEAR_BUFFER); + if (!mTextureClient) { + return nullptr; + } + + mTextureClientLocked = mTextureClient->Lock(OpenMode::OPEN_READ_WRITE); + if (!mTextureClientLocked) { + return nullptr; + } + + mDrawTarget = mTextureClient->BorrowDrawTarget(); + return mDrawTarget; + } + + already_AddRefed<ImageContainer> CreateImageAndImageContainer() + { + RefPtr<ImageContainer> container = mLayerManager->CreateImageContainer(); + RefPtr<Image> image = CreateImage(); + + if (!image) { + return nullptr; + } + container->SetCurrentImageInTransaction(image); + + return container.forget(); + } + +private: + already_AddRefed<Image> CreateImage() + { + if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_BASIC && + mDrawTarget) { + RefPtr<SourceSurface> surface = mDrawTarget->Snapshot(); + RefPtr<SourceSurfaceImage> image = new SourceSurfaceImage(mSize, surface); + // Disallow BIGIMAGE (splitting into multiple textures) for mask + // layer images + image->SetTextureFlags(TextureFlags::DISALLOW_BIGIMAGE); + return image.forget(); + } + + if (mLayerManager->GetBackendType() == LayersBackend::LAYERS_CLIENT && + mTextureClient && + mDrawTarget) { + RefPtr<TextureWrapperImage> image = + new TextureWrapperImage(mTextureClient, gfx::IntRect(gfx::IntPoint(0, 0), mSize)); + return image.forget(); + } + + return nullptr; + } + + bool mTextureClientLocked; + gfx::IntSize mSize; + LayerManager* mLayerManager; + RefPtr<gfx::DrawTarget> mDrawTarget; + RefPtr<TextureClient> mTextureClient; +}; + +/** + * Helper functions for getting user data and casting it to the correct type. + * aLayer is the layer where the user data is stored. + */ +MaskLayerUserData* GetMaskLayerUserData(Layer* aLayer) +{ + return static_cast<MaskLayerUserData*>(aLayer->GetUserData(&gMaskLayerUserData)); +} + +PaintedDisplayItemLayerUserData* GetPaintedDisplayItemLayerUserData(Layer* aLayer) +{ + return static_cast<PaintedDisplayItemLayerUserData*>( + aLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); +} + +/* static */ void +FrameLayerBuilder::Shutdown() +{ + if (gMaskLayerImageCache) { + delete gMaskLayerImageCache; + gMaskLayerImageCache = nullptr; + } +} + +void +FrameLayerBuilder::Init(nsDisplayListBuilder* aBuilder, LayerManager* aManager, + PaintedLayerData* aLayerData) +{ + mDisplayListBuilder = aBuilder; + mRootPresContext = aBuilder->RootReferenceFrame()->PresContext()->GetRootPresContext(); + if (mRootPresContext) { + mInitialDOMGeneration = mRootPresContext->GetDOMGeneration(); + } + mContainingPaintedLayer = aLayerData; + aManager->SetUserData(&gLayerManagerLayerBuilder, this); +} + +void +FrameLayerBuilder::FlashPaint(gfxContext *aContext) +{ + float r = float(rand()) / RAND_MAX; + float g = float(rand()) / RAND_MAX; + float b = float(rand()) / RAND_MAX; + aContext->SetColor(Color(r, g, b, 0.4f)); + aContext->Paint(); +} + +static FrameLayerBuilder::DisplayItemData* +AssertDisplayItemData(FrameLayerBuilder::DisplayItemData* aData) +{ + MOZ_RELEASE_ASSERT(aData); + MOZ_RELEASE_ASSERT(sAliveDisplayItemDatas && sAliveDisplayItemDatas->Contains(aData)); + MOZ_RELEASE_ASSERT(aData->mLayer); + return aData; +} + +FrameLayerBuilder::DisplayItemData* +FrameLayerBuilder::GetDisplayItemData(nsIFrame* aFrame, uint32_t aKey) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + if (array) { + for (uint32_t i = 0; i < array->Length(); i++) { + DisplayItemData* item = AssertDisplayItemData(array->ElementAt(i)); + if (item->mDisplayItemKey == aKey && + item->mLayer->Manager() == mRetainingManager) { + return item; + } + } + } + return nullptr; +} + +nsACString& +AppendToString(nsACString& s, const nsIntRect& r, + const char* pfx="", const char* sfx="") +{ + s += pfx; + s += nsPrintfCString( + "(x=%d, y=%d, w=%d, h=%d)", + r.x, r.y, r.width, r.height); + return s += sfx; +} + +nsACString& +AppendToString(nsACString& s, const nsIntRegion& r, + const char* pfx="", const char* sfx="") +{ + s += pfx; + + s += "< "; + for (auto iter = r.RectIter(); !iter.Done(); iter.Next()) { + AppendToString(s, iter.Get()) += "; "; + } + s += ">"; + + return s += sfx; +} + +/** + * Invalidate aRegion in aLayer. aLayer is in the coordinate system + * *after* aTranslation has been applied, so we need to + * apply the inverse of that transform before calling InvalidateRegion. + */ +static void +InvalidatePostTransformRegion(PaintedLayer* aLayer, const nsIntRegion& aRegion, + const nsIntPoint& aTranslation) +{ + // Convert the region from the coordinates of the container layer + // (relative to the snapped top-left of the display list reference frame) + // to the PaintedLayer's own coordinates + nsIntRegion rgn = aRegion; + rgn.MoveBy(-aTranslation); + aLayer->InvalidateRegion(rgn); +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + nsAutoCString str; + AppendToString(str, rgn); + printf_stderr("Invalidating layer %p: %s\n", aLayer, str.get()); + } +#endif +} + +static void +InvalidatePostTransformRegion(PaintedLayer* aLayer, const nsRect& aRect, + const DisplayItemClip& aClip, + const nsIntPoint& aTranslation) +{ + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*>(aLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); + + nsRect rect = aClip.ApplyNonRoundedIntersection(aRect); + + nsIntRect pixelRect = rect.ScaleToOutsidePixels(data->mXScale, data->mYScale, data->mAppUnitsPerDevPixel); + InvalidatePostTransformRegion(aLayer, pixelRect, aTranslation); +} + + +static nsIntPoint +GetTranslationForPaintedLayer(PaintedLayer* aLayer) +{ + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*> + (aLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); + NS_ASSERTION(data, "Must be a tracked painted layer!"); + + return data->mTranslation; +} + +/** + * Some frames can have multiple, nested, retaining layer managers + * associated with them (normal manager, inactive managers, SVG effects). + * In these cases we store the 'outermost' LayerManager data property + * on the frame since we can walk down the chain from there. + * + * If one of these frames has just been destroyed, we will free the inner + * layer manager when removing the entry from mFramesWithLayers. Destroying + * the layer manager destroys the LayerManagerData and calls into + * the DisplayItemData destructor. If the inner layer manager had any + * items with the same frame, then we attempt to retrieve properties + * from the deleted frame. + * + * Cache the destroyed frame pointer here so we can avoid crashing in this case. + */ + +/* static */ void +FrameLayerBuilder::RemoveFrameFromLayerManager(const nsIFrame* aFrame, + nsTArray<DisplayItemData*>* aArray) +{ + MOZ_RELEASE_ASSERT(!sDestroyedFrame); + sDestroyedFrame = aFrame; + + // Hold a reference to all the items so that they don't get + // deleted from under us. + nsTArray<RefPtr<DisplayItemData> > arrayCopy; + for (DisplayItemData* data : *aArray) { + arrayCopy.AppendElement(data); + } + +#ifdef DEBUG_DISPLAY_ITEM_DATA + if (aArray->Length()) { + LayerManagerData *rootData = aArray->ElementAt(0)->mParent; + while (rootData->mParent) { + rootData = rootData->mParent; + } + printf_stderr("Removing frame %p - dumping display data\n", aFrame); + rootData->Dump(); + } +#endif + + for (DisplayItemData* data : *aArray) { + PaintedLayer* t = data->mLayer->AsPaintedLayer(); + if (t) { + PaintedDisplayItemLayerUserData* paintedData = + static_cast<PaintedDisplayItemLayerUserData*>(t->GetUserData(&gPaintedDisplayItemLayerUserData)); + if (paintedData) { + nsRegion old = data->mGeometry->ComputeInvalidationRegion(); + nsIntRegion rgn = old.ScaleToOutsidePixels(paintedData->mXScale, paintedData->mYScale, paintedData->mAppUnitsPerDevPixel); + rgn.MoveBy(-GetTranslationForPaintedLayer(t)); + paintedData->mRegionToInvalidate.Or(paintedData->mRegionToInvalidate, rgn); + paintedData->mRegionToInvalidate.SimplifyOutward(8); + } + } + + data->mParent->mDisplayItems.RemoveEntry(data); + } + + arrayCopy.Clear(); + delete aArray; + sDestroyedFrame = nullptr; +} + +void +FrameLayerBuilder::DidBeginRetainedLayerTransaction(LayerManager* aManager) +{ + mRetainingManager = aManager; + LayerManagerData* data = static_cast<LayerManagerData*> + (aManager->GetUserData(&gLayerManagerUserData)); + if (data) { + mInvalidateAllLayers = data->mInvalidateAllLayers; + } else { + data = new LayerManagerData(aManager); + aManager->SetUserData(&gLayerManagerUserData, data); + } +} + +void +FrameLayerBuilder::StoreOptimizedLayerForFrame(nsDisplayItem* aItem, Layer* aLayer) +{ + if (!mRetainingManager) { + return; + } + + DisplayItemData* data = GetDisplayItemDataForManager(aItem, aLayer->Manager()); + NS_ASSERTION(data, "Must have already stored data for this item!"); + data->mOptLayer = aLayer; +} + +void +FrameLayerBuilder::DidEndTransaction() +{ + GetMaskLayerImageCache()->Sweep(); +} + +void +FrameLayerBuilder::WillEndTransaction() +{ + if (!mRetainingManager) { + return; + } + + // We need to save the data we'll need to support retaining. + LayerManagerData* data = static_cast<LayerManagerData*> + (mRetainingManager->GetUserData(&gLayerManagerUserData)); + NS_ASSERTION(data, "Must have data!"); + + // Update all the frames that used to have layers. + for (auto iter = data->mDisplayItems.Iter(); !iter.Done(); iter.Next()) { + DisplayItemData* data = iter.Get()->GetKey(); + if (!data->mUsed) { + // This item was visible, but isn't anymore. + PaintedLayer* t = data->mLayer->AsPaintedLayer(); + if (t && data->mGeometry) { +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Invalidating unused display item (%i) belonging to frame %p from layer %p\n", data->mDisplayItemKey, data->mFrameList[0], t); + } +#endif + InvalidatePostTransformRegion(t, + data->mGeometry->ComputeInvalidationRegion(), + data->mClip, + GetLastPaintOffset(t)); + } + + data->ClearAnimationCompositorState(); + iter.Remove(); + } else { + ComputeGeometryChangeForItem(data); + } + } + + data->mInvalidateAllLayers = false; +} + +/* static */ FrameLayerBuilder::DisplayItemData* +FrameLayerBuilder::GetDisplayItemDataForManager(nsDisplayItem* aItem, + LayerManager* aManager) +{ + const nsTArray<DisplayItemData*>* array = + aItem->Frame()->Properties().Get(LayerManagerDataProperty()); + if (array) { + for (uint32_t i = 0; i < array->Length(); i++) { + DisplayItemData* item = AssertDisplayItemData(array->ElementAt(i)); + if (item->mDisplayItemKey == aItem->GetPerFrameKey() && + item->mLayer->Manager() == aManager) { + return item; + } + } + } + return nullptr; +} + +bool +FrameLayerBuilder::HasRetainedDataFor(nsIFrame* aFrame, uint32_t aDisplayItemKey) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + if (array) { + for (uint32_t i = 0; i < array->Length(); i++) { + if (AssertDisplayItemData(array->ElementAt(i))->mDisplayItemKey == aDisplayItemKey) { + return true; + } + } + } + return false; +} + +void +FrameLayerBuilder::IterateRetainedDataFor(nsIFrame* aFrame, DisplayItemDataCallback aCallback) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + if (!array) { + return; + } + + for (uint32_t i = 0; i < array->Length(); i++) { + DisplayItemData* data = AssertDisplayItemData(array->ElementAt(i)); + if (data->mDisplayItemKey != nsDisplayItem::TYPE_ZERO) { + aCallback(aFrame, data); + } + } +} + +FrameLayerBuilder::DisplayItemData* +FrameLayerBuilder::GetOldLayerForFrame(nsIFrame* aFrame, uint32_t aDisplayItemKey) +{ + // If we need to build a new layer tree, then just refuse to recycle + // anything. + if (!mRetainingManager || mInvalidateAllLayers) + return nullptr; + + DisplayItemData *data = GetDisplayItemData(aFrame, aDisplayItemKey); + + if (data && data->mLayer->Manager() == mRetainingManager) { + return data; + } + return nullptr; +} + +Layer* +FrameLayerBuilder::GetOldLayerFor(nsDisplayItem* aItem, + nsDisplayItemGeometry** aOldGeometry, + DisplayItemClip** aOldClip) +{ + uint32_t key = aItem->GetPerFrameKey(); + nsIFrame* frame = aItem->Frame(); + + DisplayItemData* oldData = GetOldLayerForFrame(frame, key); + if (oldData) { + if (aOldGeometry) { + *aOldGeometry = oldData->mGeometry.get(); + } + if (aOldClip) { + *aOldClip = &oldData->mClip; + } + return oldData->mLayer; + } + + return nullptr; +} + +void +FrameLayerBuilder::ClearCachedGeometry(nsDisplayItem* aItem) +{ + uint32_t key = aItem->GetPerFrameKey(); + nsIFrame* frame = aItem->Frame(); + + DisplayItemData* oldData = GetOldLayerForFrame(frame, key); + if (oldData) { + oldData->mGeometry = nullptr; + } +} + +/* static */ Layer* +FrameLayerBuilder::GetDebugOldLayerFor(nsIFrame* aFrame, uint32_t aDisplayItemKey) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + + if (!array) { + return nullptr; + } + + for (uint32_t i = 0; i < array->Length(); i++) { + DisplayItemData *data = AssertDisplayItemData(array->ElementAt(i)); + + if (data->mDisplayItemKey == aDisplayItemKey) { + return data->mLayer; + } + } + return nullptr; +} + +/* static */ PaintedLayer* +FrameLayerBuilder::GetDebugSingleOldPaintedLayerForFrame(nsIFrame* aFrame) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + + if (!array) { + return nullptr; + } + + Layer* layer = nullptr; + for (DisplayItemData* data : *array) { + AssertDisplayItemData(data); + if (!data->mLayer->AsPaintedLayer()) { + continue; + } + if (layer && layer != data->mLayer) { + // More than one layer assigned, bail. + return nullptr; + } + layer = data->mLayer; + } + + if (!layer) { + return nullptr; + } + + return layer->AsPaintedLayer(); +} + +// Reset state that should not persist when a layer is recycled. +static void +ResetLayerStateForRecycling(Layer* aLayer) { + // Currently, this clears the mask layer and ancestor mask layers. + // Other cleanup may be added here. + aLayer->SetMaskLayer(nullptr); + aLayer->SetAncestorMaskLayers({}); +} + +already_AddRefed<ColorLayer> +ContainerState::CreateOrRecycleColorLayer(PaintedLayer *aPainted) +{ + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*>(aPainted->GetUserData(&gPaintedDisplayItemLayerUserData)); + RefPtr<ColorLayer> layer = data->mColorLayer; + if (layer) { + ResetLayerStateForRecycling(layer); + layer->ClearExtraDumpInfo(); + } else { + // Create a new layer + layer = mManager->CreateColorLayer(); + if (!layer) + return nullptr; + // Mark this layer as being used for painting display items + data->mColorLayer = layer; + layer->SetUserData(&gColorLayerUserData, nullptr); + + // Remove other layer types we might have stored for this PaintedLayer + data->mImageLayer = nullptr; + } + return layer.forget(); +} + +already_AddRefed<ImageLayer> +ContainerState::CreateOrRecycleImageLayer(PaintedLayer *aPainted) +{ + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*>(aPainted->GetUserData(&gPaintedDisplayItemLayerUserData)); + RefPtr<ImageLayer> layer = data->mImageLayer; + if (layer) { + ResetLayerStateForRecycling(layer); + layer->ClearExtraDumpInfo(); + } else { + // Create a new layer + layer = mManager->CreateImageLayer(); + if (!layer) + return nullptr; + // Mark this layer as being used for painting display items + data->mImageLayer = layer; + layer->SetUserData(&gImageLayerUserData, nullptr); + + // Remove other layer types we might have stored for this PaintedLayer + data->mColorLayer = nullptr; + } + return layer.forget(); +} + +already_AddRefed<ImageLayer> +ContainerState::CreateOrRecycleMaskImageLayerFor(const MaskLayerKey& aKey, + mozilla::function<void(Layer* aLayer)> aSetUserData) +{ + RefPtr<ImageLayer> result = mRecycledMaskImageLayers.Get(aKey); + if (result) { + mRecycledMaskImageLayers.Remove(aKey); + aKey.mLayer->ClearExtraDumpInfo(); + // XXX if we use clip on mask layers, null it out here + } else { + // Create a new layer + result = mManager->CreateImageLayer(); + if (!result) + return nullptr; + aSetUserData(result); + } + + return result.forget(); +} + +static const double SUBPIXEL_OFFSET_EPSILON = 0.02; + +/** + * This normally computes NSToIntRoundUp(aValue). However, if that would + * give a residual near 0.5 while aOldResidual is near -0.5, or + * it would give a residual near -0.5 while aOldResidual is near 0.5, then + * instead we return the integer in the other direction so that the residual + * is close to aOldResidual. + */ +static int32_t +RoundToMatchResidual(double aValue, double aOldResidual) +{ + int32_t v = NSToIntRoundUp(aValue); + double residual = aValue - v; + if (aOldResidual < 0) { + if (residual > 0 && fabs(residual - 1.0 - aOldResidual) < SUBPIXEL_OFFSET_EPSILON) { + // Round up instead + return int32_t(ceil(aValue)); + } + } else if (aOldResidual > 0) { + if (residual < 0 && fabs(residual + 1.0 - aOldResidual) < SUBPIXEL_OFFSET_EPSILON) { + // Round down instead + return int32_t(floor(aValue)); + } + } + return v; +} + +static void +ResetScrollPositionForLayerPixelAlignment(AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + nsIScrollableFrame* sf = nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot); + if (sf) { + sf->ResetScrollPositionForLayerPixelAlignment(); + } +} + +static void +InvalidateEntirePaintedLayer(PaintedLayer* aLayer, AnimatedGeometryRoot* aAnimatedGeometryRoot, const char *aReason) +{ +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Invalidating entire layer %p: %s\n", aLayer, aReason); + } +#endif + nsIntRect invalidate = aLayer->GetValidRegion().GetBounds(); + aLayer->InvalidateRegion(invalidate); + aLayer->SetInvalidRectToVisibleRegion(); + ResetScrollPositionForLayerPixelAlignment(aAnimatedGeometryRoot); +} + +LayerManager::PaintedLayerCreationHint +ContainerState::GetLayerCreationHint(AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + // Check whether the layer will be scrollable. This is used as a hint to + // influence whether tiled layers are used or not. + + // Check creation hint inherited from our parent. + if (mParameters.mLayerCreationHint == LayerManager::SCROLLABLE) { + return LayerManager::SCROLLABLE; + } + + // Check whether there's any active scroll frame on the animated geometry + // root chain. + for (AnimatedGeometryRoot* agr = aAnimatedGeometryRoot; + agr && agr != mContainerAnimatedGeometryRoot; + agr = agr->mParentAGR) { + nsIFrame* fParent = nsLayoutUtils::GetCrossDocParentFrame(*agr); + if (!fParent) { + break; + } + nsIScrollableFrame* scrollable = do_QueryFrame(fParent); + if (scrollable + #ifdef MOZ_B2G + && scrollable->WantAsyncScroll() + #endif + ) { + // WantAsyncScroll() returns false when the frame has overflow:hidden, + // so we won't create tiled layers for overflow:hidden frames even if + // they have a display port. The main purpose of the WantAsyncScroll check + // is to allow the B2G camera app to use hardware composer for compositing. + return LayerManager::SCROLLABLE; + } + } + return LayerManager::NONE; +} + +already_AddRefed<PaintedLayer> +ContainerState::AttemptToRecyclePaintedLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot, + nsDisplayItem* aItem, + const nsPoint& aTopLeft) +{ + Layer* oldLayer = mLayerBuilder->GetOldLayerFor(aItem); + if (!oldLayer || !oldLayer->AsPaintedLayer() || + !mPaintedLayersAvailableForRecycling.Contains(oldLayer->AsPaintedLayer())) { + return nullptr; + } + + // Try to recycle a layer + RefPtr<PaintedLayer> layer = oldLayer->AsPaintedLayer(); + mPaintedLayersAvailableForRecycling.RemoveEntry(layer); + + // Check if the layer hint has changed and whether or not the layer should + // be recreated because of it. + if (!layer->IsOptimizedFor(GetLayerCreationHint(aAnimatedGeometryRoot))) { + return nullptr; + } + + bool didResetScrollPositionForLayerPixelAlignment = false; + PaintedDisplayItemLayerUserData* data = + RecyclePaintedLayer(layer, aAnimatedGeometryRoot, + didResetScrollPositionForLayerPixelAlignment); + PreparePaintedLayerForUse(layer, data, aAnimatedGeometryRoot, aItem->ReferenceFrame(), + aTopLeft, + didResetScrollPositionForLayerPixelAlignment); + + return layer.forget(); +} + +already_AddRefed<PaintedLayer> +ContainerState::CreatePaintedLayer(PaintedLayerData* aData) +{ + LayerManager::PaintedLayerCreationHint creationHint = + GetLayerCreationHint(aData->mAnimatedGeometryRoot); + + // Create a new painted layer + RefPtr<PaintedLayer> layer = mManager->CreatePaintedLayerWithHint(creationHint); + if (!layer) { + return nullptr; + } + + // Mark this layer as being used for painting display items + PaintedDisplayItemLayerUserData* userData = new PaintedDisplayItemLayerUserData(); + layer->SetUserData(&gPaintedDisplayItemLayerUserData, userData); + ResetScrollPositionForLayerPixelAlignment(aData->mAnimatedGeometryRoot); + + PreparePaintedLayerForUse(layer, userData, aData->mAnimatedGeometryRoot, + aData->mReferenceFrame, + aData->mAnimatedGeometryRootOffset, true); + + return layer.forget(); +} + +PaintedDisplayItemLayerUserData* +ContainerState::RecyclePaintedLayer(PaintedLayer* aLayer, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + bool& didResetScrollPositionForLayerPixelAlignment) +{ + // Clear clip rect and mask layer so we don't accidentally stay clipped. + // We will reapply any necessary clipping. + ResetLayerStateForRecycling(aLayer); + aLayer->ClearExtraDumpInfo(); + + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*>( + aLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); + NS_ASSERTION(data, "Recycled PaintedLayers must have user data"); + + // This gets called on recycled PaintedLayers that are going to be in the + // final layer tree, so it's a convenient time to invalidate the + // content that changed where we don't know what PaintedLayer it belonged + // to, or if we need to invalidate the entire layer, we can do that. + // This needs to be done before we update the PaintedLayer to its new + // transform. See nsGfxScrollFrame::InvalidateInternal, where + // we ensure that mInvalidPaintedContent is updated according to the + // scroll position as of the most recent paint. + if (!FuzzyEqual(data->mXScale, mParameters.mXScale, 0.00001f) || + !FuzzyEqual(data->mYScale, mParameters.mYScale, 0.00001f) || + data->mAppUnitsPerDevPixel != mAppUnitsPerDevPixel) { +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Recycled layer %p changed scale\n", aLayer); + } +#endif + InvalidateEntirePaintedLayer(aLayer, aAnimatedGeometryRoot, "recycled layer changed state"); + didResetScrollPositionForLayerPixelAlignment = true; + } + if (!data->mRegionToInvalidate.IsEmpty()) { +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Invalidating deleted frame content from layer %p\n", aLayer); + } +#endif + aLayer->InvalidateRegion(data->mRegionToInvalidate); +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + nsAutoCString str; + AppendToString(str, data->mRegionToInvalidate); + printf_stderr("Invalidating layer %p: %s\n", aLayer, str.get()); + } +#endif + data->mRegionToInvalidate.SetEmpty(); + } + return data; +} + +void +ContainerState::PreparePaintedLayerForUse(PaintedLayer* aLayer, + PaintedDisplayItemLayerUserData* aData, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIFrame* aReferenceFrame, + const nsPoint& aTopLeft, + bool didResetScrollPositionForLayerPixelAlignment) +{ + aData->mXScale = mParameters.mXScale; + aData->mYScale = mParameters.mYScale; + aData->mLastAnimatedGeometryRootOrigin = aData->mAnimatedGeometryRootOrigin; + aData->mAnimatedGeometryRootOrigin = aTopLeft; + aData->mAppUnitsPerDevPixel = mAppUnitsPerDevPixel; + aLayer->SetAllowResidualTranslation(mParameters.AllowResidualTranslation()); + + mLayerBuilder->SavePreviousDataForLayer(aLayer, aData->mMaskClipCount); + + // Set up transform so that 0,0 in the PaintedLayer corresponds to the + // (pixel-snapped) top-left of the aAnimatedGeometryRoot. + nsPoint offset = (*aAnimatedGeometryRoot)->GetOffsetToCrossDoc(aReferenceFrame); + nscoord appUnitsPerDevPixel = (*aAnimatedGeometryRoot)->PresContext()->AppUnitsPerDevPixel(); + gfxPoint scaledOffset( + NSAppUnitsToDoublePixels(offset.x, appUnitsPerDevPixel)*mParameters.mXScale, + NSAppUnitsToDoublePixels(offset.y, appUnitsPerDevPixel)*mParameters.mYScale); + // We call RoundToMatchResidual here so that the residual after rounding + // is close to aData->mAnimatedGeometryRootPosition if possible. + nsIntPoint pixOffset(RoundToMatchResidual(scaledOffset.x, aData->mAnimatedGeometryRootPosition.x), + RoundToMatchResidual(scaledOffset.y, aData->mAnimatedGeometryRootPosition.y)); + aData->mTranslation = pixOffset; + pixOffset += mParameters.mOffset; + Matrix matrix = Matrix::Translation(pixOffset.x, pixOffset.y); + aLayer->SetBaseTransform(Matrix4x4::From2D(matrix)); + + aData->mVisibilityComputedRegion.SetEmpty(); + + // FIXME: Temporary workaround for bug 681192 and bug 724786. +#ifndef MOZ_WIDGET_ANDROID + // Calculate exact position of the top-left of the active scrolled root. + // This might not be 0,0 due to the snapping in ScaleToNearestPixels. + gfxPoint animatedGeometryRootTopLeft = scaledOffset - ThebesPoint(matrix.GetTranslation()) + mParameters.mOffset; + // If it has changed, then we need to invalidate the entire layer since the + // pixels in the layer buffer have the content at a (subpixel) offset + // from what we need. + if (!animatedGeometryRootTopLeft.WithinEpsilonOf(aData->mAnimatedGeometryRootPosition, SUBPIXEL_OFFSET_EPSILON)) { + aData->mAnimatedGeometryRootPosition = animatedGeometryRootTopLeft; + InvalidateEntirePaintedLayer(aLayer, aAnimatedGeometryRoot, "subpixel offset"); + } else if (didResetScrollPositionForLayerPixelAlignment) { + aData->mAnimatedGeometryRootPosition = animatedGeometryRootTopLeft; + } +#else + Unused << didResetScrollPositionForLayerPixelAlignment; +#endif +} + +#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING) +/** + * Returns the appunits per dev pixel for the item's frame + */ +static int32_t +AppUnitsPerDevPixel(nsDisplayItem* aItem) +{ + // The underlying frame for zoom items is the root frame of the subdocument. + // But zoom display items report their bounds etc using the parent document's + // APD because zoom items act as a conversion layer between the two different + // APDs. + if (aItem->GetType() == nsDisplayItem::TYPE_ZOOM) { + return static_cast<nsDisplayZoom*>(aItem)->GetParentAppUnitsPerDevPixel(); + } + return aItem->Frame()->PresContext()->AppUnitsPerDevPixel(); +} +#endif + +/** + * Set the visible region for aLayer. + * aOuterVisibleRegion is the visible region relative to the parent layer. + * aLayerContentsVisibleRect, if non-null, is a rectangle in the layer's + * own coordinate system to which the layer's visible region is restricted. + * Consumes *aOuterVisibleRegion. + */ +static void +SetOuterVisibleRegion(Layer* aLayer, nsIntRegion* aOuterVisibleRegion, + const nsIntRect* aLayerContentsVisibleRect = nullptr, + bool aOuterUntransformed = false) +{ + Matrix4x4 transform = aLayer->GetTransform(); + Matrix transform2D; + if (aOuterUntransformed) { + if (aLayerContentsVisibleRect) { + aOuterVisibleRegion->And(*aOuterVisibleRegion, + *aLayerContentsVisibleRect); + } + } else if (transform.Is2D(&transform2D) && !transform2D.HasNonIntegerTranslation()) { + aOuterVisibleRegion->MoveBy(-int(transform2D._31), -int(transform2D._32)); + if (aLayerContentsVisibleRect) { + aOuterVisibleRegion->And(*aOuterVisibleRegion, *aLayerContentsVisibleRect); + } + } else { + nsIntRect outerRect = aOuterVisibleRegion->GetBounds(); + // if 'transform' is not invertible, then nothing will be displayed + // for the layer, so it doesn't really matter what we do here + Rect outerVisible(outerRect.x, outerRect.y, outerRect.width, outerRect.height); + transform.Invert(); + + Rect layerContentsVisible(-float(INT32_MAX) / 2, -float(INT32_MAX) / 2, + float(INT32_MAX), float(INT32_MAX)); + if (aLayerContentsVisibleRect) { + NS_ASSERTION(aLayerContentsVisibleRect->width >= 0 && + aLayerContentsVisibleRect->height >= 0, + "Bad layer contents rectangle"); + // restrict to aLayerContentsVisibleRect before call GfxRectToIntRect, + // in case layerVisible is extremely large (as it can be when + // projecting through the inverse of a 3D transform) + layerContentsVisible = Rect( + aLayerContentsVisibleRect->x, aLayerContentsVisibleRect->y, + aLayerContentsVisibleRect->width, aLayerContentsVisibleRect->height); + } + gfxRect layerVisible = ThebesRect(transform.ProjectRectBounds(outerVisible, layerContentsVisible)); + layerVisible.RoundOut(); + nsIntRect visRect; + if (gfxUtils::GfxRectToIntRect(layerVisible, &visRect)) { + *aOuterVisibleRegion = visRect; + } else { + aOuterVisibleRegion->SetEmpty(); + } + } + + aLayer->SetVisibleRegion(LayerIntRegion::FromUnknownRegion(*aOuterVisibleRegion)); +} + +void +ContainerState::SetOuterVisibleRegionForLayer(Layer* aLayer, + const nsIntRegion& aOuterVisibleRegion, + const nsIntRect* aLayerContentsVisibleRect, + bool aOuterUntransformed) const +{ + nsIntRegion visRegion = aOuterVisibleRegion; + if (!aOuterUntransformed) { + visRegion.MoveBy(mParameters.mOffset); + } + SetOuterVisibleRegion(aLayer, &visRegion, aLayerContentsVisibleRect, + aOuterUntransformed); +} + +nscolor +ContainerState::FindOpaqueBackgroundColorInLayer(const PaintedLayerData* aData, + const nsIntRect& aRect, + bool* aOutIntersectsLayer) const +{ + *aOutIntersectsLayer = true; + + // Scan the candidate's display items. + nsIntRect deviceRect = aRect; + nsRect appUnitRect = ToAppUnits(deviceRect, mAppUnitsPerDevPixel); + appUnitRect.ScaleInverseRoundOut(mParameters.mXScale, mParameters.mYScale); + + for (auto& assignedItem : Reversed(aData->mAssignedDisplayItems)) { + nsDisplayItem* item = assignedItem.mItem; + bool snap; + nsRect bounds = item->GetBounds(mBuilder, &snap); + if (snap && mSnappingEnabled) { + nsIntRect snappedBounds = ScaleToNearestPixels(bounds); + if (!snappedBounds.Intersects(deviceRect)) + continue; + + if (!snappedBounds.Contains(deviceRect)) + return NS_RGBA(0,0,0,0); + + } else { + // The layer's visible rect is already (close enough to) pixel + // aligned, so no need to round out and in here. + if (!bounds.Intersects(appUnitRect)) + continue; + + if (!bounds.Contains(appUnitRect)) + return NS_RGBA(0,0,0,0); + } + + if (item->IsInvisibleInRect(appUnitRect)) { + continue; + } + + if (assignedItem.mClip.IsRectAffectedByClip(deviceRect, + mParameters.mXScale, + mParameters.mYScale, + mAppUnitsPerDevPixel)) { + return NS_RGBA(0,0,0,0); + } + + Maybe<nscolor> color = item->IsUniform(mBuilder); + if (color && NS_GET_A(*color) == 255) + return *color; + + return NS_RGBA(0,0,0,0); + } + + *aOutIntersectsLayer = false; + return NS_RGBA(0,0,0,0); +} + +nscolor +PaintedLayerDataNode::FindOpaqueBackgroundColor(const nsIntRegion& aTargetVisibleRegion, + int32_t aUnderIndex) const +{ + if (aUnderIndex == ABOVE_TOP) { + aUnderIndex = mPaintedLayerDataStack.Length(); + } + for (int32_t i = aUnderIndex - 1; i >= 0; --i) { + const PaintedLayerData* candidate = &mPaintedLayerDataStack[i]; + if (candidate->VisibleAboveRegionIntersects(aTargetVisibleRegion)) { + // Some non-PaintedLayer content between target and candidate; this is + // hopeless + return NS_RGBA(0,0,0,0); + } + + if (!candidate->VisibleRegionIntersects(aTargetVisibleRegion)) { + // The layer doesn't intersect our target, ignore it and move on + continue; + } + + bool intersectsLayer = true; + nsIntRect rect = aTargetVisibleRegion.GetBounds(); + nscolor color = mTree.ContState().FindOpaqueBackgroundColorInLayer( + candidate, rect, &intersectsLayer); + if (!intersectsLayer) { + continue; + } + return color; + } + if (mAllDrawingAboveBackground || + !mVisibleAboveBackgroundRegion.Intersect(aTargetVisibleRegion).IsEmpty()) { + // Some non-PaintedLayer content is between this node's background and target. + return NS_RGBA(0,0,0,0); + } + return FindOpaqueBackgroundColorInParentNode(); +} + +nscolor +PaintedLayerDataNode::FindOpaqueBackgroundColorCoveringEverything() const +{ + if (!mPaintedLayerDataStack.IsEmpty() || + mAllDrawingAboveBackground || + !mVisibleAboveBackgroundRegion.IsEmpty()) { + return NS_RGBA(0,0,0,0); + } + return FindOpaqueBackgroundColorInParentNode(); +} + +nscolor +PaintedLayerDataNode::FindOpaqueBackgroundColorInParentNode() const +{ + if (mParent) { + if (mHasClip) { + // Check whether our parent node has uniform content behind our whole + // clip. + // There's one tricky case here: If our parent node is also a scrollable, + // and is currently scrolled in such a way that this inner one is + // clipped by it, then it's not really clear how we should determine + // whether we have a uniform background in the parent: There might be + // non-uniform content in the parts that our scroll port covers in the + // parent and that are currently outside the parent's clip. + // For now, we'll fail to pull a background color in that case. + return mParent->FindOpaqueBackgroundColor(mClipRect); + } + return mParent->FindOpaqueBackgroundColorCoveringEverything(); + } + // We are the root. + return mTree.UniformBackgroundColor(); +} + +void +PaintedLayerData::UpdateCommonClipCount( + const DisplayItemClip& aCurrentClip) +{ + if (mCommonClipCount >= 0) { + mCommonClipCount = mItemClip.GetCommonRoundedRectCount(aCurrentClip, mCommonClipCount); + } else { + // first item in the layer + mCommonClipCount = aCurrentClip.GetRoundedRectCount(); + } +} + +bool +PaintedLayerData::CanOptimizeToImageLayer(nsDisplayListBuilder* aBuilder) +{ + if (!mImage) { + return false; + } + + return mImage->CanOptimizeToImageLayer(mLayer->Manager(), aBuilder); +} + +already_AddRefed<ImageContainer> +PaintedLayerData::GetContainerForImageLayer(nsDisplayListBuilder* aBuilder) +{ + if (!mImage) { + return nullptr; + } + + return mImage->GetContainer(mLayer->Manager(), aBuilder); +} + +PaintedLayerDataNode::PaintedLayerDataNode(PaintedLayerDataTree& aTree, + PaintedLayerDataNode* aParent, + AnimatedGeometryRoot* aAnimatedGeometryRoot) + : mTree(aTree) + , mParent(aParent) + , mAnimatedGeometryRoot(aAnimatedGeometryRoot) + , mAllDrawingAboveBackground(false) +{ + MOZ_ASSERT(nsLayoutUtils::IsAncestorFrameCrossDoc(mTree.Builder()->RootReferenceFrame(), *mAnimatedGeometryRoot)); + mHasClip = mTree.IsClippedWithRespectToParentAnimatedGeometryRoot(mAnimatedGeometryRoot, &mClipRect); +} + +PaintedLayerDataNode::~PaintedLayerDataNode() +{ + MOZ_ASSERT(mPaintedLayerDataStack.IsEmpty()); + MOZ_ASSERT(mChildren.IsEmpty()); +} + +PaintedLayerDataNode* +PaintedLayerDataNode::AddChildNodeFor(AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + MOZ_ASSERT(aAnimatedGeometryRoot->mParentAGR == mAnimatedGeometryRoot); + UniquePtr<PaintedLayerDataNode> child = + MakeUnique<PaintedLayerDataNode>(mTree, this, aAnimatedGeometryRoot); + mChildren.AppendElement(Move(child)); + return mChildren.LastElement().get(); +} + +template<typename NewPaintedLayerCallbackType> +PaintedLayerData* +PaintedLayerDataNode::FindPaintedLayerFor(const nsIntRect& aVisibleRect, + bool aBackfaceHidden, + const DisplayItemScrollClip* aScrollClip, + NewPaintedLayerCallbackType aNewPaintedLayerCallback) +{ + if (!mPaintedLayerDataStack.IsEmpty()) { + PaintedLayerData* lowestUsableLayer = nullptr; + for (auto& data : Reversed(mPaintedLayerDataStack)) { + if (data.mVisibleAboveRegion.Intersects(aVisibleRect)) { + break; + } + if (data.mBackfaceHidden == aBackfaceHidden && + data.mScrollClip == aScrollClip) { + lowestUsableLayer = &data; + } + nsIntRegion visibleRegion = data.mVisibleRegion; + // Also check whether the event-regions intersect the visible rect, + // unless we're in an inactive layer, in which case the event-regions + // will be hoisted out into their own layer. + // For performance reasons, we check the intersection with the bounds + // of the event-regions. + if (!mTree.ContState().IsInInactiveLayer() && + (data.mScaledHitRegionBounds.Intersects(aVisibleRect) || + data.mScaledMaybeHitRegionBounds.Intersects(aVisibleRect))) { + break; + } + if (visibleRegion.Intersects(aVisibleRect)) { + break; + } + } + if (lowestUsableLayer) { + return lowestUsableLayer; + } + } + return mPaintedLayerDataStack.AppendElement(aNewPaintedLayerCallback()); +} + +void +PaintedLayerDataNode::FinishChildrenIntersecting(const nsIntRect& aRect) +{ + for (int32_t i = mChildren.Length() - 1; i >= 0; i--) { + if (mChildren[i]->Intersects(aRect)) { + mChildren[i]->Finish(true); + mChildren.RemoveElementAt(i); + } + } +} + +void +PaintedLayerDataNode::FinishAllChildren(bool aThisNodeNeedsAccurateVisibleAboveRegion) +{ + for (int32_t i = mChildren.Length() - 1; i >= 0; i--) { + mChildren[i]->Finish(aThisNodeNeedsAccurateVisibleAboveRegion); + } + mChildren.Clear(); +} + +void +PaintedLayerDataNode::Finish(bool aParentNeedsAccurateVisibleAboveRegion) +{ + // Skip "visible above region" maintenance, because this node is going away. + FinishAllChildren(false); + + PopAllPaintedLayerData(); + + if (mParent && aParentNeedsAccurateVisibleAboveRegion) { + if (mHasClip) { + mParent->AddToVisibleAboveRegion(mClipRect); + } else { + mParent->SetAllDrawingAbove(); + } + } + mTree.NodeWasFinished(mAnimatedGeometryRoot); +} + +void +PaintedLayerDataNode::AddToVisibleAboveRegion(const nsIntRect& aRect) +{ + nsIntRegion& visibleAboveRegion = mPaintedLayerDataStack.IsEmpty() + ? mVisibleAboveBackgroundRegion + : mPaintedLayerDataStack.LastElement().mVisibleAboveRegion; + visibleAboveRegion.Or(visibleAboveRegion, aRect); + visibleAboveRegion.SimplifyOutward(8); +} + +void +PaintedLayerDataNode::SetAllDrawingAbove() +{ + PopAllPaintedLayerData(); + mAllDrawingAboveBackground = true; + mVisibleAboveBackgroundRegion.SetEmpty(); +} + +void +PaintedLayerDataNode::PopPaintedLayerData() +{ + MOZ_ASSERT(!mPaintedLayerDataStack.IsEmpty()); + size_t lastIndex = mPaintedLayerDataStack.Length() - 1; + PaintedLayerData& data = mPaintedLayerDataStack[lastIndex]; + mTree.ContState().FinishPaintedLayerData(data, [this, &data, lastIndex]() { + return this->FindOpaqueBackgroundColor(data.mVisibleRegion, lastIndex); + }); + mPaintedLayerDataStack.RemoveElementAt(lastIndex); +} + +void +PaintedLayerDataNode::PopAllPaintedLayerData() +{ + while (!mPaintedLayerDataStack.IsEmpty()) { + PopPaintedLayerData(); + } +} + +nsDisplayListBuilder* +PaintedLayerDataTree::Builder() const +{ + return mContainerState.Builder(); +} + +void +PaintedLayerDataTree::Finish() +{ + if (mRoot) { + mRoot->Finish(false); + } + MOZ_ASSERT(mNodes.Count() == 0); + mRoot = nullptr; +} + +void +PaintedLayerDataTree::NodeWasFinished(AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + mNodes.Remove(aAnimatedGeometryRoot); +} + +void +PaintedLayerDataTree::AddingOwnLayer(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIntRect* aRect, + nscolor* aOutUniformBackgroundColor) +{ + FinishPotentiallyIntersectingNodes(aAnimatedGeometryRoot, aRect); + PaintedLayerDataNode* node = EnsureNodeFor(aAnimatedGeometryRoot); + if (aRect) { + if (aOutUniformBackgroundColor) { + *aOutUniformBackgroundColor = node->FindOpaqueBackgroundColor(*aRect); + } + node->AddToVisibleAboveRegion(*aRect); + } else { + if (aOutUniformBackgroundColor) { + *aOutUniformBackgroundColor = node->FindOpaqueBackgroundColorCoveringEverything(); + } + node->SetAllDrawingAbove(); + } +} + +template<typename NewPaintedLayerCallbackType> +PaintedLayerData* +PaintedLayerDataTree::FindPaintedLayerFor(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemScrollClip* aScrollClip, + const nsIntRect& aVisibleRect, + bool aBackfaceHidden, + NewPaintedLayerCallbackType aNewPaintedLayerCallback) +{ + const nsIntRect* bounds = &aVisibleRect; + FinishPotentiallyIntersectingNodes(aAnimatedGeometryRoot, bounds); + PaintedLayerDataNode* node = EnsureNodeFor(aAnimatedGeometryRoot); + + PaintedLayerData* data = + node->FindPaintedLayerFor(aVisibleRect, aBackfaceHidden, aScrollClip, + aNewPaintedLayerCallback); + return data; +} + +void +PaintedLayerDataTree::FinishPotentiallyIntersectingNodes(AnimatedGeometryRoot* aAnimatedGeometryRoot, + const nsIntRect* aRect) +{ + AnimatedGeometryRoot* ancestorThatIsChildOfCommonAncestor = nullptr; + PaintedLayerDataNode* ancestorNode = + FindNodeForAncestorAnimatedGeometryRoot(aAnimatedGeometryRoot, + &ancestorThatIsChildOfCommonAncestor); + if (!ancestorNode) { + // None of our ancestors are in the tree. This should only happen if this + // is the very first item we're looking at. + MOZ_ASSERT(!mRoot); + return; + } + + if (ancestorNode->GetAnimatedGeometryRoot() == aAnimatedGeometryRoot) { + // aAnimatedGeometryRoot already has a node in the tree. + // This is the common case. + MOZ_ASSERT(!ancestorThatIsChildOfCommonAncestor); + if (aRect) { + ancestorNode->FinishChildrenIntersecting(*aRect); + } else { + ancestorNode->FinishAllChildren(); + } + return; + } + + // We have found an existing ancestor, but it's a proper ancestor of our + // animated geometry root. + // ancestorThatIsChildOfCommonAncestor is the last animated geometry root + // encountered on the way up from aAnimatedGeometryRoot to ancestorNode. + MOZ_ASSERT(ancestorThatIsChildOfCommonAncestor); + MOZ_ASSERT(nsLayoutUtils::IsAncestorFrameCrossDoc(*ancestorThatIsChildOfCommonAncestor, *aAnimatedGeometryRoot)); + MOZ_ASSERT(ancestorThatIsChildOfCommonAncestor->mParentAGR == ancestorNode->GetAnimatedGeometryRoot()); + + // ancestorThatIsChildOfCommonAncestor is not in the tree yet! + MOZ_ASSERT(!mNodes.Get(ancestorThatIsChildOfCommonAncestor)); + + // We're about to add a node for ancestorThatIsChildOfCommonAncestor, so we + // finish all intersecting siblings. + nsIntRect clip; + if (IsClippedWithRespectToParentAnimatedGeometryRoot(ancestorThatIsChildOfCommonAncestor, &clip)) { + ancestorNode->FinishChildrenIntersecting(clip); + } else { + ancestorNode->FinishAllChildren(); + } +} + +PaintedLayerDataNode* +PaintedLayerDataTree::EnsureNodeFor(AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + MOZ_ASSERT(aAnimatedGeometryRoot); + PaintedLayerDataNode* node = mNodes.Get(aAnimatedGeometryRoot); + if (node) { + return node; + } + + AnimatedGeometryRoot* parentAnimatedGeometryRoot = aAnimatedGeometryRoot->mParentAGR; + if (!parentAnimatedGeometryRoot) { + MOZ_ASSERT(!mRoot); + MOZ_ASSERT(*aAnimatedGeometryRoot == Builder()->RootReferenceFrame()); + mRoot = MakeUnique<PaintedLayerDataNode>(*this, nullptr, aAnimatedGeometryRoot); + node = mRoot.get(); + } else { + PaintedLayerDataNode* parentNode = EnsureNodeFor(parentAnimatedGeometryRoot); + MOZ_ASSERT(parentNode); + node = parentNode->AddChildNodeFor(aAnimatedGeometryRoot); + } + MOZ_ASSERT(node); + mNodes.Put(aAnimatedGeometryRoot, node); + return node; +} + +bool +PaintedLayerDataTree::IsClippedWithRespectToParentAnimatedGeometryRoot(AnimatedGeometryRoot* aAnimatedGeometryRoot, + nsIntRect* aOutClip) +{ + nsIScrollableFrame* scrollableFrame = nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot); + if (!scrollableFrame) { + return false; + } + nsIFrame* scrollFrame = do_QueryFrame(scrollableFrame); + nsRect scrollPort = scrollableFrame->GetScrollPortRect() + Builder()->ToReferenceFrame(scrollFrame); + *aOutClip = mContainerState.ScaleToNearestPixels(scrollPort); + return true; +} + +PaintedLayerDataNode* +PaintedLayerDataTree::FindNodeForAncestorAnimatedGeometryRoot(AnimatedGeometryRoot* aAnimatedGeometryRoot, + AnimatedGeometryRoot** aOutAncestorChild) +{ + if (!aAnimatedGeometryRoot) { + return nullptr; + } + PaintedLayerDataNode* node = mNodes.Get(aAnimatedGeometryRoot); + if (node) { + return node; + } + *aOutAncestorChild = aAnimatedGeometryRoot; + return FindNodeForAncestorAnimatedGeometryRoot(aAnimatedGeometryRoot->mParentAGR, aOutAncestorChild); +} + +static bool +CanOptimizeAwayPaintedLayer(PaintedLayerData* aData, + FrameLayerBuilder* aLayerBuilder) +{ + if (!aLayerBuilder->IsBuildingRetainedLayers()) { + return false; + } + + // If there's no painted layer with valid content in it that we can reuse, + // always create a color or image layer (and potentially throw away an + // existing completely invalid painted layer). + if (aData->mLayer->GetValidRegion().IsEmpty()) { + return true; + } + + // There is an existing painted layer we can reuse. Throwing it away can make + // compositing cheaper (see bug 946952), but it might cause us to re-allocate + // the painted layer frequently due to an animation. So we only discard it if + // we're in tree compression mode, which is triggered at a low frequency. + return aLayerBuilder->CheckInLayerTreeCompressionMode(); +} + +#ifdef DEBUG +static int32_t FindIndexOfLayerIn(nsTArray<NewLayerEntry>& aArray, + Layer* aLayer) +{ + for (uint32_t i = 0; i < aArray.Length(); ++i) { + if (aArray[i].mLayer == aLayer) { + return i; + } + } + return -1; +} +#endif + +already_AddRefed<Layer> +ContainerState::PrepareImageLayer(PaintedLayerData* aData) +{ + RefPtr<ImageContainer> imageContainer = + aData->GetContainerForImageLayer(mBuilder); + if (!imageContainer) { + return nullptr; + } + + RefPtr<ImageLayer> imageLayer = CreateOrRecycleImageLayer(aData->mLayer); + imageLayer->SetContainer(imageContainer); + aData->mImage->ConfigureLayer(imageLayer, mParameters); + imageLayer->SetPostScale(mParameters.mXScale, + mParameters.mYScale); + + if (aData->mItemClip.HasClip()) { + ParentLayerIntRect clip = + ViewAs<ParentLayerPixel>(ScaleToNearestPixels(aData->mItemClip.GetClipRect())); + clip.MoveBy(ViewAs<ParentLayerPixel>(mParameters.mOffset)); + imageLayer->SetClipRect(Some(clip)); + } else { + imageLayer->SetClipRect(Nothing()); + } + + mLayerBuilder->StoreOptimizedLayerForFrame(aData->mImage, imageLayer); + FLB_LOG_PAINTED_LAYER_DECISION(aData, + " Selected image layer=%p\n", imageLayer.get()); + + return imageLayer.forget(); +} + +already_AddRefed<Layer> +ContainerState::PrepareColorLayer(PaintedLayerData* aData) +{ + RefPtr<ColorLayer> colorLayer = CreateOrRecycleColorLayer(aData->mLayer); + colorLayer->SetColor(Color::FromABGR(aData->mSolidColor)); + + // Copy transform + colorLayer->SetBaseTransform(aData->mLayer->GetBaseTransform()); + colorLayer->SetPostScale(aData->mLayer->GetPostXScale(), + aData->mLayer->GetPostYScale()); + + nsIntRect visibleRect = aData->mVisibleRegion.GetBounds(); + visibleRect.MoveBy(-GetTranslationForPaintedLayer(aData->mLayer)); + colorLayer->SetBounds(visibleRect); + colorLayer->SetClipRect(Nothing()); + + FLB_LOG_PAINTED_LAYER_DECISION(aData, + " Selected color layer=%p\n", colorLayer.get()); + + return colorLayer.forget(); +} + +static void +SetBackfaceHiddenForLayer(bool aBackfaceHidden, Layer* aLayer) +{ + if (aBackfaceHidden) { + aLayer->SetContentFlags(aLayer->GetContentFlags() | + Layer::CONTENT_BACKFACE_HIDDEN); + } else { + aLayer->SetContentFlags(aLayer->GetContentFlags() & + ~Layer::CONTENT_BACKFACE_HIDDEN); + } +} + +template<typename FindOpaqueBackgroundColorCallbackType> +void ContainerState::FinishPaintedLayerData(PaintedLayerData& aData, FindOpaqueBackgroundColorCallbackType aFindOpaqueBackgroundColor) +{ + PaintedLayerData* data = &aData; + + if (!data->mLayer) { + // No layer was recycled, so we create a new one. + RefPtr<PaintedLayer> paintedLayer = CreatePaintedLayer(data); + data->mLayer = paintedLayer; + + NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, paintedLayer) < 0, + "Layer already in list???"); + mNewChildLayers[data->mNewChildLayersIndex].mLayer = paintedLayer.forget(); + } + + for (auto& item : data->mAssignedDisplayItems) { + MOZ_ASSERT(item.mItem->GetType() != nsDisplayItem::TYPE_LAYER_EVENT_REGIONS); + + InvalidateForLayerChange(item.mItem, data->mLayer); + mLayerBuilder->AddPaintedDisplayItem(data, item.mItem, item.mClip, + *this, item.mLayerState, + data->mAnimatedGeometryRootOffset); + } + + NewLayerEntry* newLayerEntry = &mNewChildLayers[data->mNewChildLayersIndex]; + + RefPtr<Layer> layer; + bool canOptimizeToImageLayer = data->CanOptimizeToImageLayer(mBuilder); + + FLB_LOG_PAINTED_LAYER_DECISION(data, "Selecting layer for pld=%p\n", data); + FLB_LOG_PAINTED_LAYER_DECISION(data, " Solid=%i, hasImage=%c, canOptimizeAwayPaintedLayer=%i\n", + data->mIsSolidColorInVisibleRegion, canOptimizeToImageLayer ? 'y' : 'n', + CanOptimizeAwayPaintedLayer(data, mLayerBuilder)); + + if ((data->mIsSolidColorInVisibleRegion || canOptimizeToImageLayer) && + CanOptimizeAwayPaintedLayer(data, mLayerBuilder)) { + NS_ASSERTION(!(data->mIsSolidColorInVisibleRegion && canOptimizeToImageLayer), + "Can't be a solid color as well as an image!"); + + layer = canOptimizeToImageLayer ? PrepareImageLayer(data) + : PrepareColorLayer(data); + + if (layer) { + NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, layer) < 0, + "Layer already in list???"); + NS_ASSERTION(newLayerEntry->mLayer == data->mLayer, + "Painted layer at wrong index"); + // Store optimized layer in reserved slot + newLayerEntry = &mNewChildLayers[data->mNewChildLayersIndex + 1]; + NS_ASSERTION(!newLayerEntry->mLayer, "Slot already occupied?"); + newLayerEntry->mLayer = layer; + newLayerEntry->mAnimatedGeometryRoot = data->mAnimatedGeometryRoot; + newLayerEntry->mScrollClip = data->mScrollClip; + + // Hide the PaintedLayer. We leave it in the layer tree so that we + // can find and recycle it later. + ParentLayerIntRect emptyRect; + data->mLayer->SetClipRect(Some(emptyRect)); + data->mLayer->SetVisibleRegion(LayerIntRegion()); + data->mLayer->InvalidateRegion(data->mLayer->GetValidRegion().GetBounds()); + data->mLayer->SetEventRegions(EventRegions()); + } + } + + if (!layer) { + // We couldn't optimize to an image layer or a color layer above. + layer = data->mLayer; + layer->SetClipRect(Nothing()); + FLB_LOG_PAINTED_LAYER_DECISION(data, " Selected painted layer=%p\n", layer.get()); + } + + // If the layer is a fixed background layer, the clip on the fixed background + // display item was not applied to the opaque region in + // ContainerState::ComputeOpaqueRect(), but was saved in data->mItemClip. + // Apply it to the opaque region now. Note that it's important to do this + // before the opaque region is propagated to the NewLayerEntry below. + if (data->mSingleItemFixedToViewport && data->mItemClip.HasClip()) { + nsRect clipRect = data->mItemClip.GetClipRect(); + nsRect insideRoundedCorners = data->mItemClip.ApproximateIntersectInward(clipRect); + nsIntRect insideRoundedCornersScaled = ScaleToInsidePixels(insideRoundedCorners); + data->mOpaqueRegion.AndWith(insideRoundedCornersScaled); + } + + if (mLayerBuilder->IsBuildingRetainedLayers()) { + newLayerEntry->mVisibleRegion = data->mVisibleRegion; + newLayerEntry->mOpaqueRegion = data->mOpaqueRegion; + newLayerEntry->mHideAllLayersBelow = data->mHideAllLayersBelow; + newLayerEntry->mOpaqueForAnimatedGeometryRootParent = data->mOpaqueForAnimatedGeometryRootParent; + } else { + SetOuterVisibleRegionForLayer(layer, data->mVisibleRegion); + } + + nsIntRect layerBounds = data->mBounds; + layerBounds.MoveBy(-GetTranslationForPaintedLayer(data->mLayer)); + layer->SetLayerBounds(layerBounds); + +#ifdef MOZ_DUMP_PAINTING + if (!data->mLog.IsEmpty()) { + if (PaintedLayerData* containingPld = mLayerBuilder->GetContainingPaintedLayerData()) { + containingPld->mLayer->AddExtraDumpInfo(nsCString(data->mLog)); + } else { + layer->AddExtraDumpInfo(nsCString(data->mLog)); + } + } +#endif + + nsIntRegion transparentRegion; + transparentRegion.Sub(data->mVisibleRegion, data->mOpaqueRegion); + bool isOpaque = transparentRegion.IsEmpty(); + // For translucent PaintedLayers, try to find an opaque background + // color that covers the entire area beneath it so we can pull that + // color into this layer to make it opaque. + if (layer == data->mLayer) { + nscolor backgroundColor = NS_RGBA(0,0,0,0); + if (!isOpaque) { + backgroundColor = aFindOpaqueBackgroundColor(); + if (NS_GET_A(backgroundColor) == 255) { + isOpaque = true; + } + } + + // Store the background color + PaintedDisplayItemLayerUserData* userData = + GetPaintedDisplayItemLayerUserData(data->mLayer); + NS_ASSERTION(userData, "where did our user data go?"); + if (userData->mForcedBackgroundColor != backgroundColor) { + // Invalidate the entire target PaintedLayer since we're changing + // the background color +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Forced background color has changed from #%08X to #%08X on layer %p\n", + userData->mForcedBackgroundColor, backgroundColor, data->mLayer); + nsAutoCString str; + AppendToString(str, data->mLayer->GetValidRegion()); + printf_stderr("Invalidating layer %p: %s\n", data->mLayer, str.get()); + } +#endif + data->mLayer->InvalidateRegion(data->mLayer->GetValidRegion()); + } + userData->mForcedBackgroundColor = backgroundColor; + + userData->mFontSmoothingBackgroundColor = data->mFontSmoothingBackgroundColor; + + // use a mask layer for rounded rect clipping. + // data->mCommonClipCount may be -1 if we haven't put any actual + // drawable items in this layer (i.e. it's only catching events). + int32_t commonClipCount; + // If the layer contains a single item fixed to the viewport, we removed + // its clip in ProcessDisplayItems() and saved it to set on the layer instead. + // Set the clip on the layer now. + if (data->mSingleItemFixedToViewport && data->mItemClip.HasClip()) { + nsIntRect layerClipRect = ScaleToNearestPixels(data->mItemClip.GetClipRect()); + layerClipRect.MoveBy(mParameters.mOffset); + // The clip from such an item becomes part of the layer's scrolled clip, + // and the associated mask layer one of the layer's "ancestor mask layers". + LayerClip scrolledClip; + scrolledClip.SetClipRect(ViewAs<ParentLayerPixel>(layerClipRect)); + scrolledClip.SetMaskLayerIndex( + SetupMaskLayerForScrolledClip(data->mLayer, data->mItemClip)); + data->mLayer->SetScrolledClip(Some(scrolledClip)); + // There is only one item, so all of the clips are in common to all items. + // data->mCommonClipCount will be zero because we removed the clip from + // the display item. (It could also be -1 if we're inside an inactive + // layer tree in which we don't call UpdateCommonClipCount() at all.) + MOZ_ASSERT(data->mCommonClipCount == -1 || data->mCommonClipCount == 0); + commonClipCount = data->mItemClip.GetRoundedRectCount(); + } else { + commonClipCount = std::max(0, data->mCommonClipCount); + SetupMaskLayer(layer, data->mItemClip, commonClipCount); + } + // copy commonClipCount to the entry + FrameLayerBuilder::PaintedLayerItemsEntry* entry = mLayerBuilder-> + GetPaintedLayerItemsEntry(static_cast<PaintedLayer*>(layer.get())); + entry->mCommonClipCount = commonClipCount; + } else { + // mask layer for image and color layers + SetupMaskLayer(layer, data->mItemClip); + } + + uint32_t flags = 0; + nsIWidget* widget = mContainerReferenceFrame->PresContext()->GetRootWidget(); + // See bug 941095. Not quite ready to disable this. + bool hidpi = false && widget && widget->GetDefaultScale().scale >= 2; + if (hidpi) { + flags |= Layer::CONTENT_DISABLE_SUBPIXEL_AA; + } + if (isOpaque && !data->mForceTransparentSurface) { + flags |= Layer::CONTENT_OPAQUE; + } else if (data->mNeedComponentAlpha && !hidpi) { + flags |= Layer::CONTENT_COMPONENT_ALPHA; + } + if (data->mDisableFlattening) { + flags |= Layer::CONTENT_DISABLE_FLATTENING; + } + layer->SetContentFlags(flags); + + PaintedLayerData* containingPaintedLayerData = + mLayerBuilder->GetContainingPaintedLayerData(); + if (containingPaintedLayerData) { + if (!data->mDispatchToContentHitRegion.GetBounds().IsEmpty()) { + nsRect rect = nsLayoutUtils::TransformFrameRectToAncestor( + mContainerReferenceFrame, + data->mDispatchToContentHitRegion.GetBounds(), + containingPaintedLayerData->mReferenceFrame); + containingPaintedLayerData->mDispatchToContentHitRegion.Or( + containingPaintedLayerData->mDispatchToContentHitRegion, rect); + } + if (!data->mMaybeHitRegion.GetBounds().IsEmpty()) { + nsRect rect = nsLayoutUtils::TransformFrameRectToAncestor( + mContainerReferenceFrame, + data->mMaybeHitRegion.GetBounds(), + containingPaintedLayerData->mReferenceFrame); + containingPaintedLayerData->mMaybeHitRegion.Or( + containingPaintedLayerData->mMaybeHitRegion, rect); + containingPaintedLayerData->mMaybeHitRegion.SimplifyOutward(8); + } + Maybe<Matrix4x4> matrixCache; + nsLayoutUtils::TransformToAncestorAndCombineRegions( + data->mHitRegion, + mContainerReferenceFrame, + containingPaintedLayerData->mReferenceFrame, + &containingPaintedLayerData->mHitRegion, + &containingPaintedLayerData->mMaybeHitRegion, + &matrixCache); + // See the comment in nsDisplayList::AddFrame, where the touch action regions + // are handled. The same thing applies here. + bool alreadyHadRegions = + !containingPaintedLayerData->mNoActionRegion.IsEmpty() || + !containingPaintedLayerData->mHorizontalPanRegion.IsEmpty() || + !containingPaintedLayerData->mVerticalPanRegion.IsEmpty(); + nsLayoutUtils::TransformToAncestorAndCombineRegions( + data->mNoActionRegion, + mContainerReferenceFrame, + containingPaintedLayerData->mReferenceFrame, + &containingPaintedLayerData->mNoActionRegion, + &containingPaintedLayerData->mDispatchToContentHitRegion, + &matrixCache); + nsLayoutUtils::TransformToAncestorAndCombineRegions( + data->mHorizontalPanRegion, + mContainerReferenceFrame, + containingPaintedLayerData->mReferenceFrame, + &containingPaintedLayerData->mHorizontalPanRegion, + &containingPaintedLayerData->mDispatchToContentHitRegion, + &matrixCache); + nsLayoutUtils::TransformToAncestorAndCombineRegions( + data->mVerticalPanRegion, + mContainerReferenceFrame, + containingPaintedLayerData->mReferenceFrame, + &containingPaintedLayerData->mVerticalPanRegion, + &containingPaintedLayerData->mDispatchToContentHitRegion, + &matrixCache); + if (alreadyHadRegions) { + containingPaintedLayerData->mDispatchToContentHitRegion.OrWith( + containingPaintedLayerData->CombinedTouchActionRegion()); + } + } else { + EventRegions regions; + regions.mHitRegion = ScaleRegionToOutsidePixels(data->mHitRegion); + regions.mNoActionRegion = ScaleRegionToOutsidePixels(data->mNoActionRegion); + regions.mHorizontalPanRegion = ScaleRegionToOutsidePixels(data->mHorizontalPanRegion); + regions.mVerticalPanRegion = ScaleRegionToOutsidePixels(data->mVerticalPanRegion); + // Points whose hit-region status we're not sure about need to be dispatched + // to the content thread. If a point is in both maybeHitRegion and hitRegion + // then it's not a "maybe" any more, and doesn't go into the dispatch-to- + // content region. + nsIntRegion maybeHitRegion = ScaleRegionToOutsidePixels(data->mMaybeHitRegion); + regions.mDispatchToContentHitRegion.Sub(maybeHitRegion, regions.mHitRegion); + regions.mDispatchToContentHitRegion.OrWith( + ScaleRegionToOutsidePixels(data->mDispatchToContentHitRegion)); + regions.mHitRegion.OrWith(maybeHitRegion); + + Matrix mat = layer->GetTransform().As2D(); + mat.Invert(); + regions.ApplyTranslationAndScale(mat._31, mat._32, mat._11, mat._22); + + layer->SetEventRegions(regions); + } + + SetBackfaceHiddenForLayer(data->mBackfaceHidden, data->mLayer); + if (layer != data->mLayer) { + SetBackfaceHiddenForLayer(data->mBackfaceHidden, layer); + } +} + +static bool +IsItemAreaInWindowOpaqueRegion(nsDisplayListBuilder* aBuilder, + nsDisplayItem* aItem, + const nsRect& aComponentAlphaBounds) +{ + if (!aItem->Frame()->PresContext()->IsChrome()) { + // Assume that Web content is always in the window opaque region. + return true; + } + if (aItem->ReferenceFrame() != aBuilder->RootReferenceFrame()) { + // aItem is probably in some transformed subtree. + // We're not going to bother figuring out where this landed, we're just + // going to assume it might have landed over a transparent part of + // the window. + return false; + } + return aBuilder->GetWindowOpaqueRegion().Contains(aComponentAlphaBounds); +} + +void +PaintedLayerData::Accumulate(ContainerState* aState, + nsDisplayItem* aItem, + const nsIntRegion& aClippedOpaqueRegion, + const nsIntRect& aVisibleRect, + const DisplayItemClip& aClip, + LayerState aLayerState) +{ + FLB_LOG_PAINTED_LAYER_DECISION(this, "Accumulating dp=%s(%p), f=%p against pld=%p\n", aItem->Name(), aItem, aItem->Frame(), this); + + bool snap; + nsRect itemBounds = aItem->GetBounds(aState->mBuilder, &snap); + mBounds = mBounds.Union(aState->ScaleToOutsidePixels(itemBounds, snap)); + + if (aState->mBuilder->NeedToForceTransparentSurfaceForItem(aItem)) { + mForceTransparentSurface = true; + } + if (aState->mParameters.mDisableSubpixelAntialiasingInDescendants) { + // Disable component alpha. + // Note that the transform (if any) on the PaintedLayer is always an integer translation so + // we don't have to factor that in here. + aItem->DisableComponentAlpha(); + } + + bool clipMatches = mItemClip == aClip; + mItemClip = aClip; + + mAssignedDisplayItems.AppendElement(AssignedDisplayItem(aItem, aClip, aLayerState)); + + if (!mIsSolidColorInVisibleRegion && mOpaqueRegion.Contains(aVisibleRect) && + mVisibleRegion.Contains(aVisibleRect) && !mImage) { + // A very common case! Most pages have a PaintedLayer with the page + // background (opaque) visible and most or all of the page content over the + // top of that background. + // The rest of this method won't do anything. mVisibleRegion and mOpaqueRegion + // don't need updating. mVisibleRegion contains aVisibleRect already, + // mOpaqueRegion contains aVisibleRect and therefore whatever the opaque + // region of the item is. mVisibleRegion must contain mOpaqueRegion + // and therefore aVisibleRect. + return; + } + + /* Mark as available for conversion to image layer if this is a nsDisplayImage and + * it's the only thing visible in this layer. + */ + if (nsIntRegion(aVisibleRect).Contains(mVisibleRegion) && + aClippedOpaqueRegion.Contains(mVisibleRegion) && + aItem->SupportsOptimizingToImage()) { + mImage = static_cast<nsDisplayImageContainer*>(aItem); + FLB_LOG_PAINTED_LAYER_DECISION(this, " Tracking image: nsDisplayImageContainer covers the layer\n"); + } else if (mImage) { + FLB_LOG_PAINTED_LAYER_DECISION(this, " No longer tracking image\n"); + mImage = nullptr; + } + + bool isFirstVisibleItem = mVisibleRegion.IsEmpty(); + if (isFirstVisibleItem) { + nscolor fontSmoothingBGColor; + if (aItem->ProvidesFontSmoothingBackgroundColor(&fontSmoothingBGColor)) { + mFontSmoothingBackgroundColor = fontSmoothingBGColor; + } + } + + Maybe<nscolor> uniformColor = aItem->IsUniform(aState->mBuilder); + + // Some display items have to exist (so they can set forceTransparentSurface + // below) but don't draw anything. They'll return true for isUniform but + // a color with opacity 0. + if (!uniformColor || NS_GET_A(*uniformColor) > 0) { + // Make sure that the visible area is covered by uniform pixels. In + // particular this excludes cases where the edges of the item are not + // pixel-aligned (thus the item will not be truly uniform). + if (uniformColor) { + bool snap; + nsRect bounds = aItem->GetBounds(aState->mBuilder, &snap); + if (!aState->ScaleToInsidePixels(bounds, snap).Contains(aVisibleRect)) { + uniformColor = Nothing(); + FLB_LOG_PAINTED_LAYER_DECISION(this, " Display item does not cover the visible rect\n"); + } + } + if (uniformColor) { + if (isFirstVisibleItem) { + // This color is all we have + mSolidColor = *uniformColor; + mIsSolidColorInVisibleRegion = true; + } else if (mIsSolidColorInVisibleRegion && + mVisibleRegion.IsEqual(nsIntRegion(aVisibleRect)) && + clipMatches) { + // we can just blend the colors together + mSolidColor = NS_ComposeColors(mSolidColor, *uniformColor); + } else { + FLB_LOG_PAINTED_LAYER_DECISION(this, " Layer not a solid color: Can't blend colors togethers\n"); + mIsSolidColorInVisibleRegion = false; + } + } else { + FLB_LOG_PAINTED_LAYER_DECISION(this, " Layer is not a solid color: Display item is not uniform over the visible bound\n"); + mIsSolidColorInVisibleRegion = false; + } + + mVisibleRegion.Or(mVisibleRegion, aVisibleRect); + mVisibleRegion.SimplifyOutward(4); + } + + if (!aClippedOpaqueRegion.IsEmpty()) { + for (auto iter = aClippedOpaqueRegion.RectIter(); !iter.Done(); iter.Next()) { + // We don't use SimplifyInward here since it's not defined exactly + // what it will discard. For our purposes the most important case + // is a large opaque background at the bottom of z-order (e.g., + // a canvas background), so we need to make sure that the first rect + // we see doesn't get discarded. + nsIntRegion tmp; + tmp.Or(mOpaqueRegion, iter.Get()); + // Opaque display items in chrome documents whose window is partially + // transparent are always added to the opaque region. This helps ensure + // that we get as much subpixel-AA as possible in the chrome. + if (tmp.GetNumRects() <= 4 || aItem->Frame()->PresContext()->IsChrome()) { + mOpaqueRegion = Move(tmp); + } + } + } + + if (!aState->mParameters.mDisableSubpixelAntialiasingInDescendants) { + nsRect componentAlpha = aItem->GetComponentAlphaBounds(aState->mBuilder); + if (!componentAlpha.IsEmpty()) { + nsIntRect componentAlphaRect = + aState->ScaleToOutsidePixels(componentAlpha, false).Intersect(aVisibleRect); + if (!mOpaqueRegion.Contains(componentAlphaRect)) { + if (IsItemAreaInWindowOpaqueRegion(aState->mBuilder, aItem, + componentAlpha.Intersect(aItem->GetVisibleRect()))) { + mNeedComponentAlpha = true; + } else { + aItem->DisableComponentAlpha(); + } + } + } + } + + // Ensure animated text does not get flattened, even if it forces other + // content in the container to be layerized. The content backend might + // not support subpixel positioning of text that animated transforms can + // generate. bug 633097 + if (aState->mParameters.mInActiveTransformedSubtree && + (mNeedComponentAlpha || + !aItem->GetComponentAlphaBounds(aState->mBuilder).IsEmpty())) { + mDisableFlattening = true; + } +} + +nsRegion +PaintedLayerData::CombinedTouchActionRegion() +{ + nsRegion result; + result.Or(mHorizontalPanRegion, mVerticalPanRegion); + result.OrWith(mNoActionRegion); + return result; +} + +void +PaintedLayerData::AccumulateEventRegions(ContainerState* aState, nsDisplayLayerEventRegions* aEventRegions) +{ + FLB_LOG_PAINTED_LAYER_DECISION(this, "Accumulating event regions %p against pld=%p\n", aEventRegions, this); + + mHitRegion.OrWith(aEventRegions->HitRegion()); + mMaybeHitRegion.OrWith(aEventRegions->MaybeHitRegion()); + mDispatchToContentHitRegion.OrWith(aEventRegions->DispatchToContentHitRegion()); + + // See the comment in nsDisplayList::AddFrame, where the touch action regions + // are handled. The same thing applies here. + bool alreadyHadRegions = !mNoActionRegion.IsEmpty() || + !mHorizontalPanRegion.IsEmpty() || + !mVerticalPanRegion.IsEmpty(); + mNoActionRegion.OrWith(aEventRegions->NoActionRegion()); + mHorizontalPanRegion.OrWith(aEventRegions->HorizontalPanRegion()); + mVerticalPanRegion.OrWith(aEventRegions->VerticalPanRegion()); + if (alreadyHadRegions) { + mDispatchToContentHitRegion.OrWith(CombinedTouchActionRegion()); + } + + // Calculate scaled versions of the bounds of mHitRegion and mMaybeHitRegion + // for quick access in FindPaintedLayerFor(). + mScaledHitRegionBounds = aState->ScaleToOutsidePixels(mHitRegion.GetBounds()); + mScaledMaybeHitRegionBounds = aState->ScaleToOutsidePixels(mMaybeHitRegion.GetBounds()); +} + +PaintedLayerData +ContainerState::NewPaintedLayerData(nsDisplayItem* aItem, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemScrollClip* aScrollClip, + const nsPoint& aTopLeft, + bool aShouldFixToViewport) +{ + PaintedLayerData data; + data.mAnimatedGeometryRoot = aAnimatedGeometryRoot; + data.mScrollClip = aScrollClip; + data.mAnimatedGeometryRootOffset = aTopLeft; + data.mReferenceFrame = aItem->ReferenceFrame(); + data.mSingleItemFixedToViewport = aShouldFixToViewport; + data.mBackfaceHidden = aItem->Frame()->In3DContextAndBackfaceIsHidden(); + + data.mNewChildLayersIndex = mNewChildLayers.Length(); + NewLayerEntry* newLayerEntry = mNewChildLayers.AppendElement(); + newLayerEntry->mAnimatedGeometryRoot = aAnimatedGeometryRoot; + newLayerEntry->mScrollClip = aScrollClip; + // newLayerEntry->mOpaqueRegion is filled in later from + // paintedLayerData->mOpaqueRegion, if necessary. + + // Allocate another entry for this layer's optimization to ColorLayer/ImageLayer + mNewChildLayers.AppendElement(); + + return data; +} + +#ifdef MOZ_DUMP_PAINTING +static void +DumpPaintedImage(nsDisplayItem* aItem, SourceSurface* aSurface) +{ + nsCString string(aItem->Name()); + string.Append('-'); + string.AppendInt((uint64_t)aItem); + fprintf_stderr(gfxUtils::sDumpPaintFile, "<script>array[\"%s\"]=\"", string.BeginReading()); + gfxUtils::DumpAsDataURI(aSurface, gfxUtils::sDumpPaintFile); + fprintf_stderr(gfxUtils::sDumpPaintFile, "\";</script>\n"); +} +#endif + +static void +PaintInactiveLayer(nsDisplayListBuilder* aBuilder, + LayerManager* aManager, + nsDisplayItem* aItem, + gfxContext* aContext, + nsRenderingContext* aCtx) +{ + // This item has an inactive layer. Render it to a PaintedLayer + // using a temporary BasicLayerManager. + BasicLayerManager* basic = static_cast<BasicLayerManager*>(aManager); + RefPtr<gfxContext> context = aContext; +#ifdef MOZ_DUMP_PAINTING + int32_t appUnitsPerDevPixel = AppUnitsPerDevPixel(aItem); + nsIntRect itemVisibleRect = + aItem->GetVisibleRect().ToOutsidePixels(appUnitsPerDevPixel); + + RefPtr<DrawTarget> tempDT; + if (gfxEnv::DumpPaint()) { + tempDT = gfxPlatform::GetPlatform()->CreateOffscreenContentDrawTarget( + itemVisibleRect.Size(), + SurfaceFormat::B8G8R8A8); + if (tempDT) { + context = gfxContext::CreateOrNull(tempDT); + if (!context) { + // Leave this as crash, it's in the debugging code, we want to know + gfxDevCrash(LogReason::InvalidContext) << "PaintInactive context problem " << gfx::hexa(tempDT); + return; + } + context->SetMatrix(gfxMatrix::Translation(-itemVisibleRect.x, + -itemVisibleRect.y)); + } + } +#endif + basic->BeginTransaction(); + basic->SetTarget(context); + + if (aItem->GetType() == nsDisplayItem::TYPE_MASK) { + static_cast<nsDisplayMask*>(aItem)->PaintAsLayer(aBuilder, aCtx, basic); + if (basic->InTransaction()) { + basic->AbortTransaction(); + } + } else if (aItem->GetType() == nsDisplayItem::TYPE_FILTER){ + static_cast<nsDisplayFilter*>(aItem)->PaintAsLayer(aBuilder, aCtx, basic); + if (basic->InTransaction()) { + basic->AbortTransaction(); + } + } else { + basic->EndTransaction(FrameLayerBuilder::DrawPaintedLayer, aBuilder); + } + FrameLayerBuilder *builder = static_cast<FrameLayerBuilder*>(basic->GetUserData(&gLayerManagerLayerBuilder)); + if (builder) { + builder->DidEndTransaction(); + } + + basic->SetTarget(nullptr); + +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpPaint() && tempDT) { + RefPtr<SourceSurface> surface = tempDT->Snapshot(); + DumpPaintedImage(aItem, surface); + + DrawTarget* drawTarget = aContext->GetDrawTarget(); + Rect rect(itemVisibleRect.x, itemVisibleRect.y, + itemVisibleRect.width, itemVisibleRect.height); + drawTarget->DrawSurface(surface, rect, Rect(Point(0,0), rect.Size())); + + aItem->SetPainted(); + } +#endif +} + +/** + * Chooses a single active scrolled root for the entire display list, used + * when we are flattening layers. + */ +bool +ContainerState::ChooseAnimatedGeometryRoot(const nsDisplayList& aList, + AnimatedGeometryRoot **aAnimatedGeometryRoot) +{ + for (nsDisplayItem* item = aList.GetBottom(); item; item = item->GetAbove()) { + LayerState layerState = item->GetLayerState(mBuilder, mManager, mParameters); + // Don't use an item that won't be part of any PaintedLayers to pick the + // active scrolled root. + if (layerState == LAYER_ACTIVE_FORCE) { + continue; + } + + // Try using the actual active scrolled root of the backmost item, as that + // should result in the least invalidation when scrolling. + *aAnimatedGeometryRoot = item->GetAnimatedGeometryRoot(); + return true; + } + return false; +} + +nsIntRegion +ContainerState::ComputeOpaqueRect(nsDisplayItem* aItem, + AnimatedGeometryRoot* aAnimatedGeometryRoot, + const DisplayItemClip& aClip, + nsDisplayList* aList, + bool* aHideAllLayersBelow, + bool* aOpaqueForAnimatedGeometryRootParent) +{ + bool snapOpaque; + nsRegion opaque = aItem->GetOpaqueRegion(mBuilder, &snapOpaque); + if (opaque.IsEmpty()) { + return nsIntRegion(); + } + + nsIntRegion opaquePixels; + nsRegion opaqueClipped; + for (auto iter = opaque.RectIter(); !iter.Done(); iter.Next()) { + opaqueClipped.Or(opaqueClipped, + aClip.ApproximateIntersectInward(iter.Get())); + } + if (aAnimatedGeometryRoot == mContainerAnimatedGeometryRoot && + opaqueClipped.Contains(mContainerBounds)) { + *aHideAllLayersBelow = true; + aList->SetIsOpaque(); + } + // Add opaque areas to the "exclude glass" region. Only do this when our + // container layer is going to be the rootmost layer, otherwise transforms + // etc will mess us up (and opaque contributions from other containers are + // not needed). + if (!nsLayoutUtils::GetCrossDocParentFrame(mContainerFrame)) { + mBuilder->AddWindowOpaqueRegion(opaqueClipped); + } + opaquePixels = ScaleRegionToInsidePixels(opaqueClipped, snapOpaque); + + if (IsInInactiveLayer()) { + return opaquePixels; + } + + nsIScrollableFrame* sf = nsLayoutUtils::GetScrollableFrameFor(*aAnimatedGeometryRoot); + if (sf) { + nsRect displayport; + bool usingDisplayport = + nsLayoutUtils::GetDisplayPort((*aAnimatedGeometryRoot)->GetContent(), &displayport, + RelativeTo::ScrollFrame); + if (!usingDisplayport) { + // No async scrolling, so all that matters is that the layer contents + // cover the scrollport. + displayport = sf->GetScrollPortRect(); + } + nsIFrame* scrollFrame = do_QueryFrame(sf); + displayport += scrollFrame->GetOffsetToCrossDoc(mContainerReferenceFrame); + if (opaquePixels.Contains(ScaleRegionToNearestPixels(displayport))) { + *aOpaqueForAnimatedGeometryRootParent = true; + } + } + return opaquePixels; +} + +static const DisplayItemScrollClip* +InnermostScrollClipApplicableToAGR(const DisplayItemScrollClip* aItemScrollClip, + AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + // "Applicable" scroll clips are those that are for nsIScrollableFrames + // that are ancestors of aAnimatedGeometryRoot or ancestors of aContainerScrollClip. + // They can be applied to all items sharing this animated geometry root, so + // instead of applying to the items individually, they can be applied to the + // whole layer. + for (const DisplayItemScrollClip* scrollClip = aItemScrollClip; + scrollClip; + scrollClip = scrollClip->mParent) { + nsIFrame* scrolledFrame = scrollClip->mScrollableFrame->GetScrolledFrame(); + if (nsLayoutUtils::IsAncestorFrameCrossDoc(scrolledFrame, *aAnimatedGeometryRoot)) { + // scrollClip and all its ancestors are applicable. + return scrollClip; + } + } + return nullptr; +} + +Maybe<size_t> +ContainerState::SetupMaskLayerForScrolledClip(Layer* aLayer, + const DisplayItemClip& aClip) +{ + if (aClip.GetRoundedRectCount() > 0) { + Maybe<size_t> maskLayerIndex = Some(aLayer->GetAncestorMaskLayerCount()); + if (RefPtr<Layer> maskLayer = CreateMaskLayer(aLayer, aClip, maskLayerIndex, + aClip.GetRoundedRectCount())) { + aLayer->AddAncestorMaskLayer(maskLayer); + return maskLayerIndex; + } + // Fall through to |return Nothing()|. + } + return Nothing(); +} + +void +ContainerState::SetupMaskLayerForCSSMask(Layer* aLayer, + nsDisplayMask* aMaskItem) +{ + MOZ_ASSERT(mManager->IsCompositingCheap()); + + RefPtr<ImageLayer> maskLayer = + CreateOrRecycleMaskImageLayerFor(MaskLayerKey(aLayer, Nothing()), + [](Layer* aMaskLayer) + { + aMaskLayer->SetUserData(&gCSSMaskLayerUserData, + new CSSMaskLayerUserData()); + } + ); + + CSSMaskLayerUserData* oldUserData = + static_cast<CSSMaskLayerUserData*>(maskLayer->GetUserData(&gCSSMaskLayerUserData)); + + bool snap; + nsRect bounds = aMaskItem->GetBounds(mBuilder, &snap); + nsIntRect itemRect = ScaleToOutsidePixels(bounds, snap); + CSSMaskLayerUserData newUserData(aMaskItem->Frame(), itemRect); + if (*oldUserData == newUserData) { + aLayer->SetMaskLayer(maskLayer); + return; + } + + int32_t maxSize = mManager->GetMaxTextureSize(); + IntSize surfaceSize(std::min(itemRect.width, maxSize), + std::min(itemRect.height, maxSize)); + + if (surfaceSize.IsEmpty()) { + // Return early if we know that the size of this mask surface is empty. + return; + } + + MaskImageData imageData(surfaceSize, mManager); + RefPtr<DrawTarget> dt = imageData.CreateDrawTarget(); + if (!dt || !dt->IsValid()) { + NS_WARNING("Could not create DrawTarget for mask layer."); + return; + } + + RefPtr<gfxContext> maskCtx = gfxContext::CreateOrNull(dt); + maskCtx->SetMatrix(gfxMatrix::Translation(-itemRect.TopLeft())); + maskCtx->Multiply(gfxMatrix::Scaling(mParameters.mXScale, mParameters.mYScale)); + + if (!aMaskItem->PaintMask(mBuilder, maskCtx)) { + // Mostly because of mask resource is not ready. + return; + } + + // Setup mask layer offset. + Matrix4x4 matrix; + matrix.PreTranslate(itemRect.x, itemRect.y, 0); + matrix.PreTranslate(mParameters.mOffset.x, mParameters.mOffset.y, 0); + + maskLayer->SetBaseTransform(matrix); + + RefPtr<ImageContainer> imgContainer = + imageData.CreateImageAndImageContainer(); + if (!imgContainer) { + return; + } + maskLayer->SetContainer(imgContainer); + + *oldUserData = newUserData; + aLayer->SetMaskLayer(maskLayer); +} + +/* + * Iterate through the non-clip items in aList and its descendants. + * For each item we compute the effective clip rect. Each item is assigned + * to a layer. We invalidate the areas in PaintedLayers where an item + * has moved from one PaintedLayer to another. Also, + * aState->mInvalidPaintedContent is invalidated in every PaintedLayer. + * We set the clip rect for items that generated their own layer, and + * create a mask layer to do any rounded rect clipping. + * (PaintedLayers don't need a clip rect on the layer, we clip the items + * individually when we draw them.) + * We set the visible rect for all layers, although the actual setting + * of visible rects for some PaintedLayers is deferred until the calling + * of ContainerState::Finish. + */ +void +ContainerState::ProcessDisplayItems(nsDisplayList* aList) +{ + PROFILER_LABEL("ContainerState", "ProcessDisplayItems", + js::ProfileEntry::Category::GRAPHICS); + + AnimatedGeometryRoot* lastAnimatedGeometryRoot = mContainerAnimatedGeometryRoot; + nsPoint lastAGRTopLeft; + nsPoint topLeft(0,0); + + // When NO_COMPONENT_ALPHA is set, items will be flattened into a single + // layer, so we need to choose which active scrolled root to use for all + // items. + if (mFlattenToSingleLayer) { + if (ChooseAnimatedGeometryRoot(*aList, &lastAnimatedGeometryRoot)) { + lastAGRTopLeft = (*lastAnimatedGeometryRoot)->GetOffsetToCrossDoc(mContainerReferenceFrame); + } + } + + int32_t maxLayers = gfxPrefs::MaxActiveLayers(); + int layerCount = 0; + + nsDisplayList savedItems; + nsDisplayItem* item; + while ((item = aList->RemoveBottom()) != nullptr) { + nsDisplayItem::Type itemType = item->GetType(); + + // If the item is a event regions item, but is empty (has no regions in it) + // then we should just throw it out + if (itemType == nsDisplayItem::TYPE_LAYER_EVENT_REGIONS) { + nsDisplayLayerEventRegions* eventRegions = + static_cast<nsDisplayLayerEventRegions*>(item); + if (eventRegions->IsEmpty()) { + item->~nsDisplayItem(); + continue; + } + } + + // Peek ahead to the next item and try merging with it or swapping with it + // if necessary. + nsDisplayItem* aboveItem; + while ((aboveItem = aList->GetBottom()) != nullptr) { + if (aboveItem->TryMerge(item)) { + aList->RemoveBottom(); + item->~nsDisplayItem(); + item = aboveItem; + itemType = item->GetType(); + } else { + break; + } + } + + nsDisplayList* itemSameCoordinateSystemChildren + = item->GetSameCoordinateSystemChildren(); + if (item->ShouldFlattenAway(mBuilder)) { + aList->AppendToBottom(itemSameCoordinateSystemChildren); + item->~nsDisplayItem(); + continue; + } + + savedItems.AppendToTop(item); + + NS_ASSERTION(mAppUnitsPerDevPixel == AppUnitsPerDevPixel(item), + "items in a container layer should all have the same app units per dev pixel"); + + if (mBuilder->NeedToForceTransparentSurfaceForItem(item)) { + aList->SetNeedsTransparentSurface(); + } + + if (mParameters.mForEventsAndPluginsOnly && !item->GetChildren() && + (itemType != nsDisplayItem::TYPE_LAYER_EVENT_REGIONS && + itemType != nsDisplayItem::TYPE_PLUGIN)) { + continue; + } + + LayerState layerState = item->GetLayerState(mBuilder, mManager, mParameters); + if (layerState == LAYER_INACTIVE && + nsDisplayItem::ForceActiveLayers()) { + layerState = LAYER_ACTIVE; + } + + bool forceInactive; + AnimatedGeometryRoot* animatedGeometryRoot; + AnimatedGeometryRoot* animatedGeometryRootForClip = nullptr; + if (mFlattenToSingleLayer && layerState != LAYER_ACTIVE_FORCE) { + forceInactive = true; + animatedGeometryRoot = lastAnimatedGeometryRoot; + topLeft = lastAGRTopLeft; + } else { + forceInactive = false; + if (mManager->IsWidgetLayerManager()) { + animatedGeometryRoot = item->GetAnimatedGeometryRoot(); + animatedGeometryRootForClip = item->AnimatedGeometryRootForScrollMetadata(); + } else { + // For inactive layer subtrees, splitting content into PaintedLayers + // based on animated geometry roots is pointless. It's more efficient + // to build the minimum number of layers. + animatedGeometryRoot = mContainerAnimatedGeometryRoot; + + } + topLeft = (*animatedGeometryRoot)->GetOffsetToCrossDoc(mContainerReferenceFrame); + } + if (!animatedGeometryRootForClip) { + animatedGeometryRootForClip = animatedGeometryRoot; + } + + const DisplayItemScrollClip* itemScrollClip = item->ScrollClip(); + // Now we need to separate the item's scroll clip chain into those scroll + // clips that can be applied to the whole layer (i.e. to all items + // sharing the item's animated geometry root), and those that need to be + // applied to the item itself. + const DisplayItemScrollClip* agrScrollClip = + InnermostScrollClipApplicableToAGR(itemScrollClip, animatedGeometryRootForClip); + MOZ_ASSERT(DisplayItemScrollClip::IsAncestor(agrScrollClip, itemScrollClip)); + + if (agrScrollClip != itemScrollClip) { + // Pick up any scroll clips that should apply to the item and apply them. + DisplayItemClip clip = item->GetClip(); + for (const DisplayItemScrollClip* scrollClip = itemScrollClip; + scrollClip && scrollClip != agrScrollClip && scrollClip != mContainerScrollClip; + scrollClip = scrollClip->mParent) { + if (scrollClip->mClip) { + clip.IntersectWith(*scrollClip->mClip); + } + } + item->SetClip(mBuilder, clip); + } + + bool clipMovesWithLayer = (animatedGeometryRoot == animatedGeometryRootForClip); + + bool shouldFixToViewport = !clipMovesWithLayer && + !(*animatedGeometryRoot)->GetParent() && + item->ShouldFixToViewport(mBuilder); + + // For items that are fixed to the viewport, remove their clip at the + // display item level because additional areas could be brought into + // view by async scrolling. Save the clip so we can set it on the layer + // instead later. + DisplayItemClip fixedToViewportClip = DisplayItemClip::NoClip(); + if (shouldFixToViewport) { + fixedToViewportClip = item->GetClip(); + item->SetClip(mBuilder, DisplayItemClip::NoClip()); + } + + bool snap; + nsRect itemContent = item->GetBounds(mBuilder, &snap); + if (itemType == nsDisplayItem::TYPE_LAYER_EVENT_REGIONS) { + nsDisplayLayerEventRegions* eventRegions = + static_cast<nsDisplayLayerEventRegions*>(item); + itemContent = eventRegions->GetHitRegionBounds(mBuilder, &snap); + } + nsIntRect itemDrawRect = ScaleToOutsidePixels(itemContent, snap); + bool prerenderedTransform = itemType == nsDisplayItem::TYPE_TRANSFORM && + static_cast<nsDisplayTransform*>(item)->MayBeAnimated(mBuilder); + ParentLayerIntRect clipRect; + const DisplayItemClip& itemClip = item->GetClip(); + if (itemClip.HasClip()) { + itemContent.IntersectRect(itemContent, itemClip.GetClipRect()); + clipRect = ViewAs<ParentLayerPixel>(ScaleToNearestPixels(itemClip.GetClipRect())); + if (!prerenderedTransform) { + itemDrawRect.IntersectRect(itemDrawRect, clipRect.ToUnknownRect()); + } + clipRect.MoveBy(ViewAs<ParentLayerPixel>(mParameters.mOffset)); + } +#ifdef DEBUG + nsRect bounds = itemContent; + bool dummy; + if (itemType == nsDisplayItem::TYPE_LAYER_EVENT_REGIONS) { + bounds = item->GetBounds(mBuilder, &dummy); + if (itemClip.HasClip()) { + bounds.IntersectRect(bounds, itemClip.GetClipRect()); + } + } + bounds = fixedToViewportClip.ApplyNonRoundedIntersection(bounds); + if (!bounds.IsEmpty()) { + for (const DisplayItemScrollClip* scrollClip = itemScrollClip; + scrollClip && scrollClip != mContainerScrollClip; + scrollClip = scrollClip->mParent) { + if (scrollClip->mClip) { + if (scrollClip->mIsAsyncScrollable) { + bounds = scrollClip->mClip->GetClipRect(); + } else { + bounds = scrollClip->mClip->ApplyNonRoundedIntersection(bounds); + } + } + } + } + ((nsRect&)mAccumulatedChildBounds).UnionRect(mAccumulatedChildBounds, bounds); +#endif + + nsIntRect itemVisibleRect = itemDrawRect; + // We haven't computed visibility at this point, so item->GetVisibleRect() + // is just the dirty rect that item was initialized with. We intersect it + // with the clipped item bounds to get a tighter visible rect. + itemVisibleRect = itemVisibleRect.Intersect( + ScaleToOutsidePixels(item->GetVisibleRect(), false)); + + if (maxLayers != -1 && layerCount >= maxLayers) { + forceInactive = true; + } + + // Assign the item to a layer + if (layerState == LAYER_ACTIVE_FORCE || + (layerState == LAYER_INACTIVE && !mManager->IsWidgetLayerManager()) || + (!forceInactive && + (layerState == LAYER_ACTIVE_EMPTY || + layerState == LAYER_ACTIVE))) { + + layerCount++; + + // LAYER_ACTIVE_EMPTY means the layer is created just for its metadata. + // We should never see an empty layer with any visible content! + NS_ASSERTION(layerState != LAYER_ACTIVE_EMPTY || + itemVisibleRect.IsEmpty(), + "State is LAYER_ACTIVE_EMPTY but visible rect is not."); + + // As long as the new layer isn't going to be a PaintedLayer, + // InvalidateForLayerChange doesn't need the new layer pointer. + // We also need to check the old data now, because BuildLayer + // can overwrite it. + InvalidateForLayerChange(item, nullptr); + + // If the item would have its own layer but is invisible, just hide it. + // Note that items without their own layers can't be skipped this + // way, since their PaintedLayer may decide it wants to draw them + // into its buffer even if they're currently covered. + if (itemVisibleRect.IsEmpty() && + !item->ShouldBuildLayerEvenIfInvisible(mBuilder)) { + continue; + } + + if (mScrollClipForPerspectiveChild) { + // We are the single transform child item of an nsDisplayPerspective. + // Our parent forwarded a scroll clip to us. Pick it up. + // We do this after any clipping has been applied, because this + // forwarded scroll clip is only used for scrolling (in the form of + // APZ frame metrics), not for clipping - the clip still belongs on + // the perspective item. + MOZ_ASSERT(itemType == nsDisplayItem::TYPE_TRANSFORM); + MOZ_ASSERT(!itemScrollClip); + MOZ_ASSERT(!agrScrollClip); + MOZ_ASSERT(DisplayItemScrollClip::IsAncestor(mContainerScrollClip, + mScrollClipForPerspectiveChild)); + itemScrollClip = mScrollClipForPerspectiveChild; + agrScrollClip = mScrollClipForPerspectiveChild; + } + + // 3D-transformed layers don't necessarily draw in the order in which + // they're added to their parent container layer. + bool mayDrawOutOfOrder = itemType == nsDisplayItem::TYPE_TRANSFORM && + (item->Frame()->Combines3DTransformWithAncestors() || + item->Frame()->Extend3DContext()); + + // Let mPaintedLayerDataTree know about this item, so that + // FindPaintedLayerFor and FindOpaqueBackgroundColor are aware of this + // item, even though it's not in any PaintedLayerDataStack. + // Ideally we'd only need the "else" case here and have + // mPaintedLayerDataTree figure out the right clip from the animated + // geometry root that we give it, but it can't easily figure about + // overflow:hidden clips on ancestors just by looking at the frame. + // So we'll do a little hand holding and pass the clip instead of the + // visible rect for the two important cases. + nscolor uniformColor = NS_RGBA(0,0,0,0); + nscolor* uniformColorPtr = (mayDrawOutOfOrder || IsInInactiveLayer()) ? nullptr : + &uniformColor; + nsIntRect clipRectUntyped; + const DisplayItemClip& layerClip = shouldFixToViewport ? fixedToViewportClip : itemClip; + ParentLayerIntRect layerClipRect; + nsIntRect* clipPtr = nullptr; + if (layerClip.HasClip()) { + layerClipRect = ViewAs<ParentLayerPixel>( + ScaleToNearestPixels(layerClip.GetClipRect()) + mParameters.mOffset); + clipRectUntyped = layerClipRect.ToUnknownRect(); + clipPtr = &clipRectUntyped; + } + if (*animatedGeometryRoot == item->Frame() && + *animatedGeometryRoot != mBuilder->RootReferenceFrame()) { + // This is the case for scrollbar thumbs, for example. In that case the + // clip we care about is the overflow:hidden clip on the scrollbar. + mPaintedLayerDataTree.AddingOwnLayer(animatedGeometryRoot->mParentAGR, + clipPtr, + uniformColorPtr); + } else if (prerenderedTransform) { + mPaintedLayerDataTree.AddingOwnLayer(animatedGeometryRoot, + clipPtr, + uniformColorPtr); + } else if (shouldFixToViewport) { + mPaintedLayerDataTree.AddingOwnLayer(animatedGeometryRootForClip, + clipPtr, + uniformColorPtr); + } else { + // Using itemVisibleRect here isn't perfect. itemVisibleRect can be + // larger or smaller than the potential bounds of item's contents in + // animatedGeometryRoot: It's too large if there's a clipped display + // port somewhere among item's contents (see bug 1147673), and it can + // be too small if the contents can move, because it only looks at the + // contents' current bounds and doesn't anticipate any animations. + // Time will tell whether this is good enough, or whether we need to do + // something more sophisticated here. + mPaintedLayerDataTree.AddingOwnLayer(animatedGeometryRoot, + &itemVisibleRect, uniformColorPtr); + } + + ContainerLayerParameters params = mParameters; + params.mBackgroundColor = uniformColor; + params.mLayerCreationHint = GetLayerCreationHint(animatedGeometryRoot); + params.mScrollClip = agrScrollClip; + params.mScrollClipForPerspectiveChild = nullptr; + + if (itemType == nsDisplayItem::TYPE_PERSPECTIVE) { + // Perspective items have a single child item, an nsDisplayTransform. + // If the perspective item is scrolled, but the perspective-inducing + // frame is outside the scroll frame (indicated by this items AGR + // being outside that scroll frame), we have to take special care to + // make APZ scrolling work properly. APZ needs us to put the scroll + // frame's FrameMetrics on our child transform ContainerLayer instead. + // Our agrScrollClip is the scroll clip that's applicable to our + // perspective frame, so it won't be the scroll clip for the scrolled + // frame in the case that we care about, and we'll forward that scroll + // clip to our child. + params.mScrollClipForPerspectiveChild = itemScrollClip; + } + + // Just use its layer. + // Set layerContentsVisibleRect.width/height to -1 to indicate we + // currently don't know. If BuildContainerLayerFor gets called by + // item->BuildLayer, this will be set to a proper rect. + nsIntRect layerContentsVisibleRect(0, 0, -1, -1); + params.mLayerContentsVisibleRect = &layerContentsVisibleRect; + RefPtr<Layer> ownLayer = item->BuildLayer(mBuilder, mManager, params); + if (!ownLayer) { + continue; + } + + NS_ASSERTION(!ownLayer->AsPaintedLayer(), + "Should never have created a dedicated Painted layer!"); + + if (item->BackfaceIsHidden()) { + ownLayer->SetContentFlags(ownLayer->GetContentFlags() | + Layer::CONTENT_BACKFACE_HIDDEN); + } else { + ownLayer->SetContentFlags(ownLayer->GetContentFlags() & + ~Layer::CONTENT_BACKFACE_HIDDEN); + } + + nsRect invalid; + if (item->IsInvalid(invalid)) { + ownLayer->SetInvalidRectToVisibleRegion(); + } + + // If it's not a ContainerLayer, we need to apply the scale transform + // ourselves. + if (!ownLayer->AsContainerLayer()) { + ownLayer->SetPostScale(mParameters.mXScale, + mParameters.mYScale); + } + + // Update that layer's clip and visible rects. + NS_ASSERTION(ownLayer->Manager() == mManager, "Wrong manager"); + NS_ASSERTION(!ownLayer->HasUserData(&gLayerManagerUserData), + "We shouldn't have a FrameLayerBuilder-managed layer here!"); + NS_ASSERTION(layerClip.HasClip() || + layerClip.GetRoundedRectCount() == 0, + "If we have rounded rects, we must have a clip rect"); + + // It has its own layer. Update that layer's clip and visible rects. + + ownLayer->SetClipRect(Nothing()); + ownLayer->SetScrolledClip(Nothing()); + if (layerClip.HasClip()) { + // For layers fixed to the viewport, the clip becomes part of the + // layer's scrolled clip. Otherwise, it becomes part of the layer clip. + if (shouldFixToViewport) { + LayerClip scrolledClip; + scrolledClip.SetClipRect(layerClipRect); + if (layerClip.GetRoundedRectCount() > 0) { + scrolledClip.SetMaskLayerIndex( + SetupMaskLayerForScrolledClip(ownLayer.get(), layerClip)); + } + ownLayer->SetScrolledClip(Some(scrolledClip)); + } else { + ownLayer->SetClipRect(Some(layerClipRect)); + + // rounded rectangle clipping using mask layers + // (must be done after visible rect is set on layer) + if (layerClip.GetRoundedRectCount() > 0) { + SetupMaskLayer(ownLayer, layerClip); + } + } + } else if (item->GetType() == nsDisplayItem::TYPE_MASK) { + nsDisplayMask* maskItem = static_cast<nsDisplayMask*>(item); + SetupMaskLayerForCSSMask(ownLayer, maskItem); + } + + ContainerLayer* oldContainer = ownLayer->GetParent(); + if (oldContainer && oldContainer != mContainerLayer) { + oldContainer->RemoveChild(ownLayer); + } + NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, ownLayer) < 0, + "Layer already in list???"); + + NewLayerEntry* newLayerEntry = mNewChildLayers.AppendElement(); + newLayerEntry->mLayer = ownLayer; + newLayerEntry->mAnimatedGeometryRoot = animatedGeometryRoot; + newLayerEntry->mScrollClip = agrScrollClip; + newLayerEntry->mLayerState = layerState; + + // Don't attempt to flatten compnent alpha layers that are within + // a forced active layer, or an active transform; + if (itemType == nsDisplayItem::TYPE_TRANSFORM || + layerState == LAYER_ACTIVE_FORCE) { + newLayerEntry->mPropagateComponentAlphaFlattening = false; + } + // nsDisplayTransform::BuildLayer must set layerContentsVisibleRect. + // We rely on this to ensure 3D transforms compute a reasonable + // layer visible region. + NS_ASSERTION(itemType != nsDisplayItem::TYPE_TRANSFORM || + layerContentsVisibleRect.width >= 0, + "Transform items must set layerContentsVisibleRect!"); + if (mLayerBuilder->IsBuildingRetainedLayers()) { + newLayerEntry->mLayerContentsVisibleRect = layerContentsVisibleRect; + if (itemType == nsDisplayItem::TYPE_PERSPECTIVE || + (itemType == nsDisplayItem::TYPE_TRANSFORM && + (item->Frame()->Extend3DContext() || + item->Frame()->Combines3DTransformWithAncestors() || + item->Frame()->HasPerspective()))) { + // Give untransformed visible region as outer visible region + // to avoid failure caused by singular transforms. + newLayerEntry->mUntransformedVisibleRegion = true; + newLayerEntry->mVisibleRegion = + item->GetVisibleRectForChildren().ToOutsidePixels(mAppUnitsPerDevPixel); + } else { + newLayerEntry->mVisibleRegion = itemVisibleRect; + } + newLayerEntry->mOpaqueRegion = ComputeOpaqueRect(item, + animatedGeometryRoot, layerClip, aList, + &newLayerEntry->mHideAllLayersBelow, + &newLayerEntry->mOpaqueForAnimatedGeometryRootParent); + } else { + bool useChildrenVisible = + itemType == nsDisplayItem::TYPE_TRANSFORM && + (item->Frame()->IsPreserve3DLeaf() || + item->Frame()->HasPerspective()); + const nsIntRegion &visible = useChildrenVisible ? + item->GetVisibleRectForChildren().ToOutsidePixels(mAppUnitsPerDevPixel): + itemVisibleRect; + + SetOuterVisibleRegionForLayer(ownLayer, visible, + layerContentsVisibleRect.width >= 0 ? &layerContentsVisibleRect : nullptr, + useChildrenVisible); + } + if (itemType == nsDisplayItem::TYPE_SCROLL_INFO_LAYER) { + nsDisplayScrollInfoLayer* scrollItem = static_cast<nsDisplayScrollInfoLayer*>(item); + newLayerEntry->mOpaqueForAnimatedGeometryRootParent = false; + newLayerEntry->mBaseScrollMetadata = + scrollItem->ComputeScrollMetadata(ownLayer, mParameters); + } else if ((itemType == nsDisplayItem::TYPE_SUBDOCUMENT || + itemType == nsDisplayItem::TYPE_ZOOM || + itemType == nsDisplayItem::TYPE_RESOLUTION) && + gfxPrefs::LayoutUseContainersForRootFrames()) + { + newLayerEntry->mBaseScrollMetadata = + static_cast<nsDisplaySubDocument*>(item)->ComputeScrollMetadata(ownLayer, mParameters); + } + + /** + * No need to allocate geometry for items that aren't + * part of a PaintedLayer. + */ + mLayerBuilder->AddLayerDisplayItem(ownLayer, item, layerState, nullptr); + } else { + PaintedLayerData* paintedLayerData = + mPaintedLayerDataTree.FindPaintedLayerFor(animatedGeometryRoot, agrScrollClip, + itemVisibleRect, + item->Frame()->In3DContextAndBackfaceIsHidden(), + [&]() { + return NewPaintedLayerData(item, animatedGeometryRoot, agrScrollClip, + topLeft, shouldFixToViewport); + }); + + if (itemType == nsDisplayItem::TYPE_LAYER_EVENT_REGIONS) { + nsDisplayLayerEventRegions* eventRegions = + static_cast<nsDisplayLayerEventRegions*>(item); + paintedLayerData->AccumulateEventRegions(this, eventRegions); + } else { + // check to see if the new item has rounded rect clips in common with + // other items in the layer + if (mManager->IsWidgetLayerManager()) { + paintedLayerData->UpdateCommonClipCount(itemClip); + } + nsIntRegion opaquePixels = ComputeOpaqueRect(item, + animatedGeometryRoot, itemClip, aList, + &paintedLayerData->mHideAllLayersBelow, + &paintedLayerData->mOpaqueForAnimatedGeometryRootParent); + MOZ_ASSERT(nsIntRegion(itemDrawRect).Contains(opaquePixels)); + opaquePixels.AndWith(itemVisibleRect); + paintedLayerData->Accumulate(this, item, opaquePixels, + itemVisibleRect, itemClip, layerState); + + // If we removed the clip from the display item above because it's + // fixed to the viewport, save it on the PaintedLayerData so we can + // set it on the layer later. + if (fixedToViewportClip.HasClip()) { + paintedLayerData->mItemClip = fixedToViewportClip; + } + + if (!paintedLayerData->mLayer) { + // Try to recycle the old layer of this display item. + RefPtr<PaintedLayer> layer = + AttemptToRecyclePaintedLayer(animatedGeometryRoot, item, topLeft); + if (layer) { + paintedLayerData->mLayer = layer; + + NS_ASSERTION(FindIndexOfLayerIn(mNewChildLayers, layer) < 0, + "Layer already in list???"); + mNewChildLayers[paintedLayerData->mNewChildLayersIndex].mLayer = layer.forget(); + } + } + } + } + + if (itemSameCoordinateSystemChildren && + itemSameCoordinateSystemChildren->NeedsTransparentSurface()) { + aList->SetNeedsTransparentSurface(); + } + } + + aList->AppendToTop(&savedItems); +} + +void +ContainerState::InvalidateForLayerChange(nsDisplayItem* aItem, PaintedLayer* aNewLayer) +{ + NS_ASSERTION(aItem->GetPerFrameKey(), + "Display items that render using Thebes must have a key"); + nsDisplayItemGeometry* oldGeometry = nullptr; + DisplayItemClip* oldClip = nullptr; + Layer* oldLayer = mLayerBuilder->GetOldLayerFor(aItem, &oldGeometry, &oldClip); + if (aNewLayer != oldLayer && oldLayer) { + // The item has changed layers. + // Invalidate the old bounds in the old layer and new bounds in the new layer. + PaintedLayer* t = oldLayer->AsPaintedLayer(); + if (t && oldGeometry) { + // Note that whenever the layer's scale changes, we invalidate the whole thing, + // so it doesn't matter whether we are using the old scale at last paint + // or a new scale here +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Display item type %s(%p) changed layers %p to %p!\n", aItem->Name(), aItem->Frame(), t, aNewLayer); + } +#endif + InvalidatePostTransformRegion(t, + oldGeometry->ComputeInvalidationRegion(), + *oldClip, + mLayerBuilder->GetLastPaintOffset(t)); + } + // Clear the old geometry so that invalidation thinks the item has been + // added this paint. + mLayerBuilder->ClearCachedGeometry(aItem); + aItem->NotifyRenderingChanged(); + } +} + +void +FrameLayerBuilder::ComputeGeometryChangeForItem(DisplayItemData* aData) +{ + nsDisplayItem *item = aData->mItem; + PaintedLayer* paintedLayer = aData->mLayer->AsPaintedLayer(); + if (!item || !paintedLayer) { + aData->EndUpdate(); + return; + } + + PaintedLayerItemsEntry* entry = mPaintedLayerItems.GetEntry(paintedLayer); + + nsAutoPtr<nsDisplayItemGeometry> geometry; + + PaintedDisplayItemLayerUserData* layerData = + static_cast<PaintedDisplayItemLayerUserData*>(aData->mLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); + nsPoint shift = layerData->mAnimatedGeometryRootOrigin - layerData->mLastAnimatedGeometryRootOrigin; + + const DisplayItemClip& clip = item->GetClip(); + + // If the frame is marked as invalidated, and didn't specify a rect to invalidate then we want to + // invalidate both the old and new bounds, otherwise we only want to invalidate the changed areas. + // If we do get an invalid rect, then we want to add this on top of the change areas. + nsRect invalid; + nsRegion combined; + bool notifyRenderingChanged = true; + if (!aData->mGeometry) { + // This item is being added for the first time, invalidate its entire area. + geometry = item->AllocateGeometry(mDisplayListBuilder); + combined = clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion()); +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Display item type %s(%p) added to layer %p!\n", item->Name(), item->Frame(), aData->mLayer.get()); + } +#endif + } else if (aData->mIsInvalid || (item->IsInvalid(invalid) && invalid.IsEmpty())) { + // Layout marked item/frame as needing repainting (without an explicit rect), invalidate the entire old and new areas. + geometry = item->AllocateGeometry(mDisplayListBuilder); + combined = aData->mClip.ApplyNonRoundedIntersection(aData->mGeometry->ComputeInvalidationRegion()); + combined.MoveBy(shift); + combined.Or(combined, clip.ApplyNonRoundedIntersection(geometry->ComputeInvalidationRegion())); +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Display item type %s(%p) (in layer %p) belongs to an invalidated frame!\n", item->Name(), item->Frame(), aData->mLayer.get()); + } +#endif + } else { + // Let the display item check for geometry changes and decide what needs to be + // repainted. + + const nsTArray<nsIFrame*>& changedFrames = aData->GetFrameListChanges(); + aData->mGeometry->MoveBy(shift); + item->ComputeInvalidationRegion(mDisplayListBuilder, aData->mGeometry, &combined); + + // We have an optimization to cache the drawing of background-attachment: fixed canvas + // background images so we can scroll and just blit them when they are flattened into + // the same layer as scrolling content. NotifyRenderingChanged is only used to tell + // the canvas bg image item to purge this cache. We want to be careful not to accidentally + // purge the cache if we are just invalidating due to scrolling (ie the background image + // moves on the scrolling layer but it's rendering stays the same) so if + // AddOffsetAndComputeDifference is the only thing that will invalidate we skip the + // NotifyRenderingChanged call (ComputeInvalidationRegion for background images also calls + // NotifyRenderingChanged if anything changes). + // Only allocate a new geometry object if something actually changed, otherwise the existing + // one should be fine. We always reallocate for inactive layers, since these types don't + // implement ComputeInvalidateRegion (and rely on the ComputeDifferences call in + // AddPaintedDisplayItem instead). + if (!combined.IsEmpty() || aData->mLayerState == LAYER_INACTIVE) { + geometry = item->AllocateGeometry(mDisplayListBuilder); + } else if (aData->mClip == clip && invalid.IsEmpty() && changedFrames.Length() == 0) { + notifyRenderingChanged = false; + } + aData->mClip.AddOffsetAndComputeDifference(entry->mCommonClipCount, + shift, aData->mGeometry->ComputeInvalidationRegion(), + clip, entry->mLastCommonClipCount, + geometry ? geometry->ComputeInvalidationRegion() : + aData->mGeometry->ComputeInvalidationRegion(), + &combined); + + // Add in any rect that the frame specified + combined.Or(combined, invalid); + + for (uint32_t i = 0; i < changedFrames.Length(); i++) { + combined.Or(combined, changedFrames[i]->GetVisualOverflowRect()); + } + + // Restrict invalidation to the clipped region + nsRegion clipRegion; + if (clip.ComputeRegionInClips(&aData->mClip, shift, &clipRegion)) { + combined.And(combined, clipRegion); + } +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + if (!combined.IsEmpty()) { + printf_stderr("Display item type %s(%p) (in layer %p) changed geometry!\n", item->Name(), item->Frame(), aData->mLayer.get()); + } + } +#endif + } + if (!combined.IsEmpty()) { + if (notifyRenderingChanged) { + item->NotifyRenderingChanged(); + } + InvalidatePostTransformRegion(paintedLayer, + combined.ScaleToOutsidePixels(layerData->mXScale, layerData->mYScale, layerData->mAppUnitsPerDevPixel), + layerData->mTranslation); + } + + aData->EndUpdate(geometry); +} + +void +FrameLayerBuilder::AddPaintedDisplayItem(PaintedLayerData* aLayerData, + nsDisplayItem* aItem, + const DisplayItemClip& aClip, + ContainerState& aContainerState, + LayerState aLayerState, + const nsPoint& aTopLeft) +{ + PaintedLayer* layer = aLayerData->mLayer; + PaintedDisplayItemLayerUserData* paintedData = + static_cast<PaintedDisplayItemLayerUserData*> + (layer->GetUserData(&gPaintedDisplayItemLayerUserData)); + RefPtr<BasicLayerManager> tempManager; + nsIntRect intClip; + bool hasClip = false; + if (aLayerState != LAYER_NONE) { + DisplayItemData *data = GetDisplayItemDataForManager(aItem, layer->Manager()); + if (data) { + tempManager = data->mInactiveManager; + } + if (!tempManager) { + tempManager = new BasicLayerManager(BasicLayerManager::BLM_INACTIVE); + } + + // We need to grab these before calling AddLayerDisplayItem because it will overwrite them. + nsRegion clip; + DisplayItemClip* oldClip = nullptr; + GetOldLayerFor(aItem, nullptr, &oldClip); + hasClip = aClip.ComputeRegionInClips(oldClip, + aTopLeft - paintedData->mLastAnimatedGeometryRootOrigin, + &clip); + + if (hasClip) { + intClip = clip.GetBounds().ScaleToOutsidePixels(paintedData->mXScale, + paintedData->mYScale, + paintedData->mAppUnitsPerDevPixel); + } + } + + AddLayerDisplayItem(layer, aItem, aLayerState, tempManager); + + PaintedLayerItemsEntry* entry = mPaintedLayerItems.PutEntry(layer); + if (entry) { + entry->mContainerLayerFrame = aContainerState.GetContainerFrame(); + if (entry->mContainerLayerGeneration == 0) { + entry->mContainerLayerGeneration = mContainerLayerGeneration; + } + if (tempManager) { + FLB_LOG_PAINTED_LAYER_DECISION(aLayerData, "Creating nested FLB for item %p\n", aItem); + FrameLayerBuilder* layerBuilder = new FrameLayerBuilder(); + layerBuilder->Init(mDisplayListBuilder, tempManager, aLayerData); + + tempManager->BeginTransaction(); + if (mRetainingManager) { + layerBuilder->DidBeginRetainedLayerTransaction(tempManager); + } + + UniquePtr<LayerProperties> props(LayerProperties::CloneFrom(tempManager->GetRoot())); + RefPtr<Layer> tmpLayer = + aItem->BuildLayer(mDisplayListBuilder, tempManager, ContainerLayerParameters()); + // We have no easy way of detecting if this transaction will ever actually get finished. + // For now, I've just silenced the warning with nested transactions in BasicLayers.cpp + if (!tmpLayer) { + tempManager->EndTransaction(nullptr, nullptr); + tempManager->SetUserData(&gLayerManagerLayerBuilder, nullptr); + return; + } + + bool snap; + nsRect visibleRect = + aItem->GetVisibleRect().Intersect(aItem->GetBounds(mDisplayListBuilder, &snap)); + nsIntRegion rgn = visibleRect.ToOutsidePixels(paintedData->mAppUnitsPerDevPixel); + SetOuterVisibleRegion(tmpLayer, &rgn); + + // If BuildLayer didn't call BuildContainerLayerFor, then our new layer won't have been + // stored in layerBuilder. Manually add it now. + if (mRetainingManager) { +#ifdef DEBUG_DISPLAY_ITEM_DATA + LayerManagerData* parentLmd = static_cast<LayerManagerData*> + (layer->Manager()->GetUserData(&gLayerManagerUserData)); + LayerManagerData* lmd = static_cast<LayerManagerData*> + (tempManager->GetUserData(&gLayerManagerUserData)); + lmd->mParent = parentLmd; +#endif + layerBuilder->StoreDataForFrame(aItem, tmpLayer, LAYER_ACTIVE); + } + + tempManager->SetRoot(tmpLayer); + layerBuilder->WillEndTransaction(); + tempManager->AbortTransaction(); + +#ifdef MOZ_DUMP_PAINTING + if (gfxUtils::DumpDisplayList() || gfxEnv::DumpPaint()) { + fprintf_stderr(gfxUtils::sDumpPaintFile, "Basic layer tree for painting contents of display item %s(%p):\n", aItem->Name(), aItem->Frame()); + std::stringstream stream; + tempManager->Dump(stream, "", gfxEnv::DumpPaintToFile()); + fprint_stderr(gfxUtils::sDumpPaintFile, stream); // not a typo, fprint_stderr declared in LayersLogging.h + } +#endif + + nsIntPoint offset = GetLastPaintOffset(layer) - GetTranslationForPaintedLayer(layer); + props->MoveBy(-offset); + // Effective transforms are needed by ComputeDifferences(). + tmpLayer->ComputeEffectiveTransforms(Matrix4x4()); + nsIntRegion invalid = props->ComputeDifferences(tmpLayer, nullptr); + if (aLayerState == LAYER_SVG_EFFECTS) { + invalid = nsSVGIntegrationUtils::AdjustInvalidAreaForSVGEffects(aItem->Frame(), + aItem->ToReferenceFrame(), + invalid); + } + if (!invalid.IsEmpty()) { +#ifdef MOZ_DUMP_PAINTING + if (nsLayoutUtils::InvalidationDebuggingIsEnabled()) { + printf_stderr("Inactive LayerManager(%p) for display item %s(%p) has an invalid region - invalidating layer %p\n", tempManager.get(), aItem->Name(), aItem->Frame(), layer); + } +#endif + invalid.ScaleRoundOut(paintedData->mXScale, paintedData->mYScale); + + if (hasClip) { + invalid.And(invalid, intClip); + } + + InvalidatePostTransformRegion(layer, invalid, + GetTranslationForPaintedLayer(layer)); + } + } + ClippedDisplayItem* cdi = + entry->mItems.AppendElement(ClippedDisplayItem(aItem, + mContainerLayerGeneration)); + cdi->mInactiveLayerManager = tempManager; + } +} + +FrameLayerBuilder::DisplayItemData* +FrameLayerBuilder::StoreDataForFrame(nsDisplayItem* aItem, Layer* aLayer, LayerState aState) +{ + DisplayItemData* oldData = GetDisplayItemDataForManager(aItem, mRetainingManager); + if (oldData) { + if (!oldData->mUsed) { + oldData->BeginUpdate(aLayer, aState, mContainerLayerGeneration, aItem); + } + return oldData; + } + + LayerManagerData* lmd = static_cast<LayerManagerData*> + (mRetainingManager->GetUserData(&gLayerManagerUserData)); + + RefPtr<DisplayItemData> data = + new DisplayItemData(lmd, aItem->GetPerFrameKey(), aLayer); + + data->BeginUpdate(aLayer, aState, mContainerLayerGeneration, aItem); + + lmd->mDisplayItems.PutEntry(data); + return data; +} + +void +FrameLayerBuilder::StoreDataForFrame(nsIFrame* aFrame, + uint32_t aDisplayItemKey, + Layer* aLayer, + LayerState aState) +{ + DisplayItemData* oldData = GetDisplayItemData(aFrame, aDisplayItemKey); + if (oldData && oldData->mFrameList.Length() == 1) { + oldData->BeginUpdate(aLayer, aState, mContainerLayerGeneration); + return; + } + + LayerManagerData* lmd = static_cast<LayerManagerData*> + (mRetainingManager->GetUserData(&gLayerManagerUserData)); + + RefPtr<DisplayItemData> data = + new DisplayItemData(lmd, aDisplayItemKey, aLayer, aFrame); + + data->BeginUpdate(aLayer, aState, mContainerLayerGeneration); + + lmd->mDisplayItems.PutEntry(data); +} + +FrameLayerBuilder::ClippedDisplayItem::ClippedDisplayItem(nsDisplayItem* aItem, + uint32_t aGeneration) + : mItem(aItem) + , mContainerLayerGeneration(aGeneration) +{ +} + +FrameLayerBuilder::ClippedDisplayItem::~ClippedDisplayItem() +{ + if (mInactiveLayerManager) { + mInactiveLayerManager->SetUserData(&gLayerManagerLayerBuilder, nullptr); + } +} + +FrameLayerBuilder::PaintedLayerItemsEntry::PaintedLayerItemsEntry(const PaintedLayer *aKey) + : nsPtrHashKey<PaintedLayer>(aKey) + , mContainerLayerFrame(nullptr) + , mLastCommonClipCount(0) + , mContainerLayerGeneration(0) + , mHasExplicitLastPaintOffset(false) + , mCommonClipCount(0) +{ +} + +FrameLayerBuilder::PaintedLayerItemsEntry::PaintedLayerItemsEntry(const PaintedLayerItemsEntry& aOther) + : nsPtrHashKey<PaintedLayer>(aOther.mKey) + , mItems(aOther.mItems) +{ + NS_ERROR("Should never be called, since we ALLOW_MEMMOVE"); +} + +FrameLayerBuilder::PaintedLayerItemsEntry::~PaintedLayerItemsEntry() +{ +} + +void +FrameLayerBuilder::AddLayerDisplayItem(Layer* aLayer, + nsDisplayItem* aItem, + LayerState aLayerState, + BasicLayerManager* aManager) +{ + if (aLayer->Manager() != mRetainingManager) + return; + + DisplayItemData *data = StoreDataForFrame(aItem, aLayer, aLayerState); + data->mInactiveManager = aManager; +} + +nsIntPoint +FrameLayerBuilder::GetLastPaintOffset(PaintedLayer* aLayer) +{ + PaintedLayerItemsEntry* entry = mPaintedLayerItems.PutEntry(aLayer); + if (entry) { + if (entry->mContainerLayerGeneration == 0) { + entry->mContainerLayerGeneration = mContainerLayerGeneration; + } + if (entry->mHasExplicitLastPaintOffset) + return entry->mLastPaintOffset; + } + return GetTranslationForPaintedLayer(aLayer); +} + +void +FrameLayerBuilder::SavePreviousDataForLayer(PaintedLayer* aLayer, uint32_t aClipCount) +{ + PaintedLayerItemsEntry* entry = mPaintedLayerItems.PutEntry(aLayer); + if (entry) { + if (entry->mContainerLayerGeneration == 0) { + entry->mContainerLayerGeneration = mContainerLayerGeneration; + } + entry->mLastPaintOffset = GetTranslationForPaintedLayer(aLayer); + entry->mHasExplicitLastPaintOffset = true; + entry->mLastCommonClipCount = aClipCount; + } +} + +bool +FrameLayerBuilder::CheckInLayerTreeCompressionMode() +{ + if (mInLayerTreeCompressionMode) { + return true; + } + + // If we wanted to be in layer tree compression mode, but weren't, then scheduled + // a delayed repaint where we will be. + mRootPresContext->PresShell()->GetRootFrame()->SchedulePaint(nsIFrame::PAINT_DELAYED_COMPRESS); + + return false; +} + +void +ContainerState::CollectOldLayers() +{ + for (Layer* layer = mContainerLayer->GetFirstChild(); layer; + layer = layer->GetNextSibling()) { + NS_ASSERTION(!layer->HasUserData(&gMaskLayerUserData), + "Mask layers should not be part of the layer tree."); + if (layer->HasUserData(&gPaintedDisplayItemLayerUserData)) { + NS_ASSERTION(layer->AsPaintedLayer(), "Wrong layer type"); + mPaintedLayersAvailableForRecycling.PutEntry(static_cast<PaintedLayer*>(layer)); + } + + if (Layer* maskLayer = layer->GetMaskLayer()) { + NS_ASSERTION(maskLayer->GetType() == Layer::TYPE_IMAGE, + "Could not recycle mask layer, unsupported layer type."); + mRecycledMaskImageLayers.Put(MaskLayerKey(layer, Nothing()), static_cast<ImageLayer*>(maskLayer)); + } + for (size_t i = 0; i < layer->GetAncestorMaskLayerCount(); i++) { + Layer* maskLayer = layer->GetAncestorMaskLayerAt(i); + + NS_ASSERTION(maskLayer->GetType() == Layer::TYPE_IMAGE, + "Could not recycle mask layer, unsupported layer type."); + mRecycledMaskImageLayers.Put(MaskLayerKey(layer, Some(i)), static_cast<ImageLayer*>(maskLayer)); + } + } +} + +struct OpaqueRegionEntry { + AnimatedGeometryRoot* mAnimatedGeometryRoot; + nsIntRegion mOpaqueRegion; +}; + +static OpaqueRegionEntry* +FindOpaqueRegionEntry(nsTArray<OpaqueRegionEntry>& aEntries, + AnimatedGeometryRoot* aAnimatedGeometryRoot) +{ + for (uint32_t i = 0; i < aEntries.Length(); ++i) { + OpaqueRegionEntry* d = &aEntries[i]; + if (d->mAnimatedGeometryRoot == aAnimatedGeometryRoot) { + return d; + } + } + return nullptr; +} + +void +ContainerState::SetupScrollingMetadata(NewLayerEntry* aEntry) +{ + if (mFlattenToSingleLayer) { + // animated geometry roots are forced to all match, so we can't + // use them and we don't get async scrolling. + return; + } + + if (!mBuilder->IsPaintingToWindow()) { + // async scrolling not possible, and async scrolling info not computed + // for this paint. + return; + } + + AutoTArray<ScrollMetadata,2> metricsArray; + if (aEntry->mBaseScrollMetadata) { + metricsArray.AppendElement(*aEntry->mBaseScrollMetadata); + + // The base FrameMetrics was not computed by the nsIScrollableframe, so it + // should not have a mask layer. + MOZ_ASSERT(!aEntry->mBaseScrollMetadata->HasMaskLayer()); + } + + // Any extra mask layers we need to attach to ScrollMetadatas. + // The list may already contain an entry added for the layer's scrolled clip + // so add to it rather than overwriting it (we clear the list when recycling + // a layer). + nsTArray<RefPtr<Layer>> maskLayers(aEntry->mLayer->GetAllAncestorMaskLayers()); + + for (const DisplayItemScrollClip* scrollClip = aEntry->mScrollClip; + scrollClip && scrollClip != mContainerScrollClip; + scrollClip = scrollClip->mParent) { + if (!scrollClip->mIsAsyncScrollable) { + // This scroll clip was created for a scroll frame that didn't know + // whether it needs to be async scrollable for scroll handoff. It was + // not activated, so we don't need to create a frame metrics for it. + continue; + } + + nsIScrollableFrame* scrollFrame = scrollClip->mScrollableFrame; + const DisplayItemClip* clip = scrollClip->mClip; + + Maybe<ScrollMetadata> metadata = + scrollFrame->ComputeScrollMetadata(aEntry->mLayer, mContainerReferenceFrame, mParameters, clip); + if (!metadata) { + continue; + } + + if (clip && + clip->HasClip() && + clip->GetRoundedRectCount() > 0) + { + // The clip in between this scrollframe and its ancestor scrollframe + // requires a mask layer. Since this mask layer should not move with + // the APZC associated with this FrameMetrics, we attach the mask + // layer as an additional, separate clip. + Maybe<size_t> nextIndex = Some(maskLayers.Length()); + RefPtr<Layer> maskLayer = + CreateMaskLayer(aEntry->mLayer, *clip, nextIndex, clip->GetRoundedRectCount()); + if (maskLayer) { + MOZ_ASSERT(metadata->HasScrollClip()); + metadata->ScrollClip().SetMaskLayerIndex(nextIndex); + maskLayers.AppendElement(maskLayer); + } + } + + metricsArray.AppendElement(*metadata); + } + + // Watch out for FrameMetrics copies in profiles + aEntry->mLayer->SetScrollMetadata(metricsArray); + aEntry->mLayer->SetAncestorMaskLayers(maskLayers); +} + +static inline Maybe<ParentLayerIntRect> +GetStationaryClipInContainer(Layer* aLayer) +{ + if (size_t metricsCount = aLayer->GetScrollMetadataCount()) { + return aLayer->GetScrollMetadata(metricsCount - 1).GetClipRect(); + } + return aLayer->GetClipRect(); +} + +void +ContainerState::PostprocessRetainedLayers(nsIntRegion* aOpaqueRegionForContainer) +{ + AutoTArray<OpaqueRegionEntry,4> opaqueRegions; + bool hideAll = false; + int32_t opaqueRegionForContainer = -1; + + for (int32_t i = mNewChildLayers.Length() - 1; i >= 0; --i) { + NewLayerEntry* e = &mNewChildLayers.ElementAt(i); + if (!e->mLayer) { + continue; + } + + OpaqueRegionEntry* data = FindOpaqueRegionEntry(opaqueRegions, e->mAnimatedGeometryRoot); + + SetupScrollingMetadata(e); + + if (hideAll) { + e->mVisibleRegion.SetEmpty(); + } else if (!e->mLayer->IsScrollbarContainer()) { + Maybe<ParentLayerIntRect> clipRect = GetStationaryClipInContainer(e->mLayer); + if (clipRect && opaqueRegionForContainer >= 0 && + opaqueRegions[opaqueRegionForContainer].mOpaqueRegion.Contains(clipRect->ToUnknownRect())) { + e->mVisibleRegion.SetEmpty(); + } else if (data) { + e->mVisibleRegion.Sub(e->mVisibleRegion, data->mOpaqueRegion); + } + } + + SetOuterVisibleRegionForLayer(e->mLayer, + e->mVisibleRegion, + e->mLayerContentsVisibleRect.width >= 0 ? &e->mLayerContentsVisibleRect : nullptr, + e->mUntransformedVisibleRegion); + + if (!e->mOpaqueRegion.IsEmpty()) { + AnimatedGeometryRoot* animatedGeometryRootToCover = e->mAnimatedGeometryRoot; + if (e->mOpaqueForAnimatedGeometryRootParent && + e->mAnimatedGeometryRoot->mParentAGR == mContainerAnimatedGeometryRoot) { + animatedGeometryRootToCover = mContainerAnimatedGeometryRoot; + data = FindOpaqueRegionEntry(opaqueRegions, animatedGeometryRootToCover); + } + + if (!data) { + if (animatedGeometryRootToCover == mContainerAnimatedGeometryRoot) { + NS_ASSERTION(opaqueRegionForContainer == -1, "Already found it?"); + opaqueRegionForContainer = opaqueRegions.Length(); + } + data = opaqueRegions.AppendElement(); + data->mAnimatedGeometryRoot = animatedGeometryRootToCover; + } + + nsIntRegion clippedOpaque = e->mOpaqueRegion; + Maybe<ParentLayerIntRect> clipRect = e->mLayer->GetCombinedClipRect(); + if (clipRect) { + clippedOpaque.AndWith(clipRect->ToUnknownRect()); + } + if (e->mLayer->GetIsFixedPosition() && e->mLayer->GetScrolledClip()) { + // The clip can move asynchronously, so we can't rely on opaque parts + // staying in the same place. + clippedOpaque.SetEmpty(); + } else if (e->mHideAllLayersBelow) { + hideAll = true; + } + data->mOpaqueRegion.Or(data->mOpaqueRegion, clippedOpaque); + } + + if (e->mLayer->GetType() == Layer::TYPE_READBACK) { + // ReadbackLayers need to accurately read what's behind them. So, + // we don't want to do any occlusion culling of layers behind them. + // Theoretically we could just punch out the ReadbackLayer's rectangle + // from all mOpaqueRegions, but that's probably not worth doing. + opaqueRegions.Clear(); + opaqueRegionForContainer = -1; + } + } + + if (opaqueRegionForContainer >= 0) { + aOpaqueRegionForContainer->Or(*aOpaqueRegionForContainer, + opaqueRegions[opaqueRegionForContainer].mOpaqueRegion); + } +} + +void +ContainerState::Finish(uint32_t* aTextContentFlags, + const nsIntRect& aContainerPixelBounds, + nsDisplayList* aChildItems, bool* aHasComponentAlphaChildren) +{ + mPaintedLayerDataTree.Finish(); + + if (!mParameters.mForEventsAndPluginsOnly) { + NS_ASSERTION(mContainerBounds.IsEqualInterior(mAccumulatedChildBounds), + "Bounds computation mismatch"); + } + + if (mLayerBuilder->IsBuildingRetainedLayers()) { + nsIntRegion containerOpaqueRegion; + PostprocessRetainedLayers(&containerOpaqueRegion); + if (containerOpaqueRegion.Contains(aContainerPixelBounds)) { + aChildItems->SetIsOpaque(); + } + } + + uint32_t textContentFlags = 0; + + // Make sure that current/existing layers are added to the parent and are + // in the correct order. + Layer* layer = nullptr; + Layer* prevChild = nullptr; + for (uint32_t i = 0; i < mNewChildLayers.Length(); ++i, prevChild = layer) { + if (!mNewChildLayers[i].mLayer) { + continue; + } + + layer = mNewChildLayers[i].mLayer; + + if (!layer->GetVisibleRegion().IsEmpty()) { + textContentFlags |= + layer->GetContentFlags() & (Layer::CONTENT_COMPONENT_ALPHA | + Layer::CONTENT_COMPONENT_ALPHA_DESCENDANT | + Layer::CONTENT_DISABLE_FLATTENING); + + // Notify the parent of component alpha children unless it's coming from + // within a child that has asked not to contribute to layer flattening. + if (aHasComponentAlphaChildren && + mNewChildLayers[i].mPropagateComponentAlphaFlattening && + (layer->GetContentFlags() & Layer::CONTENT_COMPONENT_ALPHA)) { + + for (int32_t j = i - 1; j >= 0; j--) { + if (mNewChildLayers[j].mVisibleRegion.Intersects(mNewChildLayers[i].mVisibleRegion.GetBounds())) { + if (mNewChildLayers[j].mLayerState != LAYER_ACTIVE_FORCE) { + *aHasComponentAlphaChildren = true; + } + break; + + } + + } + } + } + + if (!layer->GetParent()) { + // This is not currently a child of the container, so just add it + // now. + mContainerLayer->InsertAfter(layer, prevChild); + } else { + NS_ASSERTION(layer->GetParent() == mContainerLayer, + "Layer shouldn't be the child of some other container"); + if (layer->GetPrevSibling() != prevChild) { + mContainerLayer->RepositionChild(layer, prevChild); + } + } + } + + // Remove old layers that have become unused. + if (!layer) { + layer = mContainerLayer->GetFirstChild(); + } else { + layer = layer->GetNextSibling(); + } + while (layer) { + Layer *layerToRemove = layer; + layer = layer->GetNextSibling(); + mContainerLayer->RemoveChild(layerToRemove); + } + + *aTextContentFlags = textContentFlags; +} + +static inline gfxSize RoundToFloatPrecision(const gfxSize& aSize) +{ + return gfxSize(float(aSize.width), float(aSize.height)); +} + +static void RestrictScaleToMaxLayerSize(gfxSize& aScale, + const nsRect& aVisibleRect, + nsIFrame* aContainerFrame, + Layer* aContainerLayer) +{ + if (!aContainerLayer->Manager()->IsWidgetLayerManager()) { + return; + } + + nsIntRect pixelSize = + aVisibleRect.ScaleToOutsidePixels(aScale.width, aScale.height, + aContainerFrame->PresContext()->AppUnitsPerDevPixel()); + + int32_t maxLayerSize = aContainerLayer->GetMaxLayerSize(); + + if (pixelSize.width > maxLayerSize) { + float scale = (float)pixelSize.width / maxLayerSize; + scale = gfxUtils::ClampToScaleFactor(scale); + aScale.width /= scale; + } + if (pixelSize.height > maxLayerSize) { + float scale = (float)pixelSize.height / maxLayerSize; + scale = gfxUtils::ClampToScaleFactor(scale); + aScale.height /= scale; + } +} +static bool +ChooseScaleAndSetTransform(FrameLayerBuilder* aLayerBuilder, + nsDisplayListBuilder* aDisplayListBuilder, + nsIFrame* aContainerFrame, + nsDisplayItem* aContainerItem, + const nsRect& aVisibleRect, + const Matrix4x4* aTransform, + const ContainerLayerParameters& aIncomingScale, + ContainerLayer* aLayer, + LayerState aState, + ContainerLayerParameters& aOutgoingScale) +{ + nsIntPoint offset; + + Matrix4x4 transform = + Matrix4x4::Scaling(aIncomingScale.mXScale, aIncomingScale.mYScale, 1.0); + if (aTransform) { + // aTransform is applied first, then the scale is applied to the result + transform = (*aTransform)*transform; + // Set any matrix entries close to integers to be those exact integers. + // This protects against floating-point inaccuracies causing problems + // in the checks below. + // We use the fixed epsilon version here because we don't want the nudging + // to depend on the scroll position. + transform.NudgeToIntegersFixedEpsilon(); + } + Matrix transform2d; + if (aContainerFrame && + (aState == LAYER_INACTIVE || aState == LAYER_SVG_EFFECTS) && + (!aTransform || (aTransform->Is2D(&transform2d) && + !transform2d.HasNonTranslation()))) { + // When we have an inactive ContainerLayer, translate the container by the offset to the + // reference frame (and offset all child layers by the reverse) so that the coordinate + // space of the child layers isn't affected by scrolling. + // This gets confusing for complicated transform (since we'd have to compute the scale + // factors for the matrix), so we don't bother. Any frames that are building an nsDisplayTransform + // for a css transform would have 0,0 as their offset to the reference frame, so this doesn't + // matter. + nsPoint appUnitOffset = aDisplayListBuilder->ToReferenceFrame(aContainerFrame); + nscoord appUnitsPerDevPixel = aContainerFrame->PresContext()->AppUnitsPerDevPixel(); + offset = nsIntPoint( + NS_lround(NSAppUnitsToDoublePixels(appUnitOffset.x, appUnitsPerDevPixel)*aIncomingScale.mXScale), + NS_lround(NSAppUnitsToDoublePixels(appUnitOffset.y, appUnitsPerDevPixel)*aIncomingScale.mYScale)); + } + transform.PostTranslate(offset.x + aIncomingScale.mOffset.x, + offset.y + aIncomingScale.mOffset.y, + 0); + + if (transform.IsSingular()) { + return false; + } + + bool canDraw2D = transform.CanDraw2D(&transform2d); + gfxSize scale; + // XXX Should we do something for 3D transforms? + if (canDraw2D && + !aContainerFrame->Combines3DTransformWithAncestors() && + !aContainerFrame->HasPerspective()) { + // If the container's transform is animated off main thread, fix a suitable scale size + // for animation + if (aContainerItem && + aContainerItem->GetType() == nsDisplayItem::TYPE_TRANSFORM && + EffectCompositor::HasAnimationsForCompositor( + aContainerFrame, eCSSProperty_transform)) { + // Use the size of the nearest widget as the maximum size. This + // is important since it might be a popup that is bigger than the + // pres context's size. + nsPresContext* presContext = aContainerFrame->PresContext(); + nsIWidget* widget = aContainerFrame->GetNearestWidget(); + nsSize displaySize; + if (widget) { + LayoutDeviceIntSize widgetSize = widget->GetClientSize(); + int32_t p2a = presContext->AppUnitsPerDevPixel(); + displaySize.width = NSIntPixelsToAppUnits(widgetSize.width, p2a); + displaySize.height = NSIntPixelsToAppUnits(widgetSize.height, p2a); + } else { + displaySize = presContext->GetVisibleArea().Size(); + } + // compute scale using the animation on the container (ignoring + // its ancestors) + scale = nsLayoutUtils::ComputeSuitableScaleForAnimation( + aContainerFrame, aVisibleRect.Size(), + displaySize); + // multiply by the scale inherited from ancestors--we use a uniform + // scale factor to prevent blurring when the layer is rotated. + float incomingScale = std::max(aIncomingScale.mXScale, aIncomingScale.mYScale); + scale.width *= incomingScale; + scale.height *= incomingScale; + } else { + // Scale factors are normalized to a power of 2 to reduce the number of resolution changes + scale = RoundToFloatPrecision(ThebesMatrix(transform2d).ScaleFactors(true)); + // For frames with a changing transform that's not just a translation, + // round scale factors up to nearest power-of-2 boundary so that we don't + // keep having to redraw the content as it scales up and down. Rounding up to nearest + // power-of-2 boundary ensures we never scale up, only down --- avoiding + // jaggies. It also ensures we never scale down by more than a factor of 2, + // avoiding bad downscaling quality. + Matrix frameTransform; + if (ActiveLayerTracker::IsStyleAnimated(aDisplayListBuilder, aContainerFrame, eCSSProperty_transform) && + aTransform && + (!aTransform->Is2D(&frameTransform) || frameTransform.HasNonTranslationOrFlip())) { + // Don't clamp the scale factor when the new desired scale factor matches the old one + // or it was previously unscaled. + bool clamp = true; + Matrix oldFrameTransform2d; + if (aLayer->GetBaseTransform().Is2D(&oldFrameTransform2d)) { + gfxSize oldScale = RoundToFloatPrecision(ThebesMatrix(oldFrameTransform2d).ScaleFactors(true)); + if (oldScale == scale || oldScale == gfxSize(1.0, 1.0)) { + clamp = false; + } + } + if (clamp) { + scale.width = gfxUtils::ClampToScaleFactor(scale.width); + scale.height = gfxUtils::ClampToScaleFactor(scale.height); + } + } else { + // XXX Do we need to move nearly-integer values to integers here? + } + } + // If the scale factors are too small, just use 1.0. The content is being + // scaled out of sight anyway. + if (fabs(scale.width) < 1e-8 || fabs(scale.height) < 1e-8) { + scale = gfxSize(1.0, 1.0); + } + // If this is a transform container layer, then pre-rendering might + // mean we try render a layer bigger than the max texture size. If we have + // tiling, that's not a problem, since we'll automatically choose a tiled + // layer for layers of that size. If not, we need to apply clamping to + // prevent this. + if (aTransform && !gfxPrefs::LayersTilesEnabled()) { + RestrictScaleToMaxLayerSize(scale, aVisibleRect, aContainerFrame, aLayer); + } + } else { + scale = gfxSize(1.0, 1.0); + } + + // Store the inverse of our resolution-scale on the layer + aLayer->SetBaseTransform(transform); + aLayer->SetPreScale(1.0f/float(scale.width), + 1.0f/float(scale.height)); + aLayer->SetInheritedScale(aIncomingScale.mXScale, + aIncomingScale.mYScale); + + aOutgoingScale = + ContainerLayerParameters(scale.width, scale.height, -offset, aIncomingScale); + if (aTransform) { + aOutgoingScale.mInTransformedSubtree = true; + if (ActiveLayerTracker::IsStyleAnimated(aDisplayListBuilder, aContainerFrame, + eCSSProperty_transform)) { + aOutgoingScale.mInActiveTransformedSubtree = true; + } + } + if ((aLayerBuilder->IsBuildingRetainedLayers() && + (!canDraw2D || transform2d.HasNonIntegerTranslation())) || + aContainerFrame->Extend3DContext() || + aContainerFrame->Combines3DTransformWithAncestors()) { + aOutgoingScale.mDisableSubpixelAntialiasingInDescendants = true; + } + return true; +} + +already_AddRefed<ContainerLayer> +FrameLayerBuilder::BuildContainerLayerFor(nsDisplayListBuilder* aBuilder, + LayerManager* aManager, + nsIFrame* aContainerFrame, + nsDisplayItem* aContainerItem, + nsDisplayList* aChildren, + const ContainerLayerParameters& aParameters, + const Matrix4x4* aTransform, + uint32_t aFlags) +{ + uint32_t containerDisplayItemKey = + aContainerItem ? aContainerItem->GetPerFrameKey() : nsDisplayItem::TYPE_ZERO; + NS_ASSERTION(aContainerFrame, "Container display items here should have a frame"); + NS_ASSERTION(!aContainerItem || + aContainerItem->Frame() == aContainerFrame, + "Container display item must match given frame"); + + if (!aParameters.mXScale || !aParameters.mYScale) { + return nullptr; + } + + RefPtr<ContainerLayer> containerLayer; + if (aManager == mRetainingManager) { + // Using GetOldLayerFor will search merged frames, as well as the underlying + // frame. The underlying frame can change when a page scrolls, so this + // avoids layer recreation in the situation that a new underlying frame is + // picked for a layer. + Layer* oldLayer = nullptr; + if (aContainerItem) { + oldLayer = GetOldLayerFor(aContainerItem); + } else { + DisplayItemData *data = GetOldLayerForFrame(aContainerFrame, containerDisplayItemKey); + if (data) { + oldLayer = data->mLayer; + } + } + + if (oldLayer) { + NS_ASSERTION(oldLayer->Manager() == aManager, "Wrong manager"); + if (oldLayer->HasUserData(&gPaintedDisplayItemLayerUserData)) { + // The old layer for this item is actually our PaintedLayer + // because we rendered its layer into that PaintedLayer. So we + // don't actually have a retained container layer. + } else { + NS_ASSERTION(oldLayer->GetType() == Layer::TYPE_CONTAINER, + "Wrong layer type"); + containerLayer = static_cast<ContainerLayer*>(oldLayer); + ResetLayerStateForRecycling(containerLayer); + } + } + } + if (!containerLayer) { + // No suitable existing layer was found. + containerLayer = aManager->CreateContainerLayer(); + if (!containerLayer) + return nullptr; + } + + LayerState state = aContainerItem ? aContainerItem->GetLayerState(aBuilder, aManager, aParameters) : LAYER_ACTIVE; + if (state == LAYER_INACTIVE && + nsDisplayItem::ForceActiveLayers()) { + state = LAYER_ACTIVE; + } + + if (aContainerItem && state == LAYER_ACTIVE_EMPTY) { + // Empty layers only have metadata and should never have display items. We + // early exit because later, invalidation will walk up the frame tree to + // determine which painted layer gets invalidated. Since an empty layer + // should never have anything to paint, it should never be invalidated. + NS_ASSERTION(aChildren->IsEmpty(), "Should have no children"); + return containerLayer.forget(); + } + + const DisplayItemScrollClip* containerScrollClip = aParameters.mScrollClip; + + ContainerLayerParameters scaleParameters; + nsRect bounds = aChildren->GetScrollClippedBoundsUpTo(aBuilder, containerScrollClip); + nsRect childrenVisible = + aContainerItem ? aContainerItem->GetVisibleRectForChildren() : + aContainerFrame->GetVisualOverflowRectRelativeToSelf(); + if (!ChooseScaleAndSetTransform(this, aBuilder, aContainerFrame, + aContainerItem, + bounds.Intersect(childrenVisible), + aTransform, aParameters, + containerLayer, state, scaleParameters)) { + return nullptr; + } + + uint32_t oldGeneration = mContainerLayerGeneration; + mContainerLayerGeneration = ++mMaxContainerLayerGeneration; + + if (mRetainingManager) { + if (aContainerItem) { + StoreDataForFrame(aContainerItem, containerLayer, LAYER_ACTIVE); + } else { + StoreDataForFrame(aContainerFrame, containerDisplayItemKey, containerLayer, LAYER_ACTIVE); + } + } + + LayerManagerData* data = static_cast<LayerManagerData*> + (aManager->GetUserData(&gLayerManagerUserData)); + + nsIntRect pixBounds; + nscoord appUnitsPerDevPixel; + bool flattenToSingleLayer = false; + if ((aContainerFrame->GetStateBits() & NS_FRAME_NO_COMPONENT_ALPHA) && + mRetainingManager && + mRetainingManager->ShouldAvoidComponentAlphaLayers() && + !nsLayoutUtils::AsyncPanZoomEnabled(aContainerFrame)) + { + flattenToSingleLayer = true; + } + + nscolor backgroundColor = NS_RGBA(0,0,0,0); + if (aFlags & CONTAINER_ALLOW_PULL_BACKGROUND_COLOR) { + backgroundColor = aParameters.mBackgroundColor; + } + + uint32_t flags; + while (true) { + ContainerState state(aBuilder, aManager, aManager->GetLayerBuilder(), + aContainerFrame, aContainerItem, bounds, + containerLayer, scaleParameters, flattenToSingleLayer, + backgroundColor, containerScrollClip); + + state.ProcessDisplayItems(aChildren); + + // Set CONTENT_COMPONENT_ALPHA if any of our children have it. + // This is suboptimal ... a child could have text that's over transparent + // pixels in its own layer, but over opaque parts of previous siblings. + bool hasComponentAlphaChildren = false; + bool mayFlatten = + mRetainingManager && + mRetainingManager->ShouldAvoidComponentAlphaLayers() && + !flattenToSingleLayer && + !nsLayoutUtils::AsyncPanZoomEnabled(aContainerFrame); + + pixBounds = state.ScaleToOutsidePixels(bounds, false); + appUnitsPerDevPixel = state.GetAppUnitsPerDevPixel(); + state.Finish(&flags, pixBounds, aChildren, mayFlatten ? &hasComponentAlphaChildren : nullptr); + + if (hasComponentAlphaChildren && + !(flags & Layer::CONTENT_DISABLE_FLATTENING) && + containerLayer->HasMultipleChildren()) + { + // Since we don't want any component alpha layers on BasicLayers, we repeat + // the layer building process with this explicitely forced off. + // We restore the previous FrameLayerBuilder state since the first set + // of layer building will have changed it. + flattenToSingleLayer = true; + + // Restore DisplayItemData + for (auto iter = data->mDisplayItems.Iter(); !iter.Done(); iter.Next()) { + DisplayItemData* data = iter.Get()->GetKey(); + if (data->mUsed && data->mContainerLayerGeneration >= mContainerLayerGeneration) { + iter.Remove(); + } + } + + // Restore PaintedLayerItemEntries + for (auto iter = mPaintedLayerItems.Iter(); !iter.Done(); iter.Next()) { + PaintedLayerItemsEntry* entry = iter.Get(); + if (entry->mContainerLayerGeneration >= mContainerLayerGeneration) { + // We can just remove these items rather than attempting to revert them + // because we're going to want to invalidate everything when transitioning + // to component alpha flattening. + iter.Remove(); + continue; + } + + for (uint32_t i = 0; i < entry->mItems.Length(); i++) { + if (entry->mItems[i].mContainerLayerGeneration >= mContainerLayerGeneration) { + entry->mItems.TruncateLength(i); + break; + } + } + } + + aContainerFrame->AddStateBits(NS_FRAME_NO_COMPONENT_ALPHA); + continue; + } + break; + } + + // CONTENT_COMPONENT_ALPHA is propogated up to the nearest CONTENT_OPAQUE + // ancestor so that BasicLayerManager knows when to copy the background into + // pushed groups. Accelerated layers managers can't necessarily do this (only + // when the visible region is a simple rect), so we propogate + // CONTENT_COMPONENT_ALPHA_DESCENDANT all the way to the root. + if (flags & Layer::CONTENT_COMPONENT_ALPHA) { + flags |= Layer::CONTENT_COMPONENT_ALPHA_DESCENDANT; + } + + // Make sure that rounding the visible region out didn't add any area + // we won't paint + if (aChildren->IsOpaque() && !aChildren->NeedsTransparentSurface()) { + bounds.ScaleRoundIn(scaleParameters.mXScale, scaleParameters.mYScale); + if (bounds.Contains(ToAppUnits(pixBounds, appUnitsPerDevPixel))) { + // Clear CONTENT_COMPONENT_ALPHA and add CONTENT_OPAQUE instead. + flags &= ~Layer::CONTENT_COMPONENT_ALPHA; + flags |= Layer::CONTENT_OPAQUE; + } + } + containerLayer->SetContentFlags(flags); + // If aContainerItem is non-null some BuildContainerLayer further up the + // call stack is responsible for setting containerLayer's visible region. + if (!aContainerItem) { + containerLayer->SetVisibleRegion(LayerIntRegion::FromUnknownRegion(pixBounds)); + } + if (aParameters.mLayerContentsVisibleRect) { + *aParameters.mLayerContentsVisibleRect = pixBounds + scaleParameters.mOffset; + } + + mContainerLayerGeneration = oldGeneration; + nsPresContext::ClearNotifySubDocInvalidationData(containerLayer); + + return containerLayer.forget(); +} + +Layer* +FrameLayerBuilder::GetLeafLayerFor(nsDisplayListBuilder* aBuilder, + nsDisplayItem* aItem) +{ + Layer* layer = GetOldLayerFor(aItem); + if (!layer) + return nullptr; + if (layer->HasUserData(&gPaintedDisplayItemLayerUserData)) { + // This layer was created to render Thebes-rendered content for this + // display item. The display item should not use it for its own + // layer rendering. + return nullptr; + } + ResetLayerStateForRecycling(layer); + return layer; +} + +/* static */ void +FrameLayerBuilder::InvalidateAllLayers(LayerManager* aManager) +{ + LayerManagerData* data = static_cast<LayerManagerData*> + (aManager->GetUserData(&gLayerManagerUserData)); + if (data) { + data->mInvalidateAllLayers = true; + } +} + +/* static */ void +FrameLayerBuilder::InvalidateAllLayersForFrame(nsIFrame *aFrame) +{ + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + if (array) { + for (uint32_t i = 0; i < array->Length(); i++) { + AssertDisplayItemData(array->ElementAt(i))->mParent->mInvalidateAllLayers = true; + } + } +} + +/* static */ +Layer* +FrameLayerBuilder::GetDedicatedLayer(nsIFrame* aFrame, uint32_t aDisplayItemKey) +{ + //TODO: This isn't completely correct, since a frame could exist as a layer + // in the normal widget manager, and as a different layer (or no layer) + // in the secondary manager + + const nsTArray<DisplayItemData*>* array = + aFrame->Properties().Get(LayerManagerDataProperty()); + if (array) { + for (uint32_t i = 0; i < array->Length(); i++) { + DisplayItemData *element = AssertDisplayItemData(array->ElementAt(i)); + if (!element->mParent->mLayerManager->IsWidgetLayerManager()) { + continue; + } + if (element->mDisplayItemKey == aDisplayItemKey) { + if (element->mOptLayer) { + return element->mOptLayer; + } + + Layer* layer = element->mLayer; + if (!layer->HasUserData(&gColorLayerUserData) && + !layer->HasUserData(&gImageLayerUserData) && + !layer->HasUserData(&gPaintedDisplayItemLayerUserData)) { + return layer; + } + } + } + } + return nullptr; +} + +static gfxSize +PredictScaleForContent(nsIFrame* aFrame, nsIFrame* aAncestorWithScale, + const gfxSize& aScale) +{ + Matrix4x4 transform = Matrix4x4::Scaling(aScale.width, aScale.height, 1.0); + if (aFrame != aAncestorWithScale) { + // aTransform is applied first, then the scale is applied to the result + transform = nsLayoutUtils::GetTransformToAncestor(aFrame, aAncestorWithScale)*transform; + } + Matrix transform2d; + if (transform.CanDraw2D(&transform2d)) { + return ThebesMatrix(transform2d).ScaleFactors(true); + } + return gfxSize(1.0, 1.0); +} + +gfxSize +FrameLayerBuilder::GetPaintedLayerScaleForFrame(nsIFrame* aFrame) +{ + MOZ_ASSERT(aFrame, "need a frame"); + nsIFrame* last = nullptr; + for (nsIFrame* f = aFrame; f; f = nsLayoutUtils::GetCrossDocParentFrame(f)) { + last = f; + + if (nsLayoutUtils::IsPopup(f)) { + // Don't examine ancestors of a popup. It won't make sense to check + // the transform from some content inside the popup to some content + // which is an ancestor of the popup. + break; + } + + const nsTArray<DisplayItemData*>* array = + f->Properties().Get(LayerManagerDataProperty()); + if (!array) { + continue; + } + + for (uint32_t i = 0; i < array->Length(); i++) { + Layer* layer = AssertDisplayItemData(array->ElementAt(i))->mLayer; + ContainerLayer* container = layer->AsContainerLayer(); + if (!container || + !layer->Manager()->IsWidgetLayerManager()) { + continue; + } + for (Layer* l = container->GetFirstChild(); l; l = l->GetNextSibling()) { + PaintedDisplayItemLayerUserData* data = + static_cast<PaintedDisplayItemLayerUserData*> + (l->GetUserData(&gPaintedDisplayItemLayerUserData)); + if (data) { + return PredictScaleForContent(aFrame, f, gfxSize(data->mXScale, data->mYScale)); + } + } + } + } + + float presShellResolution = last->PresContext()->PresShell()->GetResolution(); + return PredictScaleForContent(aFrame, last, + gfxSize(presShellResolution, presShellResolution)); +} + +#ifdef MOZ_DUMP_PAINTING +static void DebugPaintItem(DrawTarget& aDrawTarget, + nsPresContext* aPresContext, + nsDisplayItem *aItem, + nsDisplayListBuilder* aBuilder) +{ + bool snap; + Rect bounds = NSRectToRect(aItem->GetBounds(aBuilder, &snap), + aPresContext->AppUnitsPerDevPixel()); + + RefPtr<DrawTarget> tempDT = + aDrawTarget.CreateSimilarDrawTarget(IntSize::Truncate(bounds.width, bounds.height), + SurfaceFormat::B8G8R8A8); + RefPtr<gfxContext> context = gfxContext::CreateOrNull(tempDT); + if (!context) { + // Leave this as crash, it's in the debugging code, we want to know + gfxDevCrash(LogReason::InvalidContext) << "DebugPaintItem context problem " << gfx::hexa(tempDT); + return; + } + context->SetMatrix(gfxMatrix::Translation(-bounds.x, -bounds.y)); + nsRenderingContext ctx(context); + + aItem->Paint(aBuilder, &ctx); + RefPtr<SourceSurface> surface = tempDT->Snapshot(); + DumpPaintedImage(aItem, surface); + + aDrawTarget.DrawSurface(surface, bounds, Rect(Point(0,0), bounds.Size())); + + aItem->SetPainted(); +} +#endif + +/* static */ void +FrameLayerBuilder::RecomputeVisibilityForItems(nsTArray<ClippedDisplayItem>& aItems, + nsDisplayListBuilder *aBuilder, + const nsIntRegion& aRegionToDraw, + const nsIntPoint& aOffset, + int32_t aAppUnitsPerDevPixel, + float aXScale, + float aYScale) +{ + uint32_t i; + // Update visible regions. We perform visibility analysis to take account + // of occlusion culling. + nsRegion visible = aRegionToDraw.ToAppUnits(aAppUnitsPerDevPixel); + visible.MoveBy(NSIntPixelsToAppUnits(aOffset.x, aAppUnitsPerDevPixel), + NSIntPixelsToAppUnits(aOffset.y, aAppUnitsPerDevPixel)); + visible.ScaleInverseRoundOut(aXScale, aYScale); + + for (i = aItems.Length(); i > 0; --i) { + ClippedDisplayItem* cdi = &aItems[i - 1]; + const DisplayItemClip& clip = cdi->mItem->GetClip(); + + NS_ASSERTION(AppUnitsPerDevPixel(cdi->mItem) == aAppUnitsPerDevPixel, + "a painted layer should contain items only at the same zoom"); + + MOZ_ASSERT(clip.HasClip() || clip.GetRoundedRectCount() == 0, + "If we have rounded rects, we must have a clip rect"); + + if (!clip.IsRectAffectedByClip(visible.GetBounds())) { + cdi->mItem->RecomputeVisibility(aBuilder, &visible); + continue; + } + + // Do a little dance to account for the fact that we're clipping + // to cdi->mClipRect + nsRegion clipped; + clipped.And(visible, clip.NonRoundedIntersection()); + nsRegion finalClipped = clipped; + cdi->mItem->RecomputeVisibility(aBuilder, &finalClipped); + // If we have rounded clip rects, don't subtract from the visible + // region since we aren't displaying everything inside the rect. + if (clip.GetRoundedRectCount() == 0) { + nsRegion removed; + removed.Sub(clipped, finalClipped); + nsRegion newVisible; + newVisible.Sub(visible, removed); + // Don't let the visible region get too complex. + if (newVisible.GetNumRects() <= 15) { + visible = newVisible; + } + } + } +} + +void +FrameLayerBuilder::PaintItems(nsTArray<ClippedDisplayItem>& aItems, + const nsIntRect& aRect, + gfxContext *aContext, + nsRenderingContext *aRC, + nsDisplayListBuilder* aBuilder, + nsPresContext* aPresContext, + const nsIntPoint& aOffset, + float aXScale, float aYScale, + int32_t aCommonClipCount) +{ + DrawTarget& aDrawTarget = *aRC->GetDrawTarget(); + + int32_t appUnitsPerDevPixel = aPresContext->AppUnitsPerDevPixel(); + nsRect boundRect = ToAppUnits(aRect, appUnitsPerDevPixel); + boundRect.MoveBy(NSIntPixelsToAppUnits(aOffset.x, appUnitsPerDevPixel), + NSIntPixelsToAppUnits(aOffset.y, appUnitsPerDevPixel)); + boundRect.ScaleInverseRoundOut(aXScale, aYScale); + + DisplayItemClip currentClip; + bool currentClipIsSetInContext = false; + DisplayItemClip tmpClip; + + for (uint32_t i = 0; i < aItems.Length(); ++i) { + ClippedDisplayItem* cdi = &aItems[i]; + + nsRect paintRect = cdi->mItem->GetVisibleRect().Intersect(boundRect); + if (paintRect.IsEmpty()) + continue; + +#ifdef MOZ_DUMP_PAINTING + PROFILER_LABEL_PRINTF("DisplayList", "Draw", + js::ProfileEntry::Category::GRAPHICS, "%s", cdi->mItem->Name()); +#else + PROFILER_LABEL("DisplayList", "Draw", + js::ProfileEntry::Category::GRAPHICS); +#endif + + // If the new desired clip state is different from the current state, + // update the clip. + const DisplayItemClip* clip = &cdi->mItem->GetClip(); + if (clip->GetRoundedRectCount() > 0 && + !clip->IsRectClippedByRoundedCorner(cdi->mItem->GetVisibleRect())) { + tmpClip = *clip; + tmpClip.RemoveRoundedCorners(); + clip = &tmpClip; + } + if (currentClipIsSetInContext != clip->HasClip() || + (clip->HasClip() && *clip != currentClip)) { + if (currentClipIsSetInContext) { + aContext->Restore(); + } + currentClipIsSetInContext = clip->HasClip(); + if (currentClipIsSetInContext) { + currentClip = *clip; + aContext->Save(); + NS_ASSERTION(aCommonClipCount < 100, + "Maybe you really do have more than a hundred clipping rounded rects, or maybe something has gone wrong."); + currentClip.ApplyTo(aContext, aPresContext, aCommonClipCount); + aContext->NewPath(); + } + } + + if (cdi->mInactiveLayerManager) { + bool saved = aDrawTarget.GetPermitSubpixelAA(); + PaintInactiveLayer(aBuilder, cdi->mInactiveLayerManager, cdi->mItem, aContext, aRC); + aDrawTarget.SetPermitSubpixelAA(saved); + } else { + nsIFrame* frame = cdi->mItem->Frame(); + if (aBuilder->IsPaintingToWindow()) { + frame->AddStateBits(NS_FRAME_PAINTED_THEBES); + } +#ifdef MOZ_DUMP_PAINTING + if (gfxEnv::DumpPaintItems()) { + DebugPaintItem(aDrawTarget, aPresContext, cdi->mItem, aBuilder); + } else { +#else + { +#endif + cdi->mItem->Paint(aBuilder, aRC); + } + } + + if (CheckDOMModified()) + break; + } + + if (currentClipIsSetInContext) { + aContext->Restore(); + } +} + +/** + * Returns true if it is preferred to draw the list of display + * items separately for each rect in the visible region rather + * than clipping to a complex region. + */ +static bool +ShouldDrawRectsSeparately(DrawTarget* aDrawTarget, DrawRegionClip aClip) +{ + if (!gfxPrefs::LayoutPaintRectsSeparately() || + aClip == DrawRegionClip::NONE) { + return false; + } + + return !aDrawTarget->SupportsRegionClipping(); +} + +static void DrawForcedBackgroundColor(DrawTarget& aDrawTarget, + const IntRect& aBounds, + nscolor aBackgroundColor) +{ + if (NS_GET_A(aBackgroundColor) > 0) { + ColorPattern color(ToDeviceColor(aBackgroundColor)); + aDrawTarget.FillRect(Rect(aBounds), color); + } +} + +/* + * A note on residual transforms: + * + * In a transformed subtree we sometimes apply the PaintedLayer's + * "residual transform" when drawing content into the PaintedLayer. + * This is a translation by components in the range [-0.5,0.5) provided + * by the layer system; applying the residual transform followed by the + * transforms used by layer compositing ensures that the subpixel alignment + * of the content of the PaintedLayer exactly matches what it would be if + * we used cairo/Thebes to draw directly to the screen without going through + * retained layer buffers. + * + * The visible and valid regions of the PaintedLayer are computed without + * knowing the residual transform (because we don't know what the residual + * transform is going to be until we've built the layer tree!). So we have to + * consider whether content painted in the range [x, xmost) might be painted + * outside the visible region we computed for that content. The visible region + * would be [floor(x), ceil(xmost)). The content would be rendered at + * [x + r, xmost + r), where -0.5 <= r < 0.5. So some half-rendered pixels could + * indeed fall outside the computed visible region, which is not a big deal; + * similar issues already arise when we snap cliprects to nearest pixels. + * Note that if the rendering of the content is snapped to nearest pixels --- + * which it often is --- then the content is actually rendered at + * [snap(x + r), snap(xmost + r)). It turns out that floor(x) <= snap(x + r) + * and ceil(xmost) >= snap(xmost + r), so the rendering of snapped content + * always falls within the visible region we computed. + */ + +/* static */ void +FrameLayerBuilder::DrawPaintedLayer(PaintedLayer* aLayer, + gfxContext* aContext, + const nsIntRegion& aRegionToDraw, + const nsIntRegion& aDirtyRegion, + DrawRegionClip aClip, + const nsIntRegion& aRegionToInvalidate, + void* aCallbackData) +{ + DrawTarget& aDrawTarget = *aContext->GetDrawTarget(); + + PROFILER_LABEL("FrameLayerBuilder", "DrawPaintedLayer", + js::ProfileEntry::Category::GRAPHICS); + + nsDisplayListBuilder* builder = static_cast<nsDisplayListBuilder*> + (aCallbackData); + + FrameLayerBuilder *layerBuilder = aLayer->Manager()->GetLayerBuilder(); + NS_ASSERTION(layerBuilder, "Unexpectedly null layer builder!"); + + if (layerBuilder->CheckDOMModified()) + return; + + PaintedLayerItemsEntry* entry = layerBuilder->mPaintedLayerItems.GetEntry(aLayer); + NS_ASSERTION(entry, "We shouldn't be drawing into a layer with no items!"); + if (!entry->mContainerLayerFrame) { + return; + } + + + PaintedDisplayItemLayerUserData* userData = + static_cast<PaintedDisplayItemLayerUserData*> + (aLayer->GetUserData(&gPaintedDisplayItemLayerUserData)); + NS_ASSERTION(userData, "where did our user data go?"); + + bool shouldDrawRectsSeparately = + ShouldDrawRectsSeparately(&aDrawTarget, aClip); + + if (!shouldDrawRectsSeparately) { + if (aClip == DrawRegionClip::DRAW) { + gfxUtils::ClipToRegion(aContext, aRegionToDraw); + } + + DrawForcedBackgroundColor(aDrawTarget, aRegionToDraw.GetBounds(), + userData->mForcedBackgroundColor); + } + + if (NS_GET_A(userData->mFontSmoothingBackgroundColor) > 0) { + aContext->SetFontSmoothingBackgroundColor( + Color::FromABGR(userData->mFontSmoothingBackgroundColor)); + } + + // make the origin of the context coincide with the origin of the + // PaintedLayer + gfxContextMatrixAutoSaveRestore saveMatrix(aContext); + nsIntPoint offset = GetTranslationForPaintedLayer(aLayer); + nsPresContext* presContext = entry->mContainerLayerFrame->PresContext(); + + if (!userData->mVisibilityComputedRegion.Contains(aDirtyRegion) && + !layerBuilder->GetContainingPaintedLayerData()) { + // Recompute visibility of items in our PaintedLayer, if required. Note + // that this recomputes visibility for all descendants of our display + // items too, so there's no need to do this for the items in inactive + // PaintedLayers. If aDirtyRegion has not changed since the previous call + // then we can skip this. + int32_t appUnitsPerDevPixel = presContext->AppUnitsPerDevPixel(); + RecomputeVisibilityForItems(entry->mItems, builder, aDirtyRegion, + offset, appUnitsPerDevPixel, + userData->mXScale, userData->mYScale); + userData->mVisibilityComputedRegion = aDirtyRegion; + } + + nsRenderingContext rc(aContext); + + if (shouldDrawRectsSeparately) { + for (auto iter = aRegionToDraw.RectIter(); !iter.Done(); iter.Next()) { + const nsIntRect& iterRect = iter.Get(); + gfxContextAutoSaveRestore save(aContext); + aContext->NewPath(); + aContext->Rectangle(ThebesRect(iterRect)); + aContext->Clip(); + + DrawForcedBackgroundColor(aDrawTarget, iterRect, + userData->mForcedBackgroundColor); + + // Apply the residual transform if it has been enabled, to ensure that + // snapping when we draw into aContext exactly matches the ideal transform. + // See above for why this is OK. + aContext->SetMatrix( + aContext->CurrentMatrix().Translate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)). + Scale(userData->mXScale, userData->mYScale)); + + layerBuilder->PaintItems(entry->mItems, iterRect, aContext, &rc, + builder, presContext, + offset, userData->mXScale, userData->mYScale, + entry->mCommonClipCount); + if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) { + aLayer->Manager()->AddPaintedPixelCount(iterRect.Area()); + } + } + } else { + // Apply the residual transform if it has been enabled, to ensure that + // snapping when we draw into aContext exactly matches the ideal transform. + // See above for why this is OK. + aContext->SetMatrix( + aContext->CurrentMatrix().Translate(aLayer->GetResidualTranslation() - gfxPoint(offset.x, offset.y)). + Scale(userData->mXScale,userData->mYScale)); + + layerBuilder->PaintItems(entry->mItems, aRegionToDraw.GetBounds(), aContext, &rc, + builder, presContext, + offset, userData->mXScale, userData->mYScale, + entry->mCommonClipCount); + if (gfxPrefs::GfxLoggingPaintedPixelCountEnabled()) { + aLayer->Manager()->AddPaintedPixelCount( + aRegionToDraw.GetBounds().Area()); + } + } + + aContext->SetFontSmoothingBackgroundColor(Color()); + + bool isActiveLayerManager = !aLayer->Manager()->IsInactiveLayerManager(); + + if (presContext->GetPaintFlashing() && isActiveLayerManager) { + gfxContextAutoSaveRestore save(aContext); + if (shouldDrawRectsSeparately) { + if (aClip == DrawRegionClip::DRAW) { + gfxUtils::ClipToRegion(aContext, aRegionToDraw); + } + } + FlashPaint(aContext); + } + + if (presContext->GetDocShell() && isActiveLayerManager) { + nsDocShell* docShell = static_cast<nsDocShell*>(presContext->GetDocShell()); + RefPtr<TimelineConsumers> timelines = TimelineConsumers::Get(); + + if (timelines && timelines->HasConsumer(docShell)) { + timelines->AddMarkerForDocShell(docShell, Move( + MakeUnique<LayerTimelineMarker>(aRegionToDraw))); + } + } + + if (!aRegionToInvalidate.IsEmpty()) { + aLayer->AddInvalidRect(aRegionToInvalidate.GetBounds()); + } +} + +bool +FrameLayerBuilder::CheckDOMModified() +{ + if (!mRootPresContext || + mInitialDOMGeneration == mRootPresContext->GetDOMGeneration()) + return false; + if (mDetectedDOMModification) { + // Don't spam the console with extra warnings + return true; + } + mDetectedDOMModification = true; + // Painting is not going to complete properly. There's not much + // we can do here though. Invalidating the window to get another repaint + // is likely to lead to an infinite repaint loop. + NS_WARNING("Detected DOM modification during paint, bailing out!"); + return true; +} + +/* static */ void +FrameLayerBuilder::DumpRetainedLayerTree(LayerManager* aManager, std::stringstream& aStream, bool aDumpHtml) +{ + aManager->Dump(aStream, "", aDumpHtml); +} + +nsDisplayItemGeometry* +FrameLayerBuilder::GetMostRecentGeometry(nsDisplayItem* aItem) +{ + typedef nsTArray<DisplayItemData*> DataArray; + + // Retrieve the array of DisplayItemData associated with our frame. + FrameProperties properties = aItem->Frame()->Properties(); + const DataArray* dataArray = + properties.Get(LayerManagerDataProperty()); + if (!dataArray) { + return nullptr; + } + + // Find our display item data, if it exists, and return its geometry. + uint32_t itemPerFrameKey = aItem->GetPerFrameKey(); + for (uint32_t i = 0; i < dataArray->Length(); i++) { + DisplayItemData* data = AssertDisplayItemData(dataArray->ElementAt(i)); + if (data->GetDisplayItemKey() == itemPerFrameKey) { + return data->GetGeometry(); + } + } + + return nullptr; +} + +gfx::Rect +CalculateBounds(const nsTArray<DisplayItemClip::RoundedRect>& aRects, int32_t A2D) +{ + nsRect bounds = aRects[0].mRect; + for (uint32_t i = 1; i < aRects.Length(); ++i) { + bounds.UnionRect(bounds, aRects[i].mRect); + } + + return gfx::ToRect(nsLayoutUtils::RectToGfxRect(bounds, A2D)); +} + +static void +SetClipCount(PaintedDisplayItemLayerUserData* apaintedData, + uint32_t aClipCount) +{ + if (apaintedData) { + apaintedData->mMaskClipCount = aClipCount; + } +} + +void +ContainerState::SetupMaskLayer(Layer *aLayer, + const DisplayItemClip& aClip, + uint32_t aRoundedRectClipCount) +{ + // if the number of clips we are going to mask has decreased, then aLayer might have + // cached graphics which assume the existence of a soon-to-be non-existent mask layer + // in that case, invalidate the whole layer. + PaintedDisplayItemLayerUserData* paintedData = GetPaintedDisplayItemLayerUserData(aLayer); + if (paintedData && + aRoundedRectClipCount < paintedData->mMaskClipCount) { + PaintedLayer* painted = aLayer->AsPaintedLayer(); + painted->InvalidateRegion(painted->GetValidRegion().GetBounds()); + } + + // don't build an unnecessary mask + if (aClip.GetRoundedRectCount() == 0 || + aRoundedRectClipCount == 0) { + SetClipCount(paintedData, 0); + return; + } + + RefPtr<Layer> maskLayer = + CreateMaskLayer(aLayer, aClip, Nothing(), aRoundedRectClipCount); + + if (!maskLayer) { + SetClipCount(paintedData, 0); + return; + } + + aLayer->SetMaskLayer(maskLayer); + SetClipCount(paintedData, aRoundedRectClipCount); +} + +already_AddRefed<Layer> +ContainerState::CreateMaskLayer(Layer *aLayer, + const DisplayItemClip& aClip, + const Maybe<size_t>& aForAncestorMaskLayer, + uint32_t aRoundedRectClipCount) +{ + // aLayer will never be the container layer created by an nsDisplayMask + // because nsDisplayMask propagates the DisplayItemClip to its contents + // and is not clipped itself. + // This assertion will fail if that ever stops being the case. + MOZ_ASSERT(!aLayer->GetUserData(&gCSSMaskLayerUserData), + "A layer contains round clips should not have css-mask on it."); + + // check if we can re-use the mask layer + MaskLayerKey recycleKey(aLayer, aForAncestorMaskLayer); + RefPtr<ImageLayer> maskLayer = + CreateOrRecycleMaskImageLayerFor(recycleKey, + [](Layer* aMaskLayer) + { + aMaskLayer->SetUserData(&gMaskLayerUserData, + new MaskLayerUserData()); + } + ); + MaskLayerUserData* userData = GetMaskLayerUserData(maskLayer); + + int32_t A2D = mContainerFrame->PresContext()->AppUnitsPerDevPixel(); + MaskLayerUserData newData(aClip, aRoundedRectClipCount, A2D, mParameters); + if (*userData == newData) { + return maskLayer.forget(); + } + + // calculate a more precise bounding rect + gfx::Rect boundingRect = CalculateBounds(newData.mRoundedClipRects, + newData.mAppUnitsPerDevPixel); + boundingRect.Scale(mParameters.mXScale, mParameters.mYScale); + + uint32_t maxSize = mManager->GetMaxTextureSize(); + NS_ASSERTION(maxSize > 0, "Invalid max texture size"); +#ifdef MOZ_GFX_OPTIMIZE_MOBILE + // Make mask image width aligned to 4. See Bug 1245552. + gfx::Size surfaceSize(std::min<gfx::Float>(GetAlignedStride<4>(NSToIntCeil(boundingRect.Width()), 1), maxSize), + std::min<gfx::Float>(boundingRect.Height(), maxSize)); +#else + gfx::Size surfaceSize(std::min<gfx::Float>(boundingRect.Width(), maxSize), + std::min<gfx::Float>(boundingRect.Height(), maxSize)); +#endif + + // maskTransform is applied to the clip when it is painted into the mask (as a + // component of imageTransform), and its inverse used when the mask is used for + // masking. + // It is the transform from the masked layer's space to mask space + gfx::Matrix maskTransform = + Matrix::Scaling(surfaceSize.width / boundingRect.Width(), + surfaceSize.height / boundingRect.Height()); + if (surfaceSize.IsEmpty()) { + // Return early if we know that the size of this mask surface is empty. + return nullptr; + } + + gfx::Point p = boundingRect.TopLeft(); + maskTransform.PreTranslate(-p.x, -p.y); + // imageTransform is only used when the clip is painted to the mask + gfx::Matrix imageTransform = maskTransform; + imageTransform.PreScale(mParameters.mXScale, mParameters.mYScale); + + nsAutoPtr<MaskLayerImageCache::MaskLayerImageKey> newKey( + new MaskLayerImageCache::MaskLayerImageKey()); + + // copy and transform the rounded rects + for (uint32_t i = 0; i < newData.mRoundedClipRects.Length(); ++i) { + newKey->mRoundedClipRects.AppendElement( + MaskLayerImageCache::PixelRoundedRect(newData.mRoundedClipRects[i], + mContainerFrame->PresContext())); + newKey->mRoundedClipRects[i].ScaleAndTranslate(imageTransform); + } + newKey->mForwarder = mManager->AsShadowForwarder(); + + const MaskLayerImageCache::MaskLayerImageKey* lookupKey = newKey; + + // check to see if we can reuse a mask image + RefPtr<ImageContainer> container = + GetMaskLayerImageCache()->FindImageFor(&lookupKey); + + if (!container) { + IntSize surfaceSizeInt(NSToIntCeil(surfaceSize.width), + NSToIntCeil(surfaceSize.height)); + // no existing mask image, so build a new one + MaskImageData imageData(surfaceSizeInt, mManager); + RefPtr<DrawTarget> dt = imageData.CreateDrawTarget(); + + // fail if we can't get the right surface + if (!dt || !dt->IsValid()) { + NS_WARNING("Could not create DrawTarget for mask layer."); + return nullptr; + } + + RefPtr<gfxContext> context = gfxContext::CreateOrNull(dt); + MOZ_ASSERT(context); // already checked the draw target above + context->Multiply(ThebesMatrix(imageTransform)); + + // paint the clipping rects with alpha to create the mask + aClip.FillIntersectionOfRoundedRectClips(context, + Color(1.f, 1.f, 1.f, 1.f), + newData.mAppUnitsPerDevPixel, + 0, + aRoundedRectClipCount); + + // build the image and container + MOZ_ASSERT(aLayer->Manager() == mManager); + container = imageData.CreateImageAndImageContainer(); + NS_ASSERTION(container, "Could not create image container for mask layer."); + + if (!container) { + return nullptr; + } + + GetMaskLayerImageCache()->PutImage(newKey.forget(), container); + } + + maskLayer->SetContainer(container); + + maskTransform.Invert(); + Matrix4x4 matrix = Matrix4x4::From2D(maskTransform); + matrix.PreTranslate(mParameters.mOffset.x, mParameters.mOffset.y, 0); + maskLayer->SetBaseTransform(matrix); + + // save the details of the clip in user data + *userData = Move(newData); + userData->mImageKey.Reset(lookupKey); + + return maskLayer.forget(); +} + +} // namespace mozilla |