The Tor Browser: comparison gfx/layers/composite/AsyncCompositionManager.h

--1:000000000000
+:cd34f4033a6a
+/* -*- 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/. */
+#ifndef GFX_ASYNCCOMPOSITIONMANAGER_H
+#define GFX_ASYNCCOMPOSITIONMANAGER_H
+#include "Units.h"                      // for LayerPoint, etc
+#include "mozilla/layers/LayerManagerComposite.h"  // for LayerManagerComposite
+#include "gfx3DMatrix.h"                // for gfx3DMatrix
+#include "mozilla/Attributes.h"         // for MOZ_DELETE, MOZ_FINAL, etc
+#include "mozilla/RefPtr.h"             // for RefCounted
+#include "mozilla/TimeStamp.h"          // for TimeStamp
+#include "mozilla/dom/ScreenOrientation.h"  // for ScreenOrientation
+#include "mozilla/gfx/BasePoint.h"      // for BasePoint
+#include "mozilla/layers/LayersMessages.h"  // for TargetConfig
+#include "nsAutoPtr.h"                  // for nsRefPtr
+#include "nsISupportsImpl.h"            // for LayerManager::AddRef, etc
+namespace mozilla {
+namespace layers {
+class AsyncPanZoomController;
+class Layer;
+class LayerManagerComposite;
+class AutoResolveRefLayers;
+// Represents (affine) transforms that are calculated from a content view.
+struct ViewTransform {
+ViewTransform(LayerPoint aTranslation = LayerPoint(),
+ParentLayerToScreenScale aScale = ParentLayerToScreenScale())
+: mTranslation(aTranslation)
+, mScale(aScale)
+{}
+operator gfx3DMatrix() const
+{
+return
+gfx3DMatrix::Translation(mTranslation.x, mTranslation.y, 0) *
+gfx3DMatrix::ScalingMatrix(mScale.scale, mScale.scale, 1);
+}
+bool operator==(const ViewTransform& rhs) const {
+return mTranslation == rhs.mTranslation && mScale == rhs.mScale;
+}
+bool operator!=(const ViewTransform& rhs) const {
+return !(*this == rhs);
+}
+LayerPoint mTranslation;
+ParentLayerToScreenScale mScale;
+};
+/**
+* Manage async composition effects. This class is only used with OMTC and only
+* lives on the compositor thread. It is a layer on top of the layer manager
+* (LayerManagerComposite) which deals with elements of composition which are
+* usually dealt with by dom or layout when main thread rendering, but which can
+* short circuit that stuff to directly affect layers as they are composited,
+* for example, off-main thread animation, async video, async pan/zoom.
+*/
+class AsyncCompositionManager MOZ_FINAL
+{
+friend class AutoResolveRefLayers;
+public:
+NS_INLINE_DECL_REFCOUNTING(AsyncCompositionManager)
+AsyncCompositionManager(LayerManagerComposite* aManager)
+: mLayerManager(aManager)
+, mIsFirstPaint(false)
+, mLayersUpdated(false)
+, mReadyForCompose(true)
+{
+}
+~AsyncCompositionManager()
+{
+}
+/**
+* This forces the is-first-paint flag to true. This is intended to
+* be called by the widget code when it loses its viewport information
+* (or for whatever reason wants to refresh the viewport information).
+* The information refresh happens because the compositor will call
+* SetFirstPaintViewport on the next frame of composition.
+*/
+void ForceIsFirstPaint() { mIsFirstPaint = true; }
+// Sample transforms for layer trees.  Return true to request
+// another animation frame.
+bool TransformShadowTree(TimeStamp aCurrentFrame);
+// Calculates the correct rotation and applies the transform to
+// our layer manager
+void ComputeRotation();
+// Call after updating our layer tree.
+void Updated(bool isFirstPaint, const TargetConfig& aTargetConfig)
+{
+mIsFirstPaint |= isFirstPaint;
+mLayersUpdated = true;
+mTargetConfig = aTargetConfig;
+}
+bool RequiresReorientation(mozilla::dom::ScreenOrientation aOrientation)
+{
+return mTargetConfig.orientation() != aOrientation;
+}
+// True if the underlying layer tree is ready to be composited.
+bool ReadyForCompose() { return mReadyForCompose; }
+// Returns true if the next composition will be the first for a
+// particular document.
+bool IsFirstPaint() { return mIsFirstPaint; }
+private:
+void TransformScrollableLayer(Layer* aLayer);
+// Return true if an AsyncPanZoomController content transform was
+// applied for |aLayer|.  *aWantNextFrame is set to true if the
+// controller wants another animation frame.
+bool ApplyAsyncContentTransformToTree(TimeStamp aCurrentFrame, Layer* aLayer,
+bool* aWantNextFrame);
+/**
+* Update the shadow transform for aLayer assuming that is a scrollbar,
+* so that it stays in sync with the content that is being scrolled by APZ.
+*/
+void ApplyAsyncTransformToScrollbar(TimeStamp aCurrentFrame, ContainerLayer* aLayer);
+void SetFirstPaintViewport(const LayerIntPoint& aOffset,
+const CSSToLayerScale& aZoom,
+const CSSRect& aCssPageRect);
+void SetPageRect(const CSSRect& aCssPageRect);
+void SyncViewportInfo(const LayerIntRect& aDisplayPort,
+const CSSToLayerScale& aDisplayResolution,
+bool aLayersUpdated,
+ScreenPoint& aScrollOffset,
+CSSToScreenScale& aScale,
+LayerMargin& aFixedLayerMargins,
+ScreenPoint& aOffset);
+void SyncFrameMetrics(const ScreenPoint& aScrollOffset,
+float aZoom,
+const CSSRect& aCssPageRect,
+bool aLayersUpdated,
+const CSSRect& aDisplayPort,
+const CSSToLayerScale& aDisplayResolution,
+bool aIsFirstPaint,
+LayerMargin& aFixedLayerMargins,
+ScreenPoint& aOffset);
+/**
+* Adds a translation to the transform of any fixed position (whose parent
+* layer is not fixed) or sticky position layer descendant of
+* aTransformedSubtreeRoot. The translation is chosen so that the layer's
+* anchor point relative to aTransformedSubtreeRoot's parent layer is the same
+* as it was when aTransformedSubtreeRoot's GetLocalTransform() was
+* aPreviousTransformForRoot. For sticky position layers, the translation is
+* further intersected with the layer's sticky scroll ranges.
+* This function will also adjust layers so that the given content document
+* fixed position margins will be respected during asynchronous panning and
+* zooming.
+*/
+void AlignFixedAndStickyLayers(Layer* aLayer, Layer* aTransformedSubtreeRoot,
+const gfx::Matrix4x4& aPreviousTransformForRoot,
+const LayerMargin& aFixedLayerMargins);
+/**
+* DRAWING PHASE ONLY
+*
+* For reach RefLayer in our layer tree, look up its referent and connect it
+* to the layer tree, if found.
+*/
+void ResolveRefLayers();
+/**
+* Detaches all referents resolved by ResolveRefLayers.
+* Assumes that mLayerManager->GetRoot() and mTargetConfig have not changed
+* since ResolveRefLayers was called.
+*/
+void DetachRefLayers();
+TargetConfig mTargetConfig;
+CSSRect mContentRect;
+nsRefPtr<LayerManagerComposite> mLayerManager;
+// When this flag is set, the next composition will be the first for a
+// particular document (i.e. the document displayed on the screen will change).
+// This happens when loading a new page or switching tabs. We notify the
+// front-end (e.g. Java on Android) about this so that it take the new page
+// size and zoom into account when providing us with the next view transform.
+bool mIsFirstPaint;
+// This flag is set during a layers update, so that the first composition
+// after a layers update has it set. It is cleared after that first composition.
+bool mLayersUpdated;
+bool mReadyForCompose;
+};
+class MOZ_STACK_CLASS AutoResolveRefLayers {
+public:
+AutoResolveRefLayers(AsyncCompositionManager* aManager) : mManager(aManager)
+{
+if (mManager) {
+mManager->ResolveRefLayers();
+}
+}
+~AutoResolveRefLayers()
+{
+if (mManager) {
+mManager->DetachRefLayers();
+}
+}
+private:
+AsyncCompositionManager* mManager;
+AutoResolveRefLayers(const AutoResolveRefLayers&) MOZ_DELETE;
+AutoResolveRefLayers& operator=(const AutoResolveRefLayers&) MOZ_DELETE;
+};
+} // layers
+} // mozilla
+#endif

The Tor Browser / file comparison

comparison: gfx/layers/composite/AsyncCompositionManager.h

gfx/layers/composite/AsyncCompositionManager.h