Force use of and cache render surface.

cc/trees/draw_property_utils.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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 545 matching lines @@
   bool is_clipped;
   if (render_surface->EffectTreeIndex() == EffectTree::kContentsRootNodeId) {
     // Root render surface is always clipped.
     is_clipped = true;
   } else if (render_surface->has_contributing_layer_that_escapes_clip()) {
     // We cannot clip a surface that has a contribuitng layer which escapes the
     // clip.
     is_clipped = false;
   } else if (render_surface->ClipTreeIndex() ==
              render_surface->render_target()->ClipTreeIndex()) {
-    // There is no clip between between the render surface and its target, so
+    // There is no clip between the render surface and its target, so
     // the surface need not be clipped.
     is_clipped = false;
   } else {
     // If the clips between the render surface and its target only expand the
     // clips and do not apply any new clip, we need not clip the render surface.
     const ClipNode* clip_node = clip_tree.Node(render_surface->ClipTreeIndex());
     is_clipped = clip_node->clip_type != ClipNode::ClipType::EXPANDS_CLIP;
   }
   render_surface->SetIsClipped(is_clipped);
 }
@@ skipping 88 matching lines @@
                               &render_surface_transform);
 
   ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
 static gfx::Rect LayerVisibleRect(PropertyTrees* property_trees,
                                   LayerImpl* layer) {
   const EffectNode* effect_node =
       property_trees->effect_tree.Node(layer->effect_tree_index());
+  int effect_ancestor_with_cache_render_surface =
+      effect_node->closest_ancestor_with_cache_render_surface_id;
   int effect_ancestor_with_copy_request =
       effect_node->closest_ancestor_with_copy_request_id;
-  bool non_root_copy_request =
-      effect_ancestor_with_copy_request > EffectTree::kContentsRootNodeId;
+  int lower_effect_closest_ancestor;
+  if (effect_ancestor_with_cache_render_surface == EffectTree::kInvalidNodeId) {
+    lower_effect_closest_ancestor = effect_ancestor_with_copy_request;
+  } else if (effect_ancestor_with_copy_request == EffectTree::kInvalidNodeId) {
+    lower_effect_closest_ancestor = effect_ancestor_with_cache_render_surface;
+  } else {
+    lower_effect_closest_ancestor =
+        std::min(effect_ancestor_with_cache_render_surface,
+                 effect_ancestor_with_copy_request);
+  }
+  bool non_root_copy_request_or_cache_render_surface =
+      lower_effect_closest_ancestor > EffectTree::kContentsRootNodeId;
   gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
   gfx::RectF accumulated_clip_in_root_space;
-  if (non_root_copy_request) {
+  if (non_root_copy_request_or_cache_render_surface) {
     bool include_expanding_clips = true;
     ConditionalClip accumulated_clip = ComputeAccumulatedClip(
         property_trees, include_expanding_clips, layer->clip_tree_index(),
-        effect_ancestor_with_copy_request);
+        lower_effect_closest_ancestor);
     if (!accumulated_clip.is_clipped)
       return layer_content_rect;
     accumulated_clip_in_root_space = accumulated_clip.clip_rect;
   } else {
     const ClipNode* clip_node =
         property_trees->clip_tree.Node(layer->clip_tree_index());
     accumulated_clip_in_root_space =
         clip_node->cached_accumulated_rect_in_screen_space;
   }
 
   const EffectNode* root_effect_node =
-      non_root_copy_request
-          ? property_trees->effect_tree.Node(effect_ancestor_with_copy_request)
+      non_root_copy_request_or_cache_render_surface
+          ? property_trees->effect_tree.Node(lower_effect_closest_ancestor)
           : property_trees->effect_tree.Node(EffectTree::kContentsRootNodeId);
   ConditionalClip accumulated_clip_in_layer_space =
       ComputeTargetRectInLocalSpace(
           accumulated_clip_in_root_space, property_trees,
           root_effect_node->transform_id, layer->transform_tree_index(),
           root_effect_node->id);
   if (!accumulated_clip_in_layer_space.is_clipped) {
     return layer_content_rect;
   }
   gfx::RectF clip_in_layer_space = accumulated_clip_in_layer_space.clip_rect;
@@ skipping 369 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc