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 544 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 (render_surface->ForceRenderSurface()) {

[weiliangc, 2017/06/07 21:19:01]

I don't think this is where "force no clip" should happen.

My understanding for the wanted behavior is that:
1. Everything contributing to the render surface shouldn't be clipped by
anything outside the render surface to be fully visible/fully rastered. This
would be similar to how copy request is handled in the LayerVisibleRect
function. Another part of this work is to make sure when we force render surface
the drawable_content_space ends up sum of all contributing content without being
clipped.

2. The render surface itself, when drawing to the screen, would still be
clipped. So for render surface ForceRenderSurface we shouldn't set is_clipped
false here.

[wutao, 2017/06/09 02:31:33]

Done.

+    // Avoid clipping when force use of render surface. We might need the whole
+    // surface during some animations.
+    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);
 }
 
 static void SetSurfaceDrawOpacity(const EffectTree& tree,
@@ skipping 84 matching lines @@
       effect_tree.Node(effect_node->target_id);
   property_trees->GetToTarget(transform_node->id, target_effect_node->id,
                               &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 =

[weiliangc, 2017/06/07 21:19:01]

Force render surface will look like copy request: we should find the closest
ancestor with force render surface, and ignore all clips above that while
calculating the visible rect.

[wutao, 2017/06/09 02:31:33]

As discussed offline, will cache closest_ancestor_with_cache_render_surface_id
as we do for closest_ancestor_with_copy_request_id. Then in LayerVisibleRect,
choose smaller id to calculate the visible rect.

       property_trees->effect_tree.Node(layer->effect_tree_index());
   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;
   gfx::Rect layer_content_rect = gfx::Rect(layer->bounds());
   gfx::RectF accumulated_clip_in_root_space;
   if (non_root_copy_request) {
     bool include_expanding_clips = true;
     ConditionalClip accumulated_clip = ComputeAccumulatedClip(
@@ skipping 387 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