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 42 matching lines @@
       double_sided_(true),
       should_flatten_transform_(true),
       layer_property_changed_(false),
       masks_to_bounds_(false),
       contents_opaque_(false),
       is_root_for_isolated_group_(false),
       use_parent_backface_visibility_(false),
       draw_checkerboard_for_missing_tiles_(false),
       draws_content_(false),
       hide_layer_and_subtree_(false),
-      force_render_surface_(false),
       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),
@@ skipping 123 matching lines @@
 void LayerImpl::SetClipChildren(std::set<LayerImpl*>* children) {
   if (clip_children_.get() == children)
     return;
   clip_children_.reset(children);
   SetNeedsPushProperties();
 }
 
 void LayerImpl::PassCopyRequests(ScopedPtrVector<CopyOutputRequest>* requests) {
   if (requests->empty())
     return;
-
+  DCHECK(render_surface());
   bool was_empty = copy_requests_.empty();
   copy_requests_.insert_and_take(copy_requests_.end(), requests);
   requests->clear();
 
   if (was_empty && layer_tree_impl()->IsActiveTree())
     layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
   NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::TakeCopyRequestsAndTransformToTarget(
     ScopedPtrVector<CopyOutputRequest>* requests) {
   DCHECK(!copy_requests_.empty());
   DCHECK(layer_tree_impl()->IsActiveTree());
+  DCHECK(render_target() == this);

[enne (OOO), 2014/12/16 19:08:48]

DCHECK_EQ, to differentiate NULL vs different

[enne (OOO), 2014/12/16 19:08:48]

DCHECK_EQ, to differentiate NULL vs different

[awoloszyn, 2014/12/16 21:54:29]

Done.

 
   size_t first_inserted_request = requests->size();
   requests->insert_and_take(requests->end(), &copy_requests_);
   copy_requests_.clear();
 
   for (size_t i = first_inserted_request; i < requests->size(); ++i) {
     CopyOutputRequest* request = requests->at(i);
     if (!request->has_area())
       continue;
 
     gfx::Rect request_in_layer_space = request->area();
     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));
-  draw_properties_.render_target = this;
-}
-
-void LayerImpl::ClearRenderSurface() {
-  draw_properties_.render_surface = nullptr;
-}
-
 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,
       draw_properties_.blend_mode, sorting_context_id_);
 }
 
@@ skipping 247 matching lines @@
 
 void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetTransformOrigin(transform_origin_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(bounds_);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawCheckerboardForMissingTiles(
       draw_checkerboard_for_missing_tiles_);
-  layer->SetForceRenderSurface(force_render_surface_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
+  layer->SetHasRenderSurface(!!render_surface());
   layer->SetFilters(filters());
   layer->SetBackgroundFilters(background_filters());
   layer->SetMasksToBounds(masks_to_bounds_);
   layer->SetShouldScrollOnMainThread(should_scroll_on_main_thread_);
   layer->SetHaveWheelEventHandlers(have_wheel_event_handlers_);
   layer->SetHaveScrollEventHandlers(have_scroll_event_handlers_);
   layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
   layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
   layer->SetContentsOpaque(contents_opaque_);
   layer->SetOpacity(opacity_);
@@ skipping 197 matching lines @@
 const char* LayerImpl::LayerTypeAsString() const {
   return "cc::LayerImpl";
 }
 
 void LayerImpl::ResetAllChangeTrackingForSubtree() {
   layer_property_changed_ = false;
 
   update_rect_ = gfx::Rect();
   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 834 matching lines @@
 }
 
 void LayerImpl::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
     Animation::TargetProperty target_property,
     int group) {
   if (target_property == Animation::ScrollOffset)
     layer_tree_impl_->InputScrollAnimationFinished();
 }
 
+void LayerImpl::SetHasRenderSurface(bool should_have_render_surface) {
+  if (!!render_surface() == should_have_render_surface)
+    return;
+
+  SetNeedsPushProperties();
+  layer_tree_impl()->set_needs_update_draw_properties();
+  if (should_have_render_surface) {
+    render_surface_ = make_scoped_ptr(new RenderSurfaceImpl(this));
+    return;
+  }
+  render_surface_.reset();
+}
+
 }  // namespace cc