Moving RenderSurface creation outside of CalcDrawProps

cc/layers/layer_impl.cc

 // Copyright 2012 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_impl.h"
 
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_argument.h"
 #include "base/json/json_reader.h"
 #include "base/strings/stringprintf.h"
@@ skipping 51 matching lines @@
       transform_is_invertible_(true),
       is_container_for_fixed_position_layers_(false),
       background_color_(0),
       opacity_(1.0),
       blend_mode_(SkXfermode::kSrcOver_Mode),
       num_descendants_that_draw_content_(0),
       draw_depth_(0.f),
       needs_push_properties_(false),
       num_dependents_need_push_properties_(0),
       sorting_context_id_(0),
-      current_draw_mode_(DRAW_MODE_NONE) {
+      current_draw_mode_(DRAW_MODE_NONE),
+      active_render_surface_(NULL) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
   AnimationRegistrar* registrar = layer_tree_impl_->animationRegistrar();
   layer_animation_controller_ =
       registrar->GetAnimationControllerForId(layer_id_);
   layer_animation_controller_->AddValueObserver(this);
   if (IsActive()) {
     layer_animation_controller_->set_value_provider(this);
     layer_animation_controller_->set_layer_animation_delegate(this);
@@ skipping 147 matching lines @@
     gfx::Rect request_in_content_space =
         LayerRectToContentRect(request_in_layer_space);
     request->set_area(MathUtil::MapEnclosingClippedRect(
         draw_properties_.target_space_transform, request_in_content_space));
   }
 
   layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
 }
 
 void LayerImpl::CreateRenderSurface() {
-  DCHECK(!draw_properties_.render_surface);
-  draw_properties_.render_surface =
-      make_scoped_ptr(new RenderSurfaceImpl(this));
+  DCHECK(!render_surface_);
+  render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
   draw_properties_.render_target = this;
+  SetRenderSurfaceActive(true);
 }
 
 void LayerImpl::ClearRenderSurface() {
-  draw_properties_.render_surface.reset();
+  SetRenderSurfaceActive(false);
+  render_surface_.reset();
 }
 
 void LayerImpl::ClearRenderSurfaceLayerList() {
-  if (draw_properties_.render_surface)
-    draw_properties_.render_surface->layer_list().clear();
+  if (render_surface_)
+    render_surface_->layer_list().clear();
 }
 
 void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const {
   state->SetAll(draw_properties_.target_space_transform,
                 draw_properties_.content_bounds,
                 draw_properties_.visible_content_rect,
                 draw_properties_.clip_rect,
                 draw_properties_.is_clipped,
                 draw_properties_.opacity,
                 blend_mode_,
@@ skipping 271 matching lines @@
 
   layer->SetScrollClipLayer(scroll_clip_layer_ ? scroll_clip_layer_->id()
                                                : Layer::INVALID_ID);
   layer->set_user_scrollable_horizontal(user_scrollable_horizontal_);
   layer->set_user_scrollable_vertical(user_scrollable_vertical_);
   layer->SetScrollOffsetAndDelta(
       scroll_offset_, layer->ScrollDelta() - layer->sent_scroll_delta());
   layer->SetSentScrollDelta(gfx::Vector2d());
   layer->Set3dSortingContextId(sorting_context_id_);
   layer->SetNumDescendantsThatDrawContent(num_descendants_that_draw_content_);
+  layer->SetShouldHaveRenderSurface(ShouldHaveRenderSurface());
 
   LayerImpl* scroll_parent = NULL;
   if (scroll_parent_) {
     scroll_parent = layer->layer_tree_impl()->LayerById(scroll_parent_->id());
     DCHECK(scroll_parent);
   }
 
   layer->SetScrollParent(scroll_parent);
   if (scroll_children_) {
     std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>;
@@ skipping 156 matching lines @@
 const char* LayerImpl::LayerTypeAsString() const {
   return "cc::LayerImpl";
 }
 
 void LayerImpl::ResetAllChangeTrackingForSubtree() {
   layer_property_changed_ = false;
 
   update_rect_ = gfx::RectF();
   damage_rect_ = gfx::RectF();
 
-  if (draw_properties_.render_surface)
-    draw_properties_.render_surface->ResetPropertyChangedFlag();
+  if (render_surface_)
+    render_surface_->ResetPropertyChangedFlag();
 
   if (mask_layer_)
     mask_layer_->ResetAllChangeTrackingForSubtree();
 
   if (replica_layer_) {
     // This also resets the replica mask, if it exists.
     replica_layer_->ResetAllChangeTrackingForSubtree();
   }
 
   for (size_t i = 0; i < children_.size(); ++i)
@@ skipping 802 matching lines @@
   return num_descendants_that_draw_content_;
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
+void LayerImpl::SetRenderSurfaceActive(bool active) {
+  if (active == !!active_render_surface_) {
+    return;
+  }
+
+  if (active) {
+    active_render_surface_ = render_surface_.get();
+    return;
+  }
+  if (active_render_surface_) {
+    active_render_surface_->ClearLayerLists();
+  }
+  active_render_surface_ = NULL;
+}
+
+void LayerImpl::SetShouldHaveRenderSurface(bool should_have_render_surface) {
+  if (ShouldHaveRenderSurface() == should_have_render_surface)
+    return;
+  if (should_have_render_surface) {
+    CreateRenderSurface();
+    return;
+  }
+  ClearRenderSurface();
+}
+
 }  // namespace cc