Update Chromium to beta version 37.0.2062.68

Change-Id: I188e3b5aff1bec75566014291b654eb19f5bc8ca
Reviewed-by: Andras Becsi <andras.becsi@digia.com>

1 files changed, 133 insertions, 41 deletions

diff --git a/chromium/cc/quads/draw_quad_unittest.cc b/chromium/cc/quads/draw_quad_unittest.cc
index 876c0461b37..f0f77190ffb 100644
--- a/chromium/cc/quads/draw_quad_unittest.cc
+++ b/chromium/cc/quads/draw_quad_unittest.cc
@@ -17,6 +17,7 @@
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/stream_video_draw_quad.h"
+#include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
@@ -37,17 +38,20 @@ TEST(DrawQuadTest, CopySharedQuadState) {
   bool is_clipped = true;
   float opacity = 0.25f;
   SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
+  int sorting_context_id = 65536;
 
-  scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
+  scoped_ptr<SharedQuadState> state(new SharedQuadState);
   state->SetAll(quad_transform,
                 content_bounds,
                 visible_content_rect,
                 clip_rect,
                 is_clipped,
                 opacity,
-                blend_mode);
+                blend_mode,
+                sorting_context_id);
 
-  scoped_ptr<SharedQuadState> copy(state->Copy());
+  scoped_ptr<SharedQuadState> copy(new SharedQuadState);
+  copy->CopyFrom(state.get());
   EXPECT_EQ(quad_transform, copy->content_to_target_transform);
   EXPECT_RECT_EQ(visible_content_rect, copy->visible_content_rect);
   EXPECT_EQ(opacity, copy->opacity);
@@ -63,16 +67,18 @@ scoped_ptr<SharedQuadState> CreateSharedQuadState() {
   gfx::Rect clip_rect(19, 21, 23, 25);
   bool is_clipped = false;
   float opacity = 1.f;
+  int sorting_context_id = 65536;
   SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
 
-  scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
+  scoped_ptr<SharedQuadState> state(new SharedQuadState);
   state->SetAll(quad_transform,
                 content_bounds,
                 visible_content_rect,
                 clip_rect,
                 is_clipped,
                 opacity,
-                blend_mode);
+                blend_mode,
+                sorting_context_id);
   return state.Pass();
 }
 
@@ -87,9 +93,10 @@ void CompareDrawQuad(DrawQuad* quad,
   EXPECT_EQ(copy_shared_state, copy->shared_quad_state);
 }
 
-#define CREATE_SHARED_STATE() \
-    scoped_ptr<SharedQuadState> shared_state(CreateSharedQuadState()); \
-    scoped_ptr<SharedQuadState> copy_shared_state(shared_state->Copy()); \
+#define CREATE_SHARED_STATE()                                         \
+  scoped_ptr<SharedQuadState> shared_state(CreateSharedQuadState());  \
+  scoped_ptr<SharedQuadState> copy_shared_state(new SharedQuadState); \
+  copy_shared_state->CopyFrom(shared_state.get());
 
 #define QUAD_DATA \
     gfx::Rect quad_rect(30, 40, 50, 60); \
