Add hints for potential overlay promotion on android.

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"
+#include "cc/resources/resource_provider.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
+namespace {
+
+// Utility class to make sure that we notify resource that they're promotable
+// before returning from ProcessForOverlays.
+class NotifyPromotionsBeforeReturning {
+ public:
+  NotifyPromotionsBeforeReturning(cc::ResourceProvider* resource_provider,
+                                  cc::OverlayCandidateList* candidates)
+      : resource_provider_(resource_provider), candidates_(candidates) {}
+  ~NotifyPromotionsBeforeReturning() {
+#if defined(OS_ANDROID)
+    resource_provider_->SendPromotionHints(
+        candidates_->promotable_resource_hints_);
+#endif
+  }
+
+ private:
+  cc::ResourceProvider* resource_provider_;
+  cc::OverlayCandidateList* candidates_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotifyPromotionsBeforeReturning);
+};
+
+}  // namespace
+
 namespace cc {
 
 OverlayProcessor::OverlayProcessor(OutputSurface* surface) : surface_(surface) {
 }
 
 void OverlayProcessor::Initialize() {
   DCHECK(surface_);
   OverlayCandidateValidator* validator =
       surface_->GetOverlayCandidateValidator();
   if (validator)
@@ skipping 31 matching lines @@
   overlay_damage_rect_ = render_pass->output_rect;
   *damage_rect = gfx::Rect();
   return true;
 }
 
 void OverlayProcessor::ProcessForOverlays(ResourceProvider* resource_provider,
                                           RenderPass* render_pass,
                                           OverlayCandidateList* candidates,
                                           CALayerOverlayList* ca_layer_overlays,
                                           gfx::Rect* damage_rect) {
+  // 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.
+  // TODO(liberato): should we only notify 'yes' instances, and make the
+  // glimage infer the 'no' instances?  that seems flaky, though.
+  NotifyPromotionsBeforeReturning notify(resource_provider, candidates);
+
   // 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;
   }
 
@@ skipping 40 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