Splitting of layers for correct intersections

cc/output/renderer_pixeltest.cc

Index: cc/output/renderer_pixeltest.cc
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index 08a40530eb4753c1257a963e72bcc15c5a2f0af3..0fcc309ebdd5693281fcf752f91bbe7065d5e544 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -156,6 +156,140 @@ void CreateTestTextureDrawQuad(const gfx::Rect& rect,
                false);  // nearest_neighbor
 }
 
+void CreateTestYUVVideoDrawQuad_FromVideoFrame(

[enne (OOO), 2015/02/04 21:24:00]

Ack, I touched some of these functions in a recent patch, so you're going to
have to eat some conflicts.  :(

[awoloszyn, 2015/02/12 16:48:51]

Turns out it wasn't too bad!

+    const SharedQuadState* shared_state,
+    scoped_refptr<media::VideoFrame> video_frame,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
+  const YUVVideoDrawQuad::ColorSpace color_space =
+      (video_frame->format() == media::VideoFrame::YV12J
+           ? YUVVideoDrawQuad::REC_601_JPEG
+           : YUVVideoDrawQuad::REC_601);
+  const gfx::Rect opaque_rect(0, 0, 0, 0);
+
+  if (with_alpha)
+    memset(video_frame->data(media::VideoFrame::kAPlane),
+           is_transparent ? 0 : 128,
+           video_frame->stride(media::VideoFrame::kAPlane) *
+               video_frame->rows(media::VideoFrame::kAPlane));
+
+  VideoFrameExternalResources resources =
+      video_resource_updater->CreateExternalResourcesFromVideoFrame(
+          video_frame);
+
+  EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.mailboxes.size());
+  EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
+            resources.release_callbacks.size());
+
+  ResourceProvider::ResourceId y_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kYPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kYPlane]));
+  ResourceProvider::ResourceId u_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kUPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kUPlane]));
+  ResourceProvider::ResourceId v_resource =
+      resource_provider->CreateResourceFromTextureMailbox(
+          resources.mailboxes[media::VideoFrame::kVPlane],
+          SingleReleaseCallbackImpl::Create(
+              resources.release_callbacks[media::VideoFrame::kVPlane]));
+  ResourceProvider::ResourceId a_resource = 0;
+  if (with_alpha) {
+    a_resource = resource_provider->CreateResourceFromTextureMailbox(
+        resources.mailboxes[media::VideoFrame::kAPlane],
+        SingleReleaseCallbackImpl::Create(
+            resources.release_callbacks[media::VideoFrame::kAPlane]));
+  }
+
+  YUVVideoDrawQuad* yuv_quad =
+      render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
+  yuv_quad->SetNew(shared_state, rect, opaque_rect, rect, tex_coord_rect,
+                   y_resource, u_resource, v_resource, a_resource, color_space);
+}
+
+void CreateTestYUVVideoDrawQuad_Striped(
+    const SharedQuadState* shared_state,
+    media::VideoFrame::Format format,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
+      format, rect.size(), rect, rect.size(), base::TimeDelta());
+
+  // YUV values representing a striped pattern, for validating texture
+  // coordinates for sampling.
+  uint8_t y_value = 0;
+  uint8_t u_value = 0;
+  uint8_t v_value = 0;
+  for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
+    uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
+                     video_frame->stride(media::VideoFrame::kYPlane) * i;
+    for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
+         ++j) {
+      y_row[j] = (y_value += 1);
+    }
+  }
+  for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) {
+    uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) +
+                     video_frame->stride(media::VideoFrame::kUPlane) * i;
+    uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) +
+                     video_frame->stride(media::VideoFrame::kVPlane) * i;
+    for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
+         ++j) {
+      u_row[j] = (u_value += 3);
+      v_row[j] = (v_value += 5);
+    }
+  }
+  CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      shared_state, video_frame, is_transparent, tex_coord_rect, render_pass,
+      video_resource_updater, rect, resource_provider);
+}
+
+void CreateTestYUVVideoDrawQuad_Solid(
+    const SharedQuadState* shared_state,
+    media::VideoFrame::Format format,
+    bool is_transparent,
+    const gfx::RectF& tex_coord_rect,
+    uint8 y,
+    uint8 u,
+    uint8 v,
+    RenderPass* render_pass,
+    VideoResourceUpdater* video_resource_updater,
+    const gfx::Rect& rect,
+    ResourceProvider* resource_provider) {
+  scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame(
+      format, rect.size(), rect, rect.size(), base::TimeDelta());
+
+  // YUV values of a solid, constant, color. Useful for testing that color
+  // space/color range are being handled properly.
+  memset(video_frame->data(media::VideoFrame::kYPlane), y,
+         video_frame->stride(media::VideoFrame::kYPlane) *
+             video_frame->rows(media::VideoFrame::kYPlane));
+  memset(video_frame->data(media::VideoFrame::kUPlane), u,
+         video_frame->stride(media::VideoFrame::kUPlane) *
+             video_frame->rows(media::VideoFrame::kUPlane));
+  memset(video_frame->data(media::VideoFrame::kVPlane), v,
+         video_frame->stride(media::VideoFrame::kVPlane) *
+             video_frame->rows(media::VideoFrame::kVPlane));
+
+  CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      shared_state, video_frame, is_transparent, tex_coord_rect, render_pass,
+      video_resource_updater, rect, resource_provider);
+}
+
 typedef ::testing::Types<GLRenderer,
                          SoftwareRenderer,
                          GLRendererWithExpandedViewport,
@@ -321,6 +455,258 @@ TYPED_TEST(RendererPixelTest, PremultipliedTextureWithBackground) {
       FuzzyPixelOffByOneComparator(true)));
 }
 
+static const char* types[] = {
+    "intersecting_blue_green.png",
+    "intersecting_blue_green_texture.png",

[enne (OOO), 2015/02/04 21:24:00]

What's with the weird aliasing in this image and the software one? It'd really
be nice if all of these used the same image, with fuzz.

[awoloszyn, 2015/02/12 16:48:52]

I replaced these images with more sensible ones. We still have 3, but they make
more sense.

+    "intersecting_blue_green_render_pass.png",

[enne (OOO), 2015/02/04 21:24:00]

The intersecting_blue_green_render_pass.png looks the same as
intersecting_blue_green.png to me.  Are they that different? Can the same image
be used with fuzz?

[awoloszyn, 2015/02/12 16:48:51]

I replaced most of the pictures with fuzz.

+};
+
+#define GLImageIndex(Type, number) \
+  template <>                      \
+  struct GLImage<Type> {           \
+    static const int val = number; \
+  };
+
+template <typename QuadType>
+struct GLImage {
+  static const int val = 0;
+};
+GLImageIndex(TextureDrawQuad, 1);

[enne (OOO), 2015/02/04 21:24:00]

Whoa, this is a bit obtuse to get a string into a test based on two types.

What about:

template <typename RendererType, typename QuadType>
static const char* IntersectingQuadImage() {
  return "some explicit string";
};

...and then repeat that as needed?

[awoloszyn, 2015/02/12 16:48:52]

Fixed.

