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 388 matching lines @@
   // 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;
+  LayerImpl* container_target_surface = container->render_target();
   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_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);
-    }
+  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.
@@ skipping 30 matching lines @@
   // 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();
+  gfx::Vector2dF position_offset = container->fixed_container_size_delta();
   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));
 }
@@ skipping 611 matching lines @@
     if (!layer->double_sided() && TransformToParentIsKnown(layer) &&
         IsSurfaceBackFaceVisible(layer, combined_transform))
       return;
 
     if (!layer->render_surface())
       layer->CreateRenderSurface();
 
     RenderSurfaceType* render_surface = layer->render_surface();
     render_surface->ClearLayerLists();
 
-    // The owning layer's draw transform has a scale from content to layer
-    // space which we do not want; so here we use the combined_transform
-    // instead of the draw_transform. However, we do need to add a different
-    // scale factor that accounts for the surface's pixel dimensions.
-    combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(),
-                             1.0 / render_surface_sublayer_scale.y());
-    render_surface->SetDrawTransform(combined_transform);
+    if (IsRootLayer(layer)) {
+      // The root layer's render surface size is predetermined and so the root
+      // layer can't directly support non-identity transforms.  It should just
+      // forward top-level transforms to the rest of the tree.
+      sublayer_matrix = combined_transform;
+    } else {
+      // The owning layer's draw transform has a scale from content to layer
+      // space which we do not want; so here we use the combined_transform
+      // instead of the draw_transform. However, we do need to add a different
+      // scale factor that accounts for the surface's pixel dimensions.
+      combined_transform.Scale(1.0 / render_surface_sublayer_scale.x(),
+                               1.0 / render_surface_sublayer_scale.y());
+      render_surface->SetDrawTransform(combined_transform);
 
-    // If this is the root layer, there should be no scale in the surface's draw
-    // transform.
-    if (IsRootLayer(layer)) {
-      DCHECK_EQ(render_surface_sublayer_scale.x(),
-                combined_transform_scales.x());
-      DCHECK_EQ(render_surface_sublayer_scale.y(),
-                combined_transform_scales.y());
+      // The owning layer's transform was re-parented by the surface, so the
+      // layer's new draw_transform only needs to scale the layer to surface
+      // space.
+      layer_draw_properties.target_space_transform.MakeIdentity();
+      layer_draw_properties.target_space_transform.
+          Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(),
+                render_surface_sublayer_scale.y() / layer->contents_scale_y());
+
+      // Inside the surface's subtree, we scale everything to the owning layer's
+      // scale.  The sublayer matrix transforms layer rects into target surface
+      // content space.  Conceptually, all layers in the subtree inherit the
+      // scale at the point of the render surface in the transform hierarchy,
+      // but we apply it explicitly to the owning layer and the remainder of the
+      // subtree independently.
+      DCHECK(sublayer_matrix.IsIdentity());
+      sublayer_matrix.Scale(render_surface_sublayer_scale.x(),
+                            render_surface_sublayer_scale.y());
     }
 
-    // The owning layer's transform was re-parented by the surface, so the
-    // layer's new draw_transform only needs to scale the layer to surface
-    // space.
-    layer_draw_properties.target_space_transform.MakeIdentity();
-    layer_draw_properties.target_space_transform.
-        Scale(render_surface_sublayer_scale.x() / layer->contents_scale_x(),
-              render_surface_sublayer_scale.y() / layer->contents_scale_y());
-
-    // Inside the surface's subtree, we scale everything to the owning layer's
-    // scale.  The sublayer matrix transforms layer rects into target surface
-    // content space.  Conceptually, all layers in the subtree inherit the scale
-    // at the point of the render surface in the transform hierarchy, but we
-    // apply it explicitly to the owning layer and the remainder of the subtree
-    // indenpendently.
-    DCHECK(sublayer_matrix.IsIdentity());
-    sublayer_matrix.Scale(render_surface_sublayer_scale.x(),
-                          render_surface_sublayer_scale.y());
-
     // The opacity value is moved from the layer to its surface, so that the
     // entire subtree properly inherits opacity.
     render_surface->SetDrawOpacity(accumulated_draw_opacity);
     render_surface->SetDrawOpacityIsAnimating(animating_opacity_to_target);
     animating_opacity_to_target = false;
     layer_draw_properties.opacity = 1.f;
     layer_draw_properties.opacity_is_animating = animating_opacity_to_target;
     layer_draw_properties.screen_space_opacity_is_animating =
         animating_opacity_to_screen;
 
@@ skipping 167 matching lines @@
           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,
         next_fixed_container,
         clip_rect_for_subtree,
         clip_rect_for_subtree_in_descendant_space,
         subtree_should_be_clipped,
         nearest_ancestor_that_moves_pixels,
@@ skipping 169 matching lines @@
     layer->render_target()->render_surface()->
         AddContributingDelegatedRenderPassLayer(layer);
   }
 
   SavePaintPropertiesLayer(layer);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     Layer* root_layer,
     gfx::Size device_viewport_size,
+    const gfx::Transform& device_transform,
     float device_scale_factor,
     float page_scale_factor,
     Layer* page_scale_application_layer,
     int max_texture_size,
     bool can_use_lcd_text,
     bool can_adjust_raster_scales,
     LayerList* 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);
+  gfx::Transform scaled_device_transform = device_transform;
+  scaled_device_transform.Scale(device_scale_factor, device_scale_factor);
   LayerList dummy_layer_list;
 
   // 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<Layer>(root_layer);
   CalculateDrawPropertiesInternal<Layer, LayerList, RenderSurface>(
       root_layer,
-      device_scale_transform,
+      scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      NULL,
+      root_layer,
       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);
+  gfx::Transform scaled_device_transform = device_transform;
+  scaled_device_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,
+      scaled_device_transform,
       identity_matrix,
       identity_matrix,
-      NULL,
+      root_layer,
       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 195 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