Implement transform/clip support for Android WebView.

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 780 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,
+    const gfx::Transform& next_sublayer_matrix,

[enne (OOO), 2013/05/29 20:34:12]

I'm always skeptical about adding more parameters to this function.  Maybe I'm
misunderstanding things, but is there a reason you can't just apply this
transform at the top of the tree?

     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,
@@ skipping 493 matching lines @@
 
   // Apply the sublayer transform at the anchor point of the layer.
   if (!layer->sublayer_transform().IsIdentity()) {
     sublayer_matrix.Translate(layer->anchor_point().x() * bounds.width(),
                               layer->anchor_point().y() * bounds.height());
     sublayer_matrix.PreconcatTransform(layer->sublayer_transform());
     sublayer_matrix.Translate(-layer->anchor_point().x() * bounds.width(),
                               -layer->anchor_point().y() * bounds.height());
   }
 
+  sublayer_matrix.PreconcatTransform(next_sublayer_matrix);
+
   LayerList& descendants =
       (layer->render_surface() ? layer->render_surface()->layer_list()
                                : *layer_list);
 
   // 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,
           page_scale_factor_for_transforms,
           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;
+    gfx::Transform identity_matrix;
     CalculateDrawPropertiesInternal<LayerType, LayerList, RenderSurfaceType>(
         child,
         sublayer_matrix,
         next_hierarchy_matrix,
         next_scroll_compensation_matrix,
+        identity_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,
@@ skipping 189 matching lines @@
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
 
   // 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,
+      identity_matrix,
+      device_scale_transform,
       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,
       page_scale_application_layer,
       in_subtree_of_page_scale_application_layer,
       can_use_lcd_text,
       can_adjust_raster_scales,
       &total_drawable_content_rect);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(root_layer->render_surface());
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     LayerImpl* root_layer,
     gfx::Size device_viewport_size,
+    const gfx::Transform& device_transform,
     float device_scale_factor,
     float page_scale_factor,
     LayerImpl* page_scale_application_layer,
     int max_texture_size,
     bool can_use_lcd_text,
     bool can_adjust_raster_scales,
     LayerImplList* render_surface_layer_list) {
   gfx::Rect total_drawable_content_rect;
   gfx::Transform identity_matrix;
-  gfx::Transform device_scale_transform;
-  device_scale_transform.Scale(device_scale_factor, device_scale_factor);
   LayerImplList dummy_layer_list;
   LayerSorter layer_sorter;
 
   // The root layer's render_surface should receive the device viewport as the
   // initial clip rect.
   bool subtree_should_be_clipped = true;
   gfx::Rect device_viewport_rect(device_viewport_size);
   bool in_subtree_of_page_scale_application_layer = false;
 
   // This function should have received a root layer.
   DCHECK(IsRootLayer(root_layer));
 
   PreCalculateMetaInformation<LayerImpl>(root_layer);
   CalculateDrawPropertiesInternal<LayerImpl,
                                   LayerImplList,
                                   RenderSurfaceImpl>(
       root_layer,
-      device_scale_transform,
       identity_matrix,
       identity_matrix,
+      identity_matrix,
+      device_transform,
       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,
@@ skipping 196 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