cc: Fix draw transform computation for non-drawn layers

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/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 92 matching lines @@
       use_property_trees(use_property_trees),
       render_surface_layer_list(render_surface_layer_list),
       current_render_surface_layer_list_id(
           current_render_surface_layer_list_id),
       property_trees(property_trees) {}
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
                                       const gfx::Transform& device_transform,
-                                      LayerImplList* render_surface_layer_list)
+                                      LayerImplList* render_surface_layer_list,
+                                      int current_render_surface_layer_list_id)
     : CalcDrawPropsImplInputs(root_layer,
                               device_viewport_size,
                               device_transform,
                               1.f,
                               1.f,
                               NULL,
                               NULL,
                               NULL,
                               gfx::Vector2dF(),
                               NULL,
                               std::numeric_limits<int>::max() / 2,
                               false,
                               false,
                               true,
                               false,
                               true,
                               false,
                               render_surface_layer_list,
-                              0,
+                              current_render_surface_layer_list_id,
                               GetPropertyTrees(root_layer)) {
   DCHECK(root_layer);
   DCHECK(render_surface_layer_list);
 }
 
 LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting::
     CalcDrawPropsImplInputsForTesting(LayerImpl* root_layer,
                                       const gfx::Size& device_viewport_size,
-                                      LayerImplList* render_surface_layer_list)
+                                      LayerImplList* render_surface_layer_list,
+                                      int current_render_surface_layer_list_id)
     : CalcDrawPropsImplInputsForTesting(root_layer,
                                         device_viewport_size,
                                         gfx::Transform(),
-                                        render_surface_layer_list) {}
+                                        render_surface_layer_list,
+                                        current_render_surface_layer_list_id) {}
 
 ScrollAndScaleSet::ScrollAndScaleSet()
     : page_scale_delta(1.f), top_controls_delta(0.f) {
 }
 
 ScrollAndScaleSet::~ScrollAndScaleSet() {}
 
 static gfx::Vector2dF GetEffectiveScrollDelta(LayerImpl* layer) {
   // Layer's scroll offset can have an integer part and fractional part.
   // Due to Blink's limitation, it only counter-scrolls the position-fixed
@@ skipping 295 matching lines @@
   // The current W3C spec on CSS transforms says that backface visibility should
   // be determined differently depending on whether the layer is in a "3d
   // rendering context" or not. For Chromium code, we can determine whether we
   // are in a 3d rendering context by checking if the parent preserves 3d.
 
   if (LayerIsInExisting3DRenderingContext(layer)) {
     if (use_property_trees) {
       return DrawTransformFromPropertyTrees(layer, transform_tree)
           .IsBackFaceVisible();
     } else {
-      return layer->draw_transform().IsBackFaceVisible();
+      return layer->draw_properties()
+          .target_space_transform.IsBackFaceVisible();
     }
   }
 
   // In this case, either the layer establishes a new 3d rendering context, or
   // is not in a 3d rendering context at all.
   return layer->transform().IsBackFaceVisible();
 }
 
 static bool IsSurfaceBackFaceVisible(LayerImpl* layer,
                                      const gfx::Transform& draw_transform) {
@@ skipping 45 matching lines @@
     // layer.
     visible_rect_in_target_surface_space.Intersect(
         clip_rect_of_target_surface_in_target_space);
   }
 
   if (visible_rect_in_target_surface_space.IsEmpty())
     return gfx::Rect();
 
   return CalculateVisibleRectWithCachedLayerRect(
       visible_rect_in_target_surface_space, gfx::Rect(layer->bounds()),
-      layer_rect_in_target_space, layer->draw_transform());
+      layer_rect_in_target_space,
+      layer->draw_properties().target_space_transform);
 }
 
 static bool LayerShouldBeSkipped(LayerImpl* layer,
                                  bool layer_is_drawn,
                                  bool use_property_trees,
                                  const TransformTree& transform_tree) {
   // Layers can be skipped if any of these conditions are met.
   //   - is not drawn due to it or one of its ancestors being hidden (or having
   //     no copy requests).
   //   - does not draw content.
@@ skipping 242 matching lines @@
        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
   gfx::Transform container_layer_space_to_container_target_surface_space =
-      container->draw_transform();
+      container->draw_properties().target_space_transform;
   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
@@ skipping 1144 matching lines @@
     // clipping goes on between layers here.
     clip_rect_of_target_surface_in_target_space =
         data_from_ancestor.clip_rect_of_target_surface_in_target_space;
   }
 
   layer_draw_properties.can_use_lcd_text = layer_can_use_lcd_text;
 
   // The layer bounds() includes the layer's bounds_delta() which we want
   // for the clip rect.
   gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
