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

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "cc/animation/animation.h"
@@ skipping 103 matching lines @@
     return;
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsCommit();
 }
 
 void Layer::SetNeedsFullTreeSync() {
   if (layer_tree_host_)
     layer_tree_host_->SetNeedsFullTreeSync();
 }
 
+bool Layer::IsPropertyChangeAllowed() const {
+  if (!layer_tree_host_)
+    return true;
+
+  if (!layer_tree_host_->settings().strict_layer_property_change_checking)
+    return true;
+
+  return !layer_tree_host_->in_paint_layer_contents();
+}
+
 gfx::Rect Layer::LayerRectToContentRect(const gfx::RectF& layer_rect) const {
   gfx::RectF content_rect =
       gfx::ScaleRect(layer_rect, contents_scale_x(), contents_scale_y());
   // Intersect with content rect to avoid the extra pixel because for some
   // values x and y, ceil((x / y) * y) may be x + 1.
   content_rect.Intersect(gfx::Rect(content_bounds()));
   return gfx::ToEnclosingRect(content_rect);
 }
 
 bool Layer::BlocksPendingCommit() const {
@@ skipping 36 matching lines @@
       return true;
   }
   return false;
 }
 
 void Layer::AddChild(scoped_refptr<Layer> child) {
   InsertChild(child, children_.size());
 }
 
 void Layer::InsertChild(scoped_refptr<Layer> child, size_t index) {
+  CHECK(IsPropertyChangeAllowed());
   child->RemoveFromParent();
   child->SetParent(this);
   child->stacking_order_changed_ = true;
 
   index = std::min(index, children_.size());
   children_.insert(children_.begin() + index, child);
   SetNeedsFullTreeSync();
 }
 
 void Layer::RemoveFromParent() {
+  CHECK(IsPropertyChangeAllowed());
   if (parent_)
     parent_->RemoveChildOrDependent(this);
 }
 
 void Layer::RemoveChildOrDependent(Layer* child) {
   if (mask_layer_ == child) {
     mask_layer_->SetParent(NULL);
     mask_layer_ = NULL;
     SetNeedsFullTreeSync();
     return;
@@ skipping 14 matching lines @@
     child->SetParent(NULL);
     children_.erase(iter);
     SetNeedsFullTreeSync();
     return;
   }
 }
 
 void Layer::ReplaceChild(Layer* reference, scoped_refptr<Layer> new_layer) {
   DCHECK(reference);
   DCHECK_EQ(reference->parent(), this);
+  CHECK(IsPropertyChangeAllowed());
 
   if (reference == new_layer)
     return;
 
   int reference_index = IndexOfChild(reference);
   if (reference_index == -1) {
     NOTREACHED();
     return;
   }
 
   reference->RemoveFromParent();
 
   if (new_layer) {
     new_layer->RemoveFromParent();
     InsertChild(new_layer, reference_index);
   }
 }
 
 int Layer::IndexOfChild(const Layer* reference) {
   for (size_t i = 0; i < children_.size(); ++i) {
     if (children_[i] == reference)
       return i;
   }
   return -1;
 }
 
 void Layer::SetBounds(gfx::Size size) {
+  CHECK(IsPropertyChangeAllowed());
   if (bounds() == size)
     return;
 
   bool first_resize = bounds().IsEmpty() && !size.IsEmpty();
 
   bounds_ = size;
 
   if (first_resize)
     SetNeedsDisplay();
   else
     SetNeedsCommit();
 }
 
 Layer* Layer::RootLayer() {
   Layer* layer = this;
   while (layer->parent())
     layer = layer->parent();
   return layer;
 }
 
 void Layer::RemoveAllChildren() {
+  CHECK(IsPropertyChangeAllowed());
   while (children_.size()) {
     Layer* layer = children_[0].get();
     DCHECK_EQ(this, layer->parent());
     layer->RemoveFromParent();
   }
 }
 
 void Layer::SetChildren(const LayerList& children) {
+  CHECK(IsPropertyChangeAllowed());
   if (children == children_)
     return;
 
   RemoveAllChildren();
   for (size_t i = 0; i < children.size(); ++i)
     AddChild(children[i]);
 }
 
 void Layer::SetAnchorPoint(gfx::PointF anchor_point) {
+  CHECK(IsPropertyChangeAllowed());
   if (anchor_point_ == anchor_point)
     return;
   anchor_point_ = anchor_point;
   SetNeedsCommit();
 }
 
 void Layer::SetAnchorPointZ(float anchor_point_z) {
+  CHECK(IsPropertyChangeAllowed());
   if (anchor_point_z_ == anchor_point_z)
     return;
   anchor_point_z_ = anchor_point_z;
   SetNeedsCommit();
 }
 
 void Layer::SetBackgroundColor(SkColor background_color) {
+  CHECK(IsPropertyChangeAllowed());
   if (background_color_ == background_color)
     return;
   background_color_ = background_color;
   SetNeedsCommit();
 }
 
 void Layer::CalculateContentsScale(
     float ideal_contents_scale,
     bool animating_transform_to_screen,
     float* contents_scale_x,
     float* contents_scale_y,
     gfx::Size* content_bounds) {
   *contents_scale_x = 1;
   *contents_scale_y = 1;
   *content_bounds = bounds();
 }
 
 void Layer::SetMasksToBounds(bool masks_to_bounds) {
+  CHECK(IsPropertyChangeAllowed());
   if (masks_to_bounds_ == masks_to_bounds)
     return;
   masks_to_bounds_ = masks_to_bounds;
   SetNeedsCommit();
 }
 
 void Layer::SetMaskLayer(Layer* mask_layer) {
+  CHECK(IsPropertyChangeAllowed());
   if (mask_layer_ == mask_layer)
     return;
   if (mask_layer_) {
     DCHECK_EQ(this, mask_layer_->parent());
     mask_layer_->RemoveFromParent();
   }
   mask_layer_ = mask_layer;
   if (mask_layer_) {
     DCHECK(!mask_layer_->parent());
     mask_layer_->RemoveFromParent();
     mask_layer_->SetParent(this);
     mask_layer_->SetIsMask(true);
   }
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetReplicaLayer(Layer* layer) {
+  CHECK(IsPropertyChangeAllowed());
   if (replica_layer_ == layer)
     return;
   if (replica_layer_) {
     DCHECK_EQ(this, replica_layer_->parent());
     replica_layer_->RemoveFromParent();
   }
   replica_layer_ = layer;
   if (replica_layer_) {
     DCHECK(!replica_layer_->parent());
     replica_layer_->RemoveFromParent();
     replica_layer_->SetParent(this);
   }
   SetNeedsFullTreeSync();
 }
 
 void Layer::SetFilters(const WebKit::WebFilterOperations& filters) {
+  CHECK(IsPropertyChangeAllowed());
   if (filters_ == filters)
     return;
   DCHECK(!filter_);
   filters_ = filters;
   SetNeedsCommit();
   if (!filters.isEmpty() && layer_tree_host_)
     layer_tree_host_->set_needs_filter_context();
 }
 
 void Layer::SetFilter(const skia::RefPtr<SkImageFilter>& filter) {
+  CHECK(IsPropertyChangeAllowed());
   if (filter_.get() == filter.get())
     return;
   DCHECK(filters_.isEmpty());
   filter_ = filter;
   SetNeedsCommit();
   if (filter && layer_tree_host_)
     layer_tree_host_->set_needs_filter_context();
 }
 
 void Layer::SetBackgroundFilters(const WebKit::WebFilterOperations& filters) {
+  CHECK(IsPropertyChangeAllowed());
   if (background_filters_ == filters)
     return;
   background_filters_ = filters;
   SetNeedsCommit();
   if (!filters.isEmpty() && layer_tree_host_)
     layer_tree_host_->set_needs_filter_context();
 }
 
 void Layer::SetOpacity(float opacity) {
+  CHECK(IsPropertyChangeAllowed());
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   SetNeedsCommit();
 }
 
 bool Layer::OpacityIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::Opacity);
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
 void Layer::SetContentsOpaque(bool opaque) {
+  CHECK(IsPropertyChangeAllowed());
   if (contents_opaque_ == opaque)
     return;
   contents_opaque_ = opaque;
   SetNeedsCommit();
 }
 
 void Layer::SetPosition(gfx::PointF position) {
+  CHECK(IsPropertyChangeAllowed());
   if (position_ == position)
     return;
   position_ = position;
   SetNeedsCommit();
 }
 
 bool Layer::IsContainerForFixedPositionLayers() const {
   if (!transform_.IsIdentityOrTranslation())
     return true;
   if (parent_ && !parent_->sublayer_transform_.IsIdentityOrTranslation())
     return true;
   return is_container_for_fixed_position_layers_;
 }
 
 void Layer::SetSublayerTransform(const gfx::Transform& sublayer_transform) {
+  CHECK(IsPropertyChangeAllowed());
   if (sublayer_transform_ == sublayer_transform)
     return;
   sublayer_transform_ = sublayer_transform;
   SetNeedsCommit();
 }
 
 void Layer::SetTransform(const gfx::Transform& transform) {
+  CHECK(IsPropertyChangeAllowed());
   if (transform_ == transform)
     return;
   transform_ = transform;
   SetNeedsCommit();
 }
 
 bool Layer::TransformIsAnimating() const {
   return layer_animation_controller_->IsAnimatingProperty(Animation::Transform);
 }
 
 void Layer::SetScrollOffset(gfx::Vector2d scroll_offset) {
+  CHECK(IsPropertyChangeAllowed());
   if (scroll_offset_ == scroll_offset)
     return;
   scroll_offset_ = scroll_offset;
   if (layer_scroll_client_)
     layer_scroll_client_->didScroll();
   SetNeedsCommit();
 }
 
 void Layer::SetMaxScrollOffset(gfx::Vector2d max_scroll_offset) {
+  CHECK(IsPropertyChangeAllowed());
   if (max_scroll_offset_ == max_scroll_offset)
     return;
   max_scroll_offset_ = max_scroll_offset;
   SetNeedsCommit();
 }
 
 void Layer::SetScrollable(bool scrollable) {
+  CHECK(IsPropertyChangeAllowed());
   if (scrollable_ == scrollable)
     return;
   scrollable_ = scrollable;
   SetNeedsCommit();
 }
 
 void Layer::SetShouldScrollOnMainThread(bool should_scroll_on_main_thread) {
+  CHECK(IsPropertyChangeAllowed());
   if (should_scroll_on_main_thread_ == should_scroll_on_main_thread)
     return;
   should_scroll_on_main_thread_ = should_scroll_on_main_thread;
   SetNeedsCommit();
 }
 
 void Layer::SetHaveWheelEventHandlers(bool have_wheel_event_handlers) {
+  CHECK(IsPropertyChangeAllowed());
   if (have_wheel_event_handlers_ == have_wheel_event_handlers)
     return;
   have_wheel_event_handlers_ = have_wheel_event_handlers;
   SetNeedsCommit();
 }
 
 void Layer::SetNonFastScrollableRegion(const Region& region) {
+  CHECK(IsPropertyChangeAllowed());
   if (non_fast_scrollable_region_ == region)
     return;
   non_fast_scrollable_region_ = region;
   SetNeedsCommit();
 }
 
 void Layer::SetTouchEventHandlerRegion(const Region& region) {
+  CHECK(IsPropertyChangeAllowed());
   if (touch_event_handler_region_ == region)
     return;
   touch_event_handler_region_ = region;
 }
 
 void Layer::SetDrawCheckerboardForMissingTiles(bool checkerboard) {
+  CHECK(IsPropertyChangeAllowed());
   if (draw_checkerboard_for_missing_tiles_ == checkerboard)
     return;
   draw_checkerboard_for_missing_tiles_ = checkerboard;
   SetNeedsCommit();
 }
 
 void Layer::SetForceRenderSurface(bool force) {
+  CHECK(IsPropertyChangeAllowed());
   if (force_render_surface_ == force)
     return;
   force_render_surface_ = force;
   SetNeedsCommit();
 }
 
 void Layer::SetImplTransform(const gfx::Transform& transform) {
+  CHECK(IsPropertyChangeAllowed());
   if (impl_transform_ == transform)
     return;
   impl_transform_ = transform;
   SetNeedsCommit();
 }
 
 void Layer::SetDoubleSided(bool double_sided) {
+  CHECK(IsPropertyChangeAllowed());
   if (double_sided_ == double_sided)
     return;
   double_sided_ = double_sided;
   SetNeedsCommit();
 }
 
 void Layer::SetIsDrawable(bool is_drawable) {
+  CHECK(IsPropertyChangeAllowed());
   if (is_drawable_ == is_drawable)
     return;
 
   is_drawable_ = is_drawable;
   SetNeedsCommit();
 }
 
 void Layer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
   update_rect_.Union(dirty_rect);
   needs_display_ = true;