@@ -328,11 +335,13 @@ void CompareDrawQuad(DrawQuad* quad,
     SETUP_AND_COPY_QUAD_ALL(Type, quad_all);
 
 TEST(DrawQuadTest, CopyCheckerboardDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0xfabb0011;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color);
+  CREATE_QUAD_2_NEW(CheckerboardDrawQuad, visible_rect, color);
   EXPECT_EQ(DrawQuad::CHECKERBOARD, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(color, copy_quad->color);
 
   CREATE_QUAD_1_ALL(CheckerboardDrawQuad, color);
@@ -341,12 +350,14 @@ TEST(DrawQuadTest, CopyCheckerboardDrawQuad) {
 }
 
 TEST(DrawQuadTest, CopyDebugBorderDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0xfabb0011;
   int width = 99;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width);
+  CREATE_QUAD_3_NEW(DebugBorderDrawQuad, visible_rect, color, width);
   EXPECT_EQ(DrawQuad::DEBUG_BORDER, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(width, copy_quad->width);
 
@@ -358,14 +369,20 @@ TEST(DrawQuadTest, CopyDebugBorderDrawQuad) {
 
 TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::Size size(58, 95);
   ResourceProvider::ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_4_NEW(
-      IOSurfaceDrawQuad, opaque_rect, size, resource_id, orientation);
+  CREATE_QUAD_5_NEW(IOSurfaceDrawQuad,
+                    opaque_rect,
+                    visible_rect,
+                    size,
+                    resource_id,
+                    orientation);
   EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_RECT_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);
@@ -379,6 +396,7 @@ TEST(DrawQuadTest, CopyIOSurfaceDrawQuad) {
 }
 
 TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPass::Id render_pass_id(22, 64);
   bool is_replica = true;
   ResourceProvider::ResourceId mask_resource_id = 78;
@@ -393,7 +411,8 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
   RenderPass::Id copied_render_pass_id(235, 11);
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_7_NEW_1(RenderPassDrawQuad,
+  CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
+                      visible_rect,
                       render_pass_id,
                       is_replica,
                       mask_resource_id,
@@ -403,6 +422,7 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
                       background_filters,
                       copied_render_pass_id);
   EXPECT_EQ(DrawQuad::RENDER_PASS, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(copied_render_pass_id, copy_quad->render_pass_id);
   EXPECT_EQ(is_replica, copy_quad->is_replica);
   EXPECT_EQ(mask_resource_id, copy_quad->mask_resource_id);
@@ -433,12 +453,15 @@ TEST(DrawQuadTest, CopyRenderPassDrawQuad) {
 }
 
 TEST(DrawQuadTest, CopySolidColorDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0x49494949;
   bool force_anti_aliasing_off = false;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_2_NEW(SolidColorDrawQuad, color, force_anti_aliasing_off);
+  CREATE_QUAD_3_NEW(
+      SolidColorDrawQuad, visible_rect, color, force_anti_aliasing_off);
   EXPECT_EQ(DrawQuad::SOLID_COLOR, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(color, copy_quad->color);
   EXPECT_EQ(force_anti_aliasing_off, copy_quad->force_anti_aliasing_off);
 
@@ -450,12 +473,15 @@ TEST(DrawQuadTest, CopySolidColorDrawQuad) {
 
 TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   ResourceProvider::ResourceId resource_id = 64;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaque_rect, resource_id, matrix);
+  CREATE_QUAD_4_NEW(
+      StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id, matrix);
   EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_EQ(resource_id, copy_quad->resource_id);
   EXPECT_EQ(matrix, copy_quad->matrix);
@@ -466,8 +492,25 @@ TEST(DrawQuadTest, CopyStreamVideoDrawQuad) {
   EXPECT_EQ(matrix, copy_quad->matrix);
 }
 
+TEST(DrawQuadTest, CopySurfaceDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
+  SurfaceId surface_id(1234);
+  CREATE_SHARED_STATE();
+
+  CREATE_QUAD_2_NEW(SurfaceDrawQuad, visible_rect, surface_id);
+  EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
+  EXPECT_EQ(surface_id, copy_quad->surface_id);
+
+  CREATE_QUAD_1_ALL(SurfaceDrawQuad, surface_id);
+  EXPECT_EQ(DrawQuad::SURFACE_CONTENT, copy_quad->material);
+  EXPECT_EQ(surface_id, copy_quad->surface_id);
+}
+
+
 TEST(DrawQuadTest, CopyTextureDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   unsigned resource_id = 82;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(0.5f, 224.f);
@@ -476,8 +519,9 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
   bool flipped = true;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_8_NEW(TextureDrawQuad,
+  CREATE_QUAD_9_NEW(TextureDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     resource_id,
                     premultiplied_alpha,
                     uv_top_left,
@@ -486,6 +530,7 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
                     vertex_opacity,
                     flipped);
   EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copy_quad->material);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
   EXPECT_EQ(resource_id, copy_quad->resource_id);
   EXPECT_EQ(premultiplied_alpha, copy_quad->premultiplied_alpha);
@@ -513,20 +558,23 @@ TEST(DrawQuadTest, CopyTextureDrawQuad) {
 
 TEST(DrawQuadTest, CopyTileDrawQuad) {
   gfx::Rect opaque_rect(33, 44, 22, 33);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   unsigned resource_id = 104;
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   bool swizzle_contents = true;
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_5_NEW(TileDrawQuad,
+  CREATE_QUAD_6_NEW(TileDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     resource_id,
                     tex_coord_rect,
                     texture_size,
                     swizzle_contents);
   EXPECT_EQ(DrawQuad::TILED_CONTENT, copy_quad->material);
   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(resource_id, copy_quad->resource_id);
   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
   EXPECT_EQ(texture_size, copy_quad->texture_size);
@@ -546,44 +594,53 @@ TEST(DrawQuadTest, CopyTileDrawQuad) {
 
 TEST(DrawQuadTest, CopyYUVVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
-  gfx::SizeF tex_scale(0.75f, 0.5f);
+  gfx::Rect visible_rect(40, 50, 30, 20);
+  gfx::RectF tex_coord_rect(0.0f, 0.0f, 0.75f, 0.5f);
   ResourceProvider::ResourceId y_plane_resource_id = 45;
   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_6_NEW(YUVVideoDrawQuad,
+  CREATE_QUAD_8_NEW(YUVVideoDrawQuad,
                     opaque_rect,
-                    tex_scale,
+                    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_EQ(tex_scale, copy_quad->tex_scale);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
+  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);
 
-  CREATE_QUAD_5_ALL(YUVVideoDrawQuad,
-                    tex_scale,
+  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_scale, copy_quad->tex_scale);
+  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) {
   gfx::Rect opaque_rect(33, 44, 22, 33);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   ResourceFormat texture_format = RGBA_8888;
@@ -592,8 +649,9 @@ TEST(DrawQuadTest, CopyPictureDrawQuad) {
   scoped_refptr<PicturePileImpl> picture_pile = PicturePileImpl::Create();
   CREATE_SHARED_STATE();
 
-  CREATE_QUAD_7_NEW(PictureDrawQuad,
+  CREATE_QUAD_8_NEW(PictureDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     tex_coord_rect,
                     texture_size,
                     texture_format,
@@ -602,6 +660,7 @@ TEST(DrawQuadTest, CopyPictureDrawQuad) {
                     picture_pile);
   EXPECT_EQ(DrawQuad::PICTURE_CONTENT, copy_quad->material);
   EXPECT_RECT_EQ(opaque_rect, copy_quad->opaque_rect);
+  EXPECT_RECT_EQ(visible_rect, copy_quad->visible_rect);
   EXPECT_EQ(tex_coord_rect, copy_quad->tex_coord_rect);
   EXPECT_EQ(texture_size, copy_quad->texture_size);
   EXPECT_EQ(texture_format, copy_quad->texture_format);
@@ -645,37 +704,45 @@ class DrawQuadIteratorTest : public testing::Test {
 };
 
 TEST_F(DrawQuadIteratorTest, CheckerboardDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0xfabb0011;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color);
+  CREATE_QUAD_2_NEW(CheckerboardDrawQuad, visible_rect, color);
   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 }
 
 TEST_F(DrawQuadIteratorTest, DebugBorderDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0xfabb0011;
   int width = 99;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width);
+  CREATE_QUAD_3_NEW(DebugBorderDrawQuad, visible_rect, color, width);
   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 }
 
 TEST_F(DrawQuadIteratorTest, IOSurfaceDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::Size size(58, 95);
   ResourceProvider::ResourceId resource_id = 72;
   IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_4_NEW(
-      IOSurfaceDrawQuad, opaque_rect, size, resource_id, orientation);
+  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.get()));
   EXPECT_EQ(resource_id + 1, quad_new->io_surface_resource_id);
 }
 
 TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   RenderPass::Id render_pass_id(22, 64);
   bool is_replica = true;
   ResourceProvider::ResourceId mask_resource_id = 78;
@@ -690,7 +757,8 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
   RenderPass::Id copied_render_pass_id(235, 11);
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_7_NEW_1(RenderPassDrawQuad,
+  CREATE_QUAD_8_NEW_1(RenderPassDrawQuad,
+                      visible_rect,
                       render_pass_id,
                       is_replica,
                       mask_resource_id,
@@ -708,28 +776,42 @@ TEST_F(DrawQuadIteratorTest, RenderPassDrawQuad) {
 }
 
 TEST_F(DrawQuadIteratorTest, SolidColorDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
   SkColor color = 0x49494949;
   bool force_anti_aliasing_off = false;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_2_NEW(SolidColorDrawQuad, color, force_anti_aliasing_off);
+  CREATE_QUAD_3_NEW(
+      SolidColorDrawQuad, visible_rect, color, force_anti_aliasing_off);
   EXPECT_EQ(0, IterateAndCount(quad_new.get()));
 }
 
 TEST_F(DrawQuadIteratorTest, StreamVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   ResourceProvider::ResourceId resource_id = 64;
   gfx::Transform matrix = gfx::Transform(0.5, 0.25, 1, 0.75, 0, 1);
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaque_rect, resource_id, matrix);
+  CREATE_QUAD_4_NEW(
+      StreamVideoDrawQuad, opaque_rect, visible_rect, resource_id, matrix);
   EXPECT_EQ(resource_id, quad_new->resource_id);
   EXPECT_EQ(1, IterateAndCount(quad_new.get()));
   EXPECT_EQ(resource_id + 1, quad_new->resource_id);
 }
 
+TEST_F(DrawQuadIteratorTest, SurfaceDrawQuad) {
+  gfx::Rect visible_rect(40, 50, 30, 20);
+  SurfaceId surface_id(4321);
+
+  CREATE_SHARED_STATE();
+  CREATE_QUAD_2_NEW(SurfaceDrawQuad, visible_rect, surface_id);
+  EXPECT_EQ(0, IterateAndCount(quad_new.get()));
+}
+
 TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   unsigned resource_id = 82;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(0.5f, 224.f);
@@ -738,8 +820,9 @@ TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
   bool flipped = true;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_8_NEW(TextureDrawQuad,
+  CREATE_QUAD_9_NEW(TextureDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     resource_id,
                     premultiplied_alpha,
                     uv_top_left,
@@ -754,14 +837,16 @@ TEST_F(DrawQuadIteratorTest, TextureDrawQuad) {
 
 TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
   gfx::Rect opaque_rect(33, 44, 22, 33);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   unsigned resource_id = 104;
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   bool swizzle_contents = true;
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_5_NEW(TileDrawQuad,
+  CREATE_QUAD_6_NEW(TileDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     resource_id,
                     tex_coord_rect,
                     texture_size,
@@ -773,25 +858,30 @@ TEST_F(DrawQuadIteratorTest, TileDrawQuad) {
 
 TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
   gfx::Rect opaque_rect(33, 47, 10, 12);
-  gfx::SizeF tex_scale(0.75f, 0.5f);
+  gfx::Rect visible_rect(40, 50, 30, 20);
+  gfx::RectF tex_coord_rect(0.0f, 0.0f, 0.75f, 0.5f);
   ResourceProvider::ResourceId y_plane_resource_id = 45;
   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_6_NEW(YUVVideoDrawQuad,
+  CREATE_QUAD_8_NEW(YUVVideoDrawQuad,
                     opaque_rect,
-                    tex_scale,
+                    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);
@@ -802,6 +892,7 @@ TEST_F(DrawQuadIteratorTest, YUVVideoDrawQuad) {
 // Disabled until picture draw quad is supported for ubercomp: crbug.com/231715
 TEST_F(DrawQuadIteratorTest, DISABLED_PictureDrawQuad) {
   gfx::Rect opaque_rect(33, 44, 22, 33);
+  gfx::Rect visible_rect(40, 50, 30, 20);
   gfx::RectF tex_coord_rect(31.f, 12.f, 54.f, 20.f);
   gfx::Size texture_size(85, 32);
   ResourceFormat texture_format = RGBA_8888;
@@ -810,8 +901,9 @@ TEST_F(DrawQuadIteratorTest, DISABLED_PictureDrawQuad) {
   scoped_refptr<PicturePileImpl> picture_pile = PicturePileImpl::Create();
 
   CREATE_SHARED_STATE();
-  CREATE_QUAD_7_NEW(PictureDrawQuad,
+  CREATE_QUAD_8_NEW(PictureDrawQuad,
                     opaque_rect,
+                    visible_rect,
                     tex_coord_rect,
                     texture_size,
                     texture_format,