+GLImageIndex(YUVVideoDrawQuad, 1);
+GLImageIndex(RenderPassDrawQuad, 2);
+
+template <typename RendererType, typename QuadType>
+struct TypeStruct {
+  static const char* IntersectingQuadImage() {
+    return types[GLImage<QuadType>::val];
+  }
+};
+
+template <typename QuadType>
+struct TypeStruct<SoftwareRenderer, QuadType> {
+  static const char* IntersectingQuadImage() {
+    return "intersecting_blue_green_software.png";
+  }
+};
+
+template <typename QuadType>
+struct TypeStruct<SoftwareRendererWithExpandedViewport, QuadType> {
+  static const char* IntersectingQuadImage() {
+    return "intersecting_blue_green_software.png";
+  }
+};
+
+template <typename TypeParam>
+class IntersectingQuadPixelTest : public RendererPixelTest<TypeParam> {
+ protected:
+  void SetupQuadStateAndRenderPass() {
+    viewport_rect_ = gfx::Rect(this->device_viewport_size_);
+    quad_rect_ = gfx::Rect(0, 0, this->device_viewport_size_.width(),
+                           this->device_viewport_size_.height() / 2.0);
+
+    RenderPassId id(1, 1);
+    render_pass_ = CreateTestRootRenderPass(id, viewport_rect_);
+    gfx::Transform trans;

[enne (OOO), 2015/02/04 21:24:00]

Can you leave a large comment about what this is setting up and what the result
should look like?

[awoloszyn, 2015/02/12 16:48:51]

Done.

+    trans.Translate3d(0, 0, 0.707 * this->device_viewport_size_.width() / 2.0);
+    trans.RotateAboutZAxis(46.0);

[enne (OOO), 2015/02/04 21:24:00]

Why 46 degrees? Is that why there's the weird aliasing in the output?

[awoloszyn, 2015/02/12 16:48:51]

I wanted to avoid picking a very common rotation, it turns out it does not
matter, switched back to 45degs.

+    trans.RotateAboutYAxis(46.0);
+
+    front_quad_state_ =
+        CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get());
+    front_quad_state_->clip_rect = quad_rect_;
+    front_quad_state_->sorting_context_id = 1;
+
+    trans = gfx::Transform();
+    trans.Translate3d(0, 0, -0.707 * this->device_viewport_size_.width() / 2.0);
+    trans.RotateAboutYAxis(-45.0);
+    back_quad_state_ =
+        CreateTestSharedQuadState(trans, viewport_rect_, render_pass_.get());
+    back_quad_state_->sorting_context_id = 1;
+    back_quad_state_->clip_rect = quad_rect_;
+  }
+  template <typename T>
+  void AppendBackgroundAndRunTest() {
+    SharedQuadState* background_quad_state = CreateTestSharedQuadState(
+        gfx::Transform(), viewport_rect_, render_pass_.get());
+    SolidColorDrawQuad* background_quad =
+        render_pass_->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+    background_quad->SetNew(background_quad_state, viewport_rect_,
+                            viewport_rect_, SK_ColorWHITE, false);
+    pass_list_.push_back(render_pass_.Pass());
+    const char* fileName = TypeStruct<TypeParam, T>::IntersectingQuadImage();
+    EXPECT_TRUE(this->RunPixelTest(&pass_list_,
+                                   base::FilePath(FILE_PATH_LITERAL(fileName)),
+                                   FuzzyPixelOffByOneComparator(true)));
+  }
+  template <typename T>
+  T* CreateAndAppendDrawQuad() {
+    return render_pass_->CreateAndAppendDrawQuad<T>();
+  }
+
+  scoped_ptr<RenderPass> render_pass_;
+  gfx::Rect viewport_rect_;
+  SharedQuadState* front_quad_state_;
+  SharedQuadState* back_quad_state_;
+  gfx::Rect quad_rect_;
+  RenderPassList pass_list_;
+};
+
+TYPED_TEST_CASE(IntersectingQuadPixelTest, RendererTypes);
+
+TYPED_TEST(IntersectingQuadPixelTest, SolidColorQuads) {
+  this->SetupQuadStateAndRenderPass();
+
+  SolidColorDrawQuad* quad =
+      this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  SolidColorDrawQuad* quad2 =
+      this->template CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+
+  quad->SetNew(this->front_quad_state_, this->quad_rect_, this->quad_rect_,
+               SK_ColorBLUE, false);
+  quad2->SetNew(this->back_quad_state_, this->quad_rect_, this->quad_rect_,
+                SK_ColorGREEN, false);
+  SCOPED_TRACE("IntersectingSolidColorQuads");
+  this->template AppendBackgroundAndRunTest<SolidColorDrawQuad>();
+}
+
+template <typename TypeParam>
+SkColor GetColor(const SkColor& color) {
+  return color;
+}
+
+template <>
+SkColor GetColor<GLRenderer>(const SkColor& color) {
+  return SkColorSetARGB(SkColorGetA(color), SkColorGetB(color),
+                        SkColorGetG(color), SkColorGetR(color));
+}
+template <>
+SkColor GetColor<GLRendererWithExpandedViewport>(const SkColor& color) {
+  return GetColor<GLRenderer>(color);
+}
+
+TYPED_TEST(IntersectingQuadPixelTest, TexturedQuads) {
+  this->SetupQuadStateAndRenderPass();
+  CreateTestTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 0, 255)),

