Support bottom-right anchored fixed-position elements during a pinch gesture

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 298 matching lines @@
     bool atLeastTwoLayersInSubtreeDrawContent = numDescendantsThatDrawContent > 0 && (layer->DrawsContent() || numDescendantsThatDrawContent > 1);
 
     if (layer->opacity() != 1.f && !layer->preserves_3d() && atLeastTwoLayersInSubtreeDrawContent) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostCommon::requireSurface opacity");
         return true;
     }
 
     return false;
 }
 
+static LayerImpl* nextTargetSurface(LayerImpl* layer)
+{
+    return layer->parent() ? layer->parent()->render_target() : 0;
+}
+
+void applyPositionAdjustment(Layer*, Layer*, const gfx::Transform&, gfx::Transform*) { }
+void applyPositionAdjustment(LayerImpl* layer, LayerImpl* container, const gfx::Transform& scrollCompensation, gfx::Transform* combinedTransform)
+{
+    if (layer->position_constraint().is_fixed_position()) {
+        // Special case: this layer is a composited fixed-position layer; we need to
+        // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer
+        // fixed correctly.
+        // Note carefully: this is Concat, not Preconcat (currentScrollCompensation * combinedTransform).
+        combinedTransform->ConcatTransform(scrollCompensation);
+
+        // For right-edge or bottom-edge anchored fixed position layers,
+        // the layer should relocate itself if the container changes its size.
+        bool fixedToRightEdge = layer->position_constraint().is_fixed_to_right_edge();
+        bool fixedToBottomEdge = layer->position_constraint().is_fixed_to_bottom_edge();
+        gfx::Vector2dF positionOffset = container ? container->fixed_container_size_delta() : gfx::Vector2dF();
+        positionOffset.set_x(fixedToRightEdge ? positionOffset.x() : 0);
+        positionOffset.set_y(fixedToBottomEdge ? positionOffset.y() : 0);
+        if (positionOffset.IsZero())
+            return;
+
+        // To apply bottom-right anchor compensation in the container's layer space,
+        // the following steps need to be done:
+        //     Step 1a. transform from target surface space to the container's target surface space
+        //     Step 1b. transform from container's target surface space to the container's layer space
+        //     Step 2. apply the compensation
+        //     Step 3. transform back to target surface space
+
+        gfx::Transform targetSurfaceSpaceToContainerLayerSpace;
+
+        // Step 1a
+        LayerImpl* containerTargetSurface = container ? container->render_target() : 0;
+        for (LayerImpl* currentTargetSurface = nextTargetSurface(layer);
+             currentTargetSurface && currentTargetSurface != containerTargetSurface;
+             currentTargetSurface = nextTargetSurface(currentTargetSurface)) {
+            targetSurfaceSpaceToContainerLayerSpace.ConcatTransform(currentTargetSurface->render_surface()->draw_transform());
+        }
+
+        // Step 1b
+        gfx::Transform containerTargetSurfaceSpaceToContainerLayerSpace;
+        if (container && container->draw_transform().GetInverse(&containerTargetSurfaceSpaceToContainerLayerSpace))
+            targetSurfaceSpaceToContainerLayerSpace.ConcatTransform(containerTargetSurfaceSpaceToContainerLayerSpace);
+
+        combinedTransform->ConcatTransform(targetSurfaceSpaceToContainerLayerSpace);
+
+        // Step 2
+        combinedTransform->Translate(positionOffset.x(), positionOffset.y());

[shawnsingh, 2013/03/22 04:42:11]

This Translate is applied the same way as PreConcat, instead of Concat.  So this
isn't placing the translation in the place you might think it's being placed.

What you want is   Step3*Step2*Step1 * combinedTransform

but what seems to be computed here is Step3 * Step1 * combinedTransform * Step2.

But actually that's a moot point.  To repeat our conversation from last week - I
still feel you should not be repeating this math at all.  It's just an exact
duplicate of the scroll compensation math 50 lines below this, right?   Not only
will this be less efficient, but it will also be duplicated code that becomes
more error prone and maintenance bugs WILL occur with duplicated math code =) 
Is there some subtle difference in the math that requires a separate version? 
If so, let's discuss again offline.  Otherwise, let's please add the offset
below in the existing scroll compensation code (I'm putting another comment
where it should go).

To do that, you can add a few args to the scroll compensation code as needed,
and eventually (this patch ideally, or a follow-up patch) we should re-name
"scroll compensation" to fixedPositionCompensation or something more general.

Once you do that, this function would only exist to conditionally
Concat(compensationMatrix).   The actual computation of the scroll compensation
is invoked elsewhere in layer tree host common in the correct place, and you
would want to create another wrapper function there to add the offset
computation.

+
+        // Step 3
+        gfx::Transform containerLayerSpaceTotargetSurfaceSpace;
+        if (targetSurfaceSpaceToContainerLayerSpace.GetInverse(&containerLayerSpaceTotargetSurfaceSpace))
+            combinedTransform->ConcatTransform(containerLayerSpaceTotargetSurfaceSpace);
+    }
+}
+
 gfx::Transform computeScrollCompensationForThisLayer(LayerImpl* scrollingLayer, const gfx::Transform& parentMatrix)
 {
     // For every layer that has non-zero scrollDelta, we have to compute a transform that can undo the
     // scrollDelta translation. In particular, we want this matrix to premultiply a fixed-position layer's
     // parentMatrix, so we design this transform in three steps as follows. The steps described here apply
     // from right-to-left, so Step 1 would be the right-most matrix:
     //
     //     Step 1. transform from target surface space to the exact space where scrollDelta is actually applied.
     //           -- this is inverse of the matrix in step 3
     //     Step 2. undo the scrollDelta
     //           -- this is just a translation by scrollDelta.
     //     Step 3. transform back to target surface space.
     //           -- this transform is the "partialLayerOriginTransform" = (parentMatrix * scale(layer->pageScaleDelta()));
     //
     // These steps create a matrix that both start and end in targetSurfaceSpace. So this matrix can
     // pre-multiply any fixed-position layer's drawTransform to undo the scrollDeltas -- as long as
     // that fixed position layer is fixed onto the same renderTarget as this scrollingLayer.
     //
 
     gfx::Transform partialLayerOriginTransform = parentMatrix;
     partialLayerOriginTransform.PreconcatTransform(scrollingLayer->impl_transform());
 
     gfx::Transform scrollCompensationForThisLayer = partialLayerOriginTransform; // Step 3
     scrollCompensationForThisLayer.Translate(scrollingLayer->scroll_delta().x(), scrollingLayer->scroll_delta().y()); // Step 2

[shawnsingh, 2013/03/22 04:42:11]

This is where you would apply the offset Translation.  The offset can be passed
as an arg through the scroll compensation code.

 
     gfx::Transform inversePartialLayerOriginTransform(gfx::Transform::kSkipInitialization);
     if (!partialLayerOriginTransform.GetInverse(&inversePartialLayerOriginTransform)) {
         // TODO(shawnsingh): Either we need to handle uninvertible transforms
         // here, or DCHECK that the transform is invertible.
     }
     scrollCompensationForThisLayer.PreconcatTransform(inversePartialLayerOriginTransform); // Step 1
     return scrollCompensationForThisLayer;
 }
 
