cc: Make a general iterator for DrawQuad resources.

The DrawQuad::AppendResources function needs to iterate over
all resources in the quads and do something with them. A similar
pattern will be needed for the delegated renderer layer to
iterate over all resources and remap them into the parent
comspositor's namespace.

This CL renames AppendResources into IterateResources which
calls a callback method for each resource, and allows that
method to change the id of the given resource.

Tests:
DrawQuadIteratorTest.CheckerboardDrawQuad
DrawQuadIteratorTest.DebugBorderDrawQuad
DrawQuadIteratorTest.IOSurfaceDrawQuad
DrawQuadIteratorTest.RenderPassDrawQuad
DrawQuadIteratorTest.SolidColorDrawQuad
DrawQuadIteratorTest.StreamVideoDrawQuad
DrawQuadIteratorTest.TextureDrawQuad
DrawQuadIteratorTest.TileDrawQuad
DrawQuadIteratorTest.YUVVideoDrawQuad

R=piman
BUG=123444


Review URL: https://chromiumcodereview.appspot.com/12381027

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@185454 0039d316-1c4b-4281-b951-d872f2087c98

22 files changed, 217 insertions, 33 deletions

diff --git a/cc/checkerboard_draw_quad.cc b/cc/checkerboard_draw_quad.cc
index 9dca587..bb59d79 100644
--- a/cc/checkerboard_draw_quad.cc
+++ b/cc/checkerboard_draw_quad.cc
@@ -36,6 +36,9 @@ void CheckerboardDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->color = color;
 }
 
+void CheckerboardDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {}
+
 const CheckerboardDrawQuad* CheckerboardDrawQuad::MaterialCast(
     const DrawQuad* quad) {
   DCHECK(quad->material == DrawQuad::CHECKERBOARD);
diff --git a/cc/checkerboard_draw_quad.h b/cc/checkerboard_draw_quad.h
index 5f1c83e..0fc2ce5 100644
--- a/cc/checkerboard_draw_quad.h
+++ b/cc/checkerboard_draw_quad.h
@@ -29,6 +29,9 @@ class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
 
   SkColor color;
 
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
+    OVERRIDE;
+
   static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*);
  private:
   CheckerboardDrawQuad();
diff --git a/cc/debug_border_draw_quad.cc b/cc/debug_border_draw_quad.cc
index fba8b92..4d49e73 100644
--- a/cc/debug_border_draw_quad.cc
+++ b/cc/debug_border_draw_quad.cc
@@ -43,6 +43,9 @@ void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->width = width;
 }
 
+void DebugBorderDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {}
+
 const DebugBorderDrawQuad* DebugBorderDrawQuad::MaterialCast(
     const DrawQuad* quad) {
   DCHECK(quad->material == DrawQuad::DEBUG_BORDER);
diff --git a/cc/debug_border_draw_quad.h b/cc/debug_border_draw_quad.h
index 96dcec3..e638f7f 100644
--- a/cc/debug_border_draw_quad.h
+++ b/cc/debug_border_draw_quad.h
@@ -32,6 +32,9 @@ class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
   SkColor color;
   int width;
 
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
+      OVERRIDE;
+
   static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*);
  private:
   DebugBorderDrawQuad();
diff --git a/cc/delegating_renderer.cc b/cc/delegating_renderer.cc
index 80d0c9c..d1c3429 100644
--- a/cc/delegating_renderer.cc
+++ b/cc/delegating_renderer.cc
@@ -131,6 +131,13 @@ const RendererCapabilities& DelegatingRenderer::capabilities() const {
   return capabilities_;
 }
 