[enne (OOO), 2015/02/04 21:24:00]

Do you think the texture/video/picture/content quads need to be not solid color
(even just two tone, if a split intersects that change in color) in order to
test that uv splitting works correctly? If the quad is solid color, then the uvs
could be totally bogus and the test would still pass.

[awoloszyn, 2015/02/12 16:48:51]

Fixed, now have a small square inside a large square, should show any problems
with UVs. It exposed a bug in YUVDrawQuads, so thanks for the suggestion!

+      SK_ColorTRANSPARENT, true, this->front_quad_state_,
+      this->resource_provider_.get(), this->render_pass_.get());
+  CreateTestTextureDrawQuad(
+      this->quad_rect_, GetColor<TypeParam>(SkColorSetARGB(255, 0, 255, 0)),
+      SK_ColorTRANSPARENT, true, this->back_quad_state_,
+      this->resource_provider_.get(), this->render_pass_.get());
+
+  SCOPED_TRACE("IntersectingTexturedQuads");
+  this->template AppendBackgroundAndRunTest<TextureDrawQuad>();
+}
+
+TYPED_TEST(IntersectingQuadPixelTest, PictureQuads) {
+  this->SetupQuadStateAndRenderPass();
+
+  scoped_refptr<FakePicturePileImpl> blue_pile =
+      FakePicturePileImpl::CreateFilledPile(gfx::Size(1000, 1000),
+                                            this->quad_rect_.size());
+  SkPaint blue_paint;
+  blue_paint.setColor(SK_ColorBLUE);
+  blue_pile->add_draw_rect_with_paint(this->quad_rect_, blue_paint);
+  blue_pile->RerecordPile();
+
+  PictureDrawQuad* blue_quad =
+      this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
+  blue_quad->SetNew(this->front_quad_state_, this->quad_rect_, gfx::Rect(),
+                    this->quad_rect_, this->quad_rect_, this->quad_rect_.size(),
+                    false, RGBA_8888, this->quad_rect_, 1.f, blue_pile);
+
+  scoped_refptr<FakePicturePileImpl> green_pile =
+      FakePicturePileImpl::CreateFilledPile(this->quad_rect_.size(),
+                                            this->quad_rect_.size());
+  SkPaint green_paint;
+  green_paint.setColor(SK_ColorGREEN);
+  green_pile->add_draw_rect_with_paint(this->quad_rect_, green_paint);
+  green_pile->RerecordPile();
+
+  PictureDrawQuad* green_quad =
+      this->render_pass_->template CreateAndAppendDrawQuad<PictureDrawQuad>();
+  green_quad->SetNew(this->back_quad_state_, this->quad_rect_, gfx::Rect(),
+                     this->quad_rect_, this->quad_rect_,
+                     this->quad_rect_.size(), false, RGBA_8888,
+                     this->quad_rect_, 1.f, green_pile);
+  SCOPED_TRACE("IntersectingPictureQuadsPass");
+  this->template AppendBackgroundAndRunTest<PictureDrawQuad>();
+}
+
+TYPED_TEST(IntersectingQuadPixelTest, RenderPassQuads) {
+  this->SetupQuadStateAndRenderPass();
+  RenderPassId child_pass_id1(2, 2);
+  RenderPassId child_pass_id2(2, 3);
+  scoped_ptr<RenderPass> child_pass1 =
+      CreateTestRenderPass(child_pass_id1, this->quad_rect_, gfx::Transform());
+  SharedQuadState* child1_quad_state = CreateTestSharedQuadState(
+      gfx::Transform(), this->quad_rect_, child_pass1.get());
+  scoped_ptr<RenderPass> child_pass2 =
+      CreateTestRenderPass(child_pass_id2, this->quad_rect_, gfx::Transform());
+  SharedQuadState* child2_quad_state = CreateTestSharedQuadState(
+      gfx::Transform(), this->quad_rect_, child_pass2.get());
+  SolidColorDrawQuad* quad =
+      child_pass1->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  SolidColorDrawQuad* quad2 =
+      child_pass2->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
+  quad->SetNew(child1_quad_state, this->quad_rect_, this->quad_rect_,
+               SK_ColorBLUE, false);
+  quad2->SetNew(child2_quad_state, this->quad_rect_, this->quad_rect_,
+                SK_ColorGREEN, false);
+  CreateTestRenderPassDrawQuad(this->front_quad_state_, this->quad_rect_,
+                               child_pass_id1, this->render_pass_.get());
+  CreateTestRenderPassDrawQuad(this->back_quad_state_, this->quad_rect_,
+                               child_pass_id2, this->render_pass_.get());
+
+  this->pass_list_.push_back(child_pass1.Pass());
+  this->pass_list_.push_back(child_pass2.Pass());
+  SCOPED_TRACE("IntersectingRenderQuadsPass");
+  this->template AppendBackgroundAndRunTest<RenderPassDrawQuad>();
+}
+template <typename TypeParam>
+class IntersectingQuadGLPixelTest
+    : public IntersectingQuadPixelTest<TypeParam> {
+ public:
+  void SetUp() override {
+    IntersectingQuadPixelTest<TypeParam>::SetUp();
+    video_resource_updater_.reset(
+        new VideoResourceUpdater(this->output_surface_->context_provider(),
+                                 this->resource_provider_.get()));
+    video_resource_updater2_.reset(
+        new VideoResourceUpdater(this->output_surface_->context_provider(),
+                                 this->resource_provider_.get()));
+  }
+
+ protected:
+  scoped_ptr<VideoResourceUpdater> video_resource_updater_;
+  scoped_ptr<VideoResourceUpdater> video_resource_updater2_;
+};
+
+typedef ::testing::Types<GLRenderer, GLRendererWithExpandedViewport>
+    GLRendererTypes;
+
+TYPED_TEST_CASE(IntersectingQuadGLPixelTest, GLRendererTypes);
+
+TYPED_TEST(IntersectingQuadGLPixelTest, YUVVideoQuads) {
+  this->SetupQuadStateAndRenderPass();
+
+  CreateTestYUVVideoDrawQuad_Solid(
+      this->front_quad_state_, media::VideoFrame::YV12, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 29, 255, 107,
+      this->render_pass_.get(), this->video_resource_updater_.get(),
+      this->quad_rect_, this->resource_provider_.get());
+
+  CreateTestYUVVideoDrawQuad_Solid(
+      this->back_quad_state_, media::VideoFrame::YV12, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, this->render_pass_.get(),
+      this->video_resource_updater2_.get(), this->quad_rect_,
+      this->resource_provider_.get());
+
+  SCOPED_TRACE("IntersectingVideoQuads");
+  this->template AppendBackgroundAndRunTest<YUVVideoDrawQuad>();
+}
+
 // TODO(skaslev): The software renderer does not support non-premultplied alpha.
 TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithoutBackground) {
   gfx::Rect rect(this->device_viewport_size_);
@@ -388,152 +774,12 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
 
 class VideoGLRendererPixelTest : public GLRendererPixelTest {
  protected:
-  void CreateTestYUVVideoDrawQuad_Striped(const SharedQuadState* shared_state,
-                                          media::VideoFrame::Format format,
-                                          bool is_transparent,
-                                          const gfx::RectF& tex_coord_rect,
-                                          RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values representing a striped pattern, for validating texture
-    // coordinates for sampling.
-    uint8_t y_value = 0;
-    uint8_t u_value = 0;
-    uint8_t v_value = 0;
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) {
-      uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) +
-                       video_frame->stride(media::VideoFrame::kYPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane);
-           ++j) {
-        y_row[j] = (y_value += 1);
-      }
-    }
-    for (int i = 0; i < video_frame->rows(media::VideoFrame::kUPlane); ++i) {
-      uint8_t* u_row = video_frame->data(media::VideoFrame::kUPlane) +
-                       video_frame->stride(media::VideoFrame::kUPlane) * i;
-      uint8_t* v_row = video_frame->data(media::VideoFrame::kVPlane) +
-                       video_frame->stride(media::VideoFrame::kVPlane) * i;
-      for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kUPlane);
-           ++j) {
-        u_row[j] = (u_value += 3);
-        v_row[j] = (v_value += 5);
-      }
-    }
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, is_transparent, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_Solid(const SharedQuadState* shared_state,
-                                        media::VideoFrame::Format format,
-                                        bool is_transparent,
-                                        const gfx::RectF& tex_coord_rect,
-                                        uint8 y,
-                                        uint8 u,
-                                        uint8 v,
-                                        RenderPass* render_pass) {
-    const gfx::Rect rect(this->device_viewport_size_);
-
-    scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::CreateFrame(
-            format, rect.size(), rect, rect.size(), base::TimeDelta());
-
-    // YUV values of a solid, constant, color. Useful for testing that color
-    // space/color range are being handled properly.
-    memset(video_frame->data(media::VideoFrame::kYPlane),
-           y,
-           video_frame->stride(media::VideoFrame::kYPlane) *
-               video_frame->rows(media::VideoFrame::kYPlane));
-    memset(video_frame->data(media::VideoFrame::kUPlane),
-           u,
-           video_frame->stride(media::VideoFrame::kUPlane) *
-               video_frame->rows(media::VideoFrame::kUPlane));
-    memset(video_frame->data(media::VideoFrame::kVPlane),
-           v,
-           video_frame->stride(media::VideoFrame::kVPlane) *
-               video_frame->rows(media::VideoFrame::kVPlane));
-
-    CreateTestYUVVideoDrawQuad_FromVideoFrame(
-        shared_state, video_frame, is_transparent, tex_coord_rect, render_pass);
-  }
-
-  void CreateTestYUVVideoDrawQuad_FromVideoFrame(
-      const SharedQuadState* shared_state,
-      scoped_refptr<media::VideoFrame> video_frame,
-      bool is_transparent,
-      const gfx::RectF& tex_coord_rect,
-      RenderPass* render_pass) {
-    const bool with_alpha = (video_frame->format() == media::VideoFrame::YV12A);
-    const YUVVideoDrawQuad::ColorSpace color_space =
-        (video_frame->format() == media::VideoFrame::YV12J
-             ? YUVVideoDrawQuad::REC_601_JPEG
-             : YUVVideoDrawQuad::REC_601);
-    const gfx::Rect rect(this->device_viewport_size_);
-    const gfx::Rect opaque_rect(0, 0, 0, 0);
-
-    if (with_alpha)
-      memset(video_frame->data(media::VideoFrame::kAPlane),
-             is_transparent ? 0 : 128,
-             video_frame->stride(media::VideoFrame::kAPlane) *
-                 video_frame->rows(media::VideoFrame::kAPlane));
-
-    VideoFrameExternalResources resources =
-        video_resource_updater_->CreateExternalResourcesFromVideoFrame(
-            video_frame);
-
-    EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.mailboxes.size());
-    EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()),
-              resources.release_callbacks.size());
-
-    ResourceProvider::ResourceId y_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kYPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kYPlane]));
-    ResourceProvider::ResourceId u_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kUPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kUPlane]));
-    ResourceProvider::ResourceId v_resource =
-        resource_provider_->CreateResourceFromTextureMailbox(
-            resources.mailboxes[media::VideoFrame::kVPlane],
-            SingleReleaseCallbackImpl::Create(
-                resources.release_callbacks[media::VideoFrame::kVPlane]));
-    ResourceProvider::ResourceId a_resource = 0;
-    if (with_alpha) {
-      a_resource = resource_provider_->CreateResourceFromTextureMailbox(
-          resources.mailboxes[media::VideoFrame::kAPlane],
-          SingleReleaseCallbackImpl::Create(
-              resources.release_callbacks[media::VideoFrame::kAPlane]));
-    }
-
-    YUVVideoDrawQuad* yuv_quad =
-        render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
-    yuv_quad->SetNew(shared_state,
-                     rect,
-                     opaque_rect,
-                     rect,
-                     tex_coord_rect,
-                     y_resource,
-                     u_resource,
-                     v_resource,
-                     a_resource,
-                     color_space);
-  }
-
   void SetUp() override {
     GLRendererPixelTest::SetUp();
     video_resource_updater_.reset(new VideoResourceUpdater(
         output_surface_->context_provider(), resource_provider_.get()));
   }
 
