gpu: Empty swaps for surfaceless output surfaces.

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 <unordered_map>
 #include <utility>
@@ skipping 75 matching lines @@
 
 DirectRenderer::~DirectRenderer() = default;
 
 void DirectRenderer::Initialize() {
   overlay_processor_->Initialize();
 
   auto* context_provider = output_surface_->context_provider();
 
   use_partial_swap_ = settings_->partial_swap_enabled && CanPartialSwap();
   allow_empty_swap_ = use_partial_swap_;
+  allow_partial_swap_ = use_partial_swap_;
   if (context_provider) {
     if (context_provider->ContextCapabilities().commit_overlay_planes)
       allow_empty_swap_ = true;
     if (context_provider->ContextCapabilities().dc_layers)
       supports_dc_layers_ = true;
+    if (context_provider->ContextCapabilities()
+            .disable_non_empty_post_sub_buffers) {
+      allow_partial_swap_ = false;

[jbauman, 2017/04/20 21:30:06]

If you just set use_partial_swap_=false here, then allow_empty_swap_ will be
true and you shouldn't need the allow_partial_swap_ variable at all.

[reveman, 2017/04/20 22:11:40]

Good idea. Done.

+    }
   }
 
   initialized_ = true;
 }
 
 // static
 gfx::RectF DirectRenderer::QuadVertexRect() {
   return gfx::RectF(-0.5f, -0.5f, 1.f, 1.f);
 }
 
@@ skipping 225 matching lines @@
     current_frame()->root_damage_rect =
         current_frame()->root_render_pass->output_rect;
   }
 
   // We can skip all drawing if the damage rect is now empty.
   bool skip_drawing_root_render_pass =
       current_frame()->root_damage_rect.IsEmpty() && allow_empty_swap_;
 
   // If we have to draw but don't support partial swap, the whole output should
   // be considered damaged.
-  if (!skip_drawing_root_render_pass && !use_partial_swap_)
+  if (!skip_drawing_root_render_pass && !allow_partial_swap_)
     current_frame()->root_damage_rect = root_render_pass->output_rect;
 
-  if (skip_drawing_root_render_pass) {
-    // If any of the overlays is the output surface, then ensure that the
-    // backbuffer be allocated (allocation of the backbuffer is a side-effect
-    // of BindFramebufferToOutputSurface).
-    for (auto& overlay : current_frame()->overlay_list) {
-      if (overlay.use_output_surface_for_resource) {
-        BindFramebufferToOutputSurface();
-        break;
-      }
-    }
-  } else {
+  if (!skip_drawing_root_render_pass)

[Daniele Castagna, 2017/04/19 19:10:36]

In the comment you removed it mentioned that calling
BindFramebufferToOutputSurface would cause allocation of the backbuffer (and
that was desired). Is that not the case anymore?

[reveman, 2017/04/19 23:59:03]

Yes, that was kind of a hack. Before this we still had to produce a new buffer
for empty swap to work but now that we can handle the empty swap properly that's
not the case. I think the new behavior is how you'd expect it to work and
doesn't need a comment. If we're not drawing anything then there's no longer a
need to bind the output surface to the fbo target.

     DrawRenderPassAndExecuteCopyRequests(root_render_pass);
-  }
 
   FinishDrawingFrame();
   render_passes_in_draw_order->clear();
   render_pass_filters_.clear();
   render_pass_background_filters_.clear();
 
   current_frame_valid_ = false;
 }
 
 gfx::Rect DirectRenderer::DrawingFrame::ComputeScissorRectForRenderPass()
@@ skipping 291 matching lines @@
 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