Use SwapBuffersWithBounds on Chromecast

cc/output/overlay_processor.cc

 // Copyright 2014 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/overlay_processor.h"
 
 #include "cc/output/output_surface.h"
 #include "cc/output/overlay_strategy_single_on_top.h"
 #include "cc/output/overlay_strategy_underlay.h"
 #include "cc/quads/draw_quad.h"
@@ skipping 21 matching lines @@
   cc::OverlayCandidateList* candidates_;
 
   DISALLOW_COPY_AND_ASSIGN(SendPromotionHintsBeforeReturning);
 };
 #endif
 
 }  // namespace
 
 namespace cc {
 
+void OverlayProcessor::Strategy::GetContentBounds(
+    std::vector<gfx::Rect>* bounds) {}
+
 OverlayProcessor::OverlayProcessor(OutputSurface* surface) : surface_(surface) {
 }
 
 void OverlayProcessor::Initialize() {
   DCHECK(surface_);
   OverlayCandidateValidator* validator =
       surface_->GetOverlayCandidateValidator();
   if (validator)
     validator->GetStrategies(&strategies_);
 }
 
 OverlayProcessor::~OverlayProcessor() {}
 
 gfx::Rect OverlayProcessor::GetAndResetOverlayDamage() {
   gfx::Rect result = overlay_damage_rect_;
   overlay_damage_rect_ = gfx::Rect();
   return result;
 }
 
+void OverlayProcessor::GetContentBounds(
+    std::vector<gfx::Rect>* content_bounds) {
+  DCHECK(content_bounds);
+  content_bounds->insert(content_bounds->end(), content_bounds_.begin(),

[danakj, 2017/02/14 17:28:58]

why append and not replace the contents?

[halliwell, 2017/02/15 22:29:04]

This function removed now.

+                         content_bounds_.end());
+}
+
 bool OverlayProcessor::ProcessForCALayers(
     ResourceProvider* resource_provider,
     RenderPass* render_pass,
     const RenderPassFilterList& render_pass_filters,
     const RenderPassFilterList& render_pass_background_filters,
     OverlayCandidateList* overlay_candidates,
     CALayerOverlayList* ca_layer_overlays,
     gfx::Rect* damage_rect) {
   OverlayCandidateValidator* overlay_validator =
       surface_->GetOverlayCandidateValidator();
@@ skipping 15 matching lines @@
   return true;
 }
 
 void OverlayProcessor::ProcessForOverlays(
     ResourceProvider* resource_provider,
     RenderPass* render_pass,
     const RenderPassFilterList& render_pass_filters,
     const RenderPassFilterList& render_pass_background_filters,
     OverlayCandidateList* candidates,
     CALayerOverlayList* ca_layer_overlays,
     gfx::Rect* damage_rect) {

[danakj, 2017/02/14 17:28:58]

Shall we just add the bounds here so we don't need class state? Then it would be
in directrenderer which can be more globally used as needed, and probably stored
as part of DirectRenderer::DrawingFrame?

[halliwell, 2017/02/15 22:29:04]

Done.

 #if defined(OS_ANDROID)
   // Be sure to send out notifications, regardless of whether we get to
   // processing for overlays or not.  If we don't, then we should notify that
   // they are not promotable.
   SendPromotionHintsBeforeReturning notifier(resource_provider, candidates);
 #endif
+  content_bounds_.clear();
 
   // If we have any copy requests, we can't remove any quads for overlays or
   // CALayers because the framebuffer would be missing the removed quads'
   // contents.
   if (!render_pass->copy_requests.empty()) {
     // If overlay processing was skipped for a frame there's no way to be sure
     // of the state of the previous frame, so reset.
     previous_frame_underlay_rect_ = gfx::Rect();
     return;
   }
 
   // First attempt to process for CALayers.
   if (ProcessForCALayers(resource_provider, render_pass, render_pass_filters,
                          render_pass_background_filters, candidates,
                          ca_layer_overlays, damage_rect)) {
     return;
   }
 
   // Only if that fails, attempt hardware overlay strategies.
   for (const auto& strategy : strategies_) {
     if (!strategy->Attempt(resource_provider, render_pass, candidates))
       continue;
 
     UpdateDamageRect(candidates, damage_rect);
+    strategy->GetContentBounds(&content_bounds_);
     return;
   }
 }
 
 // Subtract on-top overlays from the damage rect, unless the overlays use
 // the backbuffer as their content (in which case, add their combined rect
 // back to the damage at the end).
 // Also subtract unoccluded underlays from the damage rect if we know that the
 // same underlay was scheduled on the previous frame. If the renderer decides
 // not to swap the framebuffer there will still be a transparent hole in the
@@ skipping 18 matching lines @@
   }
 
   if (this_frame_underlay_rect == previous_frame_underlay_rect_)
     damage_rect->Subtract(this_frame_underlay_rect);
   previous_frame_underlay_rect_ = this_frame_underlay_rect;
 
   damage_rect->Union(output_surface_overlay_damage_rect);
 }
 
 }  // namespace cc