+static ResourceProvider::ResourceId AppendToArray(
+    ResourceProvider::ResourceIdArray* array,
+    ResourceProvider::ResourceId id) {
+  array->push_back(id);
+  return id;
+}
+
 void DelegatingRenderer::drawFrame(
     RenderPassList& render_passes_in_draw_order) {
   TRACE_EVENT0("cc", "DelegatingRenderer::drawFrame");
@@ -139,15 +146,20 @@ void DelegatingRenderer::drawFrame(
   out_frame.metadata = m_client->makeCompositorFrameMetadata();
 
   out_frame.delegated_frame_data = make_scoped_ptr(new DelegatedFrameData);
-  DelegatedFrameData& out_data = *out_frame.delegated_frame_data;
-
-  out_data.render_pass_list.swap(render_passes_in_draw_order);
 
+  // Collect all resource ids in the render passes into a ResourceIdArray.
   ResourceProvider::ResourceIdArray resources;
-  for (size_t i = 0; i < out_data.render_pass_list.size(); ++i) {
-    for (size_t j = 0; j < out_data.render_pass_list[i]->quad_list.size(); ++j)
-      out_data.render_pass_list[i]->quad_list[j]->AppendResources(&resources);
+  DrawQuad::ResourceIteratorCallback append_to_array =
+      base::Bind(&AppendToArray, &resources);
+  for (size_t i = 0; i < render_passes_in_draw_order.size(); ++i) {
+    RenderPass* render_pass = render_passes_in_draw_order[i];
+    for (size_t j = 0; j < render_pass->quad_list.size(); ++j)
+      render_pass->quad_list[j]->IterateResources(append_to_array);
   }
+
+  // Move the render passes and resources into the |out_frame|.
+  DelegatedFrameData& out_data = *out_frame.delegated_frame_data;
+  out_data.render_pass_list.swap(render_passes_in_draw_order);
   resource_provider_->prepareSendToParent(resources, &out_data.resource_list);
 
   output_surface_->SendFrameToParentCompositor(&out_frame);
diff --git a/cc/draw_quad.cc b/cc/draw_quad.cc
index d1f2806..47f9aa0 100644
--- a/cc/draw_quad.cc
+++ b/cc/draw_quad.cc
@@ -89,6 +89,4 @@ scoped_ptr<DrawQuad> DrawQuad::Copy(
   return copy_quad.Pass();
 }
 
-void DrawQuad::AppendResources(ResourceProvider::ResourceIdArray* resources) {}
-
 }  // namespace cc
diff --git a/cc/draw_quad.h b/cc/draw_quad.h
index dc87a5d..df62c7b 100644
--- a/cc/draw_quad.h
+++ b/cc/draw_quad.h
@@ -5,6 +5,7 @@
 #ifndef CC_DRAW_QUAD_H_
 #define CC_DRAW_QUAD_H_
 
+#include "base/callback.h"
 #include "cc/cc_export.h"
 #include "cc/resource_provider.h"
 #include "cc/shared_quad_state.h"
@@ -71,7 +72,9 @@ class CC_EXPORT DrawQuad {
         !opaque_rect.Contains(visible_rect);
   }
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources);
+  typedef base::Callback<ResourceProvider::ResourceId(
+      ResourceProvider::ResourceId)> ResourceIteratorCallback;
+  virtual void IterateResources(const ResourceIteratorCallback& callback) = 0;
 
  protected:
   DrawQuad();
diff --git a/cc/draw_quad_unittest.cc b/cc/draw_quad_unittest.cc
index e1bf9e1..f83a930 100644
--- a/cc/draw_quad_unittest.cc
+++ b/cc/draw_quad_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "cc/draw_quad.h"
 
+#include "base/bind.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/io_surface_draw_quad.h"
@@ -536,5 +537,157 @@ TEST(DrawQuadTest, copyYUVVideoDrawQuad)
     EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
 }
 
