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 324 matching lines @@
     TRACE_EVENT_INSTANT0(
         "cc",
         "LayerTreeHostCommon::SubtreeShouldRenderToSeparateSurface opacity",
         TRACE_EVENT_SCOPE_THREAD);
     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 ComputeSizeDeltaCompensation(
+    LayerImpl* layer,
+    LayerImpl* container,
+    const gfx::Vector2dF& position_offset) {
+  gfx::Transform result_transform;
+
+  // 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 target_surface_space_to_container_layer_space;
+  // Calculate step 1a
+  LayerImpl* container_target_surface =
+      container ? container->render_target() : 0;
+  for (LayerImpl* current_target_surface = NextTargetSurface(layer);
+      current_target_surface &&
+          current_target_surface != container_target_surface;
+      current_target_surface = NextTargetSurface(current_target_surface)) {
+    // Note: Concat is used here to convert the result coordinate space from
+    //       current render surface to the next render surface.
+    target_surface_space_to_container_layer_space.ConcatTransform(
+        current_target_surface->render_surface()->draw_transform());
+  }
+  // Calculate step 1b
+  if (container) {
+    gfx::Transform container_layer_space_to_container_target_surface_space =
+        container->draw_transform();
+    container_layer_space_to_container_target_surface_space.Scale(
+        container->contents_scale_x(), container->contents_scale_y());
+
+    gfx::Transform container_target_surface_space_to_container_layer_space;
+    if (container_layer_space_to_container_target_surface_space.GetInverse(
+        &container_target_surface_space_to_container_layer_space)) {
+      // Note: Again, Concat is used to conver the result coordinate space from
+      //       the container render surface to the container layer.
+      target_surface_space_to_container_layer_space.ConcatTransform(
+          container_target_surface_space_to_container_layer_space);
+    }
+  }
+
+  // Apply step 3
+  gfx::Transform container_layer_space_to_target_surface_space;
+  if (target_surface_space_to_container_layer_space.GetInverse(
+      &container_layer_space_to_target_surface_space))
+    result_transform.PreconcatTransform(
+        container_layer_space_to_target_surface_space);
+  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
+  result_transform.Translate(position_offset.x(), position_offset.y());
+
+  // Apply step 1
+  result_transform.PreconcatTransform(
+      target_surface_space_to_container_layer_space);
+
+  return result_transform;
+}
+
+void ApplyPositionAdjustment(
+    Layer* layer,
+    Layer* container,
+    const gfx::Transform& scroll_compensation,
+    gfx::Transform* combined_transform) { }
+void ApplyPositionAdjustment(
+    LayerImpl* layer,
+    LayerImpl* container,
+    const gfx::Transform& scroll_compensation,
+    gfx::Transform* combined_transform)
+{
+  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 scroll_deltas to keep
+  // this layer fixed correctly.
+  // Note carefully: this is Concat, not Preconcat
+  // (current_scroll_compensation * combined_transform).
+  combined_transform->ConcatTransform(scroll_compensation);
+
+  // For right-edge or bottom-edge anchored fixed position layers,
+  // the layer should relocate itself if the container changes its size.
+  bool fixed_to_right_edge =
+      layer->position_constraint().is_fixed_to_right_edge();
+  bool fixed_to_bottom_edge =
+      layer->position_constraint().is_fixed_to_bottom_edge();
+  gfx::Vector2dF position_offset =
+      container ? container->fixed_container_size_delta() : gfx::Vector2dF();
+  position_offset.set_x(fixed_to_right_edge ? position_offset.x() : 0);
+  position_offset.set_y(fixed_to_bottom_edge ? position_offset.y() : 0);
+  if (position_offset.IsZero())
+    return;
+
+  // Note: Again, this is Concat. The compensation matrix will be applied on
+  //       the vector in target surface space.
+  combined_transform->ConcatTransform(
+      ComputeSizeDeltaCompensation(layer, container, position_offset));
+}
+
 gfx::Transform ComputeScrollCompensationForThisLayer(
     LayerImpl* scrolling_layer,
     const gfx::Transform& parent_matrix) {
   // For every layer that has non-zero scroll_delta, we have to compute a
   // transform that can undo the scroll_delta translation. In particular, we
   // want this matrix to premultiply a fixed-position layer's parent_matrix, 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
@@ skipping 63 matching lines @@
   //  - If the fixed-position layer has its own render_surface, then the
   //  render_surface is the one who gets fixed.
   //
   // This function needs to be called AFTER layers create their own
   // render_surfaces.
   //
 
   // Avoid the overheads (including stack allocation and matrix
   // initialization/copy) if we know that the scroll compensation doesn't need
   // to be reset or adjusted.
-  if (!layer->is_container_for_fixed_position_layers() &&
+  if (!layer->IsContainerForFixedPositionLayers() &&
       layer->scroll_delta().IsZero() && !layer->render_surface())
     return current_scroll_compensation_matrix;
 
   // Start as identity matrix.
   gfx::Transform next_scroll_compensation_matrix;
 
   // If this layer is not a container, then it inherits the existing scroll
   // compensations.
-  if (!layer->is_container_for_fixed_position_layers())
+  if (!layer->IsContainerForFixedPositionLayers())
     next_scroll_compensation_matrix = current_scroll_compensation_matrix;
 
   // If the current layer has a non-zero scroll_delta, then we should compute
   // its local scroll compensation and accumulate it to the
   // next_scroll_compensation_matrix.
   if (!layer->scroll_delta().IsZero()) {
     gfx::Transform scroll_compensation_for_this_layer =
         ComputeScrollCompensationForThisLayer(layer, parent_matrix);
     next_scroll_compensation_matrix.PreconcatTransform(
         scroll_compensation_for_this_layer);
@@ skipping 181 matching lines @@
 }
 
 // Recursively walks the layer tree starting at the given node and computes all
 // the necessary transformations, clip rects, render surfaces, etc.
 template <typename LayerType, typename LayerList, typename RenderSurfaceType>
 static void CalculateDrawPropertiesInternal(
     LayerType* layer,
     const gfx::Transform& parent_matrix,
     const gfx::Transform& full_hierarchy_matrix,
     const gfx::Transform& current_scroll_compensation_matrix,
+    LayerType* current_fixed_container,
     gfx::Rect clip_rect_from_ancestor,
     gfx::Rect clip_rect_from_ancestor_in_descendant_space,
     bool ancestor_clips_subtree,
     RenderSurfaceType* nearest_ancestor_that_moves_pixels,
     LayerList* render_surface_layer_list,
     LayerList* layer_list,
     LayerSorter* layer_sorter,
     int max_texture_size,
     float device_scale_factor,
     float page_scale_factor,
@@ skipping 203 matching lines @@
   combined_transform.ConcatTransform(layer->impl_transform());
 
   if (!animating_transform_to_target && layer->scrollable() &&
       combined_transform.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(&combined_transform);
   }
 
-  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 scroll_deltas to keep
-    // this layer fixed correctly.
-    // Note carefully: this is Concat, not Preconcat
-    // (current_scroll_compensation * combined_transform).
-    combined_transform.ConcatTransform(current_scroll_compensation_matrix);
-  }
+  // Apply adjustment from position constraints.
+  ApplyPositionAdjustment(layer, current_fixed_container,
+      current_scroll_compensation_matrix, &combined_transform);
 
   // The draw_transform that gets computed below is effectively the layer's
   // draw_transform, unless the layer itself creates a render_surface. In that
   // case, the render_surface re-parents the transforms.
   layer_draw_properties.target_space_transform = combined_transform;
   // M[draw] = M[parent] * LT * S[layer2content]
   layer_draw_properties.target_space_transform.Scale
       (1.f / layer->contents_scale_x(), 1.f / layer->contents_scale_y());
 
   // The layer's screen_space_transform represents the transform between root
@@ skipping 218 matching lines @@
   // Any layers that are appended after this point are in the layer's subtree
   // and should be included in the sorting process.
   size_t sorting_start_index = descendants.size();
 
   if (!LayerShouldBeSkipped(layer))
     descendants.push_back(layer);
 
   gfx::Transform next_scroll_compensation_matrix =
       ComputeScrollCompensationMatrixForChildren(
           layer, parent_matrix, current_scroll_compensation_matrix);
+  LayerType* next_fixed_container =
+      layer->IsContainerForFixedPositionLayers() ?
+          layer : current_fixed_container;
 
   gfx::Rect accumulated_drawable_content_rect_of_children;
   for (size_t i = 0; i < layer->children().size(); ++i) {
     LayerType* child =
         LayerTreeHostCommon::get_child_as_raw_ptr(layer->children(), i);
     gfx::Rect drawable_content_rect_of_child_subtree;
     CalculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(
         child,
         sublayer_matrix,
         next_hierarchy_matrix,
         next_scroll_compensation_matrix,
+        next_fixed_container,
         clip_rect_for_subtree,
         clip_rect_for_subtree_in_descendant_space,
         subtree_should_be_clipped,
         nearest_ancestor_that_moves_pixels,
         render_surface_layer_list,
         &descendants,
         layer_sorter,
         max_texture_size,
         device_scale_factor,
         page_scale_factor,
@@ skipping 187 matching lines @@
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer,
                                   LayerList,
                                   RenderSurface>(root_layer,
                                                  device_scale_transform,
                                                  identity_matrix,
                                                  identity_matrix,
+                                                 NULL,
                                                  device_viewport_rect,
                                                  device_viewport_rect,
                                                  subtree_should_be_clipped,
                                                  NULL,
                                                  render_surface_layer_list,
                                                  &dummy_layer_list,
                                                  NULL,
                                                  max_texture_size,
                                                  device_scale_factor,
                                                  page_scale_factor,
@@ skipping 33 matching lines @@
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
                                   LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
       device_scale_transform,
       identity_matrix,
       identity_matrix,
+      NULL,
       device_viewport_rect,
       device_viewport_rect,
       subtree_should_be_clipped,
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
       max_texture_size,
       device_scale_factor,
       page_scale_factor,
@@ skipping 193 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(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc