cc: Move tiling management out of draw properties calculation.

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 63 matching lines @@
   if (target_surface_rect.Contains(layer_rect_in_target_space))
     return layer_bound_rect;
 
   // If the layer doesn't fill up the entire surface, then find the part of
   // the surface rect where the layer could be visible. This avoids trying to
   // project surface rect points that are behind the projection point.
   gfx::Rect minimal_surface_rect = target_surface_rect;
   minimal_surface_rect.Intersect(layer_rect_in_target_space);
 
   if (minimal_surface_rect.IsEmpty())
-      return gfx::Rect();
+    return gfx::Rect();
 
   // Project the corners of the target surface rect into the layer space.
   // This bounding rectangle may be larger than it needs to be (being
   // axis-aligned), but is a reasonable filter on the space to consider.
   // Non-invertible transforms will create an empty rect here.
 
   gfx::Transform surface_to_layer(gfx::Transform::kSkipInitialization);
   if (!transform.GetInverse(&surface_to_layer)) {
     // Because we cannot use the surface bounds to determine what portion of
     // the layer is visible, we must conservatively assume the full layer is
@@ skipping 817 matching lines @@
     }
     next_scroll_compensation_matrix =
         inverse_surface_draw_transform * next_scroll_compensation_matrix *
         layer->render_surface()->draw_transform();
   }
 
   return next_scroll_compensation_matrix;
 }
 
 template <typename LayerType>
+static inline void UpdateLayerScaleDrawProperties(
+    LayerType* layer,
+    float ideal_contents_scale,
+    float maximum_animation_contents_scale,
+    float page_scale_factor,
+    float device_scale_factor) {
+  layer->draw_properties().ideal_contents_scale = ideal_contents_scale;
+  layer->draw_properties().maximum_animation_contents_scale =
+      maximum_animation_contents_scale;
+  layer->draw_properties().page_scale_factor = page_scale_factor;
+  layer->draw_properties().device_scale_factor = device_scale_factor;
+}
+
+template <typename LayerType>
 static inline void CalculateContentsScale(
     LayerType* layer,
     float contents_scale,
     float device_scale_factor,
     float page_scale_factor,
     float maximum_animation_contents_scale,
     bool animating_transform_to_screen) {
   layer->CalculateContentsScale(contents_scale,
                                 device_scale_factor,
                                 page_scale_factor,
@@ skipping 821 matching lines @@
       layer,
       globals.can_adjust_raster_scales,
       ideal_contents_scale,
       globals.device_scale_factor,
       data_from_ancestor.in_subtree_of_page_scale_application_layer
           ? globals.page_scale_factor
           : 1.f,
       combined_maximum_animation_contents_scale,
       animating_transform_to_screen);
 
+  UpdateLayerScaleDrawProperties(
+      layer,
+      ideal_contents_scale,
+      combined_maximum_animation_contents_scale,
+      data_from_ancestor.in_subtree_of_page_scale_application_layer
+          ? globals.page_scale_factor
+          : 1.f,
+      globals.device_scale_factor);
+
+  LayerType* mask_layer = layer->mask_layer();
+  if (mask_layer) {
+    UpdateLayerScaleDrawProperties(
+        mask_layer,
+        ideal_contents_scale,
+        combined_maximum_animation_contents_scale,
+        data_from_ancestor.in_subtree_of_page_scale_application_layer
+            ? globals.page_scale_factor
+            : 1.f,
+        globals.device_scale_factor);
+  }
+
+  LayerType* replica_mask_layer =
+      layer->replica_layer() ? layer->replica_layer()->mask_layer() : NULL;
+  if (replica_mask_layer) {
+    UpdateLayerScaleDrawProperties(
+        replica_mask_layer,
+        ideal_contents_scale,
+        combined_maximum_animation_contents_scale,
+        data_from_ancestor.in_subtree_of_page_scale_application_layer
+            ? globals.page_scale_factor
+            : 1.f,
+        globals.device_scale_factor);
+  }
+
   // 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(
       SK_MScalar1 / layer->contents_scale_x(),
       SK_MScalar1 / layer->contents_scale_y());
 
   // The layer's screen_space_transform represents the transform between root
@@ skipping 654 matching lines @@
       inputs->current_render_surface_layer_list_id);
 
   // 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(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc