Force use of and cache render surface.

cc/trees/property_tree_builder.cc

 // Copyright 2014 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/property_tree_builder.h"
 
 #include <stddef.h>
 
 #include <map>
 #include <set>
@@ skipping 20 matching lines @@
 namespace {
 
 template <typename LayerType>
 struct DataForRecursion {
   PropertyTrees* property_trees;
   LayerType* transform_tree_parent;
   LayerType* transform_fixed_parent;
   int clip_tree_parent;
   int effect_tree_parent;
   int scroll_tree_parent;
+  int closest_ancestor_with_cache_render_surface;
   int closest_ancestor_with_copy_request;
   const LayerType* page_scale_layer;
   const LayerType* inner_viewport_scroll_layer;
   const LayerType* outer_viewport_scroll_layer;
   const LayerType* overscroll_elasticity_layer;
   gfx::Vector2dF elastic_overscroll;
   float page_scale_factor;
   bool in_subtree_of_page_scale_layer;
   bool affected_by_inner_viewport_bounds_delta;
   bool affected_by_outer_viewport_bounds_delta;
@@ skipping 548 matching lines @@
 }
 
 static inline bool DoubleSided(Layer* layer) {
   return layer->double_sided();
 }
 
 static inline bool DoubleSided(LayerImpl* layer) {
   return layer->test_properties()->double_sided;
 }
 
+static inline bool CacheRenderSurface(Layer* layer) {
+  return layer->cache_render_surface();
+}
+
+static inline bool CacheRenderSurface(LayerImpl* layer) {
+  return layer->test_properties()->cache_render_surface;
+}
+
 static inline bool ForceRenderSurface(Layer* layer) {
   return layer->force_render_surface_for_testing();
 }
 
 static inline bool ForceRenderSurface(LayerImpl* layer) {
   return layer->test_properties()->force_render_surface;
 }
 
 template <typename LayerType>
 static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
@@ skipping 186 matching lines @@
     TRACE_EVENT_INSTANT0(
         "cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
         TRACE_EVENT_SCOPE_THREAD);
     return true;
   }
 
   // If we force it.
   if (ForceRenderSurface(layer))
     return true;
 
+  // If we cache it.
+  if (CacheRenderSurface(layer))
+    return true;
+
   // If we'll make a copy of the layer's contents.
   if (HasCopyRequest(layer))
     return true;
 
   return false;
 }
 
 static void TakeCopyRequests(
     Layer* layer,
     std::vector<std::unique_ptr<CopyOutputRequest>>* copy_requests) {
@@ skipping 86 matching lines @@
 
   EffectTree& effect_tree = data_for_children->property_trees->effect_tree;
   int node_id = effect_tree.Insert(EffectNode(), parent_id);
   EffectNode* node = effect_tree.back();
 
   node->stable_id = layer->id();
   node->opacity = Opacity(layer);
   node->blend_mode = BlendMode(layer);
   node->unscaled_mask_target_size = layer->bounds();
   node->has_render_surface = should_create_render_surface;
+  node->cache_render_surface = CacheRenderSurface(layer);
   node->has_copy_request = HasCopyRequest(layer);
   node->filters = Filters(layer);
   node->background_filters = BackgroundFilters(layer);
   node->filters_origin = FiltersOrigin(layer);
   node->has_potential_opacity_animation = has_potential_opacity_animation;
   node->has_potential_filter_animation = has_potential_filter_animation;
   node->double_sided = DoubleSided(layer);
   node->subtree_hidden = HideLayerAndSubtree(layer);
   node->is_currently_animating_opacity = OpacityIsAnimating(layer);
   node->is_currently_animating_filter = FilterIsAnimating(layer);
   node->effect_changed = PropertyChanged(layer);
   node->subtree_has_copy_request = SubtreeHasCopyRequest(layer);
+  node->closest_ancestor_with_cache_render_surface_id =
+      CacheRenderSurface(layer)
+          ? node_id
+          : data_from_ancestor.closest_ancestor_with_cache_render_surface;
   node->closest_ancestor_with_copy_request_id =
       HasCopyRequest(layer)
           ? node_id
           : data_from_ancestor.closest_ancestor_with_copy_request;
 
   if (MaskLayer(layer)) {
     node->mask_layer_id = MaskLayer(layer)->id();
     effect_tree.AddMaskLayerId(node->mask_layer_id);
   }
 
@@ skipping 13 matching lines @@
     // The root render surface acts as the unbounded and untransformed
     // surface into which content is drawn. The transform node created
     // from the root layer (which includes device scale factor) and
     // the clip node created from the root layer (which includes
     // viewports) apply to the root render surface's content, but not
     // to the root render surface itself.
     node->transform_id = TransformTree::kRootNodeId;
     node->clip_id = ClipTree::kViewportNodeId;
   }
 
+  data_for_children->closest_ancestor_with_cache_render_surface =
+      node->closest_ancestor_with_cache_render_surface_id;
   data_for_children->closest_ancestor_with_copy_request =
       node->closest_ancestor_with_copy_request_id;
   data_for_children->effect_tree_parent = node_id;
   layer->SetEffectTreeIndex(node_id);
 
   // For animation subsystem purposes, if this layer has a compositor element
   // id, we build a map from that id to this effect node.
   if (layer->element_id()) {
     data_for_children->property_trees
         ->element_id_to_effect_node_index[layer->element_id()] = node_id;
@@ skipping 293 matching lines @@
     return;
   }
 
   DataForRecursion<LayerType> data_for_recursion;
   data_for_recursion.property_trees = property_trees;
   data_for_recursion.transform_tree_parent = nullptr;
   data_for_recursion.transform_fixed_parent = nullptr;
   data_for_recursion.clip_tree_parent = ClipTree::kRootNodeId;
   data_for_recursion.effect_tree_parent = EffectTree::kInvalidNodeId;
   data_for_recursion.scroll_tree_parent = ScrollTree::kRootNodeId;
+  data_for_recursion.closest_ancestor_with_cache_render_surface =
+      EffectTree::kInvalidNodeId;
   data_for_recursion.closest_ancestor_with_copy_request =
       EffectTree::kInvalidNodeId;
   data_for_recursion.page_scale_layer = page_scale_layer;
   data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
   data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
   data_for_recursion.overscroll_elasticity_layer = overscroll_elasticity_layer;
   data_for_recursion.elastic_overscroll = elastic_overscroll;
   data_for_recursion.page_scale_factor = page_scale_factor;
   data_for_recursion.in_subtree_of_page_scale_layer = false;
   data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
@@ skipping 116 matching lines @@
       root_layer, page_scale_layer, inner_viewport_scroll_layer,
       outer_viewport_scroll_layer, overscroll_elasticity_layer,
       elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
       device_transform, property_trees, color);
   property_trees->effect_tree.CreateOrReuseRenderSurfaces(
       &render_surfaces, root_layer->layer_tree_impl());
   property_trees->ResetCachedData();
 }
 
 }  // namespace cc