+class DrawQuadIteratorTest : public testing::Test {
+ protected:
+  ResourceProvider::ResourceId IncrementResourceId(
+      ResourceProvider::ResourceId id) {
+    ++num_resources_;
+    return id + 1;
+  }
+
+  int IterateAndCount(DrawQuad* quad) {
+    num_resources_ = 0;
+    quad->IterateResources(base::Bind(
+        &DrawQuadIteratorTest::IncrementResourceId,
+        base::Unretained(this)));
+    return num_resources_;
+  }
+
+ private:
+  int num_resources_;
+};
+
+TEST_F(DrawQuadIteratorTest, CheckerboardDrawQuad) {
+  SkColor color = 0xfabb0011;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color);
+  EXPECT_EQ(0, IterateAndCount(quadNew.get()));
+}
+
+TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
+  SkColor color = 0xfabb0011;
+  int width = 99;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width);
+  EXPECT_EQ(0, IterateAndCount(quadNew.get()));
+}
+
+TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
+  gfx::Rect opaqueRect(3, 7, 10, 12);
+  gfx::Size size(58, 95);
+  unsigned textureId = 72;
+  IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_4_NEW(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
+  EXPECT_EQ(0, IterateAndCount(quadNew.get()));
+}
+
+TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
+  RenderPass::Id renderPassId(22, 64);
+  bool isReplica = true;
+  ResourceProvider::ResourceId maskResourceId = 78;
+  gfx::Rect contentsChangedSinceLastFrame(42, 11, 74, 24);
+  gfx::RectF maskUVRect(-45, -21, 33, 19);
+  WebKit::WebFilterOperations filters;
+  filters.append(WebKit::WebFilterOperation::createBlurFilter(1.f));
+  WebKit::WebFilterOperations background_filters;
+  background_filters.append(
+      WebKit::WebFilterOperation::createGrayscaleFilter(1.f));
+  skia::RefPtr<SkImageFilter> filter = skia::AdoptRef(
+      new SkBlurImageFilter(SK_Scalar1, SK_Scalar1));
+
+  RenderPass::Id copiedRenderPassId(235, 11);
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_8_NEW_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskUVRect, filters, filter, background_filters, copiedRenderPassId);
+  EXPECT_EQ(maskResourceId, quadNew->mask_resource_id);
+  EXPECT_EQ(1, IterateAndCount(quadNew.get()));
+  EXPECT_EQ(maskResourceId + 1, quadNew->mask_resource_id);
+}
+
+TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
+  SkColor color = 0x49494949;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_1_NEW(SolidColorDrawQuad, color);
+  EXPECT_EQ(0, IterateAndCount(quadNew.get()));
+}
+
+TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
+  gfx::Rect opaqueRect(3, 7, 10, 12);
+  unsigned textureId = 64;
+  gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
+  EXPECT_EQ(0, IterateAndCount(quadNew.get()));
+}
+
+TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
+  gfx::Rect opaqueRect(3, 7, 10, 12);
+  unsigned resourceId = 82;
+  bool premultipliedAlpha = true;
+  gfx::PointF uvTopLeft(0.5f, 224.f);
+  gfx::PointF uvBottomRight(51.5f, 260.f);
+  const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
+  bool flipped = true;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_7_NEW(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvTopLeft, uvBottomRight, vertex_opacity, flipped);
+  EXPECT_EQ(resourceId, quadNew->resource_id);
+  EXPECT_EQ(1, IterateAndCount(quadNew.get()));
+  EXPECT_EQ(resourceId + 1, quadNew->resource_id);
+}
+
+TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
+  gfx::Rect opaqueRect(33, 44, 22, 33);
+  unsigned resourceId = 104;
+  gfx::RectF texCoordRect(31, 12, 54, 20);
+  gfx::Size textureSize(85, 32);
+  bool swizzleContents = true;
+  bool leftEdgeAA = true;
+  bool topEdgeAA = true;
+  bool rightEdgeAA = false;
+  bool bottomEdgeAA = true;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+  EXPECT_EQ(resourceId, quadNew->resource_id);
+  EXPECT_EQ(1, IterateAndCount(quadNew.get()));
+  EXPECT_EQ(resourceId + 1, quadNew->resource_id);
+}
+
+TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
+  gfx::Rect opaqueRect(3, 7, 10, 12);
+  gfx::SizeF texScale(0.75, 0.5);
+  VideoLayerImpl::FramePlane yPlane;
+  yPlane.resourceId = 45;
+  yPlane.size = gfx::Size(34, 23);
+  yPlane.format = 8;
+  VideoLayerImpl::FramePlane uPlane;
+  uPlane.resourceId = 532;
+  uPlane.size = gfx::Size(134, 16);
+  uPlane.format = 2;
+  VideoLayerImpl::FramePlane vPlane;
+  vPlane.resourceId = 4;
+  vPlane.size = gfx::Size(456, 486);
+  vPlane.format = 46;
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_5_NEW(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
+  EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material);
+  EXPECT_EQ(yPlane.resourceId, quadNew->y_plane.resourceId);
+  EXPECT_EQ(uPlane.resourceId, quadNew->u_plane.resourceId);
+  EXPECT_EQ(vPlane.resourceId, quadNew->v_plane.resourceId);
+  EXPECT_EQ(3, IterateAndCount(quadNew.get()));
+  EXPECT_EQ(yPlane.resourceId + 1, quadNew->y_plane.resourceId);
+  EXPECT_EQ(uPlane.resourceId + 1, quadNew->u_plane.resourceId);
+  EXPECT_EQ(vPlane.resourceId + 1, quadNew->v_plane.resourceId);
+}
+
+
 }  // namespace
 }  // namespace cc