@@ skipping 193 matching lines @@
 static void roundTranslationComponents(gfx::Transform* transform)
 {
     transform->matrix().setDouble(0, 3, MathUtil::Round(transform->matrix().getDouble(0, 3)));
     transform->matrix().setDouble(1, 3, MathUtil::Round(transform->matrix().getDouble(1, 3)));
 }
 
 // Recursively walks the layer tree starting at the given node and computes all the
 // necessary transformations, clipRects, render surfaces, etc.
 template<typename LayerType, typename LayerList, typename RenderSurfaceType>
 static void calculateDrawPropertiesInternal(LayerType* layer, const gfx::Transform& parentMatrix,
-    const gfx::Transform& fullHierarchyMatrix, const gfx::Transform& currentScrollCompensationMatrix,
+    const gfx::Transform& fullHierarchyMatrix, const gfx::Transform& currentScrollCompensationMatrix, LayerType* currentFixedContainer,
     const gfx::Rect& clipRectFromAncestor, const gfx::Rect& clipRectFromAncestorInDescendantSpace, bool ancestorClipsSubtree,
     RenderSurfaceType* nearestAncestorThatMovesPixels, LayerList& renderSurfaceLayerList, LayerList& layerList,
     LayerSorter* layerSorter, int maxTextureSize, float deviceScaleFactor, float pageScaleFactor, bool subtreeCanUseLCDText,
     gfx::Rect& drawableContentRectOfSubtree, bool updateTilePriorities)
 {
     // This function computes the new matrix transformations recursively for this
     // layer and all its descendants. It also computes the appropriate render surfaces.
     // Some important points to remember:
     //
     // 0. Here, transforms are notated in Matrix x Vector order, and in words we describe what
@@ skipping 135 matching lines @@
     // computation of contentsScale above.
     // Note carefully: this is Concat, not Preconcat (implTransform * combinedTransform).
     combinedTransform.ConcatTransform(layer->impl_transform());
 
     if (!animatingTransformToTarget && layer->scrollable() && combinedTransform.IsScaleOrTranslation()) {
         // Align the scrollable layer's position to screen space pixels to avoid blurriness.
         // To avoid side-effects, do this only if the transform is simple.
         roundTranslationComponents(&combinedTransform);
     }
 
-    if (layer->fixed_to_container_layer()) {
-        // Special case: this layer is a composited fixed-position layer; we need to
-        // explicitly compensate for all ancestors' nonzero scrollDeltas to keep this layer
-        // fixed correctly.
-        // Note carefully: this is Concat, not Preconcat (currentScrollCompensation * combinedTransform).
-        combinedTransform.ConcatTransform(currentScrollCompensationMatrix);
-    }
+    // Apply adjustment from position constraints.
+    applyPositionAdjustment(layer, currentFixedContainer, currentScrollCompensationMatrix, &combinedTransform);
 
     // The drawTransform that gets computed below is effectively the layer's drawTransform, unless
     // the layer itself creates a renderSurface. In that case, the renderSurface re-parents the transforms.
     layerDrawProperties.target_space_transform = combinedTransform;
     // M[draw] = M[parent] * LT * S[layer2content]
     layerDrawProperties.target_space_transform.Scale(1.0 / layer->contents_scale_x(), 1.0 / layer->contents_scale_y());
 
     // layerScreenSpaceTransform represents the transform between root layer's "screen space" and local content space.
     layerDrawProperties.screen_space_transform = fullHierarchyMatrix;
     if (!layer->preserves_3d())
@@ skipping 161 matching lines @@
     }
 
     LayerList& descendants = (layer->render_surface() ? layer->render_surface()->layer_list() : layerList);
 
     // Any layers that are appended after this point are in the layer's subtree and should be included in the sorting process.
     unsigned sortingStartIndex = descendants.size();
 
     if (!layerShouldBeSkipped(layer))
         descendants.push_back(layer);
 
     gfx::Transform nextScrollCompensationMatrix = computeScrollCompensationMatrixForChildren(layer, parentMatrix, currentScrollCompensationMatrix);;