-      layer->draw_transform(), gfx::Rect(layer->bounds()));
+      layer->draw_properties().target_space_transform,
+      gfx::Rect(layer->bounds()));
 
   if (LayerClipsSubtree(layer)) {
     layer_or_ancestor_clips_descendants = true;
     if (ancestor_clips_subtree && !render_to_separate_surface) {
       // A layer without render surface shares the same target as its ancestor.
       clip_rect_in_target_space =
           ancestor_clip_rect_in_target_space;
       clip_rect_in_target_space.Intersect(rect_in_target_space);
     } else {
       clip_rect_in_target_space = rect_in_target_space;
@@ skipping 380 matching lines @@
       current_layer, property_trees, layers_always_allowed_lcd_text,
       can_use_lcd_text, &draw_properties);
 
   const bool visible_rects_match = ApproximatelyEqual(
       current_layer->visible_layer_rect(), draw_properties.visible_layer_rect);
   CHECK(visible_rects_match)
       << "expected: " << current_layer->visible_layer_rect().ToString()
       << " actual: " << draw_properties.visible_layer_rect.ToString();
 
   const bool draw_transforms_match = ApproximatelyEqual(
-      current_layer->draw_transform(), draw_properties.target_space_transform);
+      current_layer->draw_properties().target_space_transform,
+      draw_properties.target_space_transform);
   CHECK(draw_transforms_match)
-      << "expected: " << current_layer->draw_transform().ToString()
+      << "expected: "
+      << current_layer->draw_properties().target_space_transform.ToString()
       << " actual: " << draw_properties.target_space_transform.ToString();
 
   CHECK_EQ(current_layer->draw_opacity(), draw_properties.opacity);
   CHECK_EQ(current_layer->can_use_lcd_text(), draw_properties.can_use_lcd_text);
   CHECK_EQ(current_layer->is_clipped(), draw_properties.is_clipped);
   CHECK_EQ(current_layer->screen_space_transform_is_animating(),
            draw_properties.screen_space_transform_is_animating);
 
   const bool drawable_content_rects_match =
       ApproximatelyEqual(current_layer->drawable_content_rect(),
@@ skipping 329 matching lines @@
 
 void CalculateRenderTarget(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
   CalculateRenderTargetInternal(inputs->root_layer, true,
                                 inputs->can_render_to_separate_surface);
 }
 
 void CalculateRenderSurfaceLayerList(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs) {
   const bool subtree_visible_from_ancestor = true;
+  DCHECK_EQ(
+      inputs->current_render_surface_layer_list_id,
+      inputs->root_layer->layer_tree_impl()->current_render_surface_list_id());
   CalculateRenderSurfaceLayerListInternal(
       inputs->root_layer, inputs->property_trees,
       inputs->render_surface_layer_list, nullptr, nullptr,
       subtree_visible_from_ancestor, inputs->can_render_to_separate_surface,
       inputs->current_render_surface_layer_list_id, inputs->max_texture_size,
       inputs->verify_property_trees, inputs->use_property_trees);
 }
 
 static void ComputeMaskLayerDrawProperties(const LayerImpl* layer,
                                            LayerImpl* mask_layer) {
   DrawProperties& mask_layer_draw_properties = mask_layer->draw_properties();
   mask_layer_draw_properties.visible_layer_rect = gfx::Rect(layer->bounds());
-  mask_layer_draw_properties.target_space_transform = layer->draw_transform();
+  mask_layer_draw_properties.target_space_transform =
+      layer->draw_properties().target_space_transform;
   mask_layer_draw_properties.maximum_animation_contents_scale =
       layer->draw_properties().maximum_animation_contents_scale;
   mask_layer_draw_properties.starting_animation_contents_scale =
       layer->draw_properties().starting_animation_contents_scale;
 }
 
 void CalculateDrawPropertiesAndVerify(
     LayerTreeHostCommon::CalcDrawPropsImplInputs* inputs,
     PropertyTreeOption property_tree_option) {
   inputs->render_surface_layer_list->clear();
@@ skipping 142 matching lines @@
 
 PropertyTrees* GetPropertyTrees(Layer* layer) {
   return layer->layer_tree_host()->property_trees();
 }
 
 PropertyTrees* GetPropertyTrees(LayerImpl* layer) {
   return layer->layer_tree_impl()->property_trees();
 }
 
 }  // namespace cc