diff --git a/cc/io_surface_draw_quad.cc b/cc/io_surface_draw_quad.cc
index 561a992..38332b2 100644
--- a/cc/io_surface_draw_quad.cc
+++ b/cc/io_surface_draw_quad.cc
@@ -47,8 +47,8 @@ void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->orientation = orientation;
 }
 
-void IOSurfaceDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
+void IOSurfaceDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
   // TODO(danakj): Convert to TextureDrawQuad?
   NOTIMPLEMENTED();
 }
diff --git a/cc/io_surface_draw_quad.h b/cc/io_surface_draw_quad.h
index 14368dc..994bed9 100644
--- a/cc/io_surface_draw_quad.h
+++ b/cc/io_surface_draw_quad.h
@@ -41,7 +41,7 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
   unsigned io_surface_texture_id;
   Orientation orientation;
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*);
diff --git a/cc/render_pass_draw_quad.cc b/cc/render_pass_draw_quad.cc
index fec3ce0..efdf0d8 100644
--- a/cc/render_pass_draw_quad.cc
+++ b/cc/render_pass_draw_quad.cc
@@ -81,9 +81,9 @@ void RenderPassDrawQuad::SetAll(
   this->background_filters = background_filters;
 }
 
-void RenderPassDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
-  resources->push_back(mask_resource_id);
+void RenderPassDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
+  mask_resource_id = callback.Run(mask_resource_id);
 }
 
 const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
diff --git a/cc/render_pass_draw_quad.h b/cc/render_pass_draw_quad.h
index 893de4d..1ce80b5 100644
--- a/cc/render_pass_draw_quad.h
+++ b/cc/render_pass_draw_quad.h
@@ -65,7 +65,7 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
   // background of the render pass, from behind it.
   WebKit::WebFilterOperations background_filters;
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
diff --git a/cc/solid_color_draw_quad.cc b/cc/solid_color_draw_quad.cc
index 54a9b75..757278d 100644
--- a/cc/solid_color_draw_quad.cc
+++ b/cc/solid_color_draw_quad.cc
@@ -36,6 +36,9 @@ void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->color = color;
 }
 
+void SolidColorDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {}
+
 const SolidColorDrawQuad* SolidColorDrawQuad::MaterialCast(
     const DrawQuad* quad) {
   DCHECK(quad->material == DrawQuad::SOLID_COLOR);
diff --git a/cc/solid_color_draw_quad.h b/cc/solid_color_draw_quad.h
index c8dd0c0..be3645e 100644
--- a/cc/solid_color_draw_quad.h
+++ b/cc/solid_color_draw_quad.h
@@ -29,6 +29,9 @@ class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
 
   SkColor color;
 
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
+      OVERRIDE;
+
   static const SolidColorDrawQuad* MaterialCast(const DrawQuad*);
  private:
   SolidColorDrawQuad();
diff --git a/cc/stream_video_draw_quad.cc b/cc/stream_video_draw_quad.cc
index 9dd64b8..6543c70 100644
--- a/cc/stream_video_draw_quad.cc
+++ b/cc/stream_video_draw_quad.cc
@@ -40,8 +40,8 @@ void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->matrix = matrix;
 }
 
