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 1097 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 isn't capable of transforming its render surface since

[enne (OOO), 2013/06/04 17:26:03]

Hmm.  I'm not sure about the "external to the CC instance" language.  Can you
instead say something like:

The root layer's render surface size is predetermined and so the root layer
can't directly support non-identity scale transforms.  It should just forward
top-level transforms to the rest of the tree.

[aelias_OOO_until_Jul13, 2013/06/04 17:54:20]

Done.

+      // it's not created from within this CC instance. So it should just
+      // forward top-level transforms to the rest of the tree.
+      sublayer_matrix = combined_transform;

[enne (OOO), 2013/06/04 17:26:03]

What if the root layer also has a sublayer_matrix already? Can you add a test
for this?

[aelias_OOO_until_Jul13, 2013/06/04 17:54:20]

It should be fine because that will be applied later in LTHC.  I'll add a test.

+    } 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(),

[danakj, 2013/06/04 17:26:40]

Can these checks stay in the IsRootLayer() block? A scale here would still be
meaningless and get silently dropped on the root layer (tho applied to its
children).

[danakj, 2013/06/04 17:31:30]

enne pointed out that webview may want to actually scale the subtree. Instead of
setting the webview's scale on the root layer transform, can it be set on the
root layer's sublayer transform directly, so that no information is being
silently lost here (the root layer won't draw itself with a scale), and the
dchecks can remain?

[aelias_OOO_until_Jul13, 2013/06/04 17:54:20]

Patch Set 1 above applied it directly to root-layer sublayer transform.  But we
were reluctant either to add another argument to LTHCommon or to mutate a field
on the root-layer that is normally only changed on commit.

Could you clarify what you mean by "lost information"?  Note that I added test
coverage that the root render-surface draw transform will remain identityMatrix,
if that helps.

[danakj, 2013/06/04 18:02:50]

Lost information: I mean that if you set a scale 2x on the root layer, it's
contents will still appear at 1x on the screen.

[aelias_OOO_until_Jul13, 2013/06/04 22:18:27]

I changed my mind on this, I believe this use case will work properly after all
and I don't see why we need to DCHECK that the root layer doesn't draw content. 
root->target_space_transform is set to combined_transform earlier in LTHCommon,
and note that I put the 
"layer_draw_properties.target_space_transform.MakeIdentity();" into the else
clause below.  I added test coverage for the root layer's transform in my
LTHCommon test.

-                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,
       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,
       device_viewport_rect,
       device_viewport_rect,
       subtree_should_be_clipped,
       NULL,
       render_surface_layer_list,
       &dummy_layer_list,
       &layer_sorter,
@@ skipping 198 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