/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef GFX_LAYERS_H #define GFX_LAYERS_H #include <map> #include <stdint.h> // for uint32_t, uint64_t, uint8_t #include <stdio.h> // for FILE #include <sys/types.h> // for int32_t, int64_t #include "FrameMetrics.h" // for FrameMetrics #include "Units.h" // for LayerMargin, LayerPoint, ParentLayerIntRect #include "gfxContext.h" #include "gfxTypes.h" #include "gfxPoint.h" // for gfxPoint #include "gfxRect.h" // for gfxRect #include "gfx2DGlue.h" #include "mozilla/Assertions.h" // for MOZ_ASSERT_HELPER2, etc #include "mozilla/DebugOnly.h" // for DebugOnly #include "mozilla/EventForwards.h" // for nsPaintEvent #include "mozilla/Maybe.h" // for Maybe #include "mozilla/Poison.h" #include "mozilla/RefPtr.h" // for already_AddRefed #include "mozilla/StyleAnimationValue.h" // for StyleAnimationValue, etc #include "mozilla/TimeStamp.h" // for TimeStamp, TimeDuration #include "mozilla/UniquePtr.h" // for UniquePtr #include "mozilla/gfx/BaseMargin.h" // for BaseMargin #include "mozilla/gfx/BasePoint.h" // for BasePoint #include "mozilla/gfx/Point.h" // for IntSize #include "mozilla/gfx/TiledRegion.h" // for TiledIntRegion #include "mozilla/gfx/Types.h" // for SurfaceFormat #include "mozilla/gfx/UserData.h" // for UserData, etc #include "mozilla/layers/LayersTypes.h" #include "mozilla/mozalloc.h" // for operator delete, etc #include "nsAutoPtr.h" // for nsAutoPtr, nsRefPtr, etc #include "nsCOMPtr.h" // for already_AddRefed #include "nsCSSPropertyID.h" // for nsCSSPropertyID #include "nsDebug.h" // for NS_ASSERTION #include "nsISupportsImpl.h" // for Layer::Release, etc #include "nsRect.h" // for mozilla::gfx::IntRect #include "nsRegion.h" // for nsIntRegion #include "nsString.h" // for nsCString #include "nsTArray.h" // for nsTArray #include "nsTArrayForwardDeclare.h" // for InfallibleTArray #include "nscore.h" // for nsACString, nsAString #include "mozilla/Logging.h" // for PRLogModuleInfo #include "nsIWidget.h" // For plugin window configuration information structs #include "ImageContainer.h" class gfxContext; extern uint8_t gLayerManagerLayerBuilder; namespace mozilla { class ComputedTimingFunction; class FrameLayerBuilder; class StyleAnimationValue; namespace gl { class GLContext; } // namespace gl namespace gfx { class DrawTarget; } // namespace gfx namespace dom { class OverfillCallback; } // namespace dom namespace layers { class Animation; class AnimationData; class AsyncCanvasRenderer; class AsyncPanZoomController; class BasicLayerManager; class ClientLayerManager; class Layer; class LayerMetricsWrapper; class PaintedLayer; class ContainerLayer; class ImageLayer; class ColorLayer; class CanvasLayer; class ReadbackLayer; class ReadbackProcessor; class RefLayer; class LayerComposite; class ShadowableLayer; class ShadowLayerForwarder; class LayerManagerComposite; class SpecificLayerAttributes; class Compositor; class FrameUniformityData; class PersistentBufferProvider; namespace layerscope { class LayersPacket; } // namespace layerscope #define MOZ_LAYER_DECL_NAME(n, e) \ virtual const char* Name() const override { return n; } \ virtual LayerType GetType() const override { return e; } // Defined in LayerUserData.h; please include that file instead. class LayerUserData; /* * Motivation: For truly smooth animation and video playback, we need to * be able to compose frames and render them on a dedicated thread (i.e. * off the main thread where DOM manipulation, script execution and layout * induce difficult-to-bound latency). This requires Gecko to construct * some kind of persistent scene structure (graph or tree) that can be * safely transmitted across threads. We have other scenarios (e.g. mobile * browsing) where retaining some rendered data between paints is desired * for performance, so again we need a retained scene structure. * * Our retained scene structure is a layer tree. Each layer represents * content which can be composited onto a destination surface; the root * layer is usually composited into a window, and non-root layers are * composited into their parent layers. Layers have attributes (e.g. * opacity and clipping) that influence their compositing. * * We want to support a variety of layer implementations, including * a simple "immediate mode" implementation that doesn't retain any * rendered data between paints (i.e. uses cairo in just the way that * Gecko used it before layers were introduced). But we also don't want * to have bifurcated "layers"/"non-layers" rendering paths in Gecko. * Therefore the layers API is carefully designed to permit maximally * efficient implementation in an "immediate mode" style. See the * BasicLayerManager for such an implementation. */ /** * A LayerManager controls a tree of layers. All layers in the tree * must use the same LayerManager. * * All modifications to a layer tree must happen inside a transaction. * Only the state of the layer tree at the end of a transaction is * rendered. Transactions cannot be nested * * Each transaction has two phases: * 1) Construction: layers are created, inserted, removed and have * properties set on them in this phase. * BeginTransaction and BeginTransactionWithTarget start a transaction in * the Construction phase. * 2) Drawing: PaintedLayers are rendered into in this phase, in tree * order. When the client has finished drawing into the PaintedLayers, it should * call EndTransaction to complete the transaction. * * All layer API calls happen on the main thread. * * Layers are refcounted. The layer manager holds a reference to the * root layer, and each container layer holds a reference to its children. */ class LayerManager { NS_INLINE_DECL_REFCOUNTING(LayerManager) protected: typedef mozilla::gfx::DrawTarget DrawTarget; typedef mozilla::gfx::IntSize IntSize; typedef mozilla::gfx::SurfaceFormat SurfaceFormat; public: LayerManager() : mDestroyed(false) , mSnapEffectiveTransforms(true) , mId(0) , mInTransaction(false) , mPaintedPixelCount(0) {} /** * Release layers and resources held by this layer manager, and mark * it as destroyed. Should do any cleanup necessary in preparation * for its widget going away. After this call, only user data calls * are valid on the layer manager. */ virtual void Destroy() { mDestroyed = true; mUserData.Destroy(); mRoot = nullptr; } bool IsDestroyed() { return mDestroyed; } virtual ShadowLayerForwarder* AsShadowForwarder() { return nullptr; } virtual LayerManagerComposite* AsLayerManagerComposite() { return nullptr; } virtual ClientLayerManager* AsClientLayerManager() { return nullptr; } virtual BasicLayerManager* AsBasicLayerManager() { return nullptr; } /** * Returns true if this LayerManager is owned by an nsIWidget, * and is used for drawing into the widget. */ virtual bool IsWidgetLayerManager() { return true; } virtual bool IsInactiveLayerManager() { return false; } /** * Start a new transaction. Nested transactions are not allowed so * there must be no transaction currently in progress. * This transaction will update the state of the window from which * this LayerManager was obtained. */ virtual bool BeginTransaction() = 0; /** * Start a new transaction. Nested transactions are not allowed so * there must be no transaction currently in progress. * This transaction will render the contents of the layer tree to * the given target context. The rendering will be complete when * EndTransaction returns. */ virtual bool BeginTransactionWithTarget(gfxContext* aTarget) = 0; enum EndTransactionFlags { END_DEFAULT = 0, END_NO_IMMEDIATE_REDRAW = 1 << 0, // Do not perform the drawing phase END_NO_COMPOSITE = 1 << 1, // Do not composite after drawing painted layer contents. END_NO_REMOTE_COMPOSITE = 1 << 2 // Do not schedule a composition with a remote Compositor, if one exists. }; FrameLayerBuilder* GetLayerBuilder() { return reinterpret_cast<FrameLayerBuilder*>(GetUserData(&gLayerManagerLayerBuilder)); } /** * Attempts to end an "empty transaction". There must have been no * changes to the layer tree since the BeginTransaction(). * It's possible for this to fail; PaintedLayers may need to be updated * due to VRAM data being lost, for example. In such cases this method * returns false, and the caller must proceed with a normal layer tree * update and EndTransaction. */ virtual bool EndEmptyTransaction(EndTransactionFlags aFlags = END_DEFAULT) = 0; /** * Function called to draw the contents of each PaintedLayer. * aRegionToDraw contains the region that needs to be drawn. * This would normally be a subregion of the visible region. * The callee must draw all of aRegionToDraw. Drawing outside * aRegionToDraw will be clipped out or ignored. * The callee must draw all of aRegionToDraw. * This region is relative to 0,0 in the PaintedLayer. * * aDirtyRegion should contain the total region that is be due to be painted * during the transaction, even though only aRegionToDraw should be drawn * during this call. aRegionToDraw must be entirely contained within * aDirtyRegion. If the total dirty region is unknown it is okay to pass a * subregion of the total dirty region, e.g. just aRegionToDraw, though it * may not be as efficient. * * aRegionToInvalidate contains a region whose contents have been * changed by the layer manager and which must therefore be invalidated. * For example, this could be non-empty if a retained layer internally * switches from RGBA to RGB or back ... we might want to repaint it to * consistently use subpixel-AA or not. * This region is relative to 0,0 in the PaintedLayer. * aRegionToInvalidate may contain areas that are outside * aRegionToDraw; the callee must ensure that these areas are repainted * in the current layer manager transaction or in a later layer * manager transaction. * * aContext must not be used after the call has returned. * We guarantee that buffered contents in the visible * region are valid once drawing is complete. * * The origin of aContext is 0,0 in the PaintedLayer. */ typedef void (* DrawPaintedLayerCallback)(PaintedLayer* aLayer, gfxContext* aContext, const nsIntRegion& aRegionToDraw, const nsIntRegion& aDirtyRegion, DrawRegionClip aClip, const nsIntRegion& aRegionToInvalidate, void* aCallbackData); /** * Finish the construction phase of the transaction, perform the * drawing phase, and end the transaction. * During the drawing phase, all PaintedLayers in the tree are * drawn in tree order, exactly once each, except for those layers * where it is known that the visible region is empty. */ virtual void EndTransaction(DrawPaintedLayerCallback aCallback, void* aCallbackData, EndTransactionFlags aFlags = END_DEFAULT) = 0; /** * Schedule a composition with the remote Compositor, if one exists * for this LayerManager. Useful in conjunction with the END_NO_REMOTE_COMPOSITE * flag to EndTransaction. */ virtual void Composite() {} virtual bool HasShadowManagerInternal() const { return false; } bool HasShadowManager() const { return HasShadowManagerInternal(); } virtual void StorePluginWidgetConfigurations(const nsTArray<nsIWidget::Configuration>& aConfigurations) {} bool IsSnappingEffectiveTransforms() { return mSnapEffectiveTransforms; } /** * Returns true if the layer manager can't render component alpha * layers, and layer building should do it's best to avoid * creating them. */ virtual bool ShouldAvoidComponentAlphaLayers() { return false; } /** * Returns true if this LayerManager can properly support layers with * SurfaceMode::SURFACE_COMPONENT_ALPHA. LayerManagers that can't will use * transparent surfaces (and lose subpixel-AA for text). */ virtual bool AreComponentAlphaLayersEnabled(); /** * CONSTRUCTION PHASE ONLY * Set the root layer. The root layer is initially null. If there is * no root layer, EndTransaction won't draw anything. */ virtual void SetRoot(Layer* aLayer) = 0; /** * Can be called anytime */ Layer* GetRoot() { return mRoot; } /** * Does a breadth-first search from the root layer to find the first * scrollable layer, and returns its ViewID. Note that there may be * other layers in the tree which share the same ViewID. * Can be called any time. */ FrameMetrics::ViewID GetRootScrollableLayerId(); /** * Returns a LayerMetricsWrapper containing the Root * Content Documents layer. */ LayerMetricsWrapper GetRootContentLayer(); /** * CONSTRUCTION PHASE ONLY * Called when a managee has mutated. * Subclasses overriding this method must first call their * superclass's impl */ #ifdef DEBUG // In debug builds, we check some properties of |aLayer|. virtual void Mutated(Layer* aLayer); #else virtual void Mutated(Layer* aLayer) { } #endif /** * Hints that can be used during PaintedLayer creation to influence the type * or properties of the layer created. * * NONE: No hint. * SCROLLABLE: This layer may represent scrollable content. */ enum PaintedLayerCreationHint { NONE, SCROLLABLE }; /** * CONSTRUCTION PHASE ONLY * Create a PaintedLayer for this manager's layer tree. */ virtual already_AddRefed<PaintedLayer> CreatePaintedLayer() = 0; /** * CONSTRUCTION PHASE ONLY * Create a PaintedLayer for this manager's layer tree, with a creation hint * parameter to help optimise the type of layer created. */ virtual already_AddRefed<PaintedLayer> CreatePaintedLayerWithHint(PaintedLayerCreationHint) { return CreatePaintedLayer(); } /** * CONSTRUCTION PHASE ONLY * Create a ContainerLayer for this manager's layer tree. */ virtual already_AddRefed<ContainerLayer> CreateContainerLayer() = 0; /** * CONSTRUCTION PHASE ONLY * Create an ImageLayer for this manager's layer tree. */ virtual already_AddRefed<ImageLayer> CreateImageLayer() = 0; /** * CONSTRUCTION PHASE ONLY * Create a ColorLayer for this manager's layer tree. */ virtual already_AddRefed<ColorLayer> CreateColorLayer() = 0; /** * CONSTRUCTION PHASE ONLY * Create a CanvasLayer for this manager's layer tree. */ virtual already_AddRefed<CanvasLayer> CreateCanvasLayer() = 0; /** * CONSTRUCTION PHASE ONLY * Create a ReadbackLayer for this manager's layer tree. */ virtual already_AddRefed<ReadbackLayer> CreateReadbackLayer() { return nullptr; } /** * CONSTRUCTION PHASE ONLY * Create a RefLayer for this manager's layer tree. */ virtual already_AddRefed<RefLayer> CreateRefLayer() { return nullptr; } /** * Can be called anytime, from any thread. * * Creates an Image container which forwards its images to the compositor within * layer transactions on the main thread or asynchronously using the ImageBridge IPDL protocol. * In the case of asynchronous, If the protocol is not available, the returned ImageContainer * will forward images within layer transactions. */ static already_AddRefed<ImageContainer> CreateImageContainer(ImageContainer::Mode flag = ImageContainer::SYNCHRONOUS); /** * Type of layer manager his is. This is to be used sparsely in order to * avoid a lot of Layers backend specific code. It should be used only when * Layers backend specific functionality is necessary. */ virtual LayersBackend GetBackendType() = 0; /** * Type of layers backend that will be used to composite this layer tree. * When compositing is done remotely, then this returns the layers type * of the compositor. */ virtual LayersBackend GetCompositorBackendType() { return GetBackendType(); } /** * Creates a DrawTarget which is optimized for inter-operating with this * layer manager. */ virtual already_AddRefed<DrawTarget> CreateOptimalDrawTarget(const IntSize &aSize, SurfaceFormat imageFormat); /** * Creates a DrawTarget for alpha masks which is optimized for inter- * operating with this layer manager. In contrast to CreateOptimalDrawTarget, * this surface is optimised for drawing alpha only and we assume that * drawing the mask is fairly simple. */ virtual already_AddRefed<DrawTarget> CreateOptimalMaskDrawTarget(const IntSize &aSize); /** * Creates a DrawTarget for use with canvas which is optimized for * inter-operating with this layermanager. */ virtual already_AddRefed<mozilla::gfx::DrawTarget> CreateDrawTarget(const mozilla::gfx::IntSize &aSize, mozilla::gfx::SurfaceFormat aFormat); /** * Creates a PersistentBufferProvider for use with canvas which is optimized for * inter-operating with this layermanager. */ virtual already_AddRefed<PersistentBufferProvider> CreatePersistentBufferProvider(const mozilla::gfx::IntSize &aSize, mozilla::gfx::SurfaceFormat aFormat); virtual bool CanUseCanvasLayerForSize(const gfx::IntSize &aSize) { return true; } /** * returns the maximum texture size on this layer backend, or INT32_MAX * if there is no maximum */ virtual int32_t GetMaxTextureSize() const = 0; /** * Return the name of the layer manager's backend. */ virtual void GetBackendName(nsAString& aName) = 0; /** * This setter can be used anytime. The user data for all keys is * initially null. Ownership pases to the layer manager. */ void SetUserData(void* aKey, LayerUserData* aData) { mUserData.Add(static_cast<gfx::UserDataKey*>(aKey), aData, LayerUserDataDestroy); } /** * This can be used anytime. Ownership passes to the caller! */ UniquePtr<LayerUserData> RemoveUserData(void* aKey); /** * This getter can be used anytime. */ bool HasUserData(void* aKey) { return mUserData.Has(static_cast<gfx::UserDataKey*>(aKey)); } /** * This getter can be used anytime. Ownership is retained by the layer * manager. */ LayerUserData* GetUserData(void* aKey) const { return static_cast<LayerUserData*>(mUserData.Get(static_cast<gfx::UserDataKey*>(aKey))); } /** * Must be called outside of a layers transaction. * * For the subtree rooted at |aSubtree|, this attempts to free up * any free-able resources like retained buffers, but may do nothing * at all. After this call, the layer tree is left in an undefined * state; the layers in |aSubtree|'s subtree may no longer have * buffers with valid content and may no longer be able to draw * their visible and valid regions. * * In general, a painting or forwarding transaction on |this| must * complete on the tree before it returns to a valid state. * * Resource freeing begins from |aSubtree| or |mRoot| if |aSubtree| * is null. |aSubtree|'s manager must be this. */ virtual void ClearCachedResources(Layer* aSubtree = nullptr) {} /** * Flag the next paint as the first for a document. */ virtual void SetIsFirstPaint() {} /** * Make sure that the previous transaction has been entirely * completed. * * Note: This may sychronously wait on a remote compositor * to complete rendering. */ virtual void FlushRendering() { } /** * Checks if we need to invalidate the OS widget to trigger * painting when updating this layer manager. */ virtual bool NeedsWidgetInvalidation() { return true; } virtual const char* Name() const { return "???"; } /** * Dump information about this layer manager and its managed tree to * aStream. */ void Dump(std::stringstream& aStream, const char* aPrefix="", bool aDumpHtml=false, bool aSorted=false); /** * Dump information about just this layer manager itself to aStream */ void DumpSelf(std::stringstream& aStream, const char* aPrefix="", bool aSorted=false); void Dump(bool aSorted=false); /** * Dump information about this layer manager and its managed tree to * layerscope packet. */ void Dump(layerscope::LayersPacket* aPacket); /** * Log information about this layer manager and its managed tree to * the NSPR log (if enabled for "Layers"). */ void Log(const char* aPrefix=""); /** * Log information about just this layer manager itself to the NSPR * log (if enabled for "Layers"). */ void LogSelf(const char* aPrefix=""); /** * Record (and return) frame-intervals and paint-times for frames which were presented * between calling StartFrameTimeRecording and StopFrameTimeRecording. * * - Uses a cyclic buffer and serves concurrent consumers, so if Stop is called too late * (elements were overwritten since Start), result is considered invalid and hence empty. * - Buffer is capable of holding 10 seconds @ 60fps (or more if frames were less frequent). * Can be changed (up to 1 hour) via pref: toolkit.framesRecording.bufferSize. * - Note: the first frame-interval may be longer than expected because last frame * might have been presented some time before calling StartFrameTimeRecording. */ /** * Returns a handle which represents current recording start position. */ virtual uint32_t StartFrameTimeRecording(int32_t aBufferSize); /** * Clears, then populates aFrameIntervals with the recorded frame timing * data. The array will be empty if data was overwritten since * aStartIndex was obtained. */ virtual void StopFrameTimeRecording(uint32_t aStartIndex, nsTArray<float>& aFrameIntervals); void RecordFrame(); void PostPresent(); void BeginTabSwitch(); static bool IsLogEnabled(); static mozilla::LogModule* GetLog(); bool IsCompositingCheap(LayersBackend aBackend) { // LayersBackend::LAYERS_NONE is an error state, but in that case we should try to // avoid loading the compositor! return LayersBackend::LAYERS_BASIC != aBackend && LayersBackend::LAYERS_NONE != aBackend; } virtual bool IsCompositingCheap() { return true; } bool IsInTransaction() const { return mInTransaction; } virtual void GetFrameUniformity(FrameUniformityData* aOutData) { } virtual bool RequestOverfill(mozilla::dom::OverfillCallback* aCallback) { return true; } virtual void RunOverfillCallback(const uint32_t aOverfill) { } virtual void SetRegionToClear(const nsIntRegion& aRegion) { mRegionToClear = aRegion; } virtual float RequestProperty(const nsAString& property) { return -1; } const TimeStamp& GetAnimationReadyTime() const { return mAnimationReadyTime; } virtual bool AsyncPanZoomEnabled() const { return false; } static void LayerUserDataDestroy(void* data); void AddPaintedPixelCount(int32_t aCount) { mPaintedPixelCount += aCount; } uint32_t GetAndClearPaintedPixelCount() { uint32_t count = mPaintedPixelCount; mPaintedPixelCount = 0; return count; } protected: RefPtr<Layer> mRoot; gfx::UserData mUserData; bool mDestroyed; bool mSnapEffectiveTransforms; nsIntRegion mRegionToClear; // Protected destructor, to discourage deletion outside of Release(): virtual ~LayerManager() {} // Print interesting information about this into aStreamo. Internally // used to implement Dump*() and Log*(). virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix); // Print interesting information about this into layerscope packet. // Internally used to implement Dump(). virtual void DumpPacket(layerscope::LayersPacket* aPacket); uint64_t mId; bool mInTransaction; // The time when painting most recently finished. This is recorded so that // we can time any play-pending animations from this point. TimeStamp mAnimationReadyTime; // The count of pixels that were painted in the current transaction. uint32_t mPaintedPixelCount; private: struct FramesTimingRecording { // Stores state and data for frame intervals and paint times recording. // see LayerManager::StartFrameTimeRecording() at Layers.cpp for more details. FramesTimingRecording() : mNextIndex(0) , mLatestStartIndex(0) , mCurrentRunStartIndex(0) , mIsPaused(true) {} nsTArray<float> mIntervals; TimeStamp mLastFrameTime; uint32_t mNextIndex; uint32_t mLatestStartIndex; uint32_t mCurrentRunStartIndex; bool mIsPaused; }; FramesTimingRecording mRecording; TimeStamp mTabSwitchStart; public: /* * Methods to store/get/clear a "pending scroll info update" object on a * per-scrollid basis. This is used for empty transactions that push over * scroll position updates to the APZ code. */ void SetPendingScrollUpdateForNextTransaction(FrameMetrics::ViewID aScrollId, const ScrollUpdateInfo& aUpdateInfo); Maybe<ScrollUpdateInfo> GetPendingScrollInfoUpdate(FrameMetrics::ViewID aScrollId); void ClearPendingScrollInfoUpdate(); private: std::map<FrameMetrics::ViewID,ScrollUpdateInfo> mPendingScrollUpdates; }; typedef InfallibleTArray<Animation> AnimationArray; struct AnimData { InfallibleTArray<mozilla::StyleAnimationValue> mStartValues; InfallibleTArray<mozilla::StyleAnimationValue> mEndValues; InfallibleTArray<Maybe<mozilla::ComputedTimingFunction>> mFunctions; }; /** * A Layer represents anything that can be rendered onto a destination * surface. */ class Layer { NS_INLINE_DECL_REFCOUNTING(Layer) public: // Keep these in alphabetical order enum LayerType { TYPE_CANVAS, TYPE_COLOR, TYPE_CONTAINER, TYPE_IMAGE, TYPE_READBACK, TYPE_REF, TYPE_SHADOW, TYPE_PAINTED }; /** * Returns the LayerManager this Layer belongs to. Note that the layer * manager might be in a destroyed state, at which point it's only * valid to set/get user data from it. */ LayerManager* Manager() { return mManager; } enum { /** * If this is set, the caller is promising that by the end of this * transaction the entire visible region (as specified by * SetVisibleRegion) will be filled with opaque content. */ CONTENT_OPAQUE = 0x01, /** * If this is set, the caller is notifying that the contents of this layer * require per-component alpha for optimal fidelity. However, there is no * guarantee that component alpha will be supported for this layer at * paint time. * This should never be set at the same time as CONTENT_OPAQUE. */ CONTENT_COMPONENT_ALPHA = 0x02, /** * If this is set then one of the descendant layers of this one has * CONTENT_COMPONENT_ALPHA set. */ CONTENT_COMPONENT_ALPHA_DESCENDANT = 0x04, /** * If this is set then this layer is part of a preserve-3d group, and should * be sorted with sibling layers that are also part of the same group. */ CONTENT_EXTEND_3D_CONTEXT = 0x08, /** * This indicates that the transform may be changed on during an empty * transaction where there is no possibility of redrawing the content, so the * implementation should be ready for that. */ CONTENT_MAY_CHANGE_TRANSFORM = 0x10, /** * Disable subpixel AA for this layer. This is used if the display isn't suited * for subpixel AA like hidpi or rotated content. */ CONTENT_DISABLE_SUBPIXEL_AA = 0x20, /** * If this is set then the layer contains content that may look objectionable * if not handled as an active layer (such as text with an animated transform). * This is for internal layout/FrameLayerBuilder usage only until flattening * code is obsoleted. See bug 633097 */ CONTENT_DISABLE_FLATTENING = 0x40, /** * This layer is hidden if the backface of the layer is visible * to user. */ CONTENT_BACKFACE_HIDDEN = 0x80 }; /** * CONSTRUCTION PHASE ONLY * This lets layout make some promises about what will be drawn into the * visible region of the PaintedLayer. This enables internal quality * and performance optimizations. */ void SetContentFlags(uint32_t aFlags) { NS_ASSERTION((aFlags & (CONTENT_OPAQUE | CONTENT_COMPONENT_ALPHA)) != (CONTENT_OPAQUE | CONTENT_COMPONENT_ALPHA), "Can't be opaque and require component alpha"); if (mContentFlags != aFlags) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ContentFlags", this)); mContentFlags = aFlags; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * The union of the bounds of all the display item that got flattened * into this layer. This is intended to be an approximation to the * size of the layer if the nearest scrollable ancestor had an infinitely * large displayport. Computing this more exactly is too expensive, * but this approximation is sufficient for what we need to use it for. */ virtual void SetLayerBounds(const gfx::IntRect& aLayerBounds) { if (!mLayerBounds.IsEqualEdges(aLayerBounds)) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) LayerBounds", this)); mLayerBounds = aLayerBounds; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Tell this layer which region will be visible. The visible region * is a region which contains all the contents of the layer that can * actually affect the rendering of the window. It can exclude areas * that are covered by opaque contents of other layers, and it can * exclude areas where this layer simply contains no content at all. * (This can be an overapproximation to the "true" visible region.) * * There is no general guarantee that drawing outside the bounds of the * visible region will be ignored. So if a layer draws outside the bounds * of its visible region, it needs to ensure that what it draws is valid. */ virtual void SetVisibleRegion(const LayerIntRegion& aRegion) { // IsEmpty is required otherwise we get invalidation glitches. // See bug 1288464 for investigating why. if (!mVisibleRegion.IsEqual(aRegion) || aRegion.IsEmpty()) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) VisibleRegion was %s is %s", this, mVisibleRegion.ToString().get(), aRegion.ToString().get())); mVisibleRegion = aRegion; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Set the (sub)document metrics used to render the Layer subtree * rooted at this. Note that a layer may have multiple FrameMetrics * objects; calling this function will remove all of them and replace * them with the provided FrameMetrics. See the documentation for * SetFrameMetrics(const nsTArray<FrameMetrics>&) for more details. */ void SetScrollMetadata(const ScrollMetadata& aScrollMetadata) { Manager()->ClearPendingScrollInfoUpdate(); if (mScrollMetadata.Length() != 1 || mScrollMetadata[0] != aScrollMetadata) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) FrameMetrics", this)); mScrollMetadata.ReplaceElementsAt(0, mScrollMetadata.Length(), aScrollMetadata); ScrollMetadataChanged(); Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Set the (sub)document metrics used to render the Layer subtree * rooted at this. There might be multiple metrics on this layer * because the layer may, for example, be contained inside multiple * nested scrolling subdocuments. In general a Layer having multiple * ScrollMetadata objects is conceptually equivalent to having a stack * of ContainerLayers that have been flattened into this Layer. * See the documentation in LayerMetricsWrapper.h for a more detailed * explanation of this conceptual equivalence. * * Note also that there is actually a many-to-many relationship between * Layers and ScrollMetadata, because multiple Layers may have identical * ScrollMetadata objects. This happens when those layers belong to the * same scrolling subdocument and therefore end up with the same async * transform when they are scrolled by the APZ code. */ void SetScrollMetadata(const nsTArray<ScrollMetadata>& aMetadataArray) { Manager()->ClearPendingScrollInfoUpdate(); if (mScrollMetadata != aMetadataArray) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) FrameMetrics", this)); mScrollMetadata = aMetadataArray; ScrollMetadataChanged(); Mutated(); } } /* * Compositor event handling * ========================= * When a touch-start event (or similar) is sent to the AsyncPanZoomController, * it needs to decide whether the event should be sent to the main thread. * Each layer has a list of event handling regions. When the compositor needs * to determine how to handle a touch event, it scans the layer tree from top * to bottom in z-order (traversing children before their parents). Points * outside the clip region for a layer cause that layer (and its subtree) * to be ignored. If a layer has a mask layer, and that mask layer's alpha * value is zero at the event point, then the layer and its subtree should * be ignored. * For each layer, if the point is outside its hit region, we ignore the layer * and move onto the next. If the point is inside its hit region but * outside the dispatch-to-content region, we can initiate a gesture without * consulting the content thread. Otherwise we must dispatch the event to * content. * Note that if a layer or any ancestor layer has a ForceEmptyHitRegion * override in GetEventRegionsOverride() then the hit-region must be treated * as empty. Similarly, if there is a ForceDispatchToContent override then * the dispatch-to-content region must be treated as encompassing the entire * hit region, and therefore we must consult the content thread before * initiating a gesture. (If both flags are set, ForceEmptyHitRegion takes * priority.) */ /** * CONSTRUCTION PHASE ONLY * Set the event handling region. */ void SetEventRegions(const EventRegions& aRegions) { if (mEventRegions != aRegions) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) eventregions were %s, now %s", this, mEventRegions.ToString().get(), aRegions.ToString().get())); mEventRegions = aRegions; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Set the opacity which will be applied to this layer as it * is composited to the destination. */ void SetOpacity(float aOpacity) { if (mOpacity != aOpacity) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) Opacity", this)); mOpacity = aOpacity; Mutated(); } } void SetMixBlendMode(gfx::CompositionOp aMixBlendMode) { if (mMixBlendMode != aMixBlendMode) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) MixBlendMode", this)); mMixBlendMode = aMixBlendMode; Mutated(); } } void SetForceIsolatedGroup(bool aForceIsolatedGroup) { if(mForceIsolatedGroup != aForceIsolatedGroup) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ForceIsolatedGroup", this)); mForceIsolatedGroup = aForceIsolatedGroup; Mutated(); } } bool GetForceIsolatedGroup() const { return mForceIsolatedGroup; } /** * CONSTRUCTION PHASE ONLY * Set a clip rect which will be applied to this layer as it is * composited to the destination. The coordinates are relative to * the parent layer (i.e. the contents of this layer * are transformed before this clip rect is applied). * For the root layer, the coordinates are relative to the widget, * in device pixels. * If aRect is null no clipping will be performed. */ void SetClipRect(const Maybe<ParentLayerIntRect>& aRect) { if (mClipRect) { if (!aRect) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ClipRect was %d,%d,%d,%d is <none>", this, mClipRect->x, mClipRect->y, mClipRect->width, mClipRect->height)); mClipRect.reset(); Mutated(); } else { if (!aRect->IsEqualEdges(*mClipRect)) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ClipRect was %d,%d,%d,%d is %d,%d,%d,%d", this, mClipRect->x, mClipRect->y, mClipRect->width, mClipRect->height, aRect->x, aRect->y, aRect->width, aRect->height)); mClipRect = aRect; Mutated(); } } } else { if (aRect) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ClipRect was <none> is %d,%d,%d,%d", this, aRect->x, aRect->y, aRect->width, aRect->height)); mClipRect = aRect; Mutated(); } } } /** * CONSTRUCTION PHASE ONLY * Set an optional scrolled clip on the layer. * The scrolled clip, if present, consists of a clip rect and an optional mask. * This scrolled clip is always scrolled by all scroll frames associated with * this layer. (By contrast, the scroll clips stored in ScrollMetadata are * only scrolled by scroll frames above that ScrollMetadata, and the layer's * mClipRect is always fixed to the layer contents (which may or may not be * scrolled by some of the scroll frames associated with the layer, depending * on whether the layer is fixed).) */ void SetScrolledClip(const Maybe<LayerClip>& aScrolledClip) { if (mScrolledClip != aScrolledClip) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ScrolledClip", this)); mScrolledClip = aScrolledClip; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Set a layer to mask this layer. * * The mask layer should be applied using its effective transform (after it * is calculated by ComputeEffectiveTransformForMaskLayer), this should use * this layer's parent's transform and the mask layer's transform, but not * this layer's. That is, the mask layer is specified relative to this layer's * position in it's parent layer's coord space. * Currently, only 2D translations are supported for the mask layer transform. * * Ownership of aMaskLayer passes to this. * Typical use would be an ImageLayer with an alpha image used for masking. * See also ContainerState::BuildMaskLayer in FrameLayerBuilder.cpp. */ void SetMaskLayer(Layer* aMaskLayer) { #ifdef DEBUG if (aMaskLayer) { bool maskIs2D = aMaskLayer->GetTransform().CanDraw2D(); NS_ASSERTION(maskIs2D, "Mask layer has invalid transform."); } #endif if (mMaskLayer != aMaskLayer) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) MaskLayer", this)); mMaskLayer = aMaskLayer; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Add mask layers associated with LayerClips. */ void SetAncestorMaskLayers(const nsTArray<RefPtr<Layer>>& aLayers) { if (aLayers != mAncestorMaskLayers) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) AncestorMaskLayers", this)); mAncestorMaskLayers = aLayers; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Add a mask layer associated with a LayerClip. */ void AddAncestorMaskLayer(const RefPtr<Layer>& aLayer) { mAncestorMaskLayers.AppendElement(aLayer); Mutated(); } /** * CONSTRUCTION PHASE ONLY * Tell this layer what its transform should be. The transformation * is applied when compositing the layer into its parent container. */ void SetBaseTransform(const gfx::Matrix4x4& aMatrix) { NS_ASSERTION(!aMatrix.IsSingular(), "Shouldn't be trying to draw with a singular matrix!"); mPendingTransform = nullptr; if (mTransform == aMatrix) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) BaseTransform", this)); mTransform = aMatrix; Mutated(); } /** * Can be called at any time. * * Like SetBaseTransform(), but can be called before the next * transform (i.e. outside an open transaction). Semantically, this * method enqueues a new transform value to be set immediately after * the next transaction is opened. */ void SetBaseTransformForNextTransaction(const gfx::Matrix4x4& aMatrix) { mPendingTransform = new gfx::Matrix4x4(aMatrix); } void SetPostScale(float aXScale, float aYScale) { if (mPostXScale == aXScale && mPostYScale == aYScale) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) PostScale", this)); mPostXScale = aXScale; mPostYScale = aYScale; Mutated(); } /** * CONSTRUCTION PHASE ONLY * A layer is "fixed position" when it draws content from a content * (not chrome) document, the topmost content document has a root scrollframe * with a displayport, but the layer does not move when that displayport scrolls. */ void SetIsFixedPosition(bool aFixedPosition) { if (mIsFixedPosition != aFixedPosition) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) IsFixedPosition", this)); mIsFixedPosition = aFixedPosition; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * This flag is true when the transform on the layer is a perspective * transform. The compositor treats perspective transforms specially * for async scrolling purposes. */ void SetTransformIsPerspective(bool aTransformIsPerspective) { if (mTransformIsPerspective != aTransformIsPerspective) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) TransformIsPerspective", this)); mTransformIsPerspective = aTransformIsPerspective; Mutated(); } } // Call AddAnimation to add a new animation to this layer from layout code. // Caller must fill in all the properties of the returned animation. // A later animation overrides an earlier one. Animation* AddAnimation(); // ClearAnimations clears animations on this layer. void ClearAnimations(); // This is only called when the layer tree is updated. Do not call this from // layout code. To add an animation to this layer, use AddAnimation. void SetAnimations(const AnimationArray& aAnimations); // Go through all animations in this layer and its children and, for // any animations with a null start time, update their start time such // that at |aReadyTime| the animation's current time corresponds to its // 'initial current time' value. void StartPendingAnimations(const TimeStamp& aReadyTime); // These are a parallel to AddAnimation and clearAnimations, except // they add pending animations that apply only when the next // transaction is begun. (See also // SetBaseTransformForNextTransaction.) Animation* AddAnimationForNextTransaction(); void ClearAnimationsForNextTransaction(); /** * CONSTRUCTION PHASE ONLY * If a layer represents a fixed position element, this data is stored on the * layer for use by the compositor. * * - |aScrollId| identifies the scroll frame that this element is fixed * with respect to. * * - |aAnchor| is the point on the layer that is considered the "anchor" * point, that is, the point which remains in the same position when * compositing the layer tree with a transformation (such as when * asynchronously scrolling and zooming). * * - |aSides| is the set of sides to which the element is fixed relative to. * This is used if the viewport size is changed in the compositor and * fixed position items need to shift accordingly. This value is made up * combining appropriate values from mozilla::SideBits. */ void SetFixedPositionData(FrameMetrics::ViewID aScrollId, const LayerPoint& aAnchor, int32_t aSides) { if (!mFixedPositionData || mFixedPositionData->mScrollId != aScrollId || mFixedPositionData->mAnchor != aAnchor || mFixedPositionData->mSides != aSides) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) FixedPositionData", this)); if (!mFixedPositionData) { mFixedPositionData = MakeUnique<FixedPositionData>(); } mFixedPositionData->mScrollId = aScrollId; mFixedPositionData->mAnchor = aAnchor; mFixedPositionData->mSides = aSides; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * If a layer is "sticky position", |aScrollId| holds the scroll identifier * of the scrollable content that contains it. The difference between the two * rectangles |aOuter| and |aInner| is treated as two intervals in each * dimension, with the current scroll position at the origin. For each * dimension, while that component of the scroll position lies within either * interval, the layer should not move relative to its scrolling container. */ void SetStickyPositionData(FrameMetrics::ViewID aScrollId, LayerRect aOuter, LayerRect aInner) { if (!mStickyPositionData || !mStickyPositionData->mOuter.IsEqualEdges(aOuter) || !mStickyPositionData->mInner.IsEqualEdges(aInner)) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) StickyPositionData", this)); if (!mStickyPositionData) { mStickyPositionData = new StickyPositionData; } mStickyPositionData->mScrollId = aScrollId; mStickyPositionData->mOuter = aOuter; mStickyPositionData->mInner = aInner; Mutated(); } } enum ScrollDirection { NONE, VERTICAL, HORIZONTAL }; /** * CONSTRUCTION PHASE ONLY * If a layer is a scrollbar layer, |aScrollId| holds the scroll identifier * of the scrollable content that the scrollbar is for. */ void SetScrollbarData(FrameMetrics::ViewID aScrollId, ScrollDirection aDir, float aThumbRatio) { if (mScrollbarTargetId != aScrollId || mScrollbarDirection != aDir || mScrollbarThumbRatio != aThumbRatio) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ScrollbarData", this)); mScrollbarTargetId = aScrollId; mScrollbarDirection = aDir; mScrollbarThumbRatio = aThumbRatio; Mutated(); } } // Set during construction for the container layer of scrollbar components. void SetIsScrollbarContainer() { if (!mIsScrollbarContainer) { mIsScrollbarContainer = true; Mutated(); } } // These getters can be used anytime. float GetOpacity() { return mOpacity; } gfx::CompositionOp GetMixBlendMode() const { return mMixBlendMode; } const Maybe<ParentLayerIntRect>& GetClipRect() const { return mClipRect; } const Maybe<LayerClip>& GetScrolledClip() const { return mScrolledClip; } Maybe<ParentLayerIntRect> GetScrolledClipRect() const; uint32_t GetContentFlags() { return mContentFlags; } const gfx::IntRect& GetLayerBounds() const { return mLayerBounds; } const LayerIntRegion& GetVisibleRegion() const { return mVisibleRegion; } const ScrollMetadata& GetScrollMetadata(uint32_t aIndex) const; const FrameMetrics& GetFrameMetrics(uint32_t aIndex) const; uint32_t GetScrollMetadataCount() const { return mScrollMetadata.Length(); } const nsTArray<ScrollMetadata>& GetAllScrollMetadata() { return mScrollMetadata; } bool HasScrollableFrameMetrics() const; bool IsScrollInfoLayer() const; const EventRegions& GetEventRegions() const { return mEventRegions; } ContainerLayer* GetParent() { return mParent; } Layer* GetNextSibling() { if (mNextSibling) { mNextSibling->CheckCanary(); } return mNextSibling; } const Layer* GetNextSibling() const { if (mNextSibling) { mNextSibling->CheckCanary(); } return mNextSibling; } Layer* GetPrevSibling() { return mPrevSibling; } const Layer* GetPrevSibling() const { return mPrevSibling; } virtual Layer* GetFirstChild() const { return nullptr; } virtual Layer* GetLastChild() const { return nullptr; } gfx::Matrix4x4 GetTransform() const; // Same as GetTransform(), but returns the transform as a strongly-typed // matrix. Eventually this will replace GetTransform(). const CSSTransformMatrix GetTransformTyped() const; const gfx::Matrix4x4& GetBaseTransform() const { return mTransform; } // Note: these are virtual because ContainerLayerComposite overrides them. virtual float GetPostXScale() const { return mPostXScale; } virtual float GetPostYScale() const { return mPostYScale; } bool GetIsFixedPosition() { return mIsFixedPosition; } bool GetTransformIsPerspective() const { return mTransformIsPerspective; } bool GetIsStickyPosition() { return mStickyPositionData; } FrameMetrics::ViewID GetFixedPositionScrollContainerId() { return mFixedPositionData ? mFixedPositionData->mScrollId : FrameMetrics::NULL_SCROLL_ID; } LayerPoint GetFixedPositionAnchor() { return mFixedPositionData ? mFixedPositionData->mAnchor : LayerPoint(); } int32_t GetFixedPositionSides() { return mFixedPositionData ? mFixedPositionData->mSides : eSideBitsNone; } FrameMetrics::ViewID GetStickyScrollContainerId() { return mStickyPositionData->mScrollId; } const LayerRect& GetStickyScrollRangeOuter() { return mStickyPositionData->mOuter; } const LayerRect& GetStickyScrollRangeInner() { return mStickyPositionData->mInner; } FrameMetrics::ViewID GetScrollbarTargetContainerId() { return mScrollbarTargetId; } ScrollDirection GetScrollbarDirection() { return mScrollbarDirection; } float GetScrollbarThumbRatio() { return mScrollbarThumbRatio; } bool IsScrollbarContainer() { return mIsScrollbarContainer; } Layer* GetMaskLayer() const { return mMaskLayer; } void CheckCanary() const { mCanary.Check(); } // Ancestor mask layers are associated with FrameMetrics, but for simplicity // in maintaining the layer tree structure we attach them to the layer. size_t GetAncestorMaskLayerCount() const { return mAncestorMaskLayers.Length(); } Layer* GetAncestorMaskLayerAt(size_t aIndex) const { return mAncestorMaskLayers.ElementAt(aIndex); } const nsTArray<RefPtr<Layer>>& GetAllAncestorMaskLayers() const { return mAncestorMaskLayers; } bool HasMaskLayers() const { return GetMaskLayer() || mAncestorMaskLayers.Length() > 0; } /* * Get the combined clip rect of the Layer clip and all clips on FrameMetrics. * This is intended for use in Layout. The compositor needs to apply async * transforms to find the combined clip. */ Maybe<ParentLayerIntRect> GetCombinedClipRect() const; /** * Retrieve the root level visible region for |this| taking into account * clipping applied to parent layers of |this| as well as subtracting * visible regions of higher siblings of this layer and each ancestor. * * Note translation values for offsets of visible regions and accumulated * aLayerOffset are integer rounded using IntPoint::Round. * * @param aResult - the resulting visible region of this layer. * @param aLayerOffset - this layer's total offset from the root layer. * @return - false if during layer tree traversal a parent or sibling * transform is found to be non-translational. This method returns early * in this case, results will not be valid. Returns true on successful * traversal. */ bool GetVisibleRegionRelativeToRootLayer(nsIntRegion& aResult, nsIntPoint* aLayerOffset); // Note that all lengths in animation data are either in CSS pixels or app // units and must be converted to device pixels by the compositor. AnimationArray& GetAnimations() { return mAnimations; } InfallibleTArray<AnimData>& GetAnimationData() { return mAnimationData; } uint64_t GetAnimationGeneration() { return mAnimationGeneration; } void SetAnimationGeneration(uint64_t aCount) { mAnimationGeneration = aCount; } bool HasTransformAnimation() const; /** * Returns the local transform for this layer: either mTransform or, * for shadow layers, GetShadowBaseTransform(), in either case with the * pre- and post-scales applied. */ gfx::Matrix4x4 GetLocalTransform(); /** * Same as GetLocalTransform(), but returns a strongly-typed matrix. * Eventually, this will replace GetLocalTransform(). */ const LayerToParentLayerMatrix4x4 GetLocalTransformTyped(); /** * Returns the local opacity for this layer: either mOpacity or, * for shadow layers, GetShadowOpacity() */ float GetLocalOpacity(); /** * DRAWING PHASE ONLY * * Apply pending changes to layers before drawing them, if those * pending changes haven't been overridden by later changes. */ void ApplyPendingUpdatesToSubtree(); /** * DRAWING PHASE ONLY * * Write layer-subtype-specific attributes into aAttrs. Used to * synchronize layer attributes to their shadows'. */ virtual void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) { } // Returns true if it's OK to save the contents of aLayer in an // opaque surface (a surface without an alpha channel). // If we can use a surface without an alpha channel, we should, because // it will often make painting of antialiased text faster and higher // quality. bool CanUseOpaqueSurface(); SurfaceMode GetSurfaceMode() { if (CanUseOpaqueSurface()) return SurfaceMode::SURFACE_OPAQUE; if (mContentFlags & CONTENT_COMPONENT_ALPHA) return SurfaceMode::SURFACE_COMPONENT_ALPHA; return SurfaceMode::SURFACE_SINGLE_CHANNEL_ALPHA; } // Returns true if this layer can be treated as opaque for visibility // computation. A layer may be non-opaque for visibility even if it // is not transparent, for example, if it has a mix-blend-mode. bool IsOpaqueForVisibility(); /** * This setter can be used anytime. The user data for all keys is * initially null. Ownership pases to the layer manager. */ void SetUserData(void* aKey, LayerUserData* aData) { mUserData.Add(static_cast<gfx::UserDataKey*>(aKey), aData, LayerManager::LayerUserDataDestroy); } /** * This can be used anytime. Ownership passes to the caller! */ UniquePtr<LayerUserData> RemoveUserData(void* aKey); /** * This getter can be used anytime. */ bool HasUserData(void* aKey) { return mUserData.Has(static_cast<gfx::UserDataKey*>(aKey)); } /** * This getter can be used anytime. Ownership is retained by the layer * manager. */ LayerUserData* GetUserData(void* aKey) const { return static_cast<LayerUserData*>(mUserData.Get(static_cast<gfx::UserDataKey*>(aKey))); } /** * |Disconnect()| is used by layers hooked up over IPC. It may be * called at any time, and may not be called at all. Using an * IPC-enabled layer after Destroy() (drawing etc.) results in a * safe no-op; no crashy or uaf etc. * * XXX: this interface is essentially LayerManager::Destroy, but at * Layer granularity. It might be beneficial to unify them. */ virtual void Disconnect() {} /** * Dynamic downcast to a PaintedLayer. Returns null if this is not * a PaintedLayer. */ virtual PaintedLayer* AsPaintedLayer() { return nullptr; } /** * Dynamic cast to a ContainerLayer. Returns null if this is not * a ContainerLayer. */ virtual ContainerLayer* AsContainerLayer() { return nullptr; } virtual const ContainerLayer* AsContainerLayer() const { return nullptr; } /** * Dynamic cast to a RefLayer. Returns null if this is not a * RefLayer. */ virtual RefLayer* AsRefLayer() { return nullptr; } /** * Dynamic cast to a Color. Returns null if this is not a * ColorLayer. */ virtual ColorLayer* AsColorLayer() { return nullptr; } /** * Dynamic cast to a LayerComposite. Return null if this is not a * LayerComposite. Can be used anytime. */ virtual LayerComposite* AsLayerComposite() { return nullptr; } /** * Dynamic cast to a ShadowableLayer. Return null if this is not a * ShadowableLayer. Can be used anytime. */ virtual ShadowableLayer* AsShadowableLayer() { return nullptr; } // These getters can be used anytime. They return the effective // values that should be used when drawing this layer to screen, // accounting for this layer possibly being a shadow. const Maybe<ParentLayerIntRect>& GetLocalClipRect(); const LayerIntRegion& GetLocalVisibleRegion(); bool Extend3DContext() { return GetContentFlags() & CONTENT_EXTEND_3D_CONTEXT; } bool Combines3DTransformWithAncestors() { return GetParent() && reinterpret_cast<Layer*>(GetParent())->Extend3DContext(); } bool Is3DContextLeaf() { return !Extend3DContext() && Combines3DTransformWithAncestors(); } /** * It is true if the user can see the back of the layer and the * backface is hidden. The compositor should skip the layer if the * result is true. */ bool IsBackfaceHidden(); bool IsVisible() { // For containers extending 3D context, visible region // is meaningless, since they are just intermediate result of // content. return !GetLocalVisibleRegion().IsEmpty() || Extend3DContext(); } /** * Return true if current layer content is opaque. * It does not guarantee that layer content is always opaque. */ virtual bool IsOpaque() { return GetContentFlags() & CONTENT_OPAQUE; } /** * Returns the product of the opacities of this layer and all ancestors up * to and excluding the nearest ancestor that has UseIntermediateSurface() set. */ float GetEffectiveOpacity(); /** * Returns the blendmode of this layer. */ gfx::CompositionOp GetEffectiveMixBlendMode(); /** * This returns the effective transform computed by * ComputeEffectiveTransforms. Typically this is a transform that transforms * this layer all the way to some intermediate surface or destination * surface. For non-BasicLayers this will be a transform to the nearest * ancestor with UseIntermediateSurface() (or to the root, if there is no * such ancestor), but for BasicLayers it's different. */ const gfx::Matrix4x4& GetEffectiveTransform() const { return mEffectiveTransform; } /** * This returns the effective transform for Layer's buffer computed by * ComputeEffectiveTransforms. Typically this is a transform that transforms * this layer's buffer all the way to some intermediate surface or destination * surface. For non-BasicLayers this will be a transform to the nearest * ancestor with UseIntermediateSurface() (or to the root, if there is no * such ancestor), but for BasicLayers it's different. * * By default, its value is same to GetEffectiveTransform(). * When ImageLayer is rendered with ScaleMode::STRETCH, * it becomes different from GetEffectiveTransform(). */ virtual const gfx::Matrix4x4& GetEffectiveTransformForBuffer() const { return mEffectiveTransform; } /** * @param aTransformToSurface the composition of the transforms * from the parent layer (if any) to the destination pixel grid. * * Computes mEffectiveTransform for this layer and all its descendants. * mEffectiveTransform transforms this layer up to the destination * pixel grid (whatever aTransformToSurface is relative to). * * We promise that when this is called on a layer, all ancestor layers * have already had ComputeEffectiveTransforms called. */ virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) = 0; /** * Computes the effective transform for mask layers, if this layer has any. */ void ComputeEffectiveTransformForMaskLayers(const gfx::Matrix4x4& aTransformToSurface); static void ComputeEffectiveTransformForMaskLayer(Layer* aMaskLayer, const gfx::Matrix4x4& aTransformToSurface); /** * Calculate the scissor rect required when rendering this layer. * Returns a rectangle relative to the intermediate surface belonging to the * nearest ancestor that has an intermediate surface, or relative to the root * viewport if no ancestor has an intermediate surface, corresponding to the * clip rect for this layer intersected with aCurrentScissorRect. */ RenderTargetIntRect CalculateScissorRect(const RenderTargetIntRect& aCurrentScissorRect); virtual const char* Name() const =0; virtual LayerType GetType() const =0; /** * Only the implementation should call this. This is per-implementation * private data. Normally, all layers with a given layer manager * use the same type of ImplData. */ void* ImplData() { return mImplData; } /** * Only the implementation should use these methods. */ void SetParent(ContainerLayer* aParent) { mParent = aParent; } void SetNextSibling(Layer* aSibling) { mNextSibling = aSibling; } void SetPrevSibling(Layer* aSibling) { mPrevSibling = aSibling; } /** * Dump information about this layer manager and its managed tree to * aStream. */ void Dump(std::stringstream& aStream, const char* aPrefix="", bool aDumpHtml=false, bool aSorted=false); /** * Dump information about just this layer manager itself to aStream. */ void DumpSelf(std::stringstream& aStream, const char* aPrefix=""); /** * Dump information about this layer and its child & sibling layers to * layerscope packet. */ void Dump(layerscope::LayersPacket* aPacket, const void* aParent); /** * Log information about this layer manager and its managed tree to * the NSPR log (if enabled for "Layers"). */ void Log(const char* aPrefix=""); /** * Log information about just this layer manager itself to the NSPR * log (if enabled for "Layers"). */ void LogSelf(const char* aPrefix=""); // Print interesting information about this into aStream. Internally // used to implement Dump*() and Log*(). If subclasses have // additional interesting properties, they should override this with // an implementation that first calls the base implementation then // appends additional info to aTo. virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix); // Just like PrintInfo, but this function dump information into layerscope packet, // instead of a StringStream. It is also internally used to implement Dump(); virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent); /** * Store display list log. */ void SetDisplayListLog(const char *log); /** * Return display list log. */ void GetDisplayListLog(nsCString& log); static bool IsLogEnabled() { return LayerManager::IsLogEnabled(); } /** * Returns the current area of the layer (in layer-space coordinates) * marked as needed to be recomposited. */ const virtual gfx::TiledIntRegion& GetInvalidRegion() { return mInvalidRegion; } void AddInvalidRegion(const nsIntRegion& aRegion) { mInvalidRegion.Add(aRegion); } /** * Mark the entirety of the layer's visible region as being invalid. */ void SetInvalidRectToVisibleRegion() { mInvalidRegion.SetEmpty(); mInvalidRegion.Add(GetVisibleRegion().ToUnknownRegion()); } /** * Adds to the current invalid rect. */ void AddInvalidRect(const gfx::IntRect& aRect) { mInvalidRegion.Add(aRect); } /** * Clear the invalid rect, marking the layer as being identical to what is currently * composited. */ void ClearInvalidRect() { mInvalidRegion.SetEmpty(); } // These functions allow attaching an AsyncPanZoomController to this layer, // and can be used anytime. // A layer has an APZC at index aIndex only-if GetFrameMetrics(aIndex).IsScrollable(); // attempting to get an APZC for a non-scrollable metrics will return null. // The aIndex for these functions must be less than GetScrollMetadataCount(). void SetAsyncPanZoomController(uint32_t aIndex, AsyncPanZoomController *controller); AsyncPanZoomController* GetAsyncPanZoomController(uint32_t aIndex) const; // The ScrollMetadataChanged function is used internally to ensure the APZC array length // matches the frame metrics array length. private: void ScrollMetadataChanged(); public: void ApplyPendingUpdatesForThisTransaction(); #ifdef DEBUG void SetDebugColorIndex(uint32_t aIndex) { mDebugColorIndex = aIndex; } uint32_t GetDebugColorIndex() { return mDebugColorIndex; } #endif virtual LayerRenderState GetRenderState() { return LayerRenderState(); } void Mutated() { mManager->Mutated(this); } virtual int32_t GetMaxLayerSize() { return Manager()->GetMaxTextureSize(); } /** * Returns true if this layer's effective transform is not just * a translation by integers, or if this layer or some ancestor layer * is marked as having a transform that may change without a full layer * transaction. */ bool MayResample(); RenderTargetRect TransformRectToRenderTarget(const LayerIntRect& aRect); /** * Add debugging information to the layer dump. */ void AddExtraDumpInfo(const nsACString& aStr) { #ifdef MOZ_DUMP_PAINTING mExtraDumpInfo.AppendElement(aStr); #endif } /** * Clear debugging information. Useful for recycling. */ void ClearExtraDumpInfo() { #ifdef MOZ_DUMP_PAINTING mExtraDumpInfo.Clear(); #endif } protected: Layer(LayerManager* aManager, void* aImplData); // Protected destructor, to discourage deletion outside of Release(): virtual ~Layer(); /** * We can snap layer transforms for two reasons: * 1) To avoid unnecessary resampling when a transform is a translation * by a non-integer number of pixels. * Snapping the translation to an integer number of pixels avoids * blurring the layer and can be faster to composite. * 2) When a layer is used to render a rectangular object, we need to * emulate the rendering of rectangular inactive content and snap the * edges of the rectangle to pixel boundaries. This is both to ensure * layer rendering is consistent with inactive content rendering, and to * avoid seams. * This function implements type 1 snapping. If aTransform is a 2D * translation, and this layer's layer manager has enabled snapping * (which is the default), return aTransform with the translation snapped * to nearest pixels. Otherwise just return aTransform. Call this when the * layer does not correspond to a single rectangular content object. * This function does not try to snap if aTransform has a scale, because in * that case resampling is inevitable and there's no point in trying to * avoid it. In fact snapping can cause problems because pixel edges in the * layer's content can be rendered unpredictably (jiggling) as the scale * interacts with the snapping of the translation, especially with animated * transforms. * @param aResidualTransform a transform to apply before the result transform * in order to get the results to completely match aTransform. */ gfx::Matrix4x4 SnapTransformTranslation(const gfx::Matrix4x4& aTransform, gfx::Matrix* aResidualTransform); gfx::Matrix4x4 SnapTransformTranslation3D(const gfx::Matrix4x4& aTransform, gfx::Matrix* aResidualTransform); /** * See comment for SnapTransformTranslation. * This function implements type 2 snapping. If aTransform is a translation * and/or scale, transform aSnapRect by aTransform, snap to pixel boundaries, * and return the transform that maps aSnapRect to that rect. Otherwise * just return aTransform. * @param aSnapRect a rectangle whose edges should be snapped to pixel * boundaries in the destination surface. * @param aResidualTransform a transform to apply before the result transform * in order to get the results to completely match aTransform. */ gfx::Matrix4x4 SnapTransform(const gfx::Matrix4x4& aTransform, const gfxRect& aSnapRect, gfx::Matrix* aResidualTransform); LayerManager* mManager; ContainerLayer* mParent; Layer* mNextSibling; Layer* mPrevSibling; void* mImplData; RefPtr<Layer> mMaskLayer; nsTArray<RefPtr<Layer>> mAncestorMaskLayers; // Look for out-of-bound in the middle of the structure mozilla::CorruptionCanary mCanary; gfx::UserData mUserData; gfx::IntRect mLayerBounds; LayerIntRegion mVisibleRegion; nsTArray<ScrollMetadata> mScrollMetadata; EventRegions mEventRegions; gfx::Matrix4x4 mTransform; // A mutation of |mTransform| that we've queued to be applied at the // end of the next transaction (if nothing else overrides it in the // meantime). nsAutoPtr<gfx::Matrix4x4> mPendingTransform; float mPostXScale; float mPostYScale; gfx::Matrix4x4 mEffectiveTransform; AnimationArray mAnimations; // See mPendingTransform above. nsAutoPtr<AnimationArray> mPendingAnimations; InfallibleTArray<AnimData> mAnimationData; float mOpacity; gfx::CompositionOp mMixBlendMode; bool mForceIsolatedGroup; Maybe<ParentLayerIntRect> mClipRect; Maybe<LayerClip> mScrolledClip; gfx::IntRect mTileSourceRect; gfx::TiledIntRegion mInvalidRegion; nsTArray<RefPtr<AsyncPanZoomController> > mApzcs; uint32_t mContentFlags; bool mUseTileSourceRect; bool mIsFixedPosition; bool mTransformIsPerspective; struct FixedPositionData { FrameMetrics::ViewID mScrollId; LayerPoint mAnchor; int32_t mSides; }; UniquePtr<FixedPositionData> mFixedPositionData; struct StickyPositionData { FrameMetrics::ViewID mScrollId; LayerRect mOuter; LayerRect mInner; }; nsAutoPtr<StickyPositionData> mStickyPositionData; FrameMetrics::ViewID mScrollbarTargetId; ScrollDirection mScrollbarDirection; // The scrollbar thumb ratio is the ratio of the thumb position (in the CSS // pixels of the scrollframe's parent's space) to the scroll position (in the // CSS pixels of the scrollframe's space). float mScrollbarThumbRatio; bool mIsScrollbarContainer; #ifdef DEBUG uint32_t mDebugColorIndex; #endif // If this layer is used for OMTA, then this counter is used to ensure we // stay in sync with the animation manager uint64_t mAnimationGeneration; #ifdef MOZ_DUMP_PAINTING nsTArray<nsCString> mExtraDumpInfo; #endif // Store display list log. nsCString mDisplayListLog; }; /** * A Layer which we can paint into. It is a conceptually * infinite surface, but each PaintedLayer has an associated "valid region" * of contents that it is currently storing, which is finite. PaintedLayer * implementations can store content between paints. * * PaintedLayers are rendered into during the drawing phase of a transaction. * * Currently the contents of a PaintedLayer are in the device output color * space. */ class PaintedLayer : public Layer { public: /** * CONSTRUCTION PHASE ONLY * Tell this layer that the content in some region has changed and * will need to be repainted. This area is removed from the valid * region. */ virtual void InvalidateRegion(const nsIntRegion& aRegion) = 0; /** * CONSTRUCTION PHASE ONLY * Set whether ComputeEffectiveTransforms should compute the * "residual translation" --- the translation that should be applied *before* * mEffectiveTransform to get the ideal transform for this PaintedLayer. * When this is true, ComputeEffectiveTransforms will compute the residual * and ensure that the layer is invalidated whenever the residual changes. * When it's false, a change in the residual will not trigger invalidation * and GetResidualTranslation will return 0,0. * So when the residual is to be ignored, set this to false for better * performance. */ void SetAllowResidualTranslation(bool aAllow) { mAllowResidualTranslation = aAllow; } /** * Can be used anytime */ const nsIntRegion& GetValidRegion() const { return mValidRegion; } virtual PaintedLayer* AsPaintedLayer() override { return this; } MOZ_LAYER_DECL_NAME("PaintedLayer", TYPE_PAINTED) virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) override { gfx::Matrix4x4 idealTransform = GetLocalTransform() * aTransformToSurface; gfx::Matrix residual; mEffectiveTransform = SnapTransformTranslation(idealTransform, mAllowResidualTranslation ? &residual : nullptr); // The residual can only be a translation because SnapTransformTranslation // only changes the transform if it's a translation NS_ASSERTION(residual.IsTranslation(), "Residual transform can only be a translation"); if (!gfx::ThebesPoint(residual.GetTranslation()).WithinEpsilonOf(mResidualTranslation, 1e-3f)) { mResidualTranslation = gfx::ThebesPoint(residual.GetTranslation()); DebugOnly<mozilla::gfx::Point> transformedOrig = idealTransform.TransformPoint(mozilla::gfx::Point()); #ifdef DEBUG DebugOnly<mozilla::gfx::Point> transformed = idealTransform.TransformPoint( mozilla::gfx::Point(mResidualTranslation.x, mResidualTranslation.y) ) - *&transformedOrig; #endif NS_ASSERTION(-0.5 <= (&transformed)->x && (&transformed)->x < 0.5 && -0.5 <= (&transformed)->y && (&transformed)->y < 0.5, "Residual translation out of range"); mValidRegion.SetEmpty(); } ComputeEffectiveTransformForMaskLayers(aTransformToSurface); } LayerManager::PaintedLayerCreationHint GetCreationHint() const { return mCreationHint; } bool UsedForReadback() { return mUsedForReadback; } void SetUsedForReadback(bool aUsed) { mUsedForReadback = aUsed; } /** * Returns true if aLayer is optimized for the given PaintedLayerCreationHint. */ virtual bool IsOptimizedFor(LayerManager::PaintedLayerCreationHint aCreationHint) { return true; } /** * Returns the residual translation. Apply this translation when drawing * into the PaintedLayer so that when mEffectiveTransform is applied afterwards * by layer compositing, the results exactly match the "ideal transform" * (the product of the transform of this layer and its ancestors). * Returns 0,0 unless SetAllowResidualTranslation(true) has been called. * The residual translation components are always in the range [-0.5, 0.5). */ gfxPoint GetResidualTranslation() const { return mResidualTranslation; } protected: PaintedLayer(LayerManager* aManager, void* aImplData, LayerManager::PaintedLayerCreationHint aCreationHint = LayerManager::NONE) : Layer(aManager, aImplData) , mValidRegion() , mCreationHint(aCreationHint) , mUsedForReadback(false) , mAllowResidualTranslation(false) { mContentFlags = 0; // Clear NO_TEXT, NO_TEXT_OVER_TRANSPARENT } virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override; /** * ComputeEffectiveTransforms snaps the ideal transform to get mEffectiveTransform. * mResidualTranslation is the translation that should be applied *before* * mEffectiveTransform to get the ideal transform. */ gfxPoint mResidualTranslation; nsIntRegion mValidRegion; /** * The creation hint that was used when constructing this layer. */ const LayerManager::PaintedLayerCreationHint mCreationHint; /** * Set when this PaintedLayer is participating in readback, i.e. some * ReadbackLayer (may) be getting its background from this layer. */ bool mUsedForReadback; /** * True when */ bool mAllowResidualTranslation; }; /** * A Layer which other layers render into. It holds references to its * children. */ class ContainerLayer : public Layer { public: ~ContainerLayer(); /** * CONSTRUCTION PHASE ONLY * Insert aChild into the child list of this container. aChild must * not be currently in any child list or the root for the layer manager. * If aAfter is non-null, it must be a child of this container and * we insert after that layer. If it's null we insert at the start. */ virtual bool InsertAfter(Layer* aChild, Layer* aAfter); /** * CONSTRUCTION PHASE ONLY * Remove aChild from the child list of this container. aChild must * be a child of this container. */ virtual bool RemoveChild(Layer* aChild); /** * CONSTRUCTION PHASE ONLY * Reposition aChild from the child list of this container. aChild must * be a child of this container. * If aAfter is non-null, it must be a child of this container and we * reposition after that layer. If it's null, we reposition at the start. */ virtual bool RepositionChild(Layer* aChild, Layer* aAfter); void SetPreScale(float aXScale, float aYScale) { if (mPreXScale == aXScale && mPreYScale == aYScale) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) PreScale", this)); mPreXScale = aXScale; mPreYScale = aYScale; Mutated(); } void SetInheritedScale(float aXScale, float aYScale) { if (mInheritedXScale == aXScale && mInheritedYScale == aYScale) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) InheritedScale", this)); mInheritedXScale = aXScale; mInheritedYScale = aYScale; Mutated(); } void SetScaleToResolution(bool aScaleToResolution, float aResolution) { if (mScaleToResolution == aScaleToResolution && mPresShellResolution == aResolution) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ScaleToResolution", this)); mScaleToResolution = aScaleToResolution; mPresShellResolution = aResolution; Mutated(); } virtual void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) override; void SortChildrenBy3DZOrder(nsTArray<Layer*>& aArray); // These getters can be used anytime. virtual ContainerLayer* AsContainerLayer() override { return this; } virtual const ContainerLayer* AsContainerLayer() const override { return this; } virtual Layer* GetFirstChild() const override { return mFirstChild; } virtual Layer* GetLastChild() const override { return mLastChild; } float GetPreXScale() const { return mPreXScale; } float GetPreYScale() const { return mPreYScale; } float GetInheritedXScale() const { return mInheritedXScale; } float GetInheritedYScale() const { return mInheritedYScale; } float GetPresShellResolution() const { return mPresShellResolution; } bool ScaleToResolution() const { return mScaleToResolution; } MOZ_LAYER_DECL_NAME("ContainerLayer", TYPE_CONTAINER) /** * ContainerLayer backends need to override ComputeEffectiveTransforms * since the decision about whether to use a temporary surface for the * container is backend-specific. ComputeEffectiveTransforms must also set * mUseIntermediateSurface. */ virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) override = 0; /** * Call this only after ComputeEffectiveTransforms has been invoked * on this layer. * Returns true if this will use an intermediate surface. This is largely * backend-dependent, but it affects the operation of GetEffectiveOpacity(). */ bool UseIntermediateSurface() { return mUseIntermediateSurface; } /** * Returns the rectangle covered by the intermediate surface, * in this layer's coordinate system. * * NOTE: Since this layer has an intermediate surface it follows * that LayerPixel == RenderTargetPixel */ RenderTargetIntRect GetIntermediateSurfaceRect() { NS_ASSERTION(mUseIntermediateSurface, "Must have intermediate surface"); return RenderTargetIntRect::FromUnknownRect(GetLocalVisibleRegion().ToUnknownRegion().GetBounds()); } /** * Returns true if this container has more than one non-empty child */ bool HasMultipleChildren(); /** * Returns true if this container supports children with component alpha. * Should only be called while painting a child of this layer. */ bool SupportsComponentAlphaChildren() { return mSupportsComponentAlphaChildren; } /** * Returns true if aLayer or any layer in its parent chain has the opaque * content flag set. */ static bool HasOpaqueAncestorLayer(Layer* aLayer); void SetChildrenChanged(bool aVal) { mChildrenChanged = aVal; } void SetEventRegionsOverride(EventRegionsOverride aVal) { if (mEventRegionsOverride == aVal) { return; } MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) EventRegionsOverride", this)); mEventRegionsOverride = aVal; Mutated(); } EventRegionsOverride GetEventRegionsOverride() const { return mEventRegionsOverride; } protected: friend class ReadbackProcessor; void DidInsertChild(Layer* aLayer); void DidRemoveChild(Layer* aLayer); void Collect3DContextLeaves(nsTArray<Layer*>& aToSort); ContainerLayer(LayerManager* aManager, void* aImplData); /** * A default implementation of ComputeEffectiveTransforms for use by OpenGL * and D3D. */ void DefaultComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface); /** * A default implementation to compute and set the value for SupportsComponentAlphaChildren(). * * If aNeedsSurfaceCopy is provided, then it is set to true if the caller needs to copy the background * up into the intermediate surface created, false otherwise. */ void DefaultComputeSupportsComponentAlphaChildren(bool* aNeedsSurfaceCopy = nullptr); /** * Loops over the children calling ComputeEffectiveTransforms on them. */ void ComputeEffectiveTransformsForChildren(const gfx::Matrix4x4& aTransformToSurface); virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override; /** * True for if the container start a new 3D context extended by one * or more children. */ bool Creates3DContextWithExtendingChildren(); Layer* mFirstChild; Layer* mLastChild; float mPreXScale; float mPreYScale; // The resolution scale inherited from the parent layer. This will already // be part of mTransform. float mInheritedXScale; float mInheritedYScale; // For layers corresponding to an nsDisplayResolution, the resolution of the // associated pres shell; for other layers, 1.0. float mPresShellResolution; // Whether the compositor should scale to mPresShellResolution. bool mScaleToResolution; bool mUseIntermediateSurface; bool mSupportsComponentAlphaChildren; bool mMayHaveReadbackChild; // This is updated by ComputeDifferences. This will be true if we need to invalidate // the intermediate surface. bool mChildrenChanged; EventRegionsOverride mEventRegionsOverride; }; /** * A Layer which just renders a solid color in its visible region. It actually * can fill any area that contains the visible region, so if you need to * restrict the area filled, set a clip region on this layer. */ class ColorLayer : public Layer { public: virtual ColorLayer* AsColorLayer() override { return this; } /** * CONSTRUCTION PHASE ONLY * Set the color of the layer. */ virtual void SetColor(const gfx::Color& aColor) { if (mColor != aColor) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) Color", this)); mColor = aColor; Mutated(); } } void SetBounds(const gfx::IntRect& aBounds) { if (!mBounds.IsEqualEdges(aBounds)) { mBounds = aBounds; Mutated(); } } const gfx::IntRect& GetBounds() { return mBounds; } // This getter can be used anytime. virtual const gfx::Color& GetColor() { return mColor; } MOZ_LAYER_DECL_NAME("ColorLayer", TYPE_COLOR) virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) override { gfx::Matrix4x4 idealTransform = GetLocalTransform() * aTransformToSurface; mEffectiveTransform = SnapTransformTranslation(idealTransform, nullptr); ComputeEffectiveTransformForMaskLayers(aTransformToSurface); } protected: ColorLayer(LayerManager* aManager, void* aImplData) : Layer(aManager, aImplData) , mColor() {} virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override; gfx::IntRect mBounds; gfx::Color mColor; }; /** * A Layer for HTML Canvas elements. It's backed by either a * gfxASurface or a GLContext (for WebGL layers), and has some control * for intelligent updating from the source if necessary (for example, * if hardware compositing is not available, for reading from the GL * buffer into an image surface that we can layer composite.) * * After Initialize is called, the underlying canvas Surface/GLContext * must not be modified during a layer transaction. */ class CanvasLayer : public Layer { public: struct Data { Data() : mBufferProvider(nullptr) , mGLContext(nullptr) , mRenderer(nullptr) , mFrontbufferGLTex(0) , mSize(0,0) , mHasAlpha(false) , mIsGLAlphaPremult(true) , mIsMirror(false) { } // One of these three must be specified for Canvas2D, but never more than one PersistentBufferProvider* mBufferProvider; // A BufferProvider for the Canvas contents mozilla::gl::GLContext* mGLContext; // or this, for GL. AsyncCanvasRenderer* mRenderer; // or this, for OffscreenCanvas // Frontbuffer override uint32_t mFrontbufferGLTex; // The size of the canvas content gfx::IntSize mSize; // Whether the canvas drawingbuffer has an alpha channel. bool mHasAlpha; // Whether mGLContext contains data that is alpha-premultiplied. bool mIsGLAlphaPremult; // Whether the canvas front buffer is already being rendered somewhere else. // When true, do not swap buffers or Morph() to another factory on mGLContext bool mIsMirror; }; /** * CONSTRUCTION PHASE ONLY * Initialize this CanvasLayer with the given data. The data must * have either mSurface or mGLContext initialized (but not both), as * well as mSize. * * This must only be called once. */ virtual void Initialize(const Data& aData) = 0; /** * Check the data is owned by this layer is still valid for rendering */ virtual bool IsDataValid(const Data& aData) { return true; } /** * Notify this CanvasLayer that the canvas surface contents have * changed (or will change) before the next transaction. */ void Updated() { mDirty = true; SetInvalidRectToVisibleRegion(); } /** * Notify this CanvasLayer that the canvas surface contents have * been painted since the last change. */ void Painted() { mDirty = false; } /** * Returns true if the canvas surface contents have changed since the * last paint. */ bool IsDirty() { // We can only tell if we are dirty if we're part of the // widget's retained layer tree. if (!mManager || !mManager->IsWidgetLayerManager()) { return true; } return mDirty; } /** * Register a callback to be called at the start of each transaction. */ typedef void PreTransactionCallback(void* closureData); void SetPreTransactionCallback(PreTransactionCallback* callback, void* closureData) { mPreTransCallback = callback; mPreTransCallbackData = closureData; } const nsIntRect& GetBounds() const { return mBounds; } protected: void FirePreTransactionCallback() { if (mPreTransCallback) { mPreTransCallback(mPreTransCallbackData); } } public: /** * Register a callback to be called at the end of each transaction. */ typedef void (* DidTransactionCallback)(void* aClosureData); void SetDidTransactionCallback(DidTransactionCallback aCallback, void* aClosureData) { mPostTransCallback = aCallback; mPostTransCallbackData = aClosureData; } /** * CONSTRUCTION PHASE ONLY * Set the filter used to resample this image (if necessary). */ void SetSamplingFilter(gfx::SamplingFilter aSamplingFilter) { if (mSamplingFilter != aSamplingFilter) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) Filter", this)); mSamplingFilter = aSamplingFilter; Mutated(); } } gfx::SamplingFilter GetSamplingFilter() const { return mSamplingFilter; } MOZ_LAYER_DECL_NAME("CanvasLayer", TYPE_CANVAS) virtual void ComputeEffectiveTransforms(const gfx::Matrix4x4& aTransformToSurface) override { // Snap our local transform first, and snap the inherited transform as well. // This makes our snapping equivalent to what would happen if our content // was drawn into a PaintedLayer (gfxContext would snap using the local // transform, then we'd snap again when compositing the PaintedLayer). mEffectiveTransform = SnapTransform(GetLocalTransform(), gfxRect(0, 0, mBounds.width, mBounds.height), nullptr)* SnapTransformTranslation(aTransformToSurface, nullptr); ComputeEffectiveTransformForMaskLayers(aTransformToSurface); } bool GetIsAsyncRenderer() const { return !!mAsyncRenderer; } protected: CanvasLayer(LayerManager* aManager, void* aImplData); virtual ~CanvasLayer(); virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override; void FireDidTransactionCallback() { if (mPostTransCallback) { mPostTransCallback(mPostTransCallbackData); } } /** * 0, 0, canvaswidth, canvasheight */ gfx::IntRect mBounds; PreTransactionCallback* mPreTransCallback; void* mPreTransCallbackData; DidTransactionCallback mPostTransCallback; void* mPostTransCallbackData; gfx::SamplingFilter mSamplingFilter; RefPtr<AsyncCanvasRenderer> mAsyncRenderer; private: /** * Set to true in Updated(), cleared during a transaction. */ bool mDirty; }; /** * ContainerLayer that refers to a "foreign" layer tree, through an * ID. Usage of RefLayer looks like * * Construction phase: * allocate ID for layer subtree * create RefLayer, SetReferentId(ID) * * Composition: * look up subtree for GetReferentId() * ConnectReferentLayer(subtree) * compose * ClearReferentLayer() * * Clients will usually want to Connect/Clear() on each transaction to * avoid difficulties managing memory across multiple layer subtrees. */ class RefLayer : public ContainerLayer { friend class LayerManager; private: virtual bool InsertAfter(Layer* aChild, Layer* aAfter) override { MOZ_CRASH("GFX: RefLayer"); return false; } virtual bool RemoveChild(Layer* aChild) override { MOZ_CRASH("GFX: RefLayer"); return false; } virtual bool RepositionChild(Layer* aChild, Layer* aAfter) override { MOZ_CRASH("GFX: RefLayer"); return false; } public: /** * CONSTRUCTION PHASE ONLY * Set the ID of the layer's referent. */ void SetReferentId(uint64_t aId) { MOZ_ASSERT(aId != 0); if (mId != aId) { MOZ_LAYERS_LOG_IF_SHADOWABLE(this, ("Layer::Mutated(%p) ReferentId", this)); mId = aId; Mutated(); } } /** * CONSTRUCTION PHASE ONLY * Connect this ref layer to its referent, temporarily. * ClearReferentLayer() must be called after composition. */ void ConnectReferentLayer(Layer* aLayer) { MOZ_ASSERT(!mFirstChild && !mLastChild); MOZ_ASSERT(!aLayer->GetParent()); if (aLayer->Manager() != Manager()) { // This can happen when e.g. rendering while dragging tabs // between windows - aLayer's manager may be the manager for the // old window's tab. In that case, it will be changed before the // next render (see SetLayerManager). It is simply easier to // ignore the rendering here than it is to pause it. NS_WARNING("ConnectReferentLayer failed - Incorrect LayerManager"); return; } mFirstChild = mLastChild = aLayer; aLayer->SetParent(this); } /** * DRAWING PHASE ONLY * |aLayer| is the same as the argument to ConnectReferentLayer(). */ void DetachReferentLayer(Layer* aLayer) { mFirstChild = mLastChild = nullptr; aLayer->SetParent(nullptr); } // These getters can be used anytime. virtual RefLayer* AsRefLayer() override { return this; } virtual int64_t GetReferentId() { return mId; } /** * DRAWING PHASE ONLY */ virtual void FillSpecificAttributes(SpecificLayerAttributes& aAttrs) override; MOZ_LAYER_DECL_NAME("RefLayer", TYPE_REF) protected: RefLayer(LayerManager* aManager, void* aImplData) : ContainerLayer(aManager, aImplData) , mId(0) {} virtual void PrintInfo(std::stringstream& aStream, const char* aPrefix) override; virtual void DumpPacket(layerscope::LayersPacket* aPacket, const void* aParent) override; // 0 is a special value that means "no ID". uint64_t mId; }; void SetAntialiasingFlags(Layer* aLayer, gfx::DrawTarget* aTarget); #ifdef MOZ_DUMP_PAINTING void WriteSnapshotToDumpFile(Layer* aLayer, gfx::DataSourceSurface* aSurf); void WriteSnapshotToDumpFile(LayerManager* aManager, gfx::DataSourceSurface* aSurf); void WriteSnapshotToDumpFile(Compositor* aCompositor, gfx::DrawTarget* aTarget); #endif // A utility function used by different LayerManager implementations. gfx::IntRect ToOutsideIntRect(const gfxRect &aRect); } // namespace layers } // namespace mozilla #endif /* GFX_LAYERS_H */