[shawnsingh, 2013/03/22 04:42:11]

computeScrollCompensationMatrixForChildren is the function you want to pass
whatever offset information is needed.   If you think it's appropriate, you can
create a wrapper function that (a) computes the offset for the appropriate
container and (b) calls computeScrollCompensationMatrixForChildren, and call
that here instead.

+    LayerType* nextFixedContainer = layer->is_container_for_fixed_position_layers() ? layer : currentFixedContainer;
 
     gfx::Rect accumulatedDrawableContentRectOfChildren;
     for (size_t i = 0; i < layer->children().size(); ++i) {
         LayerType* child = LayerTreeHostCommon::getChildAsRawPtr(layer->children(), i);
         gfx::Rect drawableContentRectOfChildSubtree;
-        calculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix,
+        calculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(child, sublayerMatrix, nextHierarchyMatrix, nextScrollCompensationMatrix, nextFixedContainer,
                                                                                  clipRectForSubtree, clipRectForSubtreeInDescendantSpace, subtreeShouldBeClipped, nearestAncestorThatMovesPixels,
                                                                                  renderSurfaceLayerList, descendants, layerSorter, maxTextureSize, deviceScaleFactor, pageScaleFactor,
                                                                                  subtreeCanUseLCDText, drawableContentRectOfChildSubtree, updateTilePriorities);
         if (!drawableContentRectOfChildSubtree.IsEmpty()) {
             accumulatedDrawableContentRectOfChildren.Union(drawableContentRectOfChildSubtree);
             if (child->render_surface())
                 descendants.push_back(child);
         }
     }
 
@@ skipping 122 matching lines @@
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
     bool updateTilePriorities = false;
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     preCalculateMetaInformation<Layer>(rootLayer);
     calculateDrawPropertiesInternal<Layer, std::vector<scoped_refptr<Layer> >, RenderSurface>(
-        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, 0,
         deviceViewportRect, deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, 0, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect,
         updateTilePriorities);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->render_surface());
 }
 
 void LayerTreeHostCommon::calculateDrawProperties(LayerImpl* rootLayer, const gfx::Size& deviceViewportSize, float deviceScaleFactor, float pageScaleFactor, int maxTextureSize, bool canUseLCDText, std::vector<LayerImpl*>& renderSurfaceLayerList, bool updateTilePriorities)
 {
     gfx::Rect totalDrawableContentRect;
     gfx::Transform identityMatrix;
     gfx::Transform deviceScaleTransform;
     deviceScaleTransform.Scale(deviceScaleFactor, deviceScaleFactor);
     std::vector<LayerImpl*> dummyLayerList;
     LayerSorter layerSorter;
     
     // The root layer's renderSurface should receive the deviceViewport as the initial clipRect.
     bool subtreeShouldBeClipped = true;
     gfx::Rect deviceViewportRect(gfx::Point(), deviceViewportSize);
 
     // This function should have received a root layer.
     DCHECK(isRootLayer(rootLayer));
 
     preCalculateMetaInformation<LayerImpl>(rootLayer);
     calculateDrawPropertiesInternal<LayerImpl, std::vector<LayerImpl*>, RenderSurfaceImpl>(
-        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix,
+        rootLayer, deviceScaleTransform, identityMatrix, identityMatrix, 0,
         deviceViewportRect, deviceViewportRect, subtreeShouldBeClipped, 0, renderSurfaceLayerList,
         dummyLayerList, &layerSorter, maxTextureSize,
         deviceScaleFactor, pageScaleFactor, canUseLCDText, totalDrawableContentRect,
         updateTilePriorities);
 
     // The dummy layer list should not have been used.
     DCHECK(dummyLayerList.size() == 0);
     // A root layer renderSurface should always exist after calculateDrawProperties.
     DCHECK(rootLayer->render_surface());
 }
@@ skipping 127 matching lines @@
 
   // At this point, we think the point does hit the touch event handler region on the layer, but we need to walk up
   // the parents to ensure that the layer was not clipped in such a way that the
   // hit point actually should not hit the layer.
   if (pointIsClippedBySurfaceOrClipRect(screenSpacePoint, layerImpl))
      return false;
 
   return true;
 }
 }  // namespace cc