Force use of and cache render surface.

cc/output/direct_renderer.cc

 // Copyright 2012 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/output/direct_renderer.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 606 matching lines @@
   ScopedResource* texture = render_pass_textures_[render_pass->id].get();
   DCHECK(texture);
 
   gfx::Size size = RenderPassTextureSize(render_pass);
   size.Enlarge(enlarge_pass_texture_amount_.width(),
                enlarge_pass_texture_amount_.height());
   if (!texture->id()) {
     texture->Allocate(
         size, ResourceProvider::TEXTURE_HINT_IMMUTABLE_FRAMEBUFFER,
         BackbufferFormat(), current_frame()->current_render_pass->color_space);
+  } else {
+    if (render_pass->force_render_surface &&

[jbauman, 2017/06/07 22:05:34]

Could we instead set the damage rectangle to empty in the surface aggregator,
and in the direct renderer avoid setting up the renderpass at all if the damage
rect is empty?

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

Sounds good and thanks for your sample cl.

The damage_rect also includes damage from the render surface itself. When
damage_rect is not empty, the render_pass may not have damage from contributing
render surfaces/layers/surface quads. Therefore, in both situations:
damage_rect.IsEmpty() or !(render_pass->has_damage_from_contributing_content()),
we can reuse the texture.

+        !(render_pass->has_property_change_on_contributing_render_surface ||
+          render_pass->has_damage_on_surface_quad)) {

[jbauman, 2017/05/30 22:04:07]

What exactly does it mean if there's damage on a surface quad here?
There shouldn't be any surface quads given to the direct renderer.

[wutao, 2017/05/30 23:12:52]

The surface_quad damage is accumulated during surface_aggregation and pass here
to indicate if we can reuse the texture. Since we do not have the concept of
surface quad (all should be flattened) in the renderer, we might give it
different name or grouped with other attribute/damage we will use at last.

+      return false;
+    }
   }
   DCHECK(texture->id());
 
   if (BindFramebufferToTexture(texture)) {
     InitializeViewport(current_frame(), render_pass->output_rect,
                        gfx::Rect(render_pass->output_rect.size()),
                        texture->size());
     return true;
   }
 
   return false;
 }
 
 bool DirectRenderer::HasAllocatedResourcesForTesting(int render_pass_id) const {
   auto iter = render_pass_textures_.find(render_pass_id);
   return iter != render_pass_textures_.end() && iter->second->id();
 }
 
 // static
 gfx::Size DirectRenderer::RenderPassTextureSize(const RenderPass* render_pass) {
   return render_pass->output_rect.size();
 }
 
 void DirectRenderer::SetCurrentFrameForTesting(const DrawingFrame& frame) {
   current_frame_valid_ = true;
   current_frame_ = frame;
 }
 
 }  // namespace cc