Support videos with JPEG color range in GPU YUV convert path.

It's worth noting that the media_browsertests Yuv* tests compare video pixels with a reference image, but whether or not the hardware path is used, copying the pixels from the video into a canvas goes through the software path, so despite looking correct onscreen when GPU-accelerated, the JPEG color range video tests will still fail until the software path properly supports the JPEG color range.

BUG=172898

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

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

8 files changed, 233 insertions, 39 deletions

diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index e6e54a1..2002116 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -183,6 +183,10 @@ void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
       DCHECK_GE(frame_resources_.size(), 3u);
       if (frame_resources_.size() < 3u)
         break;
+      YUVVideoDrawQuad::ColorSpace color_space =
+          frame_->format() == media::VideoFrame::YV12J
+              ? YUVVideoDrawQuad::REC_601_JPEG
+              : YUVVideoDrawQuad::REC_601;
       gfx::RectF tex_coord_rect(
           tex_x_offset, tex_y_offset, tex_width_scale, tex_height_scale);
       scoped_ptr<YUVVideoDrawQuad> yuv_video_quad = YUVVideoDrawQuad::Create();
@@ -195,7 +199,8 @@ void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
           frame_resources_[0],
           frame_resources_[1],
           frame_resources_[2],
-          frame_resources_.size() > 3 ? frame_resources_[3] : 0);
+          frame_resources_.size() > 3 ? frame_resources_[3] : 0,
+          color_space);
       quad_sink->Append(yuv_video_quad.PassAs<DrawQuad>());
       break;
     }
diff --git a/cc/output/gl_renderer.cc b/cc/output/gl_renderer.cc
index bb1ecbf..8e60f94 100644
--- a/cc/output/gl_renderer.cc
+++ b/cc/output/gl_renderer.cc
@@ -1777,9 +1777,12 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
   // These values are magic numbers that are used in the transformation from YUV
   // to RGB color values.  They are taken from the following webpage:
   // http://www.fourcc.org/fccyvrgb.php
-  float yuv_to_rgb[9] = {1.164f, 1.164f, 1.164f, 0.0f, -.391f,
-                         2.018f, 1.596f, -.813f, 0.0f, };
-  GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
+  float yuv_to_rgb_rec601[9] = {
+      1.164f, 1.164f, 1.164f, 0.0f, -.391f, 2.018f, 1.596f, -.813f, 0.0f,
+  };
+  float yuv_to_rgb_rec601_jpeg[9] = {
+      1.f, 1.f, 1.f, 0.0f, -.34414f, 1.772f, 1.402f, -.71414f, 0.0f,
+  };
 
   // These values map to 16, 128, and 128 respectively, and are computed
   // as a fraction over 256 (e.g. 16 / 256 = 0.0625).
@@ -1787,7 +1790,30 @@ void GLRenderer::DrawYUVVideoQuad(const DrawingFrame* frame,
   //   Y - 16   : Gives 16 values of head and footroom for overshooting
   //   U - 128  : Turns unsigned U into signed U [-128,127]
   //   V - 128  : Turns unsigned V into signed V [-128,127]
-  float yuv_adjust[3] = {-0.0625f, -0.5f, -0.5f, };
+  float yuv_adjust_rec601[3] = {
+      -0.0625f, -0.5f, -0.5f,
+  };
+
+  // Same as above, but without the head and footroom.
+  float yuv_adjust_rec601_jpeg[3] = {
+      0.0f, -0.5f, -0.5f,
+  };
+
+  float* yuv_to_rgb = NULL;
+  float* yuv_adjust = NULL;
+
+  switch (quad->color_space) {
+    case YUVVideoDrawQuad::REC_601:
+      yuv_to_rgb = yuv_to_rgb_rec601;
+      yuv_adjust = yuv_adjust_rec601;
+      break;
+    case YUVVideoDrawQuad::REC_601_JPEG:
+      yuv_to_rgb = yuv_to_rgb_rec601_jpeg;
+      yuv_adjust = yuv_adjust_rec601_jpeg;
+      break;
+  }
+
+  GLC(gl_, gl_->UniformMatrix3fv(yuv_matrix_location, 1, 0, yuv_to_rgb));
   GLC(gl_, gl_->Uniform3fv(yuv_adj_location, 1, yuv_adjust));
 
   SetShaderOpacity(quad->opacity(), alpha_location);
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index ce3abfa..869bb9b 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -398,14 +398,12 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBackground) {
 
 class VideoGLRendererPixelTest : public GLRendererPixelTest {
  protected:
-  scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad(
+  scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Striped(
       SharedQuadState* shared_state,
       media::VideoFrame::Format format,
       bool is_transparent,
       const gfx::RectF& tex_coord_rect) {
-    const bool with_alpha = (format == media::VideoFrame::YV12A);
     const gfx::Rect rect(this->device_viewport_size_);
-    const gfx::Rect opaque_rect(0, 0, 0, 0);
 
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateFrame(
@@ -435,6 +433,56 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
         v_row[j] = (v_value += 5);
       }
     }
+    return CreateTestYUVVideoDrawQuad_FromVideoFrame(
+        shared_state, video_frame, is_transparent, tex_coord_rect);
+  }
+
+  scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_Solid(
+      SharedQuadState* shared_state,
+      media::VideoFrame::Format format,
+      bool is_transparent,
+      const gfx::RectF& tex_coord_rect,
+      uint8 y,
+      uint8 u,
+      uint8 v) {
+    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));
+
+    return CreateTestYUVVideoDrawQuad_FromVideoFrame(
+        shared_state, video_frame, is_transparent, tex_coord_rect);
+  }
+
+  scoped_ptr<YUVVideoDrawQuad> CreateTestYUVVideoDrawQuad_FromVideoFrame(
+      SharedQuadState* shared_state,
+      scoped_refptr<media::VideoFrame> video_frame,
+      bool is_transparent,
+      const gfx::RectF& tex_coord_rect) {
+    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,
@@ -446,8 +494,9 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
             video_frame);
 
     EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type);
-    EXPECT_EQ(media::VideoFrame::NumPlanes(format), resources.mailboxes.size());
-    EXPECT_EQ(media::VideoFrame::NumPlanes(format),
+    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 =
@@ -482,7 +531,8 @@ class VideoGLRendererPixelTest : public GLRendererPixelTest {
                      y_resource,
                      u_resource,
                      v_resource,
-                     a_resource);
+                     a_resource,
+                     color_space);
     return yuv_quad.Pass();
   }
 
@@ -506,10 +556,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect);
 
   scoped_ptr<YUVVideoDrawQuad> yuv_quad =
-      CreateTestYUVVideoDrawQuad(shared_state.get(),
-                                 media::VideoFrame::YV12,
-                                 false,
-                                 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
+      CreateTestYUVVideoDrawQuad_Striped(shared_state.get(),
+                                         media::VideoFrame::YV12,
+                                         false,
+                                         gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
 
   pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
 
@@ -532,11 +582,11 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
       CreateTestSharedQuadState(gfx::Transform(), rect);
 
   // Intentionally sets frame format to I420 for testing coverage.
-  scoped_ptr<YUVVideoDrawQuad> yuv_quad =
-      CreateTestYUVVideoDrawQuad(shared_state.get(),
-                                 media::VideoFrame::I420,
-                                 false,
-                                 gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f));
+  scoped_ptr<YUVVideoDrawQuad> yuv_quad = CreateTestYUVVideoDrawQuad_Striped(
+      shared_state.get(),
+      media::VideoFrame::I420,
+      false,
+      gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f));
 
   pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
 
@@ -549,6 +599,96 @@ TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) {
       FuzzyPixelOffByOneComparator(true)));
 }
 
+TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) {
+  gfx::Rect rect(this->device_viewport_size_);
+
+  RenderPass::Id id(1, 1);
+  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
+
+  scoped_ptr<SharedQuadState> shared_state =
+      CreateTestSharedQuadState(gfx::Transform(), rect);
+
+  // In MPEG color range YUV values of (15,128,128) should produce black.
+  scoped_ptr<YUVVideoDrawQuad> yuv_quad =
+      CreateTestYUVVideoDrawQuad_Solid(shared_state.get(),
+                                       media::VideoFrame::YV12,
+                                       false,
+                                       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                       15,
+                                       128,
+                                       128);
+
+  pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  // If we didn't get black out of the YUV values above, then we probably have a
+  // color range issue.
+  EXPECT_TRUE(this->RunPixelTest(&pass_list,
+                                 base::FilePath(FILE_PATH_LITERAL("black.png")),
+                                 FuzzyPixelOffByOneComparator(true)));
+}
+
+TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) {
+  gfx::Rect rect(this->device_viewport_size_);
+
+  RenderPass::Id id(1, 1);
+  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
+
+  scoped_ptr<SharedQuadState> shared_state =
+      CreateTestSharedQuadState(gfx::Transform(), rect);
+
+  // YUV of (149,43,21) should be green (0,255,0) in RGB.
+  scoped_ptr<YUVVideoDrawQuad> yuv_quad =
+      CreateTestYUVVideoDrawQuad_Solid(shared_state.get(),
+                                       media::VideoFrame::YV12J,
+                                       false,
+                                       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                       149,
+                                       43,
+                                       21);
+
+  pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  EXPECT_TRUE(this->RunPixelTest(&pass_list,
+                                 base::FilePath(FILE_PATH_LITERAL("green.png")),
+                                 FuzzyPixelOffByOneComparator(true)));
+}
+
+TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) {
+  gfx::Rect rect(this->device_viewport_size_);
+
+  RenderPass::Id id(1, 1);
+  scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect);
+
+  scoped_ptr<SharedQuadState> shared_state =
+      CreateTestSharedQuadState(gfx::Transform(), rect);
+
+  // Dark grey in JPEG color range (in MPEG, this is black).
+  scoped_ptr<YUVVideoDrawQuad> yuv_quad =
+      CreateTestYUVVideoDrawQuad_Solid(shared_state.get(),
+                                       media::VideoFrame::YV12J,
+                                       false,
+                                       gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f),
+                                       15,
+                                       128,
+                                       128);
+
+  pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
+
+  RenderPassList pass_list;
+  pass_list.push_back(pass.Pass());
+
+  EXPECT_TRUE(
+      this->RunPixelTest(&pass_list,
+                         base::FilePath(FILE_PATH_LITERAL("dark_grey.png")),
+                         FuzzyPixelOffByOneComparator(true)));
+}
+
 TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
   gfx::Rect rect(this->device_viewport_size_);
 
@@ -559,10 +699,10 @@ TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) {
       CreateTestSharedQuadState(gfx::Transform(), rect);
 
   scoped_ptr<YUVVideoDrawQuad> yuv_quad =
-      CreateTestYUVVideoDrawQuad(shared_state.get(),
-                                 media::VideoFrame::YV12A,
-                                 false,
-                                 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
+      CreateTestYUVVideoDrawQuad_Striped(shared_state.get(),
+                                         media::VideoFrame::YV12A,
+                                         false,
+                                         gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
 
   pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
 
@@ -590,10 +730,10 @@ TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) {
       CreateTestSharedQuadState(gfx::Transform(), rect);
 
   scoped_ptr<YUVVideoDrawQuad> yuv_quad =
-      CreateTestYUVVideoDrawQuad(shared_state.get(),
-                                 media::VideoFrame::YV12A,
-                                 true,
-                                 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
+      CreateTestYUVVideoDrawQuad_Striped(shared_state.get(),
+                                         media::VideoFrame::YV12A,
+                                         true,
+                                         gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f));
 
   pass->quad_list.push_back(yuv_quad.PassAs<DrawQuad>());
 
diff --git a/cc/quads/draw_quad_unittest.cc b/cc/quads/draw_quad_unittest.cc
index 2b491f4..cb11609 100644
--- a/cc/quads/draw_quad_unittest.cc
+++ b/cc/quads/draw_quad_unittest.cc
@@ -594,16 +594,18 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   ResourceProvider::ResourceId u_plane_resource_id = 532;
   ResourceProvider::ResourceId v_plane_resource_id = 4;
   ResourceProvider::ResourceId a_plane_resource_id = 63;
+  YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601_JPEG;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_7_NEW(YUVVideoDrawQuad,
+  CREATE_QUAD_8_NEW(YUVVideoDrawQuad,
                     opaque_rect,
                     visible_rect,
                     tex_coord_rect,
                     y_plane_resource_id,
                     u_plane_resource_id,
                     v_plane_resource_id,
-                    a_plane_resource_id);
+                    a_plane_resource_id,
+                    color_space);
   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
@@ -612,19 +614,22 @@ TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   EXPECT_EQ(u_plane_resource_id, copy_quad->u_plane_resource_id);
   EXPECT_EQ(v_plane_resource_id, copy_quad->v_plane_resource_id);
   EXPECT_EQ(a_plane_resource_id, copy_quad->a_plane_resource_id);
+  EXPECT_EQ(color_space, copy_quad->color_space);
 
-  CREATE_QUAD_5_ALL(YUVVideoDrawQuad,
+  CREATE_QUAD_6_ALL(YUVVideoDrawQuad,
                     tex_coord_rect,
                     y_plane_resource_id,
                     u_plane_resource_id,
                     v_plane_resource_id,
-                    a_plane_resource_id);
+                    a_plane_resource_id,
+                    color_space);
   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
   EXPECT_EQ(y_plane_resource_id, copy_quad->y_plane_resource_id);
   EXPECT_EQ(u_plane_resource_id, copy_quad->u_plane_resource_id);
   EXPECT_EQ(v_plane_resource_id, copy_quad->v_plane_resource_id);
   EXPECT_EQ(a_plane_resource_id, copy_quad->a_plane_resource_id);
+  EXPECT_EQ(color_space, copy_quad->color_space);
 }
 
 TEST(DrawQuadTest, CopyPictureDrawQuad) {
@@ -853,21 +858,24 @@ TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
   ResourceProvider::ResourceId u_plane_resource_id = 532;
   ResourceProvider::ResourceId v_plane_resource_id = 4;
   ResourceProvider::ResourceId a_plane_resource_id = 63;
+  YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601_JPEG;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_7_NEW(YUVVideoDrawQuad,
+  CREATE_QUAD_8_NEW(YUVVideoDrawQuad,
                     opaque_rect,
                     visible_rect,
                     tex_coord_rect,
                     y_plane_resource_id,
                     u_plane_resource_id,
                     v_plane_resource_id,
-                    a_plane_resource_id);
+                    a_plane_resource_id,
+                    color_space);
   EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copy_quad->material);
   EXPECT_EQ(y_plane_resource_id, quad_new->y_plane_resource_id);
   EXPECT_EQ(u_plane_resource_id, quad_new->u_plane_resource_id);
   EXPECT_EQ(v_plane_resource_id, quad_new->v_plane_resource_id);
   EXPECT_EQ(a_plane_resource_id, quad_new->a_plane_resource_id);
+  EXPECT_EQ(color_space, quad_new->color_space);
   EXPECT_EQ(4, IterateAndCount(quad_new.get()));
   EXPECT_EQ(y_plane_resource_id + 1, quad_new->y_plane_resource_id);
   EXPECT_EQ(u_plane_resource_id + 1, quad_new->u_plane_resource_id);
diff --git a/cc/quads/yuv_video_draw_quad.cc b/cc/quads/yuv_video_draw_quad.cc
index ea56677..bb8ec73 100644
--- a/cc/quads/yuv_video_draw_quad.cc
+++ b/cc/quads/yuv_video_draw_quad.cc
@@ -29,7 +29,8 @@ void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
                               unsigned y_plane_resource_id,
                               unsigned u_plane_resource_id,
                               unsigned v_plane_resource_id,
-                              unsigned a_plane_resource_id) {
+                              unsigned a_plane_resource_id,
+                              ColorSpace color_space) {
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
@@ -38,6 +39,7 @@ void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
   this->u_plane_resource_id = u_plane_resource_id;
   this->v_plane_resource_id = v_plane_resource_id;
   this->a_plane_resource_id = a_plane_resource_id;
+  this->color_space = color_space;
 }
 
 void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
@@ -49,7 +51,8 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                               unsigned y_plane_resource_id,
                               unsigned u_plane_resource_id,
                               unsigned v_plane_resource_id,
-                              unsigned a_plane_resource_id) {
+                              unsigned a_plane_resource_id,
+                              ColorSpace color_space) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
   this->tex_coord_rect = tex_coord_rect;
