The Tor Browser: gfx/layers/composite/AsyncCompositionManager.cpp@129ffea94266 (annotated)

gfx/layers/composite/AsyncCompositionManager.cpp@129ffea94266 (annotated)

gfx/layers/composite/AsyncCompositionManager.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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(),
 .0f/c->GetPreYScale(),
 );
   }
   layerTransform3D = layerTransform3D *
     Matrix4x4().Scale(1.0f/aLayer->GetPostXScale(),
 .0f/aLayer->GetPostYScale(),
 );
   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())),
 .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(),
 );
       }
       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(),
 .0f/container->GetPreYScale(),
 );
     transform = transform * Matrix4x4().Scale(1.0f/aLayer->GetPostXScale(),
 .0f/aLayer->GetPostYScale(),
 );
     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(),
 .0f/aScrollbar->GetPreYScale(),
 );
   transform = transform * Matrix4x4().Scale(1.0f/aScrollbar->GetPostXScale(),
 .0f/aScrollbar->GetPostYScale(),
 );
   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(),
 .0f/container->GetPreYScale(),
 );
   computedTransform.ScalePost(1.0f/container->GetPostXScale(),
 .0f/container->GetPostYScale(),
 );
   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 / annotate

gfx/layers/composite/AsyncCompositionManager.cpp@129ffea94266 (annotated)

gfx/layers/composite/AsyncCompositionManager.cpp