@@ skipping 21 matching lines @@
 
   if (layer_tree_host_ && layer_tree_host_->CommitRequested())
     return;
 
   // Only request a commit if we have a fixed positioned descendant.
   if (DescendantIsFixedToContainerLayer())
     SetNeedsCommit();
 }
 
 void Layer::SetPositionConstraint(const LayerPositionConstraint& constraint) {
-    if (position_constraint_ == constraint)
-        return;
-    position_constraint_ = constraint;
-    SetNeedsCommit();
+  CHECK(IsPropertyChangeAllowed());
+  if (position_constraint_ == constraint)
+    return;
+  position_constraint_ = constraint;
+  SetNeedsCommit();
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetAnchorPoint(anchor_point_);
   layer->SetAnchorPointZ(anchor_point_z_);
   layer->SetBackgroundColor(background_color_);
-  layer->SetBounds(bounds_);
+  layer->SetBounds(last_bounds_);

[danakj, 2013/04/12 16:44:40]

I think this is problematic because if the bounds change, we still use the new
bounds, even though we push the old bounds.

We should either:
1) Conditionally set the real value or a "pending" value, and copying the
pending value over the real value after pushprops.
2) Make a PaintProperties struct on the layer. Save this struct before painting.
Use the values instead of live values during painting/pushing.

   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDebugName(debug_name_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
       draw_checkerboard_for_missing_tiles_);
   layer->SetForceRenderSurface(force_render_surface_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetFilters(filters());
   layer->SetFilter(filter());
@@ skipping 58 matching lines @@
 }
 
 scoped_ptr<LayerImpl> Layer::CreateLayerImpl(LayerTreeImpl* tree_impl) {
   return LayerImpl::Create(tree_impl, layer_id_);
 }
 
 bool Layer::DrawsContent() const {
   return is_drawable_;
 }
 
+void Layer::PrepareToUpdate() {
+  // Save layer properties that might change during Update().
+  // PushProperties() should use these saved values.
+  last_bounds_ = bounds_;
+}
+
 bool Layer::NeedMoreUpdates() {
   return false;
 }
 
 void Layer::SetDebugName(const std::string& debug_name) {
   debug_name_ = debug_name;
   SetNeedsCommit();
 }
 
 void Layer::SetRasterScale(float scale) {
@@ skipping 135 matching lines @@
 
 ScrollbarLayer* Layer::ToScrollbarLayer() {
   return NULL;
 }
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 }  // namespace cc