cc: Add strict layer property change checking and handle bounds changes during paint.

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 250 matching lines @@
   // Mask layers don't get this call, so explicitly update them so they can
   // kick off tile rasterization.
   if (layer->mask_layer())
     layer->mask_layer()->UpdateTilePriorities();
   if (layer->replica_layer() && layer->replica_layer()->mask_layer())
     layer->replica_layer()->mask_layer()->UpdateTilePriorities();
 }
 
 static inline void UpdateTilePrioritiesForLayer(Layer* layer) {}
 
+static inline void PrepareToUpdateLayer(LayerImpl* layer) {}
+
+static inline void PrepareToUpdateLayer(Layer* layer) {
+  layer->PrepareToUpdate();
+
+  if (layer->mask_layer())
+    layer->mask_layer()->PrepareToUpdate();
+  if (layer->replica_layer() && layer->replica_layer()->mask_layer())
+    layer->replica_layer()->mask_layer()->PrepareToUpdate();
+}
+
 template <typename LayerType>
 static bool SubtreeShouldRenderToSeparateSurface(
     LayerType* layer,
     bool axis_aligned_with_respect_to_parent) {
   //
   // A layer and its descendants should render onto a new RenderSurfaceImpl if
   // any of these rules hold:
   //
 
   // The root layer should always have a render_surface.
@@ skipping 479 matching lines @@
     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,
     float page_scale_factor,
     bool subtree_can_use_lcd_text,
     gfx::Rect* drawable_content_rect_of_subtree,
-    bool update_tile_priorities) {
+    bool update_tile_priorities,
+    bool prepare_to_update) {
   // This function computes the new matrix transformations recursively for this
   // layer and all its descendants. It also computes the appropriate render
   // surfaces.
   // Some important points to remember:
   //
   // 0. Here, transforms are notated in Matrix x Vector order, and in words we
   // describe what the transform does from left to right.
   //
   // 1. In our terminology, the "layer origin" refers to the top-left corner of
   // a layer, and the positive Y-axis points downwards. This interpretation is
@@ skipping 458 matching lines @@
         subtree_should_be_clipped,
         nearest_ancestor_that_moves_pixels,
         render_surface_layer_list,
         &descendants,
         layer_sorter,
         max_texture_size,
         device_scale_factor,
         page_scale_factor,
         subtree_can_use_lcd_text,
         &drawable_content_rect_of_child_subtree,
-        update_tile_priorities);
+        update_tile_priorities,
+        prepare_to_update);
     if (!drawable_content_rect_of_child_subtree.IsEmpty()) {
       accumulated_drawable_content_rect_of_children.Union(
           drawable_content_rect_of_child_subtree);
       if (child->render_surface())
         descendants.push_back(child);
     }
   }
 
   if (layer->render_surface() && !IsRootLayer(layer) &&
       layer->render_surface()->layer_list().empty()) {
@@ skipping 142 matching lines @@
     *drawable_content_rect_of_subtree =
         gfx::ToEnclosingRect(layer->render_surface()->DrawableContentRect());
   } else {
     *drawable_content_rect_of_subtree = local_drawable_content_rect_of_subtree;
   }
 
   if (layer->HasContributingDelegatedRenderPasses()) {
     layer->render_target()->render_surface()->
         AddContributingDelegatedRenderPassLayer(layer);
   }
+
+  if (prepare_to_update)
+    PrepareToUpdateLayer(layer);
 }
 
 void LayerTreeHostCommon::CalculateDrawProperties(
     Layer* root_layer,
     gfx::Size device_viewport_size,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
     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);
   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 update_tile_priorities = false;
+  bool prepare_to_update = true;
 
   // 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,
                                                  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,
                                                  can_use_lcd_text,
                                                  &total_drawable_content_rect,
-                                                 update_tile_priorities);
+                                                 update_tile_priorities,
+                                                 prepare_to_update);
 
   // 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,
     float device_scale_factor,
     float page_scale_factor,
     int max_texture_size,
     bool can_use_lcd_text,
     LayerImplList* render_surface_layer_list,
     bool update_tile_priorities) {
   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 prepare_to_update = 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,
       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,
       page_scale_factor,
       can_use_lcd_text,
       &total_drawable_content_rect,
-      update_tile_priorities);
+      update_tile_priorities,
+      prepare_to_update);
 
   // 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());
 }
 
 static bool PointHitsRect(
     gfx::PointF screen_space_point,
@@ skipping 180 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