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;
+}
+
+// This function returns a translation matrix that can be applied on a vector
+// that's in the layer's target surface coordinate, while the position offset is
+// specified in some ancestor layer's coordinate.
+gfx::Transform computeTranslateInContainerLayerSpace(LayerImpl* layer, LayerImpl* container, const gfx::Vector2dF& positionOffset)

[shawnsingh, 2013/03/23 00:07:03]

can we rename this to something like computeSizeDeltaCompensation, instead?  (1)
to self-document the similarity between scroll compensation and sizeDelta
compensation being similar.  (2) the existing name in my opinion is actually a
bit misleading, "in container layer space" doesn't actually indicate what the
spaces are at the input and output of applying the transform.

[trchen, 2013/03/26 01:45:28]

Done.

+{
+    gfx::Transform resultTransform;
+
+    // To apply a translate 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;

[shawnsingh, 2013/03/23 00:07:03]

There's some inconsistency in transform names in layer_tree_host_common.  Some
other places in code use left-to-right naming at the moment (to be changed
later) ... so it's a good idea to put a comment somewhere that says these
transforms are named the way they are interpreted from right-to-left (with
matrix*columnVector ordering).

[trchen, 2013/03/26 01:45:28]

I don't understand your suggestion here. No matter column vector or row vector
is used, the transformation converts a vector in target surface space to the
container layer space. The way I see it is that Transform as an opaque object,
which contains a pipeline of operations that will be applied on a vector.
Preconcat means we insert an operation at the front and concat means we append
an operation at the end of the pipeline.

I don't mind to change it to "containerLayerSpaceFromTargetSurfaceSpace". I
think it's a better practice (Hungarian notation) actually. Just want to confirm
your intention first.

+    // Calculate 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());

[shawnsingh, 2013/03/23 00:07:03]

A comment about using Concat would be nice here, too, since Concat is so rarely
used.  Also for Concat used a few lines below, too.

[trchen, 2013/03/26 01:45:28]

Done.

+    }
+    // Calculate step 1b
+    gfx::Transform containerTargetSurfaceSpaceToContainerLayerSpace;
+    if (container && container->draw_transform().GetInverse(&containerTargetSurfaceSpaceToContainerLayerSpace))
+        targetSurfaceSpaceToContainerLayerSpace.ConcatTransform(containerTargetSurfaceSpaceToContainerLayerSpace);
+
+    // Apply step 3
+    gfx::Transform containerLayerSpaceTotargetSurfaceSpace;
+    if (targetSurfaceSpaceToContainerLayerSpace.GetInverse(&containerLayerSpaceTotargetSurfaceSpace))
+        resultTransform.PreconcatTransform(containerLayerSpaceTotargetSurfaceSpace);
+    else {
+        // FIXME: A non-invertible matrix could still make meaningful projection.
+        // For example ScaleZ(0) is non-invertible but the layer is still visible.
+        return gfx::Transform();
+    }
+
+    // Apply step 2
+    resultTransform.Translate(positionOffset.x(), positionOffset.y());
+
+    // Apply step 1
+    resultTransform.PreconcatTransform(targetSurfaceSpaceToContainerLayerSpace);
+
+    return resultTransform;
+}
+
+
+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())
+        return;
+
+    // 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;
+
+    combinedTransform->ConcatTransform(computeTranslateInContainerLayerSpace(layer, container, positionOffset));
+}
+
 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
@@ skipping 217 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 162 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);;
+    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