Force use of and cache render surface.

cc/layers/render_surface_impl.cc

 // Copyright 2011 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/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 135 matching lines @@
 }
 
 const FilterOperations& RenderSurfaceImpl::BackgroundFilters() const {
   return OwningEffectNode()->background_filters;
 }
 
 bool RenderSurfaceImpl::HasCopyRequest() const {
   return OwningEffectNode()->has_copy_request;
 }
 
+bool RenderSurfaceImpl::CacheRenderSurface() const {
+  return OwningEffectNode()->cache_render_surface;
+}
+
 int RenderSurfaceImpl::TransformTreeIndex() const {
   return OwningEffectNode()->transform_id;
 }
 
 int RenderSurfaceImpl::ClipTreeIndex() const {
   return OwningEffectNode()->clip_id;
 }
 
 int RenderSurfaceImpl::EffectTreeIndex() const {
   return effect_tree_index_;
@@ skipping 29 matching lines @@
   gfx::Rect clip_in_surface_space =
       MathUtil::ProjectEnclosingClippedRect(target_to_surface, clip_rect());
   gfx::Rect expanded_clip_in_surface_space =
       Filters().MapRectReverse(clip_in_surface_space, SurfaceScale().matrix());
   gfx::Rect expanded_clip_in_target_space = MathUtil::MapEnclosingClippedRect(
       draw_transform(), expanded_clip_in_surface_space);
   return expanded_clip_in_target_space;
 }
 
 gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() {
-  if (HasCopyRequest() || !is_clipped())
+  if (CacheRenderSurface() || HasCopyRequest() || !is_clipped())
     return accumulated_content_rect();
 
   if (accumulated_content_rect().IsEmpty())
     return gfx::Rect();
 
   // Calculate projection from the target surface rect to local
   // space. Non-invertible draw transforms means no able to bring clipped rect
   // in target space back to local space, early out without clip.
   gfx::Transform target_to_surface(gfx::Transform::kSkipInitialization);
   if (!draw_transform().GetInverse(&target_to_surface))
@@ skipping 114 matching lines @@
   return ancestor_property_changed_ || property_trees->full_tree_damaged ||
          property_trees->transform_tree.Node(TransformTreeIndex())
              ->transform_changed ||
          property_trees->effect_tree.Node(EffectTreeIndex())->effect_changed;
 }
 
 void RenderSurfaceImpl::NoteAncestorPropertyChanged() {
   ancestor_property_changed_ = true;
 }
 
+bool RenderSurfaceImpl::HasDamageFromeContributingContent() const {
+  return damage_tracker_->has_damage_from_contributing_content();
+}
+
 gfx::Rect RenderSurfaceImpl::GetDamageRect() const {
   gfx::Rect damage_rect;
   bool is_valid_rect = damage_tracker_->GetDamageRectIfValid(&damage_rect);
   if (!is_valid_rect)
     return content_rect();
   return damage_rect;
 }
 
 void RenderSurfaceImpl::ResetPropertyChangedFlags() {
   surface_property_changed_ = false;
   ancestor_property_changed_ = false;
 }
 
 std::unique_ptr<RenderPass> RenderSurfaceImpl::CreateRenderPass() {
   std::unique_ptr<RenderPass> pass = RenderPass::Create(num_contributors_);
   gfx::Rect damage_rect = GetDamageRect();
   damage_rect.Intersect(content_rect());
   pass->SetNew(id(), content_rect(), damage_rect,
                draw_properties_.screen_space_transform);
   pass->filters = Filters();
   pass->background_filters = BackgroundFilters();
+  pass->cache_render_surface = CacheRenderSurface();
+  pass->has_damage_from_contributing_content =
+      HasDamageFromeContributingContent();
   return pass;
 }
 
 void RenderSurfaceImpl::AppendQuads(RenderPass* render_pass,
                                     AppendQuadsData* append_quads_data) {
   gfx::Rect visible_layer_rect =
       occlusion_in_content_space().GetUnoccludedContentRect(content_rect());
   if (visible_layer_rect.IsEmpty())
     return;
 
@@ skipping 162 matching lines @@
         NOTIMPLEMENTED();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 }
 
 }  // namespace cc