Use SwapBuffersWithBounds on Chromecast

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 383 matching lines @@
   const auto& context_caps =
       output_surface_->context_provider()->ContextCapabilities();
   DCHECK(!context_caps.iosurface || context_caps.texture_rectangle);
 
   use_discard_framebuffer_ = context_caps.discard_framebuffer;
   use_sync_query_ = context_caps.sync_query;
   use_blend_equation_advanced_ = context_caps.blend_equation_advanced;
   use_blend_equation_advanced_coherent_ =
       context_caps.blend_equation_advanced_coherent;
   use_occlusion_query_ = context_caps.occlusion_query;
+  use_swap_with_bounds_ = context_caps.swap_buffers_with_bounds;
 
   InitializeSharedObjects();
 }
 
 GLRenderer::~GLRenderer() {
   CleanupSharedObjects();
 
   if (context_visibility_) {
     auto* context_provider = output_surface_->context_provider();
     auto* cache_controller = context_provider->CacheController();
     cache_controller->ClientBecameNotVisible(std::move(context_visibility_));
   }
 }
 
 bool GLRenderer::CanPartialSwap() {
   auto* context_provider = output_surface_->context_provider();
   return context_provider->ContextCapabilities().post_sub_buffer;

[danakj, 2017/02/16 18:54:19]

Should this be false if use_swap_with_bounds_? We're entering a bit of a strange
tristate represented by 2 bools which have 2^2=4 states. So there is now an
invalid/unused state represented. What if use_partial_swap_ and
use_swap_with_bounds_ became an enum instead?

[halliwell, 2017/02/23 18:01:46]

It's true that a 3-state enum represents the state better.  But I'm missing some
context here: use_partial_swap_ is state of DirectRenderer, whereas for now,
swap with bounds is only a concern of GLRenderer.  Making it 3-state requires
pushing that concept up into DirectRenderer ... I'm not clear whether that's a
significant drawback.

For this patchset, I just fixed up CanPartialSwap here to return false if using
swap with bounds.

[danakj, 2017/02/24 22:05:18]

Ya, I think with the optional changes u did this is a lot more clear and i'm
happy where it landed

 }
 
 ResourceFormat GLRenderer::BackbufferFormat() const {
   // TODO(ccameron): If we are targeting high bit depth or HDR, we should use
   // RGBA_F16 here.
   return resource_provider_->best_texture_format();
 }
 
 void GLRenderer::DidChangeVisibility() {
   if (visible_) {
@@ skipping 2194 matching lines @@
   DCHECK(visible_);
 
   TRACE_EVENT0("cc", "GLRenderer::SwapBuffers");
   // We're done! Time to swapbuffers!
 
   gfx::Size surface_size = surface_size_for_swap_buffers();
 
   OutputSurfaceFrame output_frame;
   output_frame.latency_info = std::move(latency_info);
   output_frame.size = surface_size;
-  if (use_partial_swap_) {
+  if (use_swap_with_bounds_) {
+    output_frame.content_bounds = current_frame()->root_content_bounds;
+    swap_buffer_rect_ = gfx::Rect(surface_size);

[danakj, 2017/02/16 18:54:19]

Do you intentionally overload not supporting empty swaps with swap_with_bounds_?
See the else case below.

[halliwell, 2017/02/23 18:01:46]

Correct.  The case of allow_empty_swap_ when use_partial_swap_ is false
corresponds to calling CommitOverlayPlanes instead of Swap.

+    output_frame.sub_buffer_rect = swap_buffer_rect_;
+  } else if (use_partial_swap_) {
     // If supported, we can save significant bandwidth by only swapping the
     // damaged/scissored region (clamped to the viewport).
     swap_buffer_rect_.Intersect(gfx::Rect(surface_size));
     int flipped_y_pos_of_rect_bottom = surface_size.height() -
                                        swap_buffer_rect_.y() -
                                        swap_buffer_rect_.height();
     output_frame.sub_buffer_rect =
         gfx::Rect(swap_buffer_rect_.x(),
                   FlippedRootFramebuffer() ? flipped_y_pos_of_rect_bottom
                                            : swap_buffer_rect_.y(),
@@ skipping 880 matching lines @@
     return;
 
   // Report GPU overdraw as a percentage of |max_result|.
   TRACE_COUNTER1(
       TRACE_DISABLED_BY_DEFAULT("cc.debug.overdraw"), "GPU Overdraw",
       (std::accumulate(overdraw->begin(), overdraw->end(), 0) * 100) /
           max_result);
 }
 
 }  // namespace cc