Force use of and cache render surface.

cc/quads/render_pass.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/quads/render_pass.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
@@ skipping 53 matching lines @@
 RenderPass::RenderPass()
     : quad_list(kDefaultNumQuadsToReserve),
       shared_quad_state_list(alignof(SharedQuadState),
                              sizeof(SharedQuadState),
                              kDefaultNumSharedQuadStatesToReserve) {}
 
 // Each layer usually produces one shared quad state, so the number of layers
 // is a good hint for what to reserve here.
 RenderPass::RenderPass(size_t num_layers)
     : has_transparent_background(true),
+      cache_render_pass(false),
+      has_damage_from_contributing_content(false),
       quad_list(kDefaultNumQuadsToReserve),
       shared_quad_state_list(alignof(SharedQuadState),
                              sizeof(SharedQuadState),
                              num_layers) {}
 
 RenderPass::RenderPass(size_t shared_quad_state_list_size,
                        size_t quad_list_size)
     : has_transparent_background(true),
+      cache_render_pass(false),
+      has_damage_from_contributing_content(false),
       quad_list(quad_list_size),
       shared_quad_state_list(alignof(SharedQuadState),
                              sizeof(SharedQuadState),
                              shared_quad_state_list_size) {}
 
 RenderPass::~RenderPass() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.quads"), "cc::RenderPass",
       reinterpret_cast<void*>(id));
 }
 
 std::unique_ptr<RenderPass> RenderPass::Copy(int new_id) const {
   std::unique_ptr<RenderPass> copy_pass(
       Create(shared_quad_state_list.size(), quad_list.size()));
   copy_pass->SetAll(new_id, output_rect, damage_rect, transform_to_root_target,
                     filters, background_filters, color_space,
-                    has_transparent_background);
+                    has_transparent_background, cache_render_pass,
+                    has_damage_from_contributing_content);
   return copy_pass;
 }
 
 std::unique_ptr<RenderPass> RenderPass::DeepCopy() const {
   // Since we can't copy these, it's wrong to use DeepCopy in a situation where
   // you may have copy_requests present.
   DCHECK_EQ(copy_requests.size(), 0u);
 
   std::unique_ptr<RenderPass> copy_pass(
       Create(shared_quad_state_list.size(), quad_list.size()));
   copy_pass->SetAll(id, output_rect, damage_rect, transform_to_root_target,
                     filters, background_filters, color_space,
-                    has_transparent_background);
+                    has_transparent_background, cache_render_pass,
+                    has_damage_from_contributing_content);
   for (auto* shared_quad_state : shared_quad_state_list) {
     SharedQuadState* copy_shared_quad_state =
         copy_pass->CreateAndAppendSharedQuadState();
     *copy_shared_quad_state = *shared_quad_state;
   }
   SharedQuadStateList::ConstIterator sqs_iter = shared_quad_state_list.begin();
   SharedQuadStateList::Iterator copy_sqs_iter =
       copy_pass->shared_quad_state_list.begin();
   for (auto* quad : quad_list) {
     while (quad->shared_quad_state != *sqs_iter) {
@@ skipping 42 matching lines @@
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::SetAll(uint64_t id,
                         const gfx::Rect& output_rect,
                         const gfx::Rect& damage_rect,
                         const gfx::Transform& transform_to_root_target,
                         const FilterOperations& filters,
                         const FilterOperations& background_filters,
                         const gfx::ColorSpace& color_space,
-                        bool has_transparent_background) {
+                        bool has_transparent_background,
+                        bool cache_render_pass,
+                        bool has_damage_from_contributing_content) {
   DCHECK(id);
 
   this->id = id;
   this->output_rect = output_rect;
   this->damage_rect = damage_rect;
   this->transform_to_root_target = transform_to_root_target;
   this->filters = filters;
   this->background_filters = background_filters;
   this->color_space = color_space;
   this->has_transparent_background = has_transparent_background;
+  this->cache_render_pass = cache_render_pass;
+  this->has_damage_from_contributing_content =
+      has_damage_from_contributing_content;
 
   DCHECK(quad_list.empty());
   DCHECK(shared_quad_state_list.empty());
 }
 
 void RenderPass::AsValueInto(base::trace_event::TracedValue* value) const {
   MathUtil::AddToTracedValue("output_rect", output_rect, value);
   MathUtil::AddToTracedValue("damage_rect", damage_rect, value);
 
   value->SetBoolean("has_transparent_background", has_transparent_background);
+  value->SetBoolean("cache_render_pass", cache_render_pass);
+  value->SetBoolean("has_damage_from_contributing_content",
+                    has_damage_from_contributing_content);
   value->SetInteger("copy_requests",
                     base::saturated_cast<int>(copy_requests.size()));
 
   value->BeginArray("filters");
   filters.AsValueInto(value);
   value->EndArray();
 
   value->BeginArray("background_filters");
   background_filters.AsValueInto(value);
   value->EndArray();
@@ skipping 66 matching lines @@
     case DrawQuad::RENDER_PASS:
     case DrawQuad::INVALID:
       LOG(FATAL) << "Invalid DrawQuad material " << quad->material;
       break;
   }
   quad_list.back()->shared_quad_state = shared_quad_state;
   return quad_list.back();
 }
 
 }  // namespace cc