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

--1:000000000000
+:abb8f544661a
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=2 et tw=80 : */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+#include "mozilla/layers/AsyncCompositionManager.h"
+#include <stdint.h>                     // for uint32_t
+#include "AnimationCommon.h"            // for ComputedTimingFunction
+#include "CompositorParent.h"           // for CompositorParent, etc
+#include "FrameMetrics.h"               // for FrameMetrics
+#include "LayerManagerComposite.h"      // for LayerManagerComposite, etc
+#include "Layers.h"                     // for Layer, ContainerLayer, etc
+#include "gfxPoint.h"                   // for gfxPoint, gfxSize
+#include "gfxPoint3D.h"                 // for gfxPoint3D
+#include "mozilla/WidgetUtils.h"        // for ComputeTransformForRotation
+#include "mozilla/gfx/BaseRect.h"       // for BaseRect
+#include "mozilla/gfx/Point.h"          // for RoundedToInt, PointTyped
+#include "mozilla/gfx/Rect.h"           // for RoundedToInt, RectTyped
+#include "mozilla/gfx/ScaleFactor.h"    // for ScaleFactor
+#include "mozilla/layers/AsyncPanZoomController.h"
+#include "mozilla/layers/Compositor.h"  // for Compositor
+#include "nsAnimationManager.h"         // for ElementAnimations
+#include "nsCSSPropList.h"
+#include "nsCoord.h"                    // for NSAppUnitsToFloatPixels, etc
+#include "nsDebug.h"                    // for NS_ASSERTION, etc
+#include "nsDeviceContext.h"            // for nsDeviceContext
+#include "nsDisplayList.h"              // for nsDisplayTransform, etc
+#include "nsMathUtils.h"                // for NS_round
+#include "nsPoint.h"                    // for nsPoint
+#include "nsRect.h"                     // for nsIntRect
+#include "nsRegion.h"                   // for nsIntRegion
+#include "nsStyleAnimation.h"           // for nsStyleAnimation::Value, etc
+#include "nsTArray.h"                   // for nsTArray, nsTArray_Impl, etc
+#include "nsTArrayForwardDeclare.h"     // for InfallibleTArray
+#if defined(MOZ_WIDGET_ANDROID)
+# include <android/log.h>
+# include "AndroidBridge.h"
+#endif
+#include "GeckoProfiler.h"
+struct nsCSSValueSharedList;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+namespace mozilla {
+namespace layers {
+enum Op { Resolve, Detach };
+static bool
+IsSameDimension(ScreenOrientation o1, ScreenOrientation o2)
+{
+bool isO1portrait = (o1 == eScreenOrientation_PortraitPrimary || o1 == eScreenOrientation_PortraitSecondary);
+bool isO2portrait = (o2 == eScreenOrientation_PortraitPrimary || o2 == eScreenOrientation_PortraitSecondary);
+return !(isO1portrait ^ isO2portrait);
+}
+static bool
+ContentMightReflowOnOrientationChange(const nsIntRect& rect)
+{
+return rect.width != rect.height;
+}
+template<Op OP>
+static void
+WalkTheTree(Layer* aLayer,
+bool& aReady,
+const TargetConfig& aTargetConfig)
+{
+if (RefLayer* ref = aLayer->AsRefLayer()) {
+if (const CompositorParent::LayerTreeState* state = CompositorParent::GetIndirectShadowTree(ref->GetReferentId())) {
+if (Layer* referent = state->mRoot) {
+if (!ref->GetVisibleRegion().IsEmpty()) {
+ScreenOrientation chromeOrientation = aTargetConfig.orientation();
+ScreenOrientation contentOrientation = state->mTargetConfig.orientation();
+if (!IsSameDimension(chromeOrientation, contentOrientation) &&
+ContentMightReflowOnOrientationChange(aTargetConfig.clientBounds())) {
+aReady = false;
+}
+}
+if (OP == Resolve) {
+ref->ConnectReferentLayer(referent);
+} else {
+ref->DetachReferentLayer(referent);
+}
+}
+}
+}
+for (Layer* child = aLayer->GetFirstChild();
+child; child = child->GetNextSibling()) {
+WalkTheTree<OP>(child, aReady, aTargetConfig);
+}
+}
+void
+AsyncCompositionManager::ResolveRefLayers()
+{
+if (!mLayerManager->GetRoot()) {
+return;
+}
+mReadyForCompose = true;
+WalkTheTree<Resolve>(mLayerManager->GetRoot(),
+mReadyForCompose,
+mTargetConfig);
+}
+void
+AsyncCompositionManager::DetachRefLayers()
+{
+if (!mLayerManager->GetRoot()) {
+return;
+}
+WalkTheTree<Detach>(mLayerManager->GetRoot(),
+mReadyForCompose,
+mTargetConfig);
+}
+void
+AsyncCompositionManager::ComputeRotation()
+{
+if (!mTargetConfig.naturalBounds().IsEmpty()) {
+mLayerManager->SetWorldTransform(
+ComputeTransformForRotation(mTargetConfig.naturalBounds(),
+mTargetConfig.rotation()));
+}
+}
+static bool
+GetBaseTransform2D(Layer* aLayer, Matrix* aTransform)
+{
+// Start with the animated transform if there is one
+return (aLayer->AsLayerComposite()->GetShadowTransformSetByAnimation() ?
+aLayer->GetLocalTransform() : aLayer->GetTransform()).Is2D(aTransform);
+}
+static void
+TranslateShadowLayer2D(Layer* aLayer,
+const gfxPoint& aTranslation)
+{
+Matrix layerTransform;
+if (!GetBaseTransform2D(aLayer, &layerTransform)) {
+return;
+}
+// Apply the 2D translation to the layer transform.
+layerTransform._31 += aTranslation.x;
+layerTransform._32 += aTranslation.y;
+// The transform already takes the resolution scale into account.  Since we
+// will apply the resolution scale again when computing the effective
+// transform, we must apply the inverse resolution scale here.
+Matrix4x4 layerTransform3D = Matrix4x4::From2D(layerTransform);
+if (ContainerLayer* c = aLayer->AsContainerLayer()) {
+layerTransform3D.Scale(1.0f/c->GetPreXScale(),
+1.0f/c->GetPreYScale(),
+1);
+}
+layerTransform3D = layerTransform3D *
+Matrix4x4().Scale(1.0f/aLayer->GetPostXScale(),
+1.0f/aLayer->GetPostYScale(),
+1);
+LayerComposite* layerComposite = aLayer->AsLayerComposite();
+layerComposite->SetShadowTransform(layerTransform3D);
+layerComposite->SetShadowTransformSetByAnimation(false);
+const nsIntRect* clipRect = aLayer->GetClipRect();
+if (clipRect) {
+nsIntRect transformedClipRect(*clipRect);
+transformedClipRect.MoveBy(aTranslation.x, aTranslation.y);
+layerComposite->SetShadowClipRect(&transformedClipRect);
+}
+}
+static bool
+AccumulateLayerTransforms2D(Layer* aLayer,
+Layer* aAncestor,
+Matrix& aMatrix)
+{
+// Accumulate the transforms between this layer and the subtree root layer.
+for (Layer* l = aLayer; l && l != aAncestor; l = l->GetParent()) {
+Matrix l2D;
+if (!GetBaseTransform2D(l, &l2D)) {
+return false;
+}
+aMatrix *= l2D;
+}
+return true;
+}
+static LayerPoint
+GetLayerFixedMarginsOffset(Layer* aLayer,
+const LayerMargin& aFixedLayerMargins)
+{
+// Work out the necessary translation, in root scrollable layer space.
+// Because fixed layer margins are stored relative to the root scrollable
+// layer, we can just take the difference between these values.
+LayerPoint translation;
+const LayerPoint& anchor = aLayer->GetFixedPositionAnchor();
+const LayerMargin& fixedMargins = aLayer->GetFixedPositionMargins();
+if (fixedMargins.left >= 0) {
+if (anchor.x > 0) {
+translation.x -= aFixedLayerMargins.right - fixedMargins.right;
+} else {
+translation.x += aFixedLayerMargins.left - fixedMargins.left;
+}
+}
+if (fixedMargins.top >= 0) {
+if (anchor.y > 0) {
+translation.y -= aFixedLayerMargins.bottom - fixedMargins.bottom;
+} else {
+translation.y += aFixedLayerMargins.top - fixedMargins.top;
+}
+}
+return translation;
+}
+static gfxFloat
+IntervalOverlap(gfxFloat aTranslation, gfxFloat aMin, gfxFloat aMax)
+{
+// Determine the amount of overlap between the 1D vector |aTranslation|
+// and the interval [aMin, aMax].
+if (aTranslation > 0) {
+return std::max(0.0, std::min(aMax, aTranslation) - std::max(aMin, 0.0));
+} else {
+return std::min(0.0, std::max(aMin, aTranslation) - std::min(aMax, 0.0));
+}
+}
+void
+AsyncCompositionManager::AlignFixedAndStickyLayers(Layer* aLayer,
+Layer* aTransformedSubtreeRoot,
+const Matrix4x4& aPreviousTransformForRoot,
+const LayerMargin& aFixedLayerMargins)
+{
+bool isRootFixed = aLayer->GetIsFixedPosition() &&
+!aLayer->GetParent()->GetIsFixedPosition();
+bool isStickyForSubtree = aLayer->GetIsStickyPosition() &&
+aTransformedSubtreeRoot->AsContainerLayer() &&
+aLayer->GetStickyScrollContainerId() ==
+aTransformedSubtreeRoot->AsContainerLayer()->GetFrameMetrics().GetScrollId();
+if (aLayer != aTransformedSubtreeRoot && (isRootFixed || isStickyForSubtree)) {
+// Insert a translation so that the position of the anchor point is the same
+// before and after the change to the transform of aTransformedSubtreeRoot.
+// This currently only works for fixed layers with 2D transforms.
+// Accumulate the transforms between this layer and the subtree root layer.
+Matrix ancestorTransform;
+if (!AccumulateLayerTransforms2D(aLayer->GetParent(), aTransformedSubtreeRoot,
+ancestorTransform)) {
+return;
+}
+Matrix oldRootTransform;
+Matrix newRootTransform;
+if (!aPreviousTransformForRoot.Is2D(&oldRootTransform) ||
+!aTransformedSubtreeRoot->GetLocalTransform().Is2D(&newRootTransform)) {
+return;
+}
+// Calculate the cumulative transforms between the subtree root with the
+// old transform and the current transform.
+Matrix oldCumulativeTransform = ancestorTransform * oldRootTransform;
+Matrix newCumulativeTransform = ancestorTransform * newRootTransform;
+if (newCumulativeTransform.IsSingular()) {
+return;
+}
+Matrix newCumulativeTransformInverse = newCumulativeTransform;
+newCumulativeTransformInverse.Invert();
+// Now work out the translation necessary to make sure the layer doesn't
+// move given the new sub-tree root transform.
+Matrix layerTransform;
+if (!GetBaseTransform2D(aLayer, &layerTransform)) {
+return;
+}
+// Calculate any offset necessary, in previous transform sub-tree root
+// space. This is used to make sure fixed position content respects
+// content document fixed position margins.
+LayerPoint offsetInOldSubtreeLayerSpace = GetLayerFixedMarginsOffset(aLayer, aFixedLayerMargins);
+// Add the above offset to the anchor point so we can offset the layer by
+// and amount that's specified in old subtree layer space.
+const LayerPoint& anchorInOldSubtreeLayerSpace = aLayer->GetFixedPositionAnchor();
+LayerPoint offsetAnchorInOldSubtreeLayerSpace = anchorInOldSubtreeLayerSpace + offsetInOldSubtreeLayerSpace;
+// Add the local layer transform to the two points to make the equation
+// below this section more convenient.
+Point anchor(anchorInOldSubtreeLayerSpace.x, anchorInOldSubtreeLayerSpace.y);
+Point offsetAnchor(offsetAnchorInOldSubtreeLayerSpace.x, offsetAnchorInOldSubtreeLayerSpace.y);
+Point locallyTransformedAnchor = layerTransform * anchor;
+Point locallyTransformedOffsetAnchor = layerTransform * offsetAnchor;
+// Transforming the locallyTransformedAnchor by oldCumulativeTransform
+// returns the layer's anchor point relative to the parent of
+// aTransformedSubtreeRoot, before the new transform was applied.
+// Then, applying newCumulativeTransformInverse maps that point relative
+// to the layer's parent, which is the same coordinate space as
+// locallyTransformedAnchor again, allowing us to subtract them and find
+// out the offset necessary to make sure the layer stays stationary.
+Point oldAnchorPositionInNewSpace =
+newCumulativeTransformInverse * (oldCumulativeTransform * locallyTransformedOffsetAnchor);
+Point translation = oldAnchorPositionInNewSpace - locallyTransformedAnchor;
+if (aLayer->GetIsStickyPosition()) {
+// For sticky positioned layers, the difference between the two rectangles
+// defines a pair of translation intervals in each dimension through which
+// the layer should not move relative to the scroll container. To
+// accomplish this, we limit each dimension of the |translation| to that
+// part of it which overlaps those intervals.
+const LayerRect& stickyOuter = aLayer->GetStickyScrollRangeOuter();
+const LayerRect& stickyInner = aLayer->GetStickyScrollRangeInner();
+translation.y = IntervalOverlap(translation.y, stickyOuter.y, stickyOuter.YMost()) -
+IntervalOverlap(translation.y, stickyInner.y, stickyInner.YMost());
+translation.x = IntervalOverlap(translation.x, stickyOuter.x, stickyOuter.XMost()) -
+IntervalOverlap(translation.x, stickyInner.x, stickyInner.XMost());
+}
+// Finally, apply the 2D translation to the layer transform.
+TranslateShadowLayer2D(aLayer, ThebesPoint(translation));
+// The transform has now been applied, so there's no need to iterate over
+// child layers.
+return;
+}
+// Fixed layers are relative to their nearest scrollable layer, so when we
+// encounter a scrollable layer, reset the transform to that layer and remove
+// the fixed margins.
+if (aLayer->AsContainerLayer() &&
+aLayer->AsContainerLayer()->GetFrameMetrics().IsScrollable() &&
+aLayer != aTransformedSubtreeRoot) {
+AlignFixedAndStickyLayers(aLayer, aLayer, aLayer->GetTransform(), LayerMargin(0, 0, 0, 0));
+return;
+}
+for (Layer* child = aLayer->GetFirstChild();
+child; child = child->GetNextSibling()) {
+AlignFixedAndStickyLayers(child, aTransformedSubtreeRoot,
+aPreviousTransformForRoot, aFixedLayerMargins);
+}
+}
+static void
+SampleValue(float aPortion, Animation& aAnimation, nsStyleAnimation::Value& aStart,
+nsStyleAnimation::Value& aEnd, Animatable* aValue)
+{
+nsStyleAnimation::Value interpolatedValue;
+NS_ASSERTION(aStart.GetUnit() == aEnd.GetUnit() ||
+aStart.GetUnit() == nsStyleAnimation::eUnit_None ||
+aEnd.GetUnit() == nsStyleAnimation::eUnit_None, "Must have same unit");
+nsStyleAnimation::Interpolate(aAnimation.property(), aStart, aEnd,
+aPortion, interpolatedValue);
+if (aAnimation.property() == eCSSProperty_opacity) {
+*aValue = interpolatedValue.GetFloatValue();
+return;
+}
+nsCSSValueSharedList* interpolatedList =
+interpolatedValue.GetCSSValueSharedListValue();
+TransformData& data = aAnimation.data().get_TransformData();
+nsPoint origin = data.origin();
+// we expect all our transform data to arrive in css pixels, so here we must
+// adjust to dev pixels.
+double cssPerDev = double(nsDeviceContext::AppUnitsPerCSSPixel())
+/ double(data.appUnitsPerDevPixel());
+gfxPoint3D transformOrigin = data.transformOrigin();
+transformOrigin.x = transformOrigin.x * cssPerDev;
+transformOrigin.y = transformOrigin.y * cssPerDev;
+gfxPoint3D perspectiveOrigin = data.perspectiveOrigin();
+perspectiveOrigin.x = perspectiveOrigin.x * cssPerDev;
+perspectiveOrigin.y = perspectiveOrigin.y * cssPerDev;
+nsDisplayTransform::FrameTransformProperties props(interpolatedList,
+transformOrigin,
+perspectiveOrigin,
+data.perspective());
+gfx3DMatrix transform =
+nsDisplayTransform::GetResultingTransformMatrix(props, origin,
+data.appUnitsPerDevPixel(),
+&data.bounds());
+gfxPoint3D scaledOrigin =
+gfxPoint3D(NS_round(NSAppUnitsToFloatPixels(origin.x, data.appUnitsPerDevPixel())),
+NS_round(NSAppUnitsToFloatPixels(origin.y, data.appUnitsPerDevPixel())),
+0.0f);
+transform.Translate(scaledOrigin);
+InfallibleTArray<TransformFunction> functions;
+Matrix4x4 realTransform;
+ToMatrix4x4(transform, realTransform);
+functions.AppendElement(TransformMatrix(realTransform));
+*aValue = functions;
+}
+static bool
+SampleAnimations(Layer* aLayer, TimeStamp aPoint)
+{
+AnimationArray& animations = aLayer->GetAnimations();
+InfallibleTArray<AnimData>& animationData = aLayer->GetAnimationData();
+bool activeAnimations = false;
+for (uint32_t i = animations.Length(); i-- !=0; ) {
+Animation& animation = animations[i];
+AnimData& animData = animationData[i];
+activeAnimations = true;
+TimeDuration elapsedDuration = aPoint - animation.startTime();
+// Skip animations that are yet to start.
+//
+// Currently, this should only happen when the refresh driver is under test
+// control and is made to produce a time in the past or is restored from
+// test control causing it to jump backwards in time.
+//
+// Since activeAnimations is true, this could mean we keep compositing
+// unnecessarily during the delay, but so long as this only happens while
+// the refresh driver is under test control that should be ok.
+if (elapsedDuration.ToSeconds() < 0) {
+continue;
+}
+double numIterations = animation.numIterations() != -1 ?
+animation.numIterations() : NS_IEEEPositiveInfinity();
+double positionInIteration =
+ElementAnimations::GetPositionInIteration(elapsedDuration,
+animation.duration(),
+numIterations,
+animation.direction());
+NS_ABORT_IF_FALSE(0.0 <= positionInIteration &&
+positionInIteration <= 1.0,
+"position should be in [0-1]");
+int segmentIndex = 0;
+AnimationSegment* segment = animation.segments().Elements();
+while (segment->endPortion() < positionInIteration) {
+++segment;
+++segmentIndex;
+}
+double positionInSegment = (positionInIteration - segment->startPortion()) /
+(segment->endPortion() - segment->startPortion());
+double portion = animData.mFunctions[segmentIndex]->GetValue(positionInSegment);
+// interpolate the property
+Animatable interpolatedValue;
+SampleValue(portion, animation, animData.mStartValues[segmentIndex],
+animData.mEndValues[segmentIndex], &interpolatedValue);
+LayerComposite* layerComposite = aLayer->AsLayerComposite();
+switch (animation.property()) {
+case eCSSProperty_opacity:
+{
+layerComposite->SetShadowOpacity(interpolatedValue.get_float());
+break;
+}
+case eCSSProperty_transform:
+{
+Matrix4x4 matrix = interpolatedValue.get_ArrayOfTransformFunction()[0].get_TransformMatrix().value();
+if (ContainerLayer* c = aLayer->AsContainerLayer()) {
+matrix = matrix * Matrix4x4().Scale(c->GetInheritedXScale(),
+c->GetInheritedYScale(),
+1);
+}
+layerComposite->SetShadowTransform(matrix);
+layerComposite->SetShadowTransformSetByAnimation(true);
+break;
+}
+default:
+NS_WARNING("Unhandled animated property");
+}
+}
+for (Layer* child = aLayer->GetFirstChild(); child;
+child = child->GetNextSibling()) {
+activeAnimations |= SampleAnimations(child, aPoint);
+}
+return activeAnimations;
+}
+bool
+AsyncCompositionManager::ApplyAsyncContentTransformToTree(TimeStamp aCurrentFrame,
+Layer *aLayer,
+bool* aWantNextFrame)
+{
+bool appliedTransform = false;
+for (Layer* child = aLayer->GetFirstChild();
+child; child = child->GetNextSibling()) {
+appliedTransform |=
+ApplyAsyncContentTransformToTree(aCurrentFrame, child, aWantNextFrame);
+}
+ContainerLayer* container = aLayer->AsContainerLayer();
+if (!container) {
+return appliedTransform;
+}
+if (AsyncPanZoomController* controller = container->GetAsyncPanZoomController()) {
+LayerComposite* layerComposite = aLayer->AsLayerComposite();
+Matrix4x4 oldTransform = aLayer->GetTransform();
+ViewTransform treeTransform;
+ScreenPoint scrollOffset;
+*aWantNextFrame |=
+controller->SampleContentTransformForFrame(aCurrentFrame,
+&treeTransform,
+scrollOffset);
+const FrameMetrics& metrics = container->GetFrameMetrics();
+CSSToLayerScale paintScale = metrics.LayersPixelsPerCSSPixel();
+CSSRect displayPort(metrics.mCriticalDisplayPort.IsEmpty() ?
+metrics.mDisplayPort : metrics.mCriticalDisplayPort);
+LayerMargin fixedLayerMargins(0, 0, 0, 0);
+ScreenPoint offset(0, 0);
+SyncFrameMetrics(scrollOffset, treeTransform.mScale.scale, metrics.mScrollableRect,
+mLayersUpdated, displayPort, paintScale,
+mIsFirstPaint, fixedLayerMargins, offset);
+mIsFirstPaint = false;
+mLayersUpdated = false;
+// Apply the render offset
+mLayerManager->GetCompositor()->SetScreenRenderOffset(offset);
+Matrix4x4 transform;
+ToMatrix4x4(gfx3DMatrix(treeTransform), transform);
+transform = transform * aLayer->GetTransform();
+// GetTransform already takes the pre- and post-scale into account.  Since we
+// will apply the pre- and post-scale again when computing the effective
+// transform, we must apply the inverses here.
+transform.Scale(1.0f/container->GetPreXScale(),
+1.0f/container->GetPreYScale(),
+1);
+transform = transform * Matrix4x4().Scale(1.0f/aLayer->GetPostXScale(),
+1.0f/aLayer->GetPostYScale(),
+1);
+layerComposite->SetShadowTransform(transform);
+NS_ASSERTION(!layerComposite->GetShadowTransformSetByAnimation(),
+"overwriting animated transform!");
+// Apply resolution scaling to the old transform - the layer tree as it is
+// doesn't have the necessary transform to display correctly.
+LayoutDeviceToLayerScale resolution = metrics.mCumulativeResolution;
+oldTransform.Scale(resolution.scale, resolution.scale, 1);
+AlignFixedAndStickyLayers(aLayer, aLayer, oldTransform, fixedLayerMargins);
+appliedTransform = true;
+}
+if (container->GetScrollbarDirection() != Layer::NONE) {
+ApplyAsyncTransformToScrollbar(aCurrentFrame, container);
+}
+return appliedTransform;
+}
+static bool
+LayerHasNonContainerDescendants(ContainerLayer* aContainer)
+{
+for (Layer* child = aContainer->GetFirstChild();
+child; child = child->GetNextSibling()) {
+ContainerLayer* container = child->AsContainerLayer();
+if (!container || LayerHasNonContainerDescendants(container)) {
+return true;
+}
+}
+return false;
+}
+static bool
+LayerIsContainerForScrollbarTarget(Layer* aTarget, ContainerLayer* aScrollbar)
+{
+if (!aTarget->AsContainerLayer()) {
+return false;
+}
+AsyncPanZoomController* apzc = aTarget->AsContainerLayer()->GetAsyncPanZoomController();
+if (!apzc) {
+return false;
+}
+const FrameMetrics& metrics = aTarget->AsContainerLayer()->GetFrameMetrics();
+if (metrics.GetScrollId() != aScrollbar->GetScrollbarTargetContainerId()) {
+return false;
+}
+return true;
+}
+static void
+ApplyAsyncTransformToScrollbarForContent(TimeStamp aCurrentFrame, ContainerLayer* aScrollbar,
+Layer* aContent, bool aScrollbarIsChild)
+{
+ContainerLayer* content = aContent->AsContainerLayer();
+if (!LayerHasNonContainerDescendants(content)) {
+return;
+}
+const FrameMetrics& metrics = content->GetFrameMetrics();
+AsyncPanZoomController* apzc = content->GetAsyncPanZoomController();
+if (aScrollbarIsChild) {
+// Because we try to apply the scrollbar transform before we apply the async transform on
+// the actual content, we need to ensure that the APZC has updated any pending animations
+// to the current frame timestamp before we extract the transforms from it. The code in this
+// block accomplishes that and throws away the temp variables.
+// TODO: it might be cleaner to do a pass through the layer tree to advance all the APZC
+// transforms before updating the layer shadow transforms. That will allow removal of this code.
+ViewTransform treeTransform;
+ScreenPoint scrollOffset;
+apzc->SampleContentTransformForFrame(aCurrentFrame, &treeTransform, scrollOffset);
+}
+gfx3DMatrix asyncTransform = gfx3DMatrix(apzc->GetCurrentAsyncTransform());
+gfx3DMatrix nontransientTransform = apzc->GetNontransientAsyncTransform();
+gfx3DMatrix transientTransform = asyncTransform * nontransientTransform.Inverse();
+// |transientTransform| represents the amount by which we have scrolled and
+// zoomed since the last paint. Because the scrollbar was sized and positioned based
+// on the painted content, we need to adjust it based on transientTransform so that
+// it reflects what the user is actually seeing now.
+// - The scroll thumb needs to be scaled in the direction of scrolling by the inverse
+//   of the transientTransform scale (representing the zoom). This is because zooming
+//   in decreases the fraction of the whole scrollable rect that is in view.
+// - It needs to be translated in opposite direction of the transientTransform
+//   translation (representing the scroll). This is because scrolling down, which
+//   translates the layer content up, should result in moving the scroll thumb down.
+//   The amount of the translation to the scroll thumb should be such that the ratio
+//   of the translation to the size of the scroll port is the same as the ratio
+//   of the scroll amount to the size of the scrollable rect.
+Matrix4x4 scrollbarTransform;
+if (aScrollbar->GetScrollbarDirection() == Layer::VERTICAL) {
+float scale = metrics.CalculateCompositedSizeInCssPixels().height / metrics.mScrollableRect.height;
+scrollbarTransform = scrollbarTransform * Matrix4x4().Scale(1.f, 1.f / transientTransform.GetYScale(), 1.f);
+scrollbarTransform = scrollbarTransform * Matrix4x4().Translate(0, -transientTransform._42 * scale, 0);
+}
+if (aScrollbar->GetScrollbarDirection() == Layer::HORIZONTAL) {
+float scale = metrics.CalculateCompositedSizeInCssPixels().width / metrics.mScrollableRect.width;
+scrollbarTransform = scrollbarTransform * Matrix4x4().Scale(1.f / transientTransform.GetXScale(), 1.f, 1.f);
+scrollbarTransform = scrollbarTransform * Matrix4x4().Translate(-transientTransform._41 * scale, 0, 0);
+}
+Matrix4x4 transform = scrollbarTransform * aScrollbar->GetTransform();
+if (aScrollbarIsChild) {
+// If the scrollbar layer is a child of the content it is a scrollbar for, then we
+// need to do an extra untransform to cancel out the transient async transform on
+// the content. This is needed because otherwise that transient async transform is
+// part of the effective transform of this scrollbar, and the scrollbar will jitter
+// as the content scrolls.
+Matrix4x4 targetUntransform;
+ToMatrix4x4(transientTransform.Inverse(), targetUntransform);
+transform = transform * targetUntransform;
+}
+// GetTransform already takes the pre- and post-scale into account.  Since we
+// will apply the pre- and post-scale again when computing the effective
+// transform, we must apply the inverses here.
+transform.Scale(1.0f/aScrollbar->GetPreXScale(),
+1.0f/aScrollbar->GetPreYScale(),
+1);
+transform = transform * Matrix4x4().Scale(1.0f/aScrollbar->GetPostXScale(),
+1.0f/aScrollbar->GetPostYScale(),
+1);
+aScrollbar->AsLayerComposite()->SetShadowTransform(transform);
+}
+void
+AsyncCompositionManager::ApplyAsyncTransformToScrollbar(TimeStamp aCurrentFrame, ContainerLayer* aLayer)
+{
+// If this layer corresponds to a scrollbar, then there should be a layer that
+// is a previous sibling or a parent that has a matching ViewID on its FrameMetrics.
+// That is the content that this scrollbar is for. We pick up the transient
+// async transform from that layer and use it to update the scrollbar position.
+// Note that it is possible that the content layer is no longer there; in
+// this case we don't need to do anything because there can't be an async
+// transform on the content.
+// We only apply the transform if the scroll-target layer has non-container
+// children (i.e. when it has some possibly-visible content). This is to
+// avoid moving scroll-bars in the situation that only a scroll information
+// layer has been built for a scroll frame, as this would result in a
+// disparity between scrollbars and visible content.
+for (Layer* scrollTarget = aLayer->GetPrevSibling();
+scrollTarget;
+scrollTarget = scrollTarget->GetPrevSibling()) {
+if (LayerIsContainerForScrollbarTarget(scrollTarget, aLayer)) {
+// Found a sibling that matches our criteria
+ApplyAsyncTransformToScrollbarForContent(aCurrentFrame, aLayer, scrollTarget, false);
+return;
+}
+}
+// If we didn't find a sibling, look for a parent
+Layer* scrollTarget = aLayer->GetParent();
+if (scrollTarget && LayerIsContainerForScrollbarTarget(scrollTarget, aLayer)) {
+ApplyAsyncTransformToScrollbarForContent(aCurrentFrame, aLayer, scrollTarget, true);
+}
+}
+void
+AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer)
+{
+LayerComposite* layerComposite = aLayer->AsLayerComposite();
+ContainerLayer* container = aLayer->AsContainerLayer();
+const FrameMetrics& metrics = container->GetFrameMetrics();
+// We must apply the resolution scale before a pan/zoom transform, so we call
+// GetTransform here.
+gfx3DMatrix currentTransform;
+To3DMatrix(aLayer->GetTransform(), currentTransform);
+Matrix4x4 oldTransform = aLayer->GetTransform();
+gfx3DMatrix treeTransform;
+CSSToLayerScale geckoZoom = metrics.LayersPixelsPerCSSPixel();
+LayerIntPoint scrollOffsetLayerPixels = RoundedToInt(metrics.GetScrollOffset() * geckoZoom);
+if (mIsFirstPaint) {
+mContentRect = metrics.mScrollableRect;
+SetFirstPaintViewport(scrollOffsetLayerPixels,
+geckoZoom,
+mContentRect);
+mIsFirstPaint = false;
+} else if (!metrics.mScrollableRect.IsEqualEdges(mContentRect)) {
+mContentRect = metrics.mScrollableRect;
+SetPageRect(mContentRect);
+}
+// We synchronise the viewport information with Java after sending the above
+// notifications, so that Java can take these into account in its response.
+// Calculate the absolute display port to send to Java
+LayerIntRect displayPort = RoundedToInt(
+(metrics.mCriticalDisplayPort.IsEmpty()
+? metrics.mDisplayPort
+: metrics.mCriticalDisplayPort
+) * geckoZoom);
+displayPort += scrollOffsetLayerPixels;
+LayerMargin fixedLayerMargins(0, 0, 0, 0);
+ScreenPoint offset(0, 0);
+// Ideally we would initialize userZoom to AsyncPanZoomController::CalculateResolution(metrics)
+// but this causes a reftest-ipc test to fail (see bug 883646 comment 27). The reason for this
+// appears to be that metrics.mZoom is poorly initialized in some scenarios. In these scenarios,
+// however, we can assume there is no async zooming in progress and so the following statement
+// works fine.
+CSSToScreenScale userZoom(metrics.mDevPixelsPerCSSPixel * metrics.mCumulativeResolution * LayerToScreenScale(1));
+ScreenPoint userScroll = metrics.GetScrollOffset() * userZoom;
+SyncViewportInfo(displayPort, geckoZoom, mLayersUpdated,
+userScroll, userZoom, fixedLayerMargins,
+offset);
+mLayersUpdated = false;
+// Apply the render offset
+mLayerManager->GetCompositor()->SetScreenRenderOffset(offset);
+// Handle transformations for asynchronous panning and zooming. We determine the
+// zoom used by Gecko from the transformation set on the root layer, and we
+// determine the scroll offset used by Gecko from the frame metrics of the
+// primary scrollable layer. We compare this to the user zoom and scroll
+// offset in the view transform we obtained from Java in order to compute the
+// transformation we need to apply.
+LayerToScreenScale zoomAdjust = userZoom / geckoZoom;
+LayerPoint geckoScroll(0, 0);
+if (metrics.IsScrollable()) {
+geckoScroll = metrics.GetScrollOffset() * geckoZoom;
+}
+LayerPoint translation = (userScroll / zoomAdjust) - geckoScroll;
+treeTransform = gfx3DMatrix(ViewTransform(-translation,
+userZoom
+/ metrics.mDevPixelsPerCSSPixel
+/ metrics.GetParentResolution()));
+// The transform already takes the resolution scale into account.  Since we
+// will apply the resolution scale again when computing the effective
+// transform, we must apply the inverse resolution scale here.
+gfx3DMatrix computedTransform = treeTransform * currentTransform;
+computedTransform.Scale(1.0f/container->GetPreXScale(),
+1.0f/container->GetPreYScale(),
+1);
+computedTransform.ScalePost(1.0f/container->GetPostXScale(),
+1.0f/container->GetPostYScale(),
+1);
+Matrix4x4 matrix;
+ToMatrix4x4(computedTransform, matrix);
+layerComposite->SetShadowTransform(matrix);
+NS_ASSERTION(!layerComposite->GetShadowTransformSetByAnimation(),
+"overwriting animated transform!");
+// Apply resolution scaling to the old transform - the layer tree as it is
+// doesn't have the necessary transform to display correctly.
+oldTransform.Scale(metrics.mResolution.scale, metrics.mResolution.scale, 1);
+// Make sure that overscroll and under-zoom are represented in the old
+// transform so that fixed position content moves and scales accordingly.
+// These calculations will effectively scale and offset fixed position layers
+// in screen space when the compensatory transform is performed in
+// AlignFixedAndStickyLayers.
+ScreenRect contentScreenRect = mContentRect * userZoom;
+gfxPoint3D overscrollTranslation;
+if (userScroll.x < contentScreenRect.x) {
+overscrollTranslation.x = contentScreenRect.x - userScroll.x;
+} else if (userScroll.x + metrics.mCompositionBounds.width > contentScreenRect.XMost()) {
+overscrollTranslation.x = contentScreenRect.XMost() -
+(userScroll.x + metrics.mCompositionBounds.width);
+}
+if (userScroll.y < contentScreenRect.y) {
+overscrollTranslation.y = contentScreenRect.y - userScroll.y;
+} else if (userScroll.y + metrics.mCompositionBounds.height > contentScreenRect.YMost()) {
+overscrollTranslation.y = contentScreenRect.YMost() -
+(userScroll.y + metrics.mCompositionBounds.height);
+}
+oldTransform.Translate(overscrollTranslation.x,
+overscrollTranslation.y,
+overscrollTranslation.z);
+gfx::Size underZoomScale(1.0f, 1.0f);
+if (mContentRect.width * userZoom.scale < metrics.mCompositionBounds.width) {
+underZoomScale.width = (mContentRect.width * userZoom.scale) /
+metrics.mCompositionBounds.width;
+}
+if (mContentRect.height * userZoom.scale < metrics.mCompositionBounds.height) {
+underZoomScale.height = (mContentRect.height * userZoom.scale) /
+metrics.mCompositionBounds.height;
+}
+oldTransform.Scale(underZoomScale.width, underZoomScale.height, 1);
+// Make sure fixed position layers don't move away from their anchor points
+// when we're asynchronously panning or zooming
+AlignFixedAndStickyLayers(aLayer, aLayer, oldTransform, fixedLayerMargins);
+}
+bool
+AsyncCompositionManager::TransformShadowTree(TimeStamp aCurrentFrame)
+{
+PROFILER_LABEL("AsyncCompositionManager", "TransformShadowTree");
+Layer* root = mLayerManager->GetRoot();
+if (!root) {
+return false;
+}
+// NB: we must sample animations *before* sampling pan/zoom
+// transforms.
+bool wantNextFrame = SampleAnimations(root, aCurrentFrame);
+// FIXME/bug 775437: unify this interface with the ~native-fennec
+// derived code
+//
+// Attempt to apply an async content transform to any layer that has
+// an async pan zoom controller (which means that it is rendered
+// async using Gecko). If this fails, fall back to transforming the
+// primary scrollable layer.  "Failing" here means that we don't
+// find a frame that is async scrollable.  Note that the fallback
+// code also includes Fennec which is rendered async.  Fennec uses
+// its own platform-specific async rendering that is done partially
+// in Gecko and partially in Java.
+if (!ApplyAsyncContentTransformToTree(aCurrentFrame, root, &wantNextFrame)) {
+nsAutoTArray<Layer*,1> scrollableLayers;
+#ifdef MOZ_WIDGET_ANDROID
+scrollableLayers.AppendElement(mLayerManager->GetPrimaryScrollableLayer());
+#else
+mLayerManager->GetScrollableLayers(scrollableLayers);
+#endif
+for (uint32_t i = 0; i < scrollableLayers.Length(); i++) {
+if (scrollableLayers[i]) {
+TransformScrollableLayer(scrollableLayers[i]);
+}
+}
+}
+return wantNextFrame;
+}
+void
+AsyncCompositionManager::SetFirstPaintViewport(const LayerIntPoint& aOffset,
+const CSSToLayerScale& aZoom,
+const CSSRect& aCssPageRect)
+{
+#ifdef MOZ_WIDGET_ANDROID
+AndroidBridge::Bridge()->SetFirstPaintViewport(aOffset, aZoom, aCssPageRect);
+#endif
+}
+void
+AsyncCompositionManager::SetPageRect(const CSSRect& aCssPageRect)
+{
+#ifdef MOZ_WIDGET_ANDROID
+AndroidBridge::Bridge()->SetPageRect(aCssPageRect);
+#endif
+}
+void
+AsyncCompositionManager::SyncViewportInfo(const LayerIntRect& aDisplayPort,
+const CSSToLayerScale& aDisplayResolution,
+bool aLayersUpdated,
+ScreenPoint& aScrollOffset,
+CSSToScreenScale& aScale,
+LayerMargin& aFixedLayerMargins,
+ScreenPoint& aOffset)
+{
+#ifdef MOZ_WIDGET_ANDROID
+AndroidBridge::Bridge()->SyncViewportInfo(aDisplayPort,
+aDisplayResolution,
+aLayersUpdated,
+aScrollOffset,
+aScale,
+aFixedLayerMargins,
+aOffset);
+#endif
+}
+void
+AsyncCompositionManager::SyncFrameMetrics(const ScreenPoint& aScrollOffset,
+float aZoom,
+const CSSRect& aCssPageRect,
+bool aLayersUpdated,
+const CSSRect& aDisplayPort,
+const CSSToLayerScale& aDisplayResolution,
+bool aIsFirstPaint,
+LayerMargin& aFixedLayerMargins,
+ScreenPoint& aOffset)
+{
+#ifdef MOZ_WIDGET_ANDROID
+AndroidBridge::Bridge()->SyncFrameMetrics(aScrollOffset, aZoom, aCssPageRect,
+aLayersUpdated, aDisplayPort,
+aDisplayResolution, aIsFirstPaint,
+aFixedLayerMargins, aOffset);
+#endif
+}
+} // namespace layers
+} // namespace mozilla

The Tor Browser / file comparison

comparison: gfx/layers/composite/AsyncCompositionManager.cpp

gfx/layers/composite/AsyncCompositionManager.cpp