@@ -57,6 +60,7 @@ void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
   this->u_plane_resource_id = u_plane_resource_id;
   this->v_plane_resource_id = v_plane_resource_id;
   this->a_plane_resource_id = a_plane_resource_id;
+  this->color_space = color_space;
 }
 
 void YUVVideoDrawQuad::IterateResources(
diff --git a/cc/quads/yuv_video_draw_quad.h b/cc/quads/yuv_video_draw_quad.h
index 65b35e0..c95681f 100644
--- a/cc/quads/yuv_video_draw_quad.h
+++ b/cc/quads/yuv_video_draw_quad.h
@@ -15,6 +15,12 @@ namespace cc {
 
 class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
  public:
+  enum ColorSpace {
+    REC_601,       // SDTV standard with restricted "studio swing" color range.
+    REC_601_JPEG,  // Full color range [0, 255] variant of the above.
+    COLOR_SPACE_LAST = REC_601_JPEG
+  };
+
   virtual ~YUVVideoDrawQuad();
 
   static scoped_ptr<YUVVideoDrawQuad> Create();
@@ -27,7 +33,8 @@ class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
               unsigned y_plane_resource_id,
               unsigned u_plane_resource_id,
               unsigned v_plane_resource_id,
-              unsigned a_plane_resource_id);
+              unsigned a_plane_resource_id,
+              ColorSpace color_space);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               const gfx::Rect& rect,
@@ -38,13 +45,15 @@ class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
               unsigned y_plane_resource_id,
               unsigned u_plane_resource_id,
               unsigned v_plane_resource_id,
-              unsigned a_plane_resource_id);
+              unsigned a_plane_resource_id,
+              ColorSpace color_space);
 
   gfx::RectF tex_coord_rect;
   unsigned y_plane_resource_id;
   unsigned u_plane_resource_id;
   unsigned v_plane_resource_id;
   unsigned a_plane_resource_id;
+  ColorSpace color_space;
 
   virtual void IterateResources(const ResourceIteratorCallback& callback)
       OVERRIDE;
diff --git a/cc/test/data/dark_grey.png b/cc/test/data/dark_grey.png
new file mode 100644
index 0000000..dd22983
--- /dev/null
+++ b/cc/test/data/dark_grey.png
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index 56e2b07..a68e00b 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -225,6 +225,7 @@ void TestRenderPass::AppendOneOfEveryQuadType(
             resource_provider->best_texture_format());
     resource_provider->AllocateForTesting(plane_resources[i]);
   }
+  YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601;
   scoped_ptr<YUVVideoDrawQuad> yuv_quad = YUVVideoDrawQuad::Create();
   yuv_quad->SetNew(shared_state2.get(),
                    rect,
@@ -234,7 +235,8 @@ void TestRenderPass::AppendOneOfEveryQuadType(
                    plane_resources[0],
                    plane_resources[1],
                    plane_resources[2],
-                   plane_resources[3]);
+                   plane_resources[3],
+                   color_space);
   AppendQuad(yuv_quad.PassAs<DrawQuad>());
 
   AppendSharedQuadState(shared_state.Pass());