Create RenderSurface on Effect Tree

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/json/json_reader.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 70 matching lines @@
       transform_tree_index_(-1),
       effect_tree_index_(-1),
       clip_tree_index_(-1),
       draw_depth_(0.f),
       needs_push_properties_(false),
       num_dependents_need_push_properties_(0),
       sorting_context_id_(0),
       current_draw_mode_(DRAW_MODE_NONE),
       element_id_(0),
       mutable_properties_(kMutablePropertyNone),
+      force_render_surface_(false),
       num_layer_or_descendants_with_copy_request_(0),
       frame_timing_requests_dirty_(false),
       visited_(false),
       layer_or_descendant_is_drawn_(false),
       layer_or_descendant_has_input_handler_(false),
       sorted_for_recursion_(false) {
   DCHECK_GT(layer_id_, 0);
   DCHECK(layer_tree_impl_);
   layer_tree_impl_->RegisterLayer(this);
 
@@ skipping 172 matching lines @@
   // handle preserving these output requests (and their surface).
   if (!copy_requests_.empty()) {
     layer_tree_impl()->RemoveLayerWithCopyOutputRequest(this);
     // Destroying these will abort them.
     copy_requests_.clear();
   }
 
   if (requests->empty())
     return;
 
-  DCHECK(render_surface());
   bool was_empty = copy_requests_.empty();
   for (auto& request : *requests)
     copy_requests_.push_back(std::move(request));
   requests->clear();
 
   if (was_empty && layer_tree_impl()->IsActiveTree())
     layer_tree_impl()->AddLayerWithCopyOutputRequest(this);
   NoteLayerPropertyChangedForSubtree();
 }
 
@@ skipping 272 matching lines @@
   return LayerImpl::Create(tree_impl, layer_id_, scroll_offset_);
 }
 
 void LayerImpl::PushPropertiesTo(LayerImpl* layer) {
   layer->SetTransformOrigin(transform_origin_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(bounds_);
   layer->SetDoubleSided(double_sided_);
   layer->SetDrawsContent(DrawsContent());
   layer->SetHideLayerAndSubtree(hide_layer_and_subtree_);
+  // If whether layer has render surface changes, we need to update draw
+  // properties.
+  // TODO(weiliangc): Should be safely removed after impl side is able to
+  // update render surfaces without rebuilding property trees.
+  if (layer->has_render_surface() != has_render_surface())
+    layer->layer_tree_impl()->set_needs_update_draw_properties();
   layer->SetHasRenderSurface(!!render_surface());
+  layer->SetForceRenderSurface(force_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->SetScrollBlocksOn(scroll_blocks_on_);
   layer->SetNonFastScrollableRegion(non_fast_scrollable_region_);
   layer->SetTouchEventHandlerRegion(touch_event_handler_region_);
   layer->SetContentsOpaque(contents_opaque_);
@@ skipping 761 matching lines @@
   if (!layer_animation_controller_)
     return layer_tree_impl_->HasOnlyTranslationTransforms(this);
 
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_->HasOnlyTranslationTransforms(
       observer_type);
 }
 
+bool LayerImpl::AnimationsPreserveAxisAlignment() const {
+  return layer_animation_controller_
+             ? layer_animation_controller_->AnimationsPreserveAxisAlignment()
+             : layer_tree_impl_->AnimationsPreserveAxisAlignment(this);
+}
+
 bool LayerImpl::MaximumTargetScale(float* max_scale) const {
   if (!layer_animation_controller_)
     return layer_tree_impl_->MaximumTargetScale(this, max_scale);
 
   LayerAnimationController::ObserverType observer_type =
       IsActive() ? LayerAnimationController::ObserverType::ACTIVE
                  : LayerAnimationController::ObserverType::PENDING;
   return layer_animation_controller_->MaximumTargetScale(observer_type,
                                                          max_scale);
 }
@@ skipping 424 matching lines @@
     int group) {
   if (target_property == Animation::SCROLL_OFFSET)
     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();
 }
 
 gfx::Transform LayerImpl::DrawTransform() const {
   // Only drawn layers have up-to-date draw properties when property trees are
   // enabled.
@@ skipping 16 matching lines @@
   // enabled.
   if (layer_tree_impl()->settings().use_property_trees &&
       !IsDrawnRenderSurfaceLayerListMember()) {
     return ScreenSpaceTransformFromPropertyTrees(
         this, layer_tree_impl()->property_trees()->transform_tree);
   }
 
   return draw_properties().screen_space_transform;
 }
 
+void LayerImpl::SetForceRenderSurface(bool force_render_surface) {
+  if (force_render_surface == force_render_surface_)
+    return;
+
+  force_render_surface_ = force_render_surface;
+  NoteLayerPropertyChanged();
+}
+
 Region LayerImpl::GetInvalidationRegion() {
   return Region(update_rect_);
 }
 
 gfx::Rect LayerImpl::GetEnclosingRectInTargetSpace() const {
   return MathUtil::MapEnclosingClippedRect(DrawTransform(),
                                            gfx::Rect(bounds()));
 }
 
 gfx::Rect LayerImpl::GetScaledEnclosingRectInTargetSpace(float scale) const {
@@ skipping 16 matching lines @@
            .layer_transforms_should_scale_layer_contents) {
     return default_scale;
   }
 
   gfx::Vector2dF transform_scales = MathUtil::ComputeTransform2dScaleComponents(
       DrawTransform(), default_scale);
   return std::max(transform_scales.x(), transform_scales.y());
 }
 
 }  // namespace cc