-void StreamVideoDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
+void StreamVideoDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
   // TODO(danakj): Convert to TextureDrawQuad?
   NOTIMPLEMENTED();
 }
diff --git a/cc/stream_video_draw_quad.h b/cc/stream_video_draw_quad.h
index dfcbb3e..daefeb9 100644
--- a/cc/stream_video_draw_quad.h
+++ b/cc/stream_video_draw_quad.h
@@ -33,7 +33,7 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
   unsigned texture_id;
   gfx::Transform matrix;
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
diff --git a/cc/texture_draw_quad.cc b/cc/texture_draw_quad.cc
index 2f48686..03f89e2 100644
--- a/cc/texture_draw_quad.cc
+++ b/cc/texture_draw_quad.cc
@@ -65,9 +65,9 @@ void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->flipped = flipped;
 }
 
-void TextureDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
-  resources->push_back(resource_id);
+void TextureDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
+  resource_id = callback.Run(resource_id);
 }
 
 const TextureDrawQuad* TextureDrawQuad::MaterialCast(const DrawQuad* quad) {
diff --git a/cc/texture_draw_quad.h b/cc/texture_draw_quad.h
index df50558..0e0146d 100644
--- a/cc/texture_draw_quad.h
+++ b/cc/texture_draw_quad.h
@@ -45,7 +45,7 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
   float vertex_opacity[4];
   bool flipped;
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const TextureDrawQuad* MaterialCast(const DrawQuad*);
diff --git a/cc/tile_draw_quad.cc b/cc/tile_draw_quad.cc
index d33feb7..f430f2b 100644
--- a/cc/tile_draw_quad.cc
+++ b/cc/tile_draw_quad.cc
@@ -75,9 +75,9 @@ void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->bottom_edge_aa = bottom_edge_aa;
 }
 
-void TileDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
-  resources->push_back(resource_id);
+void TileDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
+  resource_id = callback.Run(resource_id);
 }
 
 const TileDrawQuad* TileDrawQuad::MaterialCast(
diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h
index 1bc9783..2018a54 100644
--- a/cc/tile_draw_quad.h
+++ b/cc/tile_draw_quad.h
@@ -60,7 +60,7 @@ class CC_EXPORT TileDrawQuad : public DrawQuad {
     return left_edge_aa || top_edge_aa || right_edge_aa || bottom_edge_aa;
   }
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const TileDrawQuad* MaterialCast(const DrawQuad*);
diff --git a/cc/yuv_video_draw_quad.cc b/cc/yuv_video_draw_quad.cc
index 891cf94..c5e0dbd 100644
--- a/cc/yuv_video_draw_quad.cc
+++ b/cc/yuv_video_draw_quad.cc
@@ -49,11 +49,11 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->v_plane = v_plane;
 }
 
-void YUVVideoDrawQuad::AppendResources(
-    ResourceProvider::ResourceIdArray* resources) {
-  resources->push_back(y_plane.resourceId);
-  resources->push_back(u_plane.resourceId);
-  resources->push_back(v_plane.resourceId);
+void YUVVideoDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {
+  y_plane.resourceId = callback.Run(y_plane.resourceId);
+  u_plane.resourceId = callback.Run(u_plane.resourceId);
+  v_plane.resourceId = callback.Run(v_plane.resourceId);
 }
 
 const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
diff --git a/cc/yuv_video_draw_quad.h b/cc/yuv_video_draw_quad.h
index 13c24cf..28d35ea 100644
--- a/cc/yuv_video_draw_quad.h
+++ b/cc/yuv_video_draw_quad.h
@@ -42,7 +42,7 @@ class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
   VideoLayerImpl::FramePlane u_plane;
   VideoLayerImpl::FramePlane v_plane;
 
-  virtual void AppendResources(ResourceProvider::ResourceIdArray* resources)
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
 
   static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);