cc: Remove redundant overlay arguments

Whether or not a quad can be made into an overlay is dependent on
whether there is a GLImage backing the texture resources that the quad
uses.

Prior to this patch, this information was passed along to the layer or
quad via a side-channel, in the form of a "allow overlay" argument.

Now, store this information in the cc::Resource, in particular, through
the cc::TextureMailbox that it is created from, and have the overlay
strategy query the property of the cc::Resource.

Add appropriate plumbing of the parameters from the cc::TextureMailbox,
through the cc::Resource, to cc::TransferableResource, and finally to
a cc::Resource in other compositors.

R=reveman,fsamuel,dcheng
TBR=danakj
BUG=533690
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1387283002

Cr-Commit-Position: refs/heads/master@{#353128}

40 files changed, 241 insertions, 247 deletions

diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 902a73d..d7c6cda 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -79,14 +79,9 @@ void IOSurfaceLayerImpl::AppendQuads(
 
   IOSurfaceDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
-  quad->SetNew(shared_quad_state,
-               quad_rect,
-               opaque_rect,
-               visible_quad_rect,
-               io_surface_size_,
-               io_surface_resource_id_,
-               IOSurfaceDrawQuad::FLIPPED,
-               false);
+  quad->SetNew(shared_quad_state, quad_rect, opaque_rect, visible_quad_rect,
+               io_surface_size_, io_surface_resource_id_,
+               IOSurfaceDrawQuad::FLIPPED);
   ValidateQuadResources(quad);
 }
 
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 404d479..e864219 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -177,7 +177,6 @@ void TextureLayerImpl::AppendQuads(RenderPass* render_pass,
                nearest_neighbor_);
   if (!valid_texture_copy_) {
     quad->set_resource_size_in_pixels(texture_mailbox_.size_in_pixels());
-    quad->set_allow_overlay(texture_mailbox_.allow_overlay());
   }
   ValidateQuadResources(quad);
 }
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 3313aa5..d6aa570 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -128,7 +128,7 @@ bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
         external_resources.read_lock_fences_enabled);
     frame_resources_.push_back(FrameResource(
         resource_id, external_resources.mailboxes[i].size_in_pixels(),
-        external_resources.mailboxes[i].allow_overlay()));
+        external_resources.mailboxes[i].is_overlay_candidate()));
   }
 
   return true;
@@ -313,7 +313,6 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       stream_video_quad->SetNew(
           shared_quad_state, quad_rect, opaque_rect, visible_quad_rect,
           frame_resources_[0].id, frame_resources_[0].size_in_pixels,
-          frame_resources_[0].allow_overlay,
           scale * provider_client_impl_->StreamTextureMatrix());
       ValidateQuadResources(stream_video_quad);
       break;
@@ -327,8 +326,7 @@ void VideoLayerImpl::AppendQuads(RenderPass* render_pass,
       io_surface_quad->SetNew(shared_quad_state, quad_rect, opaque_rect,
                               visible_quad_rect, visible_rect.size(),
                               frame_resources_[0].id,
-                              IOSurfaceDrawQuad::UNFLIPPED,
-                              frame_resources_[0].allow_overlay);
+                              IOSurfaceDrawQuad::UNFLIPPED);
       ValidateQuadResources(io_surface_quad);
       break;
     }