- private:
   scoped_ptr<VideoResourceUpdater> video_resource_updater_;
 };
 
@@ -546,11 +792,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12,
+                                     false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     gfx::Rect(this->device_viewport_size_),
+                                     this->resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -571,11 +817,11 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Intentionally sets frame format to I420 for testing coverage.
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::I420,
-                                     false,
-                                     gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(
+      shared_state, media::VideoFrame::I420, false,
+      gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), pass.get(),
+      video_resource_updater_.get(), gfx::Rect(this->device_viewport_size_),
+      this->resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -596,14 +842,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // In MPEG color range YUV values of (15,128,128) should produce black.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
+      video_resource_updater_.get(), gfx::Rect(this->device_viewport_size_),
+      this->resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -625,14 +868,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // YUV of (149,43,21) should be green (0,255,0) in RGB.
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   149,
-                                   43,
-                                   21,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(),
+      video_resource_updater_.get(), gfx::Rect(this->device_viewport_size_),
+      this->resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -652,14 +892,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
   // Dark grey in JPEG color range (in MPEG, this is black).
-  CreateTestYUVVideoDrawQuad_Solid(shared_state,
-                                   media::VideoFrame::YV12J,
-                                   false,
-                                   gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                   15,
-                                   128,
-                                   128,
-                                   pass.get());
+  CreateTestYUVVideoDrawQuad_Solid(
+      shared_state, media::VideoFrame::YV12J, false,
+      gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(),
+      video_resource_updater_.get(), gfx::Rect(this->device_viewport_size_),
+      this->resource_provider_.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
@@ -679,11 +916,11 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     false,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
+                                     false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     gfx::Rect(this->device_viewport_size_),
+                                     this->resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
@@ -707,11 +944,11 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
   SharedQuadState* shared_state =
       CreateTestSharedQuadState(gfx::Transform(), rect, pass.get());
 
-  CreateTestYUVVideoDrawQuad_Striped(shared_state,
-                                     media::VideoFrame::YV12A,
-                                     true,
-                                     gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
-                                     pass.get());
+  CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A,
+                                     true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                     pass.get(), video_resource_updater_.get(),
+                                     gfx::Rect(this->device_viewport_size_),
+                                     this->resource_provider_.get());
 
   SolidColorDrawQuad* color_quad =
       pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();