diff --git a/cc/layers/video_layer_impl.h b/cc/layers/video_layer_impl.h
index 6fab7f5..127700b 100644
--- a/cc/layers/video_layer_impl.h
+++ b/cc/layers/video_layer_impl.h
@@ -63,13 +63,15 @@ class CC_EXPORT VideoLayerImpl : public LayerImpl {
   scoped_ptr<VideoResourceUpdater> updater_;
   VideoFrameExternalResources::ResourceType frame_resource_type_;
   struct FrameResource {
-    FrameResource(ResourceId id, gfx::Size size_in_pixels, bool allow_overlay)
+    FrameResource(ResourceId id,
+                  gfx::Size size_in_pixels,
+                  bool is_overlay_candidate)
         : id(id),
           size_in_pixels(size_in_pixels),
-          allow_overlay(allow_overlay) {}
+          is_overlay_candidate(is_overlay_candidate) {}
     ResourceId id;
     gfx::Size size_in_pixels;
-    bool allow_overlay;
+    bool is_overlay_candidate;
   };
   std::vector<FrameResource> frame_resources_;
 
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index f981518..1be41e9 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -239,8 +239,8 @@ void DirectRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
   // If we have any copy requests, we can't remove any quads for overlays,
   // otherwise the framebuffer will be missing the overlay contents.
   if (root_render_pass->copy_requests.empty()) {
-    overlay_processor_->ProcessForOverlays(render_passes_in_draw_order,
-                                           &frame.overlay_list);
+    overlay_processor_->ProcessForOverlays(
+        resource_provider_, render_passes_in_draw_order, &frame.overlay_list);
   }
 
   for (size_t i = 0; i < render_passes_in_draw_order->size(); ++i) {
diff --git a/cc/output/gl_renderer_unittest.cc b/cc/output/gl_renderer_unittest.cc
index c2fae69..7e35ad4 100644
--- a/cc/output/gl_renderer_unittest.cc
+++ b/cc/output/gl_renderer_unittest.cc
@@ -2007,8 +2007,9 @@ class TestOverlayProcessor : public OverlayProcessor {
    public:
     Strategy() {}
     ~Strategy() override {}
-    MOCK_METHOD2(Attempt,
-                 bool(RenderPassList* render_passes,
+    MOCK_METHOD3(Attempt,
+                 bool(ResourceProvider* resource_provider,
+                      RenderPassList* render_passes,
                       OverlayCandidateList* candidates));
   };
 
@@ -2065,7 +2066,8 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
 
   unsigned sync_point = 0;
   TextureMailbox mailbox =
-      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
+      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point,
+                     gfx::Size(256, 256), true);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
   ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
@@ -2082,14 +2084,13 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
                        premultiplied_alpha, gfx::PointF(0, 0),
                        gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor);
-  overlay_quad->set_allow_overlay(true);
 
   // DirectRenderer::DrawFrame calls into OverlayProcessor::ProcessForOverlays.
   // Attempt will be called for each strategy in OverlayProcessor. We have
   // added a fake strategy, so checking for Attempt calls checks if there was
   // any attempt to overlay, which there shouldn't be. We can't use the quad
   // list because the render pass is cleaned up by DrawFrame.
-  EXPECT_CALL(*processor->strategy_, Attempt(_, _)).Times(0);
+  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(0);
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
   Mock::VerifyAndClearExpectations(processor->strategy_);
@@ -2106,7 +2107,7 @@ TEST_F(GLRendererTest, DontOverlayWithCopyRequests) {
                        gfx::PointF(1, 1), SK_ColorTRANSPARENT, vertex_opacity,
                        flipped, nearest_neighbor);
 
-  EXPECT_CALL(*processor->strategy_, Attempt(_, _)).Times(1);
+  EXPECT_CALL(*processor->strategy_, Attempt(_, _, _)).Times(1);
   renderer.DrawFrame(&render_passes_in_draw_order_, 1.f, viewport_rect,
                      viewport_rect, false);
 }
@@ -2195,7 +2196,8 @@ TEST_F(GLRendererTest, OverlaySyncPointsAreProcessed) {
 
   unsigned sync_point = 29;
   TextureMailbox mailbox =
-      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
+      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point,
+                     gfx::Size(256, 256), true);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
   ResourceId resource_id = resource_provider->CreateResourceFromTextureMailbox(
@@ -2216,7 +2218,6 @@ TEST_F(GLRendererTest, OverlaySyncPointsAreProcessed) {
                        viewport_rect, resource_id, premultiplied_alpha,
                        uv_top_left, uv_bottom_right, SK_ColorTRANSPARENT,
                        vertex_opacity, flipped, nearest_neighbor);
-  overlay_quad->set_allow_overlay(true);
 
   // Verify that overlay_quad actually gets turned into an overlay, and even
   // though it's not drawn, that its sync point is waited on.
diff --git a/cc/output/overlay_candidate.cc b/cc/output/overlay_candidate.cc
index 4e6a36b..658f153 100644
--- a/cc/output/overlay_candidate.cc
+++ b/cc/output/overlay_candidate.cc
@@ -12,6 +12,8 @@
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
+#include "cc/quads/tile_draw_quad.h"
+#include "cc/resources/resource_provider.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 
@@ -178,7 +180,8 @@ OverlayCandidate::OverlayCandidate()
 OverlayCandidate::~OverlayCandidate() {}
 
 // static
-bool OverlayCandidate::FromDrawQuad(const DrawQuad* quad,
+bool OverlayCandidate::FromDrawQuad(ResourceProvider* resource_provider,
+                                    const DrawQuad* quad,
                                     OverlayCandidate* candidate) {
   if (quad->needs_blending || quad->shared_quad_state->opacity != 1.f ||
       quad->shared_quad_state->blend_mode != SkXfermode::kSrcOver_Mode)
@@ -196,13 +199,15 @@ bool OverlayCandidate::FromDrawQuad(const DrawQuad* quad,
 
   switch (quad->material) {
     case DrawQuad::TEXTURE_CONTENT:
-      return FromTextureQuad(TextureDrawQuad::MaterialCast(quad), candidate);
+      return FromTextureQuad(resource_provider,
+                             TextureDrawQuad::MaterialCast(quad), candidate);
     case DrawQuad::STREAM_VIDEO_CONTENT:
-      return FromStreamVideoQuad(StreamVideoDrawQuad::MaterialCast(quad),
+      return FromStreamVideoQuad(resource_provider,
+                                 StreamVideoDrawQuad::MaterialCast(quad),
                                  candidate);
     case DrawQuad::IO_SURFACE_CONTENT:
-      return FromIOSurfaceQuad(IOSurfaceDrawQuad::MaterialCast(quad),
-                               candidate);
+      return FromIOSurfaceQuad(
+          resource_provider, IOSurfaceDrawQuad::MaterialCast(quad), candidate);
     default:
       break;
   }
@@ -223,9 +228,10 @@ bool OverlayCandidate::IsInvisibleQuad(const DrawQuad* quad) {
 }
 
 // static
-bool OverlayCandidate::FromTextureQuad(const TextureDrawQuad* quad,
+bool OverlayCandidate::FromTextureQuad(ResourceProvider* resource_provider,
+                                       const TextureDrawQuad* quad,
                                        OverlayCandidate* candidate) {
-  if (!quad->allow_overlay())
+  if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, quad->y_flipped);
@@ -241,9 +247,10 @@ bool OverlayCandidate::FromTextureQuad(const TextureDrawQuad* quad,
 }
 
 // static
-bool OverlayCandidate::FromStreamVideoQuad(const StreamVideoDrawQuad* quad,
+bool OverlayCandidate::FromStreamVideoQuad(ResourceProvider* resource_provider,
+                                           const StreamVideoDrawQuad* quad,
                                            OverlayCandidate* candidate) {
-  if (!quad->allow_overlay())
+  if (!resource_provider->IsOverlayCandidate(quad->resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, false);
@@ -286,9 +293,10 @@ bool OverlayCandidate::FromStreamVideoQuad(const StreamVideoDrawQuad* quad,
 }
 
 // static
-bool OverlayCandidate::FromIOSurfaceQuad(const IOSurfaceDrawQuad* quad,
+bool OverlayCandidate::FromIOSurfaceQuad(ResourceProvider* resource_provider,
+                                         const IOSurfaceDrawQuad* quad,
                                          OverlayCandidate* candidate) {
-  if (!quad->allow_overlay)
+  if (!resource_provider->IsOverlayCandidate(quad->io_surface_resource_id()))
     return false;
   gfx::OverlayTransform overlay_transform = GetOverlayTransform(
       quad->shared_quad_state->quad_to_target_transform, false);
diff --git a/cc/output/overlay_candidate.h b/cc/output/overlay_candidate.h
index 2584d9b..aa42ba1 100644
--- a/cc/output/overlay_candidate.h
+++ b/cc/output/overlay_candidate.h
@@ -25,12 +25,15 @@ class DrawQuad;
 class IOSurfaceDrawQuad;
 class StreamVideoDrawQuad;
 class TextureDrawQuad;
+class ResourceProvider;
 
 class CC_EXPORT OverlayCandidate {
  public:
   // Returns true and fills in |candidate| if |draw_quad| is of a known quad
   // type and contains an overlayable resource.
-  static bool FromDrawQuad(const DrawQuad* quad, OverlayCandidate* candidate);
+  static bool FromDrawQuad(ResourceProvider* resource_provider,
+                           const DrawQuad* quad,
+                           OverlayCandidate* candidate);
   // Returns true if |quad| will not block quads underneath from becoming
   // an overlay.
   static bool IsInvisibleQuad(const DrawQuad* quad);
@@ -69,11 +72,14 @@ class CC_EXPORT OverlayCandidate {
   bool overlay_handled;
 
  private:
-  static bool FromTextureQuad(const TextureDrawQuad* quad,
+  static bool FromTextureQuad(ResourceProvider* resource_provider,
+                              const TextureDrawQuad* quad,
                               OverlayCandidate* candidate);
-  static bool FromStreamVideoQuad(const StreamVideoDrawQuad* quad,
+  static bool FromStreamVideoQuad(ResourceProvider* resource_provider,
+                                  const StreamVideoDrawQuad* quad,
                                   OverlayCandidate* candidate);
-  static bool FromIOSurfaceQuad(const IOSurfaceDrawQuad* quad,
+  static bool FromIOSurfaceQuad(ResourceProvider* resource_provider,
+                                const IOSurfaceDrawQuad* quad,
                                 OverlayCandidate* candidate);
 };
 
diff --git a/cc/output/overlay_processor.cc b/cc/output/overlay_processor.cc
index 789fc13..69368a1 100644
--- a/cc/output/overlay_processor.cc
+++ b/cc/output/overlay_processor.cc
@@ -25,10 +25,11 @@ void OverlayProcessor::Initialize() {
 
 OverlayProcessor::~OverlayProcessor() {}
 
-void OverlayProcessor::ProcessForOverlays(RenderPassList* render_passes,
+void OverlayProcessor::ProcessForOverlays(ResourceProvider* resource_provider,
+                                          RenderPassList* render_passes,
                                           OverlayCandidateList* candidates) {
   for (auto strategy : strategies_) {
-    if (strategy->Attempt(render_passes, candidates))
+    if (strategy->Attempt(resource_provider, render_passes, candidates))
       return;
   }
 }
diff --git a/cc/output/overlay_processor.h b/cc/output/overlay_processor.h
index d4e1369..48ffe6b 100644
--- a/cc/output/overlay_processor.h
+++ b/cc/output/overlay_processor.h
@@ -24,7 +24,8 @@ class CC_EXPORT OverlayProcessor {
     // current set of render passes. Returns true if the strategy was successful
     // and adds any additional passes necessary to represent overlays to
     // |render_passes|.
-    virtual bool Attempt(RenderPassList* render_passes,
+    virtual bool Attempt(ResourceProvider* resource_provider,
+                         RenderPassList* render_passes,
                          OverlayCandidateList* candidates) = 0;
   };
   typedef ScopedPtrVector<Strategy> StrategyList;
@@ -34,7 +35,8 @@ class CC_EXPORT OverlayProcessor {
   // Virtual to allow testing different strategies.
   virtual void Initialize();
 
-  void ProcessForOverlays(RenderPassList* render_passes,
+  void ProcessForOverlays(ResourceProvider* resource_provider,
+                          RenderPassList* render_passes,
                           OverlayCandidateList* candidates);
 
  protected:
diff --git a/cc/output/overlay_strategy_all_or_nothing.cc b/cc/output/overlay_strategy_all_or_nothing.cc
index 3550d4f..40c58cd 100644
--- a/cc/output/overlay_strategy_all_or_nothing.cc
+++ b/cc/output/overlay_strategy_all_or_nothing.cc
@@ -17,7 +17,8 @@ OverlayStrategyAllOrNothing::OverlayStrategyAllOrNothing(
 
 OverlayStrategyAllOrNothing::~OverlayStrategyAllOrNothing() {}
 
-bool OverlayStrategyAllOrNothing::Attempt(RenderPassList* render_passes,
+bool OverlayStrategyAllOrNothing::Attempt(ResourceProvider* resource_provider,
+                                          RenderPassList* render_passes,
                                           OverlayCandidateList* candidates) {
   QuadList& quad_list = render_passes->back()->quad_list;
   OverlayCandidateList new_candidates;
@@ -25,7 +26,7 @@ bool OverlayStrategyAllOrNothing::Attempt(RenderPassList* render_passes,
 
   for (const DrawQuad* quad : quad_list) {
     OverlayCandidate candidate;
-    if (!OverlayCandidate::FromDrawQuad(quad, &candidate))
+    if (!OverlayCandidate::FromDrawQuad(resource_provider, quad, &candidate))
       return false;
     candidate.plane_z_order = next_z_order--;
     new_candidates.push_back(candidate);
diff --git a/cc/output/overlay_strategy_all_or_nothing.h b/cc/output/overlay_strategy_all_or_nothing.h
index 3262fce..94d88f0 100644
--- a/cc/output/overlay_strategy_all_or_nothing.h
+++ b/cc/output/overlay_strategy_all_or_nothing.h
@@ -20,7 +20,8 @@ class CC_EXPORT OverlayStrategyAllOrNothing
       OverlayCandidateValidator* capability_checker);
   ~OverlayStrategyAllOrNothing() override;
 
-  bool Attempt(RenderPassList* render_passes,
+  bool Attempt(ResourceProvider* resource_provider,
+               RenderPassList* render_passes,
                OverlayCandidateList* candidate_list) override;
 
  private:
diff --git a/cc/output/overlay_strategy_sandwich.cc b/cc/output/overlay_strategy_sandwich.cc
index 515afa5..79279ad 100644
--- a/cc/output/overlay_strategy_sandwich.cc
+++ b/cc/output/overlay_strategy_sandwich.cc
@@ -40,12 +40,13 @@ OverlayStrategySandwich::OverlayStrategySandwich(
 
 OverlayStrategySandwich::~OverlayStrategySandwich() {}
 
-bool OverlayStrategySandwich::Attempt(RenderPassList* render_passes,
+bool OverlayStrategySandwich::Attempt(ResourceProvider* resource_provider,
+                                      RenderPassList* render_passes,
                                       OverlayCandidateList* candidate_list) {
   QuadList& quad_list = render_passes->back()->quad_list;
   for (auto it = quad_list.begin(); it != quad_list.end();) {
     OverlayCandidate candidate;
-    if (OverlayCandidate::FromDrawQuad(*it, &candidate))
+    if (OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate))
       it = TryOverlay(render_passes->back(), candidate_list, candidate, it);
     else
       ++it;
diff --git a/cc/output/overlay_strategy_sandwich.h b/cc/output/overlay_strategy_sandwich.h
index afab8e6..076ea9d 100644
--- a/cc/output/overlay_strategy_sandwich.h
+++ b/cc/output/overlay_strategy_sandwich.h
@@ -21,7 +21,8 @@ class CC_EXPORT OverlayStrategySandwich : public OverlayProcessor::Strategy {
       OverlayCandidateValidator* capability_checker);
   ~OverlayStrategySandwich() override;
 
-  bool Attempt(RenderPassList* render_passes,
+  bool Attempt(ResourceProvider* resource_provider,
+               RenderPassList* render_passes,
                OverlayCandidateList* candidate_list) override;
 
  private:
diff --git a/cc/output/overlay_strategy_single_on_top.cc b/cc/output/overlay_strategy_single_on_top.cc
index d08da5c..ca254b2 100644
--- a/cc/output/overlay_strategy_single_on_top.cc
+++ b/cc/output/overlay_strategy_single_on_top.cc
@@ -18,12 +18,13 @@ OverlayStrategySingleOnTop::OverlayStrategySingleOnTop(
 
 OverlayStrategySingleOnTop::~OverlayStrategySingleOnTop() {}
 
-bool OverlayStrategySingleOnTop::Attempt(RenderPassList* render_passes,
+bool OverlayStrategySingleOnTop::Attempt(ResourceProvider* resource_provider,
+                                         RenderPassList* render_passes,
                                          OverlayCandidateList* candidate_list) {
-  QuadList& quad_list = render_passes->back()->quad_list;
-  for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
+  QuadList* quad_list = &render_passes->back()->quad_list;
+  for (auto it = quad_list->begin(); it != quad_list->end(); ++it) {
     OverlayCandidate candidate;
-    if (OverlayCandidate::FromDrawQuad(*it, &candidate) &&
+    if (OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate) &&
         TryOverlay(quad_list, candidate_list, candidate, it)) {
       return true;
     }
@@ -33,12 +34,12 @@ bool OverlayStrategySingleOnTop::Attempt(RenderPassList* render_passes,
 }
 
 bool OverlayStrategySingleOnTop::TryOverlay(
-    QuadList& quad_list,
+    QuadList* quad_list,
     OverlayCandidateList* candidate_list,
     const OverlayCandidate& candidate,
     QuadList::Iterator candidate_iterator) {
   // Check that no prior quads overlap it.
-  for (auto overlap_iter = quad_list.cbegin();
+  for (auto overlap_iter = quad_list->cbegin();
        overlap_iter != candidate_iterator; ++overlap_iter) {
     gfx::RectF overlap_rect = MathUtil::MapClippedRect(
         overlap_iter->shared_quad_state->quad_to_target_transform,
@@ -58,7 +59,7 @@ bool OverlayStrategySingleOnTop::TryOverlay(
 
   // If the candidate can be handled by an overlay, create a pass for it.
   if (new_candidate_list.back().overlay_handled) {
-    quad_list.EraseAndInvalidateAllPointers(candidate_iterator);
+    quad_list->EraseAndInvalidateAllPointers(candidate_iterator);
     candidate_list->swap(new_candidate_list);
     return true;
   }
diff --git a/cc/output/overlay_strategy_single_on_top.h b/cc/output/overlay_strategy_single_on_top.h
index e2991e4..bdf2cc2 100644
--- a/cc/output/overlay_strategy_single_on_top.h
+++ b/cc/output/overlay_strategy_single_on_top.h
@@ -17,11 +17,12 @@ class CC_EXPORT OverlayStrategySingleOnTop : public OverlayProcessor::Strategy {
       OverlayCandidateValidator* capability_checker);
   ~OverlayStrategySingleOnTop() override;
 
-  bool Attempt(RenderPassList* render_passes,
+  bool Attempt(ResourceProvider* resource_provider,
+               RenderPassList* render_passes,
                OverlayCandidateList* candidate_list) override;
 
  private:
-  bool TryOverlay(QuadList& quad_list,
+  bool TryOverlay(QuadList* quad_list,
                   OverlayCandidateList* candidate_list,
                   const OverlayCandidate& candidate,
                   QuadList::Iterator candidate_iterator);
diff --git a/cc/output/overlay_strategy_underlay.cc b/cc/output/overlay_strategy_underlay.cc
index 805855c..9a8a362 100644
--- a/cc/output/overlay_strategy_underlay.cc
+++ b/cc/output/overlay_strategy_underlay.cc
@@ -18,12 +18,13 @@ OverlayStrategyUnderlay::OverlayStrategyUnderlay(
 
 OverlayStrategyUnderlay::~OverlayStrategyUnderlay() {}
 
-bool OverlayStrategyUnderlay::Attempt(RenderPassList* render_passes,
+bool OverlayStrategyUnderlay::Attempt(ResourceProvider* resource_provider,
+                                      RenderPassList* render_passes,
                                       OverlayCandidateList* candidate_list) {
   QuadList& quad_list = render_passes->back()->quad_list;
   for (auto it = quad_list.begin(); it != quad_list.end(); ++it) {
     OverlayCandidate candidate;
-    if (!OverlayCandidate::FromDrawQuad(*it, &candidate))
+    if (!OverlayCandidate::FromDrawQuad(resource_provider, *it, &candidate))
       continue;
 
     // Add the overlay.
diff --git a/cc/output/overlay_strategy_underlay.h b/cc/output/overlay_strategy_underlay.h
index 473e696..f276c1c 100644
--- a/cc/output/overlay_strategy_underlay.h
+++ b/cc/output/overlay_strategy_underlay.h
@@ -22,7 +22,8 @@ class CC_EXPORT OverlayStrategyUnderlay : public OverlayProcessor::Strategy {
       OverlayCandidateValidator* capability_checker);
   ~OverlayStrategyUnderlay() override;
 
-  bool Attempt(RenderPassList* render_passes,
+  bool Attempt(ResourceProvider* resource_provider,
+               RenderPassList* render_passes,
                OverlayCandidateList* candidate_list) override;
 
  private:
diff --git a/cc/output/overlay_unittest.cc b/cc/output/overlay_unittest.cc
index 4f66a93..722002e 100644
--- a/cc/output/overlay_unittest.cc
+++ b/cc/output/overlay_unittest.cc
@@ -203,10 +203,13 @@ scoped_ptr<RenderPass> CreateRenderPass() {
   return pass.Pass();
 }
 
-ResourceId CreateResource(ResourceProvider* resource_provider) {
+ResourceId CreateResource(ResourceProvider* resource_provider,
+                          const gfx::Size& size,
+                          bool is_overlay_candidate) {
   unsigned sync_point = 0;
   TextureMailbox mailbox =
-      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
+      TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point, size,
+                     is_overlay_candidate);
   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
       SingleReleaseCallbackImpl::Create(base::Bind(&MailboxReleased));
 
@@ -229,13 +232,14 @@ TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
                                        const SharedQuadState* shared_quad_state,
                                        RenderPass* render_pass,
                                        const gfx::Rect& rect) {
-  ResourceId resource_id = CreateResource(resource_provider);
   bool premultiplied_alpha = false;
   bool flipped = false;
   bool nearest_neighbor = false;
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
   gfx::Size resource_size_in_pixels = gfx::Size(64, 64);
-  bool allow_overlay = true;
+  bool is_overlay_candidate = true;
+  ResourceId resource_id = CreateResource(
+      resource_provider, resource_size_in_pixels, is_overlay_candidate);
 
   TextureDrawQuad* overlay_quad =
       render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
@@ -251,7 +255,6 @@ TextureDrawQuad* CreateCandidateQuadAt(ResourceProvider* resource_provider,
                        vertex_opacity,
                        flipped,
                        nearest_neighbor);
-  overlay_quad->set_allow_overlay(allow_overlay);
   overlay_quad->set_resource_size_in_pixels(resource_size_in_pixels);
 
   return overlay_quad;
@@ -263,14 +266,15 @@ StreamVideoDrawQuad* CreateCandidateVideoQuadAt(
     RenderPass* render_pass,
     const gfx::Rect& rect,
     const gfx::Transform& transform) {
-  ResourceId resource_id = CreateResource(resource_provider);
   gfx::Size resource_size_in_pixels = gfx::Size(64, 64);
-  bool allow_overlay = true;
+  bool is_overlay_candidate = true;
+  ResourceId resource_id = CreateResource(
+      resource_provider, resource_size_in_pixels, is_overlay_candidate);
 
   StreamVideoDrawQuad* overlay_quad =
       render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
   overlay_quad->SetNew(shared_quad_state, rect, rect, rect, resource_id,
-                       resource_size_in_pixels, allow_overlay, transform);
+                       resource_size_in_pixels, transform);
 
   return overlay_quad;
 }
@@ -414,7 +418,8 @@ TEST_F(SandwichTest, SuccessfulSingleOverlay) {
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
@@ -455,7 +460,8 @@ TEST_F(SandwichTest, CroppedSingleOverlay) {
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   // Ensure that the display and uv rects have cropping applied to them.
   ASSERT_EQ(1U, pass_list.size());
@@ -483,7 +489,8 @@ TEST_F(SandwichTest, SuccessfulTwoOverlays) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   // Both candidates should become overlays.
   EXPECT_EQ(1u, pass_list.size());
@@ -516,7 +523,8 @@ TEST_F(SandwichTest, OverlappingOverlays) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   // Only one of the candidates should become an overlay.
   EXPECT_EQ(1u, pass_list.size());
@@ -550,7 +558,8 @@ TEST_F(SandwichTest, SuccessfulSandwichOverlay) {
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(2U, candidate_list.size());
@@ -605,7 +614,8 @@ TEST_F(SandwichTest, MultiQuadOverlay) {
   RenderPass* main_pass = pass_list.back();
   OverlayCandidateList candidate_list;
   EXPECT_EQ(4U, main_pass->quad_list.size());
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(3U, candidate_list.size());
 
@@ -656,7 +666,8 @@ TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
@@ -689,7 +700,8 @@ TEST_F(SingleOverlayOnTopTest, NoCandidates) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
@@ -713,7 +725,8 @@ TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
@@ -742,7 +755,8 @@ TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, candidate_list.size());
 
   // This should be the same.
@@ -760,7 +774,8 @@ TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -776,7 +791,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBlending) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -792,7 +808,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -807,7 +824,8 @@ TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -822,7 +840,8 @@ TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -838,7 +857,8 @@ TEST_F(SingleOverlayOnTopTest, RejectNonAxisAlignedTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -854,7 +874,8 @@ TEST_F(SingleOverlayOnTopTest, AllowClipped) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -872,7 +893,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVerticalFlip) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL,
@@ -892,7 +914,8 @@ TEST_F(SingleOverlayOnTopTest, AllowHorizontalFlip) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL,
@@ -911,7 +934,8 @@ TEST_F(SingleOverlayOnTopTest, AllowPositiveScaleTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -928,7 +952,8 @@ TEST_F(SingleOverlayOnTopTest, Allow90DegreeRotation) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_90, candidate_list.back().transform);
@@ -946,7 +971,8 @@ TEST_F(SingleOverlayOnTopTest, Allow180DegreeRotation) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_180, candidate_list.back().transform);
@@ -964,7 +990,8 @@ TEST_F(SingleOverlayOnTopTest, Allow270DegreeRotation) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(gfx::OVERLAY_TRANSFORM_ROTATE_270, candidate_list.back().transform);
@@ -987,7 +1014,8 @@ TEST_F(SingleOverlayOnTopTest, AllowNotTopIfNotOccluded) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1010,7 +1038,8 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentOnTop) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1031,7 +1060,8 @@ TEST_F(SingleOverlayOnTopTest, AllowTransparentColorOnTop) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1054,7 +1084,8 @@ TEST_F(SingleOverlayOnTopTest, RejectOpaqueColorOnTop) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1075,7 +1106,8 @@ TEST_F(SingleOverlayOnTopTest, RejectTransparentColorOnTopWithoutBlending) {
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1089,7 +1121,8 @@ TEST_F(SingleOverlayOnTopTest, RejectVideoSwapTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
@@ -1103,7 +1136,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoXMirrorTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1117,7 +1151,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoBothMirrorTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1131,7 +1166,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoNormalTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1145,7 +1181,8 @@ TEST_F(SingleOverlayOnTopTest, AllowVideoYMirrorTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(1U, candidate_list.size());
 }
@@ -1162,7 +1199,8 @@ TEST_F(UnderlayTest, OverlayLayerUnderMainLayer) {
   pass_list.push_back(pass.Pass());
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
@@ -1184,7 +1222,8 @@ TEST_F(UnderlayTest, AllowOnTop) {
   pass_list.push_back(pass.Pass());
 
   OverlayCandidateList candidate_list;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   ASSERT_EQ(1U, candidate_list.size());
   EXPECT_EQ(-1, candidate_list[0].plane_z_order);
@@ -1206,7 +1245,8 @@ TEST_F(AllOrNothingOverlayTest, SuccessfulOverlappingOverlays) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidates;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidates);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidates);
 
   // Both quads should become overlays.
   EXPECT_EQ(2u, candidates.size());
@@ -1236,7 +1276,8 @@ TEST_F(AllOrNothingOverlayTest, RejectQuadWithTransform) {
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidates;
-  overlay_processor_->ProcessForOverlays(&pass_list, &candidates);
+  overlay_processor_->ProcessForOverlays(resource_provider_.get(), &pass_list,
+                                         &candidates);
 
   // No quads should become overlays.
   EXPECT_EQ(0u, candidates.size());
@@ -1449,9 +1490,12 @@ TEST_F(GLRendererWithOverlaysTest, ResourcesExportedAndReturnedWithDelay) {
   Init(use_validator);
   renderer_->set_expect_overlays(true);
 
-  ResourceId resource1 = CreateResource(resource_provider_.get());
-  ResourceId resource2 = CreateResource(resource_provider_.get());
-  ResourceId resource3 = CreateResource(resource_provider_.get());
+  ResourceId resource1 =
+      CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
+  ResourceId resource2 =
+      CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
+  ResourceId resource3 =
+      CreateResource(resource_provider_.get(), gfx::Size(32, 32), true);
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
   RenderPassList pass_list;
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index a1d1a90..2fd7a80c 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -384,34 +384,22 @@ TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
   gfx::Size size(58, 95);
   ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
-  bool allow_overlay = true;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_6_NEW(IOSurfaceDrawQuad,
-                    opaque_rect,
-                    visible_rect,
-                    size,
-                    resource_id,
-                    orientation,
-                    allow_overlay);
+  CREATE_QUAD_5_NEW(IOSurfaceDrawQuad, opaque_rect, visible_rect, size,
+                    resource_id, orientation);
   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_EQ(size, copy_quad->io_surface_size);
   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id());
   EXPECT_EQ(orientation, copy_quad->orientation);
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 
-  CREATE_QUAD_4_ALL(IOSurfaceDrawQuad,
-                    size,
-                    resource_id,
-                    orientation,
-                    allow_overlay);
+  CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, resource_id, orientation);
   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
   EXPECT_EQ(size, copy_quad->io_surface_size);
   EXPECT_EQ(resource_id, copy_quad->io_surface_resource_id());
   EXPECT_EQ(orientation, copy_quad->orientation);
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 }
 
 TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
@@ -495,25 +483,22 @@ TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   ResourceId resource_id = 64;
   gfx::Size resource_size_in_pixels = gfx::Size(40, 41);
-  bool allow_overlay = true;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_6_NEW(StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id,
-                    resource_size_in_pixels, allow_overlay, matrix);
+  CREATE_QUAD_5_NEW(StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id,
+                    resource_size_in_pixels, matrix);
   EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copy_quad->material);
   EXPECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_EQ(resource_id, copy_quad->resource_id());
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay());
   EXPECT_EQ(resource_size_in_pixels, copy_quad->resource_size_in_pixels());
   EXPECT_EQ(matrix, copy_quad->matrix);
 
-  CREATE_QUAD_4_ALL(StreamVideoDrawQuad, resource_id, resource_size_in_pixels,
-                    allow_overlay, matrix);
+  CREATE_QUAD_3_ALL(StreamVideoDrawQuad, resource_id, resource_size_in_pixels,
+                    matrix);
   EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copy_quad->material);
   EXPECT_EQ(resource_id, copy_quad->resource_id());
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay());
   EXPECT_EQ(resource_size_in_pixels, copy_quad->resource_size_in_pixels());
   EXPECT_EQ(matrix, copy_quad->matrix);
 }
@@ -539,7 +524,6 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   unsigned resource_id = 82;
   gfx::Size resource_size_in_pixels = gfx::Size(40, 41);
-  bool allow_overlay = true;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(0.5f, 224.f);
   gfx::PointF uv_bottom_right(51.5f, 260.f);
@@ -570,13 +554,12 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
   EXPECT_EQ(y_flipped, copy_quad->y_flipped);
   EXPECT_EQ(nearest_neighbor, copy_quad->nearest_neighbor);
 
-  CREATE_QUAD_10_ALL(TextureDrawQuad, resource_id, resource_size_in_pixels,
-                     allow_overlay, premultiplied_alpha, uv_top_left,
-                     uv_bottom_right, SK_ColorTRANSPARENT, vertex_opacity,
-                     y_flipped, nearest_neighbor);
+  CREATE_QUAD_9_ALL(TextureDrawQuad, resource_id, resource_size_in_pixels,
+                    premultiplied_alpha, uv_top_left, uv_bottom_right,
+                    SK_ColorTRANSPARENT, vertex_opacity, y_flipped,
+                    nearest_neighbor);
   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copy_quad->material);
   EXPECT_EQ(resource_id, copy_quad->resource_id());
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay());
   EXPECT_EQ(resource_size_in_pixels, copy_quad->resource_size_in_pixels());
   EXPECT_EQ(premultiplied_alpha, copy_quad->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, copy_quad->uv_top_left);
@@ -745,20 +728,13 @@ TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
   gfx::Size size(58, 95);
   ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
-  bool allow_overlay = true;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_6_NEW(IOSurfaceDrawQuad,
-                    opaque_rect,
-                    visible_rect,
-                    size,
-                    resource_id,
-                    orientation,
-                    allow_overlay);
+  CREATE_QUAD_5_NEW(IOSurfaceDrawQuad, opaque_rect, visible_rect, size,
+                    resource_id, orientation);
   EXPECT_EQ(resource_id, quad_new->io_surface_resource_id());
   EXPECT_EQ(1, IterateAndCount(quad_new));
   EXPECT_EQ(resource_id + 1, quad_new->io_surface_resource_id());
-  EXPECT_EQ(allow_overlay, copy_quad->allow_overlay);
 }
 
 TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
@@ -816,14 +792,12 @@ TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
   gfx::Rect visible_rect(40, 50, 30, 20);
   ResourceId resource_id = 64;
   gfx::Size resource_size_in_pixels = gfx::Size(40, 41);
-  bool allow_overlay = true;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_6_NEW(StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id,
-                    resource_size_in_pixels, allow_overlay, matrix);
+  CREATE_QUAD_5_NEW(StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id,
+                    resource_size_in_pixels, matrix);
   EXPECT_EQ(resource_id, quad_new->resource_id());
-  EXPECT_EQ(allow_overlay, quad_new->allow_overlay());
   EXPECT_EQ(resource_size_in_pixels, quad_new->resource_size_in_pixels());
   EXPECT_EQ(1, IterateAndCount(quad_new));
   EXPECT_EQ(resource_id + 1, quad_new->resource_id());
diff --git a/cc/quads/io_surface_draw_quad.cc b/cc/quads/io_surface_draw_quad.cc
index 32e2ffc4..1ed0021 100644
--- a/cc/quads/io_surface_draw_quad.cc
+++ b/cc/quads/io_surface_draw_quad.cc
@@ -11,9 +11,7 @@
 
 namespace cc {
 
-IOSurfaceDrawQuad::IOSurfaceDrawQuad()
-    : orientation(FLIPPED), allow_overlay(false) {
-}
+IOSurfaceDrawQuad::IOSurfaceDrawQuad() : orientation(FLIPPED) {}
 
 void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                const gfx::Rect& rect,
@@ -21,8 +19,7 @@ void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
-                               Orientation orientation,
-                               bool allow_overlay) {
+                               Orientation orientation) {
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
@@ -30,7 +27,6 @@ void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
   resources.ids[kIOSurfaceResourceIdIndex] = io_surface_resource_id;
   resources.count = 1;
   this->orientation = orientation;
-  this->allow_overlay = allow_overlay;
 }
 
 void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -40,15 +36,13 @@ void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                bool needs_blending,
                                const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
-                               Orientation orientation,
-                               bool allow_overlay) {
+                               Orientation orientation) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   this->io_surface_size = io_surface_size;
   resources.ids[kIOSurfaceResourceIdIndex] = io_surface_resource_id;
   resources.count = 1;
   this->orientation = orientation;
-  this->allow_overlay = allow_overlay;
 }
 
 const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
diff --git a/cc/quads/io_surface_draw_quad.h b/cc/quads/io_surface_draw_quad.h
index 0374aa9..4a8a072 100644
--- a/cc/quads/io_surface_draw_quad.h
+++ b/cc/quads/io_surface_draw_quad.h
@@ -28,8 +28,7 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
-              Orientation orientation,
-              bool allow_overlay);
+              Orientation orientation);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
@@ -38,12 +37,10 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
               bool needs_blending,
               const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
-              Orientation orientation,
-              bool allow_overlay);
+              Orientation orientation);
 
   gfx::Size io_surface_size;
   Orientation orientation;
-  bool allow_overlay;
 
   ResourceId io_surface_resource_id() const {
     return resources.ids[kIOSurfaceResourceIdIndex];
diff --git a/cc/quads/stream_video_draw_quad.cc b/cc/quads/stream_video_draw_quad.cc
index c25e5d5..7760168 100644
--- a/cc/quads/stream_video_draw_quad.cc
+++ b/cc/quads/stream_video_draw_quad.cc
@@ -20,14 +20,12 @@ void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                                  const gfx::Rect& visible_rect,
                                  unsigned resource_id,
                                  gfx::Size resource_size_in_pixels,
-                                 bool allow_overlay,
                                  const gfx::Transform& matrix) {
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   resources.ids[kResourceIdIndex] = resource_id;
   overlay_resources.size_in_pixels[kResourceIdIndex] = resource_size_in_pixels;
-  overlay_resources.allow_overlay[kResourceIdIndex] = allow_overlay;
   resources.count = 1;
   this->matrix = matrix;
 }
@@ -39,13 +37,11 @@ void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                                  bool needs_blending,
                                  unsigned resource_id,
                                  gfx::Size resource_size_in_pixels,
-                                 bool allow_overlay,
                                  const gfx::Transform& matrix) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   resources.ids[kResourceIdIndex] = resource_id;
   overlay_resources.size_in_pixels[kResourceIdIndex] = resource_size_in_pixels;
-  overlay_resources.allow_overlay[kResourceIdIndex] = allow_overlay;
   resources.count = 1;
   this->matrix = matrix;
 }
@@ -63,8 +59,6 @@ void StreamVideoDrawQuad::ExtendValue(
 }
 
 StreamVideoDrawQuad::OverlayResources::OverlayResources() {
-  for (size_t i = 0; i < Resources::kMaxResourceIdCount; ++i)
-    allow_overlay[i] = false;
 }
 
 }  // namespace cc
diff --git a/cc/quads/stream_video_draw_quad.h b/cc/quads/stream_video_draw_quad.h
index 519c353..1044fdc 100644
--- a/cc/quads/stream_video_draw_quad.h
+++ b/cc/quads/stream_video_draw_quad.h
@@ -22,7 +22,6 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
               const gfx::Rect& visible_rect,
               unsigned resource_id,
               gfx::Size resource_size_in_pixels,
-              bool allow_overlay,
               const gfx::Transform& matrix);
 
   void SetAll(const SharedQuadState* shared_quad_state,
@@ -32,16 +31,13 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
               bool needs_blending,
               unsigned resource_id,
               gfx::Size resource_size_in_pixels,
-              bool allow_overlay,
               const gfx::Transform& matrix);
 
   gfx::Transform matrix;
 
   struct OverlayResources {
     OverlayResources();
-
     gfx::Size size_in_pixels[Resources::kMaxResourceIdCount];
-    bool allow_overlay[Resources::kMaxResourceIdCount];
   };
   OverlayResources overlay_resources;
 
@@ -51,9 +47,6 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
   const gfx::Size& resource_size_in_pixels() const {
     return overlay_resources.size_in_pixels[kResourceIdIndex];
   }
-  bool allow_overlay() const {
-    return overlay_resources.allow_overlay[kResourceIdIndex];
-  }
 
  private:
   static const size_t kResourceIdIndex = 0;
diff --git a/cc/quads/texture_draw_quad.cc b/cc/quads/texture_draw_quad.cc
index c469c87..370277b 100644
--- a/cc/quads/texture_draw_quad.cc
+++ b/cc/quads/texture_draw_quad.cc
@@ -60,7 +60,6 @@ void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                              bool needs_blending,
                              unsigned resource_id,
                              gfx::Size resource_size_in_pixels,
-                             bool allow_overlay,
                              bool premultiplied_alpha,
                              const gfx::PointF& uv_top_left,
                              const gfx::PointF& uv_bottom_right,
@@ -72,7 +71,6 @@ void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                    opaque_rect, visible_rect, needs_blending);
   resources.ids[kResourceIdIndex] = resource_id;
   overlay_resources.size_in_pixels[kResourceIdIndex] = resource_size_in_pixels;
-  overlay_resources.allow_overlay[kResourceIdIndex] = allow_overlay;
   resources.count = 1;
   this->premultiplied_alpha = premultiplied_alpha;
   this->uv_top_left = uv_top_left;
@@ -110,8 +108,6 @@ void TextureDrawQuad::ExtendValue(base::trace_event::TracedValue* value) const {
 }
 
 TextureDrawQuad::OverlayResources::OverlayResources() {
-  for (size_t i = 0; i < Resources::kMaxResourceIdCount; ++i)
-    allow_overlay[i] = false;
 }
 
 }  // namespace cc
diff --git a/cc/quads/texture_draw_quad.h b/cc/quads/texture_draw_quad.h
index 40c7623..9b9fab9 100644
--- a/cc/quads/texture_draw_quad.h
+++ b/cc/quads/texture_draw_quad.h
@@ -36,7 +36,6 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
               bool needs_blending,
               unsigned resource_id,
               gfx::Size resource_size_in_pixels,
-              bool allow_overlay,
               bool premultiplied_alpha,
               const gfx::PointF& uv_top_left,
               const gfx::PointF& uv_bottom_right,
@@ -57,7 +56,6 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
     OverlayResources();
 
     gfx::Size size_in_pixels[Resources::kMaxResourceIdCount];
-    bool allow_overlay[Resources::kMaxResourceIdCount];
   };
   OverlayResources overlay_resources;
 
@@ -68,12 +66,6 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
   void set_resource_size_in_pixels(const gfx::Size& size_in_pixels) {
     overlay_resources.size_in_pixels[kResourceIdIndex] = size_in_pixels;
   }
-  bool allow_overlay() const {
-    return overlay_resources.allow_overlay[kResourceIdIndex];
-  }
-  void set_allow_overlay(bool allow_overlay) {
-    overlay_resources.allow_overlay[kResourceIdIndex] = allow_overlay;
-  }
 
   static const TextureDrawQuad* MaterialCast(const DrawQuad*);
 
diff --git a/cc/resources/resource_provider.cc b/cc/resources/resource_provider.cc
index 083b486..c9d0389 100644
--- a/cc/resources/resource_provider.cc
+++ b/cc/resources/resource_provider.cc
@@ -221,6 +221,7 @@ ResourceProvider::Resource::Resource(GLuint texture_id,
       allocated(false),
       read_lock_fences_enabled(false),
       has_shared_bitmap_id(false),
+      is_overlay_candidate(false),
       read_lock_fence(NULL),
       size(size),
       origin(origin),
@@ -521,6 +522,7 @@ ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
       base::Bind(&SingleReleaseCallbackImpl::Run,
                  base::Owned(release_callback_impl.release()));
   resource->read_lock_fences_enabled = read_lock_fences_enabled;
+  resource->is_overlay_candidate = mailbox.is_overlay_candidate();
   return id;
 }
 
@@ -779,6 +781,11 @@ bool ResourceProvider::CanLockForWrite(ResourceId id) {
          !resource->lost && ReadLockFenceHasPassed(resource);
 }
 
+bool ResourceProvider::IsOverlayCandidate(ResourceId id) {
+  Resource* resource = GetResource(id);
+  return resource->is_overlay_candidate;
+}
+
 void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
@@ -1220,6 +1227,7 @@ void ResourceProvider::ReceiveFromChild(
                                          it->mailbox_holder.texture_target,
                                          it->mailbox_holder.sync_point);
       resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
+      resource->is_overlay_candidate = it->is_overlay_candidate;
     }
     resource->child_id = child;
     // Don't allocate a texture for a child.
@@ -1321,6 +1329,7 @@ void ResourceProvider::TransferResource(GLES2Interface* gl,
   resource->size = source->size;
   resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
   resource->is_repeated = (source->wrap_mode == GL_REPEAT);
+  resource->is_overlay_candidate = source->is_overlay_candidate;
 
   if (source->type == RESOURCE_TYPE_BITMAP) {
     resource->mailbox_holder.mailbox = source->shared_bitmap_id;
diff --git a/cc/resources/resource_provider.h b/cc/resources/resource_provider.h
index 4af135e..ca97bc4 100644
--- a/cc/resources/resource_provider.h
+++ b/cc/resources/resource_provider.h
@@ -422,6 +422,9 @@ class CC_EXPORT ResourceProvider
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
+  // Indicates if this resource may be used for a hardware overlay plane.
+  bool IsOverlayCandidate(ResourceId id);
+
   void WaitSyncPointIfNeeded(ResourceId id);
 
   static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
@@ -495,6 +498,7 @@ class CC_EXPORT ResourceProvider
     bool allocated : 1;
     bool read_lock_fences_enabled : 1;
     bool has_shared_bitmap_id : 1;
+    bool is_overlay_candidate : 1;
     scoped_refptr<Fence> read_lock_fence;
     gfx::Size size;
     Origin origin;
diff --git a/cc/resources/texture_mailbox.cc b/cc/resources/texture_mailbox.cc
index 7e4dd29..ff4c6f9 100644
--- a/cc/resources/texture_mailbox.cc
+++ b/cc/resources/texture_mailbox.cc
@@ -15,37 +15,35 @@ TextureMailbox::TextureMailbox() : shared_bitmap_(NULL) {
 TextureMailbox::TextureMailbox(const gpu::MailboxHolder& mailbox_holder)
     : mailbox_holder_(mailbox_holder),
       shared_bitmap_(NULL),
-      allow_overlay_(false),
-      nearest_neighbor_(false) {
-}
+      is_overlay_candidate_(false),
+      nearest_neighbor_(false) {}
 
 TextureMailbox::TextureMailbox(const gpu::Mailbox& mailbox,
                                uint32 target,
                                uint32 sync_point)
     : mailbox_holder_(mailbox, target, sync_point),
       shared_bitmap_(NULL),
-      allow_overlay_(false),
-      nearest_neighbor_(false) {
-}
+      is_overlay_candidate_(false),
+      nearest_neighbor_(false) {}
 
 TextureMailbox::TextureMailbox(const gpu::Mailbox& mailbox,
                                uint32 target,
                                uint32 sync_point,
                                const gfx::Size& size_in_pixels,
-                               bool allow_overlay)
+                               bool is_overlay_candidate)
     : mailbox_holder_(mailbox, target, sync_point),
       shared_bitmap_(nullptr),
       size_in_pixels_(size_in_pixels),
-      allow_overlay_(allow_overlay),
+      is_overlay_candidate_(is_overlay_candidate),
       nearest_neighbor_(false) {
-  DCHECK_IMPLIES(allow_overlay, !size_in_pixels.IsEmpty());
+  DCHECK_IMPLIES(is_overlay_candidate, !size_in_pixels.IsEmpty());
 }
 
 TextureMailbox::TextureMailbox(SharedBitmap* shared_bitmap,
                                const gfx::Size& size_in_pixels)
     : shared_bitmap_(shared_bitmap),
       size_in_pixels_(size_in_pixels),
-      allow_overlay_(false),
+      is_overlay_candidate_(false),
       nearest_neighbor_(false) {
   // If an embedder of cc gives an invalid TextureMailbox, we should crash
   // here to identify the offender.
diff --git a/cc/resources/texture_mailbox.h b/cc/resources/texture_mailbox.h
index 47e71ac..9fc0fb8 100644
--- a/cc/resources/texture_mailbox.h
+++ b/cc/resources/texture_mailbox.h
@@ -26,7 +26,7 @@ class CC_EXPORT TextureMailbox {
                  uint32 target,
                  uint32 sync_point,
                  const gfx::Size& size_in_pixels,
-                 bool allow_overlay);
+                 bool is_overlay_candidate);
   TextureMailbox(SharedBitmap* shared_bitmap, const gfx::Size& size_in_pixels);
 
   ~TextureMailbox();
@@ -45,7 +45,7 @@ class CC_EXPORT TextureMailbox {
     mailbox_holder_.sync_point = sync_point;
   }
 
-  bool allow_overlay() const { return allow_overlay_; }
+  bool is_overlay_candidate() const { return is_overlay_candidate_; }
   bool nearest_neighbor() const { return nearest_neighbor_; }
   void set_nearest_neighbor(bool nearest_neighbor) {
     nearest_neighbor_ = nearest_neighbor;
@@ -61,7 +61,7 @@ class CC_EXPORT TextureMailbox {
   gpu::MailboxHolder mailbox_holder_;
   SharedBitmap* shared_bitmap_;
   gfx::Size size_in_pixels_;
-  bool allow_overlay_;
+  bool is_overlay_candidate_;
   bool nearest_neighbor_;
 };
 
diff --git a/cc/resources/transferable_resource.cc b/cc/resources/transferable_resource.cc
index 89771a7..7832cfe 100644
--- a/cc/resources/transferable_resource.cc
+++ b/cc/resources/transferable_resource.cc
@@ -14,8 +14,7 @@ TransferableResource::TransferableResource()
       read_lock_fences_enabled(false),
       is_repeated(false),
       is_software(false),
-      allow_overlay(false) {
-}
+      is_overlay_candidate(false) {}
 
 TransferableResource::~TransferableResource() {
 }
diff --git a/cc/resources/transferable_resource.h b/cc/resources/transferable_resource.h
index 6f38a62..750a172 100644
--- a/cc/resources/transferable_resource.h
+++ b/cc/resources/transferable_resource.h
@@ -37,7 +37,7 @@ struct CC_EXPORT TransferableResource {
   bool read_lock_fences_enabled;
   bool is_repeated;
   bool is_software;
-  bool allow_overlay;
+  bool is_overlay_candidate;
 };
 
 }  // namespace cc
diff --git a/cc/surfaces/surface_aggregator_perftest.cc b/cc/surfaces/surface_aggregator_perftest.cc
index 71589ed..2960c44 100644
--- a/cc/surfaces/surface_aggregator_perftest.cc
+++ b/cc/surfaces/surface_aggregator_perftest.cc
@@ -74,7 +74,7 @@ class SurfaceAggregatorPerfTest : public testing::Test {
         bool flipped = false;
         bool nearest_neighbor = false;
         quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending, j,
-                     gfx::Size(), false, premultiplied_alpha, uv_top_left,
+                     gfx::Size(), premultiplied_alpha, uv_top_left,
                      uv_bottom_right, background_color, vertex_opacity, flipped,
                      nearest_neighbor);
       }
diff --git a/cc/surfaces/surface_aggregator_unittest.cc b/cc/surfaces/surface_aggregator_unittest.cc
index b2476d9..bfec6e6 100644
--- a/cc/surfaces/surface_aggregator_unittest.cc
+++ b/cc/surfaces/surface_aggregator_unittest.cc
@@ -1582,9 +1582,9 @@ void SubmitCompositorFrameWithResources(ResourceId* resource_ids,
     bool flipped = false;
     bool nearest_neighbor = false;
     quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
-                 resource_ids[i], gfx::Size(), false, premultiplied_alpha,
-                 uv_top_left, uv_bottom_right, background_color, vertex_opacity,
-                 flipped, nearest_neighbor);
+                 resource_ids[i], gfx::Size(), premultiplied_alpha, uv_top_left,
+                 uv_bottom_right, background_color, vertex_opacity, flipped,
+                 nearest_neighbor);
   }
   frame_data->render_pass_list.push_back(pass.Pass());
   scoped_ptr<CompositorFrame> frame(new CompositorFrame);
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index c858ea5..bb3a809 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -219,7 +219,7 @@ void AddOneOfEveryQuadType(RenderPass* to_pass,
       to_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   io_surface_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
                           gfx::Size(50, 50), resource7,
-                          IOSurfaceDrawQuad::FLIPPED, false);
+                          IOSurfaceDrawQuad::FLIPPED);
 
   if (child_pass.layer_id) {
     RenderPassDrawQuad* render_pass_quad =
@@ -245,7 +245,7 @@ void AddOneOfEveryQuadType(RenderPass* to_pass,
   StreamVideoDrawQuad* stream_video_quad =
       to_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
   stream_video_quad->SetNew(shared_state, rect, opaque_rect, visible_rect,
-                            resource6, gfx::Size(), false, gfx::Transform());
+                            resource6, gfx::Size(), gfx::Transform());
 
   TextureDrawQuad* texture_quad =
       to_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc
index f05a253..7b14aeb 100644
--- a/content/common/cc_messages.cc
+++ b/content/common/cc_messages.cc
@@ -800,7 +800,6 @@ void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Write(
     const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     WriteParam(m, p.size_in_pixels[i]);
-    WriteParam(m, p.allow_overlay[i]);
   }
 }
 
@@ -811,8 +810,6 @@ bool ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Read(
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     if (!ReadParam(m, iter, &p->size_in_pixels[i]))
       return false;
-    if (!ReadParam(m, iter, &p->allow_overlay[i]))
-      return false;
   }
   return true;
 }
@@ -823,8 +820,6 @@ void ParamTraits<cc::StreamVideoDrawQuad::OverlayResources>::Log(
   l->append("StreamVideoDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
-    l->append(", ");
-    LogParam(p.allow_overlay[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
@@ -836,7 +831,6 @@ void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Write(
     const param_type& p) {
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     WriteParam(m, p.size_in_pixels[i]);
-    WriteParam(m, p.allow_overlay[i]);
   }
 }
 
@@ -847,8 +841,6 @@ bool ParamTraits<cc::TextureDrawQuad::OverlayResources>::Read(
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     if (!ReadParam(m, iter, &p->size_in_pixels[i]))
       return false;
-    if (!ReadParam(m, iter, &p->allow_overlay[i]))
-      return false;
   }
   return true;
 }
@@ -859,8 +851,6 @@ void ParamTraits<cc::TextureDrawQuad::OverlayResources>::Log(
   l->append("TextureDrawQuad::OverlayResources([");
   for (size_t i = 0; i < cc::DrawQuad::Resources::kMaxResourceIdCount; ++i) {
     LogParam(p.size_in_pixels[i], l);
-    l->append(", ");
-    LogParam(p.allow_overlay[i], l);
     if (i < (cc::DrawQuad::Resources::kMaxResourceIdCount - 1))
       l->append(", ");
   }
diff --git a/content/common/cc_messages.h b/content/common/cc_messages.h
index 55a8c49..2dac19f 100644
--- a/content/common/cc_messages.h
+++ b/content/common/cc_messages.h
@@ -187,7 +187,6 @@ IPC_STRUCT_TRAITS_BEGIN(cc::IOSurfaceDrawQuad)
   IPC_STRUCT_TRAITS_PARENT(cc::DrawQuad)
   IPC_STRUCT_TRAITS_MEMBER(io_surface_size)
   IPC_STRUCT_TRAITS_MEMBER(orientation)
-  IPC_STRUCT_TRAITS_MEMBER(allow_overlay)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(cc::RenderPassDrawQuad)
@@ -269,7 +268,7 @@ IPC_STRUCT_TRAITS_BEGIN(cc::TransferableResource)
   IPC_STRUCT_TRAITS_MEMBER(read_lock_fences_enabled)
   IPC_STRUCT_TRAITS_MEMBER(is_repeated)
   IPC_STRUCT_TRAITS_MEMBER(is_software)
-  IPC_STRUCT_TRAITS_MEMBER(allow_overlay)
+  IPC_STRUCT_TRAITS_MEMBER(is_overlay_candidate)
 IPC_STRUCT_TRAITS_END()
 
 IPC_STRUCT_TRAITS_BEGIN(cc::ReturnedResource)
diff --git a/content/common/cc_messages_unittest.cc b/content/common/cc_messages_unittest.cc
index 4cb3dc6..1a20504 100644
--- a/content/common/cc_messages_unittest.cc
+++ b/content/common/cc_messages_unittest.cc
@@ -131,7 +131,6 @@ class CCMessagesTest : public testing::Test {
     EXPECT_EQ(a->io_surface_size.ToString(), b->io_surface_size.ToString());
     EXPECT_EQ(a->io_surface_resource_id(), b->io_surface_resource_id());
     EXPECT_EQ(a->orientation, b->orientation);
-    EXPECT_EQ(a->allow_overlay, b->allow_overlay);
   }
 
   void Compare(const RenderPassDrawQuad* a, const RenderPassDrawQuad* b) {
@@ -161,7 +160,6 @@ class CCMessagesTest : public testing::Test {
   void Compare(const StreamVideoDrawQuad* a, const StreamVideoDrawQuad* b) {
     EXPECT_EQ(a->resource_id(), b->resource_id());
     EXPECT_EQ(a->resource_size_in_pixels(), b->resource_size_in_pixels());
-    EXPECT_EQ(a->allow_overlay(), b->allow_overlay());
     EXPECT_EQ(a->matrix, b->matrix);
   }
 
@@ -172,7 +170,6 @@ class CCMessagesTest : public testing::Test {
   void Compare(const TextureDrawQuad* a, const TextureDrawQuad* b) {
     EXPECT_EQ(a->resource_id(), b->resource_id());
     EXPECT_EQ(a->resource_size_in_pixels(), b->resource_size_in_pixels());
-    EXPECT_EQ(a->allow_overlay(), b->allow_overlay());
     EXPECT_EQ(a->premultiplied_alpha, b->premultiplied_alpha);
     EXPECT_EQ(a->uv_top_left, b->uv_top_left);
     EXPECT_EQ(a->uv_bottom_right, b->uv_bottom_right);
@@ -216,7 +213,7 @@ class CCMessagesTest : public testing::Test {
     }
     EXPECT_EQ(a.mailbox_holder.texture_target, b.mailbox_holder.texture_target);
     EXPECT_EQ(a.mailbox_holder.sync_point, b.mailbox_holder.sync_point);
-    EXPECT_EQ(a.allow_overlay, b.allow_overlay);
+    EXPECT_EQ(a.is_overlay_candidate, b.is_overlay_candidate);
   }
 };
 
@@ -269,7 +266,6 @@ TEST_F(CCMessagesTest, AllQuads) {
   SkXfermode::Mode arbitrary_blend_mode3 = SkXfermode::kOverlay_Mode;
   IOSurfaceDrawQuad::Orientation arbitrary_orientation =
       IOSurfaceDrawQuad::UNFLIPPED;
-  bool arbitrary_allow_overlay = true;
   ResourceId arbitrary_resourceid1 = 55;
   ResourceId arbitrary_resourceid2 = 47;
   ResourceId arbitrary_resourceid3 = 23;
@@ -339,8 +335,7 @@ TEST_F(CCMessagesTest, AllQuads) {
                        arbitrary_bool1,
                        arbitrary_size1,
                        arbitrary_resourceid3,
-                       arbitrary_orientation,
-                       arbitrary_allow_overlay);
+                       arbitrary_orientation);
   pass_cmp->CopyFromAndAppendDrawQuad(iosurface_in,
                                       iosurface_in->shared_quad_state);
 
@@ -389,7 +384,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   streamvideo_in->SetAll(
       shared_state3_in, arbitrary_rect2, arbitrary_rect2_inside_rect2,
       arbitrary_rect1_inside_rect2, arbitrary_bool1, arbitrary_resourceid2,
-      arbitrary_size1, arbitrary_bool2, arbitrary_matrix1);
+      arbitrary_size1, arbitrary_matrix1);
   pass_cmp->CopyFromAndAppendDrawQuad(streamvideo_in,
                                       streamvideo_in->shared_quad_state);
 
@@ -412,7 +407,7 @@ TEST_F(CCMessagesTest, AllQuads) {
   texture_in->SetAll(shared_state3_in, arbitrary_rect2,
                      arbitrary_rect2_inside_rect2, arbitrary_rect1_inside_rect2,
                      arbitrary_bool1, arbitrary_resourceid1, arbitrary_size1,
-                     arbitrary_bool2, arbitrary_bool3, arbitrary_pointf1,
+                     arbitrary_bool2, arbitrary_pointf1,
                      arbitrary_pointf2, arbitrary_color, arbitrary_float_array,
                      arbitrary_bool4, arbitrary_bool5);
   pass_cmp->CopyFromAndAppendDrawQuad(texture_in,
@@ -645,7 +640,7 @@ TEST_F(CCMessagesTest, Resources) {
   arbitrary_resource1.mailbox_holder.mailbox.SetName(arbitrary_mailbox1);
   arbitrary_resource1.mailbox_holder.texture_target = GL_TEXTURE_2D;
   arbitrary_resource1.mailbox_holder.sync_point = arbitrary_uint1;
-  arbitrary_resource1.allow_overlay = true;
+  arbitrary_resource1.is_overlay_candidate = true;
 
   TransferableResource arbitrary_resource2;
   arbitrary_resource2.id = 789132;
@@ -655,7 +650,7 @@ TEST_F(CCMessagesTest, Resources) {
   arbitrary_resource2.mailbox_holder.mailbox.SetName(arbitrary_mailbox2);
   arbitrary_resource2.mailbox_holder.texture_target = GL_TEXTURE_EXTERNAL_OES;
   arbitrary_resource2.mailbox_holder.sync_point = arbitrary_uint2;
-  arbitrary_resource2.allow_overlay = false;
+  arbitrary_resource2.is_overlay_candidate = false;
 
   scoped_ptr<RenderPass> renderpass_in = RenderPass::Create();
   renderpass_in->SetNew(
diff --git a/mojo/converters/surfaces/surfaces_type_converters.cc b/mojo/converters/surfaces/surfaces_type_converters.cc
index 6e901df..381c6d2 100644
--- a/mojo/converters/surfaces/surfaces_type_converters.cc
+++ b/mojo/converters/surfaces/surfaces_type_converters.cc
@@ -152,7 +152,7 @@ bool ConvertDrawQuad(const QuadPtr& input,
       texture_quad->SetAll(
           sqs, input->rect.To<gfx::Rect>(), input->opaque_rect.To<gfx::Rect>(),
           input->visible_rect.To<gfx::Rect>(), input->needs_blending,
-          texture_quad_state->resource_id, gfx::Size(), false,
+          texture_quad_state->resource_id, gfx::Size(),
           texture_quad_state->premultiplied_alpha,
           texture_quad_state->uv_top_left.To<gfx::PointF>(),
           texture_quad_state->uv_bottom_right.To<gfx::PointF>(),
diff --git a/mojo/converters/surfaces/tests/surface_unittest.cc b/mojo/converters/surfaces/tests/surface_unittest.cc
index 90aab3c58..30b1884 100644
--- a/mojo/converters/surfaces/tests/surface_unittest.cc
+++ b/mojo/converters/surfaces/tests/surface_unittest.cc
@@ -112,12 +112,10 @@ TEST_F(SurfaceLibQuadTest, TextureQuad) {
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
   bool y_flipped = false;
   bool nearest_neighbor = false;
-  bool allow_overlay = false;
   texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
-                       resource_id, gfx::Size(), allow_overlay,
-                       premultiplied_alpha, uv_top_left, uv_bottom_right,
-                       background_color, vertex_opacity, y_flipped,
-                       nearest_neighbor);
+                       resource_id, gfx::Size(), premultiplied_alpha,
+                       uv_top_left, uv_bottom_right, background_color,
+                       vertex_opacity, y_flipped, nearest_neighbor);
 
   QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(*texture_quad);
   ASSERT_FALSE(mojo_quad.is_null());
@@ -266,12 +264,10 @@ TEST(SurfaceLibTest, RenderPass) {
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
   bool y_flipped = false;
   bool nearest_neighbor = false;
-  bool allow_overlay = false;
   texture_quad->SetAll(sqs, rect, opaque_rect, visible_rect, needs_blending,
-                       resource_id, gfx::Size(), allow_overlay,
-                       premultiplied_alpha, uv_top_left, uv_bottom_right,
-                       background_color, vertex_opacity, y_flipped,
-                       nearest_neighbor);
+                       resource_id, gfx::Size(), premultiplied_alpha,
+                       uv_top_left, uv_bottom_right, background_color,
+                       vertex_opacity, y_flipped, nearest_neighbor);
 
   PassPtr mojo_pass = Pass::From(*pass);
   ASSERT_FALSE(mojo_pass.is_null());