Update Chromium to beta version 37.0.2062.68

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

32 files changed, 564 insertions, 296 deletions

diff --git a/chromium/cc/quads/checkerboard_draw_quad.cc b/chromium/cc/quads/checkerboard_draw_quad.cc
index 5e17d885f48..921a553b2c2 100644
--- a/chromium/cc/quads/checkerboard_draw_quad.cc
+++ b/chromium/cc/quads/checkerboard_draw_quad.cc
@@ -16,10 +16,10 @@ scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::Create() {
 }
 
 void CheckerboardDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                                  gfx::Rect rect,
+                                  const gfx::Rect& rect,
+                                  const gfx::Rect& visible_rect,
                                   SkColor color) {
   gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect();
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect,
                    visible_rect, needs_blending);
@@ -27,9 +27,9 @@ void CheckerboardDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void CheckerboardDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                                  gfx::Rect rect,
-                                  gfx::Rect opaque_rect,
-                                  gfx::Rect visible_rect,
+                                  const gfx::Rect& rect,
+                                  const gfx::Rect& opaque_rect,
+                                  const gfx::Rect& visible_rect,
                                   bool needs_blending,
                                   SkColor color) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect,
diff --git a/chromium/cc/quads/checkerboard_draw_quad.h b/chromium/cc/quads/checkerboard_draw_quad.h
index 4f7452eb0a6..d59e53f912e 100644
--- a/chromium/cc/quads/checkerboard_draw_quad.h
+++ b/chromium/cc/quads/checkerboard_draw_quad.h
@@ -17,13 +17,14 @@ class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
   static scoped_ptr<CheckerboardDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
               SkColor color);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               SkColor color);
 
diff --git a/chromium/cc/quads/content_draw_quad_base.cc b/chromium/cc/quads/content_draw_quad_base.cc
index 947af0b2d94..18d3d10c34a 100644
--- a/chromium/cc/quads/content_draw_quad_base.cc
+++ b/chromium/cc/quads/content_draw_quad_base.cc
@@ -19,12 +19,12 @@ ContentDrawQuadBase::~ContentDrawQuadBase() {
 
 void ContentDrawQuadBase::SetNew(const SharedQuadState* shared_quad_state,
                                  DrawQuad::Material material,
-                                 gfx::Rect rect,
-                                 gfx::Rect opaque_rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& opaque_rect,
+                                 const gfx::Rect& visible_rect,
                                  const gfx::RectF& tex_coord_rect,
-                                 gfx::Size texture_size,
+                                 const gfx::Size& texture_size,
                                  bool swizzle_contents) {
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, material, rect, opaque_rect,
                    visible_rect, needs_blending);
@@ -35,12 +35,12 @@ void ContentDrawQuadBase::SetNew(const SharedQuadState* shared_quad_state,
 
 void ContentDrawQuadBase::SetAll(const SharedQuadState* shared_quad_state,
                                  DrawQuad::Material material,
-                                 gfx::Rect rect,
-                                 gfx::Rect opaque_rect,
-                                 gfx::Rect visible_rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& opaque_rect,
+                                 const gfx::Rect& visible_rect,
                                  bool needs_blending,
                                  const gfx::RectF& tex_coord_rect,
-                                 gfx::Size texture_size,
+                                 const gfx::Size& texture_size,
                                  bool swizzle_contents) {
   DrawQuad::SetAll(shared_quad_state, material, rect, opaque_rect,
                    visible_rect, needs_blending);
diff --git a/chromium/cc/quads/content_draw_quad_base.h b/chromium/cc/quads/content_draw_quad_base.h
index cbf18ca2b15..a286e100861 100644
--- a/chromium/cc/quads/content_draw_quad_base.h
+++ b/chromium/cc/quads/content_draw_quad_base.h
@@ -18,20 +18,21 @@ class CC_EXPORT ContentDrawQuadBase : public DrawQuad {
  public:
   void SetNew(const SharedQuadState* shared_quad_state,
               DrawQuad::Material material,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               bool swizzle_contents);
 
   void SetAll(const SharedQuadState* shared_quad_state,
               DrawQuad::Material material,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               bool swizzle_contents);
 
   gfx::RectF tex_coord_rect;
diff --git a/chromium/cc/quads/debug_border_draw_quad.cc b/chromium/cc/quads/debug_border_draw_quad.cc
index 89ee8e01281..9c575aada19 100644
--- a/chromium/cc/quads/debug_border_draw_quad.cc
+++ b/chromium/cc/quads/debug_border_draw_quad.cc
@@ -19,11 +19,11 @@ scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::Create() {
 }
 
 void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                                 gfx::Rect rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& visible_rect,
                                  SkColor color,
                                  int width) {
   gfx::Rect opaque_rect;
-  gfx::Rect visible_rect = rect;
   bool needs_blending = SkColorGetA(color) < 255;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect,
                    visible_rect, needs_blending);
@@ -32,9 +32,9 @@ void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                                 gfx::Rect rect,
-                                 gfx::Rect opaque_rect,
-                                 gfx::Rect visible_rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& opaque_rect,
+                                 const gfx::Rect& visible_rect,
                                  bool needs_blending,
                                  SkColor color,
                                  int width) {
diff --git a/chromium/cc/quads/debug_border_draw_quad.h b/chromium/cc/quads/debug_border_draw_quad.h
index 5b369514b50..2bfccc4b9bc 100644
--- a/chromium/cc/quads/debug_border_draw_quad.h
+++ b/chromium/cc/quads/debug_border_draw_quad.h
@@ -17,14 +17,15 @@ class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
   static scoped_ptr<DebugBorderDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
               SkColor color,
               int width);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               SkColor color,
               int width);
diff --git a/chromium/cc/quads/draw_quad.cc b/chromium/cc/quads/draw_quad.cc
index f3cd8189545..e2d6059a611 100644
--- a/chromium/cc/quads/draw_quad.cc
+++ b/chromium/cc/quads/draw_quad.cc
@@ -15,6 +15,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"
@@ -36,9 +37,9 @@ DrawQuad::DrawQuad()
 
 void DrawQuad::SetAll(const SharedQuadState* shared_quad_state,
                       Material material,
-                      gfx::Rect rect,
-                      gfx::Rect opaque_rect,
-                      gfx::Rect visible_rect,
+                      const gfx::Rect& rect,
+                      const gfx::Rect& opaque_rect,
+                      const gfx::Rect& visible_rect,
                       bool needs_blending) {
   DCHECK(rect.Contains(visible_rect)) << "rect: " << rect.ToString()
                                       << " visible_rect: "
@@ -89,6 +90,9 @@ scoped_ptr<DrawQuad> DrawQuad::Copy(
     case STREAM_VIDEO_CONTENT:
       copy_quad.reset(TypedCopy<StreamVideoDrawQuad>(this));
       break;
+    case SURFACE_CONTENT:
+      copy_quad.reset(TypedCopy<SurfaceDrawQuad>(this));
+      break;
     case YUV_VIDEO_CONTENT:
       copy_quad.reset(TypedCopy<YUVVideoDrawQuad>(this));
       break;
diff --git a/chromium/cc/quads/draw_quad.h b/chromium/cc/quads/draw_quad.h
index c3696d6f301..1803eb31013 100644
--- a/chromium/cc/quads/draw_quad.h
+++ b/chromium/cc/quads/draw_quad.h
@@ -37,11 +37,13 @@ class CC_EXPORT DrawQuad {
     IO_SURFACE_CONTENT,
     PICTURE_CONTENT,
     RENDER_PASS,
-    TEXTURE_CONTENT,
     SOLID_COLOR,
+    STREAM_VIDEO_CONTENT,
+    SURFACE_CONTENT,
+    TEXTURE_CONTENT,
     TILED_CONTENT,
     YUV_VIDEO_CONTENT,
-    STREAM_VIDEO_CONTENT,
+    MATERIAL_LAST = YUV_VIDEO_CONTENT
   };
 
   virtual ~DrawQuad();
@@ -131,9 +133,9 @@ class CC_EXPORT DrawQuad {
 
   void SetAll(const SharedQuadState* shared_quad_state,
               Material material,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending);
   virtual void ExtendValue(base::DictionaryValue* value) const = 0;
 };
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,
diff --git a/chromium/cc/quads/io_surface_draw_quad.cc b/chromium/cc/quads/io_surface_draw_quad.cc
index 2c986dd3a23..a7a8f691ca2 100644
--- a/chromium/cc/quads/io_surface_draw_quad.cc
+++ b/chromium/cc/quads/io_surface_draw_quad.cc
@@ -20,12 +20,12 @@ scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::Create() {
 }
 
 void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                               gfx::Rect rect,
-                               gfx::Rect opaque_rect,
-                               gfx::Size io_surface_size,
+                               const gfx::Rect& rect,
+                               const gfx::Rect& opaque_rect,
+                               const gfx::Rect& visible_rect,
+                               const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
                                Orientation orientation) {
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
@@ -35,11 +35,11 @@ void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                               gfx::Rect rect,
-                               gfx::Rect opaque_rect,
-                               gfx::Rect visible_rect,
+                               const gfx::Rect& rect,
+                               const gfx::Rect& opaque_rect,
+                               const gfx::Rect& visible_rect,
                                bool needs_blending,
-                               gfx::Size io_surface_size,
+                               const gfx::Size& io_surface_size,
                                unsigned io_surface_resource_id,
                                Orientation orientation) {
   DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
diff --git a/chromium/cc/quads/io_surface_draw_quad.h b/chromium/cc/quads/io_surface_draw_quad.h
index fc8b5019402..a23e54c40f8 100644
--- a/chromium/cc/quads/io_surface_draw_quad.h
+++ b/chromium/cc/quads/io_surface_draw_quad.h
@@ -16,24 +16,26 @@ class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
  public:
   enum Orientation {
     FLIPPED,
-    UNFLIPPED
+    UNFLIPPED,
+    ORIENTATION_LAST = UNFLIPPED
   };
 
   static scoped_ptr<IOSurfaceDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Size io_surface_size,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
+              const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
               Orientation orientation);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
-              gfx::Size io_surface_size,
+              const gfx::Size& io_surface_size,
               unsigned io_surface_resource_id,
               Orientation orientation);
 
diff --git a/chromium/cc/quads/picture_draw_quad.cc b/chromium/cc/quads/picture_draw_quad.cc
index bdb12e64d7a..37bb07e907b 100644
--- a/chromium/cc/quads/picture_draw_quad.cc
+++ b/chromium/cc/quads/picture_draw_quad.cc
@@ -21,22 +21,24 @@ scoped_ptr<PictureDrawQuad> PictureDrawQuad::Create() {
 }
 
 void PictureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                             gfx::Rect rect,
-                             gfx::Rect opaque_rect,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect,
                              const gfx::RectF& tex_coord_rect,
-                             gfx::Size texture_size,
+                             const gfx::Size& texture_size,
                              ResourceFormat texture_format,
-                             gfx::Rect content_rect,
+                             const gfx::Rect& content_rect,
                              float contents_scale,
                              scoped_refptr<PicturePileImpl> picture_pile) {
-  ContentDrawQuadBase::SetNew(shared_quad_state,
-                              DrawQuad::PICTURE_CONTENT,
-                              rect,
-                              opaque_rect,
-                              tex_coord_rect,
-                              texture_size,
-                              !PlatformColor::SameComponentOrder(
-                                  texture_format));
+  ContentDrawQuadBase::SetNew(
+      shared_quad_state,
+      DrawQuad::PICTURE_CONTENT,
+      rect,
+      opaque_rect,
+      visible_rect,
+      tex_coord_rect,
+      texture_size,
+      !PlatformColor::SameComponentOrder(texture_format));
   this->content_rect = content_rect;
   this->contents_scale = contents_scale;
   this->picture_pile = picture_pile;
@@ -44,14 +46,14 @@ void PictureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void PictureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                             gfx::Rect rect,
-                             gfx::Rect opaque_rect,
-                             gfx::Rect visible_rect,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect,
                              bool needs_blending,
                              const gfx::RectF& tex_coord_rect,
-                             gfx::Size texture_size,
+                             const gfx::Size& texture_size,
                              ResourceFormat texture_format,
-                             gfx::Rect content_rect,
+                             const gfx::Rect& content_rect,
                              float contents_scale,
                              scoped_refptr<PicturePileImpl> picture_pile) {
   ContentDrawQuadBase::SetAll(shared_quad_state,
diff --git a/chromium/cc/quads/picture_draw_quad.h b/chromium/cc/quads/picture_draw_quad.h
index 9bea70b4609..ea1735fa7fd 100644
--- a/chromium/cc/quads/picture_draw_quad.h
+++ b/chromium/cc/quads/picture_draw_quad.h
@@ -23,24 +23,25 @@ class CC_EXPORT PictureDrawQuad : public ContentDrawQuadBase {
   virtual ~PictureDrawQuad();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               ResourceFormat texture_format,
-              gfx::Rect content_rect,
+              const gfx::Rect& content_rect,
               float contents_scale,
               scoped_refptr<PicturePileImpl> picture_pile);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               ResourceFormat texture_format,
-              gfx::Rect content_rect,
+              const gfx::Rect& content_rect,
               float contents_scale,
               scoped_refptr<PicturePileImpl> picture_pile);
 
diff --git a/chromium/cc/quads/render_pass.cc b/chromium/cc/quads/render_pass.cc
index 53cb83703a3..afcc6e816fb 100644
--- a/chromium/cc/quads/render_pass.cc
+++ b/chromium/cc/quads/render_pass.cc
@@ -20,7 +20,7 @@ const size_t kDefaultNumQuadsToReserve = 128;
 namespace cc {
 
 void* RenderPass::Id::AsTracingId() const {
-  COMPILE_ASSERT(sizeof(size_t) <= sizeof(void*),  // NOLINT(runtime/sizeof)
+  COMPILE_ASSERT(sizeof(size_t) <= sizeof(void*),  // NOLINT
                  size_t_bigger_than_pointer);
   return reinterpret_cast<void*>(base::HashPair(layer_id, index));
 }
@@ -33,16 +33,13 @@ scoped_ptr<RenderPass> RenderPass::Create(size_t num_layers) {
   return make_scoped_ptr(new RenderPass(num_layers));
 }
 
-RenderPass::RenderPass()
-    : id(Id(-1, -1)),
-      has_transparent_background(true) {
+RenderPass::RenderPass() : id(Id(-1, -1)), has_transparent_background(true) {
   shared_quad_state_list.reserve(kDefaultNumSharedQuadStatesToReserve);
   quad_list.reserve(kDefaultNumQuadsToReserve);
 }
 
 RenderPass::RenderPass(size_t num_layers)
-    : id(Id(-1, -1)),
-      has_transparent_background(true) {
+    : id(Id(-1, -1)), has_transparent_background(true) {
   // Each layer usually produces one shared quad state, so the number of layers
   // is a good hint for what to reserve here.
   shared_quad_state_list.reserve(num_layers);
@@ -82,8 +79,9 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
                       source->transform_to_root_target,
                       source->has_transparent_background);
     for (size_t i = 0; i < source->shared_quad_state_list.size(); ++i) {
-      copy_pass->shared_quad_state_list.push_back(
-          source->shared_quad_state_list[i]->Copy());
+      SharedQuadState* copy_shared_quad_state =
+          copy_pass->CreateAndAppendSharedQuadState();
+      copy_shared_quad_state->CopyFrom(source->shared_quad_state_list[i]);
     }
     for (size_t i = 0, sqs_i = 0; i < source->quad_list.size(); ++i) {
       while (source->quad_list[i]->shared_quad_state !=
@@ -112,11 +110,14 @@ void RenderPass::CopyAll(const ScopedPtrVector<RenderPass>& in,
 }
 
 void RenderPass::SetNew(Id id,
-                        gfx::Rect output_rect,
-                        gfx::RectF damage_rect,
+                        const gfx::Rect& output_rect,
+                        const gfx::Rect& damage_rect,
                         const gfx::Transform& transform_to_root_target) {
   DCHECK_GT(id.layer_id, 0);
   DCHECK_GE(id.index, 0);
+  DCHECK(damage_rect.IsEmpty() || output_rect.Contains(damage_rect))
+      << "damage_rect: " << damage_rect.ToString()
+      << " output_rect: " << output_rect.ToString();
 
   this->id = id;
   this->output_rect = output_rect;
@@ -128,8 +129,8 @@ void RenderPass::SetNew(Id id,
 }
 
 void RenderPass::SetAll(Id id,
-                        gfx::Rect output_rect,
-                        gfx::RectF damage_rect,
+                        const gfx::Rect& output_rect,
+                        const gfx::Rect& damage_rect,
                         const gfx::Transform& transform_to_root_target,
                         bool has_transparent_background) {
   DCHECK_GT(id.layer_id, 0);
@@ -168,4 +169,13 @@ scoped_ptr<base::Value> RenderPass::AsValue() const {
   return value.PassAs<base::Value>();
 }
 
+SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
+  shared_quad_state_list.push_back(make_scoped_ptr(new SharedQuadState));
+  return shared_quad_state_list.back();
+}
+
+void RenderPass::AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad) {
+  quad_list.push_back(draw_quad.Pass());
+}
+
 }  // namespace cc
diff --git a/chromium/cc/quads/render_pass.h b/chromium/cc/quads/render_pass.h
index 407381fb172..778a71438fa 100644
--- a/chromium/cc/quads/render_pass.h
+++ b/chromium/cc/quads/render_pass.h
@@ -76,24 +76,27 @@ class CC_EXPORT RenderPass {
                       ScopedPtrVector<RenderPass>* out);
 
   void SetNew(Id id,
-              gfx::Rect output_rect,
-              gfx::RectF damage_rect,
+              const gfx::Rect& output_rect,
+              const gfx::Rect& damage_rect,
               const gfx::Transform& transform_to_root_target);
 
   void SetAll(Id id,
-              gfx::Rect output_rect,
-              gfx::RectF damage_rect,
+              const gfx::Rect& output_rect,
+              const gfx::Rect& damage_rect,
               const gfx::Transform& transform_to_root_target,
               bool has_transparent_background);
 
   scoped_ptr<base::Value> AsValue() const;
 
+  SharedQuadState* CreateAndAppendSharedQuadState();
+  void AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad);
+
   // Uniquely identifies the render pass in the compositor's current frame.
   Id id;
 
   // These are in the space of the render pass' physical pixels.
   gfx::Rect output_rect;
-  gfx::RectF damage_rect;
+  gfx::Rect damage_rect;
 
   // Transforms from the origin of the |output_rect| to the origin of the root
   // render pass' |output_rect|.
diff --git a/chromium/cc/quads/render_pass_draw_quad.cc b/chromium/cc/quads/render_pass_draw_quad.cc
index af8cd8c492c..81b0da285e5 100644
--- a/chromium/cc/quads/render_pass_draw_quad.cc
+++ b/chromium/cc/quads/render_pass_draw_quad.cc
@@ -36,19 +36,19 @@ scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Copy(
 
 void RenderPassDrawQuad::SetNew(
     const SharedQuadState* shared_quad_state,
-    gfx::Rect rect,
+    const gfx::Rect& rect,
+    const gfx::Rect& visible_rect,
     RenderPass::Id render_pass_id,
     bool is_replica,
     ResourceProvider::ResourceId mask_resource_id,
-    gfx::Rect contents_changed_since_last_frame,
-    gfx::RectF mask_uv_rect,
+    const gfx::Rect& contents_changed_since_last_frame,
+    const gfx::RectF& mask_uv_rect,
     const FilterOperations& filters,
     const FilterOperations& background_filters) {
   DCHECK_GT(render_pass_id.layer_id, 0);
   DCHECK_GE(render_pass_id.index, 0);
 
   gfx::Rect opaque_rect;
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   SetAll(shared_quad_state, rect, opaque_rect, visible_rect, needs_blending,
          render_pass_id, is_replica, mask_resource_id,
@@ -58,15 +58,15 @@ void RenderPassDrawQuad::SetNew(
 
 void RenderPassDrawQuad::SetAll(
     const SharedQuadState* shared_quad_state,
-    gfx::Rect rect,
-    gfx::Rect opaque_rect,
-    gfx::Rect visible_rect,
+    const gfx::Rect& rect,
+    const gfx::Rect& opaque_rect,
+    const gfx::Rect& visible_rect,
     bool needs_blending,
     RenderPass::Id render_pass_id,
     bool is_replica,
     ResourceProvider::ResourceId mask_resource_id,
-    gfx::Rect contents_changed_since_last_frame,
-    gfx::RectF mask_uv_rect,
+    const gfx::Rect& contents_changed_since_last_frame,
+    const gfx::RectF& mask_uv_rect,
     const FilterOperations& filters,
     const FilterOperations& background_filters) {
   DCHECK_GT(render_pass_id.layer_id, 0);
diff --git a/chromium/cc/quads/render_pass_draw_quad.h b/chromium/cc/quads/render_pass_draw_quad.h
index 8546c45621c..1f6217ddc8c 100644
--- a/chromium/cc/quads/render_pass_draw_quad.h
+++ b/chromium/cc/quads/render_pass_draw_quad.h
@@ -21,25 +21,26 @@ class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
   virtual ~RenderPassDrawQuad();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
               RenderPass::Id render_pass_id,
               bool is_replica,
               ResourceProvider::ResourceId mask_resource_id,
-              gfx::Rect contents_changed_since_last_frame,
-              gfx::RectF mask_uv_rect,
+              const gfx::Rect& contents_changed_since_last_frame,
+              const gfx::RectF& mask_uv_rect,
               const FilterOperations& filters,
               const FilterOperations& background_filters);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               RenderPass::Id render_pass_id,
               bool is_replica,
               ResourceProvider::ResourceId mask_resource_id,
-              gfx::Rect contents_changed_since_last_frame,
-              gfx::RectF mask_uv_rect,
+              const gfx::Rect& contents_changed_since_last_frame,
+              const gfx::RectF& mask_uv_rect,
               const FilterOperations& filters,
               const FilterOperations& background_filters);
 
diff --git a/chromium/cc/quads/render_pass_unittest.cc b/chromium/cc/quads/render_pass_unittest.cc
index e70a33dd685..59af62d2ed1 100644
--- a/chromium/cc/quads/render_pass_unittest.cc
+++ b/chromium/cc/quads/render_pass_unittest.cc
@@ -28,7 +28,7 @@ struct RenderPassSize {
   SharedQuadStateList shared_quad_state_list;
   gfx::Transform transform_to_root_target;
   gfx::Rect output_rect;
-  gfx::RectF damage_rect;
+  gfx::Rect damage_rect;
   bool has_transparent_background;
   ScopedPtrVector<CopyOutputRequest> copy_callbacks;
 };
@@ -79,20 +79,20 @@ TEST(RenderPassTest, CopyShouldBeIdenticalExceptIdAndQuads) {
   pass->copy_requests.push_back(CopyOutputRequest::CreateEmptyRequest());
 
   // Stick a quad in the pass, this should not get copied.
-  scoped_ptr<SharedQuadState> shared_state = SharedQuadState::Create();
+  SharedQuadState* shared_state = pass->CreateAndAppendSharedQuadState();
   shared_state->SetAll(gfx::Transform(),
                        gfx::Size(),
                        gfx::Rect(),
                        gfx::Rect(),
                        false,
                        1,
-                       SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state.Pass());
+                       SkXfermode::kSrcOver_Mode,
+                       0);
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
       CheckerboardDrawQuad::Create();
   checkerboard_quad->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(), SkColor());
+      pass->shared_quad_state_list.back(), gfx::Rect(), gfx::Rect(), SkColor());
   pass->quad_list.push_back(checkerboard_quad.PassAs<DrawQuad>());
 
   RenderPass::Id new_id(63, 4);
@@ -130,49 +130,57 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                has_transparent_background);
 
   // Two quads using one shared state.
-  scoped_ptr<SharedQuadState> shared_state1 = SharedQuadState::Create();
+  SharedQuadState* shared_state1 = pass->CreateAndAppendSharedQuadState();
   shared_state1->SetAll(gfx::Transform(),
                         gfx::Size(1, 1),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state1.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad1->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(1, 1, 1, 1), SkColor());
+  checkerboard_quad1->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(1, 1, 1, 1),
+                             gfx::Rect(1, 1, 1, 1),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad2->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(2, 2, 2, 2), SkColor());
+  checkerboard_quad2->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(2, 2, 2, 2),
+                             gfx::Rect(2, 2, 2, 2),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 
   // And two quads using another shared state.
-  scoped_ptr<SharedQuadState> shared_state2 = SharedQuadState::Create();
+  SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState();
   shared_state2->SetAll(gfx::Transform(),
                         gfx::Size(2, 2),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state2.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad3 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad3->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
+  checkerboard_quad3->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(3, 3, 3, 3),
+                             gfx::Rect(3, 3, 3, 3),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad3.PassAs<DrawQuad>());
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad4 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad4->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(4, 4, 4, 4), SkColor());
+  checkerboard_quad4->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(4, 4, 4, 4),
+                             gfx::Rect(4, 4, 4, 4),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad4.PassAs<DrawQuad>());
 
   // A second render pass with a quad.
@@ -190,26 +198,30 @@ TEST(RenderPassTest, CopyAllShouldBeIdentical) {
                   contrib_transform_to_root,
                   contrib_has_transparent_background);
 
-  scoped_ptr<SharedQuadState> contrib_shared_state = SharedQuadState::Create();
+  SharedQuadState* contrib_shared_state =
+      contrib->CreateAndAppendSharedQuadState();
   contrib_shared_state->SetAll(gfx::Transform(),
                                gfx::Size(2, 2),
                                gfx::Rect(),
                                gfx::Rect(),
                                false,
                                1,
-                               SkXfermode::kSrcOver_Mode);
-  contrib->AppendSharedQuadState(contrib_shared_state.Pass());
+                               SkXfermode::kSrcOver_Mode,
+                               0);
 
   scoped_ptr<CheckerboardDrawQuad> contrib_quad =
       CheckerboardDrawQuad::Create();
-  contrib_quad->SetNew(
-      contrib->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
+  contrib_quad->SetNew(contrib->shared_quad_state_list.back(),
+                       gfx::Rect(3, 3, 3, 3),
+                       gfx::Rect(3, 3, 3, 3),
+                       SkColor());
   contrib->quad_list.push_back(contrib_quad.PassAs<DrawQuad>());
 
   // And a RenderPassDrawQuad for the contributing pass.
   scoped_ptr<RenderPassDrawQuad> pass_quad = RenderPassDrawQuad::Create();
   pass_quad->SetNew(pass->shared_quad_state_list.back(),
                     contrib_output_rect,
+                    contrib_output_rect,
                     contrib_id,
                     false,  // is_replica
                     0,      // mask_resource_id
@@ -247,59 +259,63 @@ TEST(RenderPassTest, CopyAllWithCulledQuads) {
                has_transparent_background);
 
   // A shared state with a quad.
-  scoped_ptr<SharedQuadState> shared_state1 = SharedQuadState::Create();
+  SharedQuadState* shared_state1 = pass->CreateAndAppendSharedQuadState();
   shared_state1->SetAll(gfx::Transform(),
                         gfx::Size(1, 1),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state1.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad1 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad1->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(1, 1, 1, 1), SkColor());
+  checkerboard_quad1->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(1, 1, 1, 1),
+                             gfx::Rect(1, 1, 1, 1),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad1.PassAs<DrawQuad>());
 
   // A shared state with no quads, they were culled.
-  scoped_ptr<SharedQuadState> shared_state2 = SharedQuadState::Create();
+  SharedQuadState* shared_state2 = pass->CreateAndAppendSharedQuadState();
   shared_state2->SetAll(gfx::Transform(),
                         gfx::Size(2, 2),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state2.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   // A second shared state with no quads.
-  scoped_ptr<SharedQuadState> shared_state3 = SharedQuadState::Create();
+  SharedQuadState* shared_state3 = pass->CreateAndAppendSharedQuadState();
   shared_state3->SetAll(gfx::Transform(),
                         gfx::Size(2, 2),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state3.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   // A last shared state with a quad again.
-  scoped_ptr<SharedQuadState> shared_state4 = SharedQuadState::Create();
+  SharedQuadState* shared_state4 = pass->CreateAndAppendSharedQuadState();
   shared_state4->SetAll(gfx::Transform(),
                         gfx::Size(2, 2),
                         gfx::Rect(),
                         gfx::Rect(),
                         false,
                         1,
-                        SkXfermode::kSrcOver_Mode);
-  pass->AppendSharedQuadState(shared_state4.Pass());
+                        SkXfermode::kSrcOver_Mode,
+                        0);
 
   scoped_ptr<CheckerboardDrawQuad> checkerboard_quad2 =
       CheckerboardDrawQuad::Create();
-  checkerboard_quad2->SetNew(
-      pass->shared_quad_state_list.back(), gfx::Rect(3, 3, 3, 3), SkColor());
+  checkerboard_quad2->SetNew(pass->shared_quad_state_list.back(),
+                             gfx::Rect(3, 3, 3, 3),
+                             gfx::Rect(3, 3, 3, 3),
+                             SkColor());
   pass->quad_list.push_back(checkerboard_quad2.PassAs<DrawQuad>());
 
   pass_list.push_back(pass.PassAs<RenderPass>());
diff --git a/chromium/cc/quads/shared_quad_state.cc b/chromium/cc/quads/shared_quad_state.cc
index 56584577917..57959e3cdd9 100644
--- a/chromium/cc/quads/shared_quad_state.cc
+++ b/chromium/cc/quads/shared_quad_state.cc
@@ -11,7 +11,11 @@
 namespace cc {
 
 SharedQuadState::SharedQuadState()
-    : is_clipped(false), opacity(0.f), blend_mode(SkXfermode::kSrcOver_Mode) {}
+    : is_clipped(false),
+      opacity(0.f),
+      blend_mode(SkXfermode::kSrcOver_Mode),
+      sorting_context_id(0) {
+}
 
 SharedQuadState::~SharedQuadState() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
@@ -19,21 +23,18 @@ SharedQuadState::~SharedQuadState() {
       "cc::SharedQuadState", this);
 }
 
-scoped_ptr<SharedQuadState> SharedQuadState::Create() {
-  return make_scoped_ptr(new SharedQuadState);
-}
-
-scoped_ptr<SharedQuadState> SharedQuadState::Copy() const {
-  return make_scoped_ptr(new SharedQuadState(*this));
+void SharedQuadState::CopyFrom(const SharedQuadState* other) {
+  *this = *other;
 }
 
 void SharedQuadState::SetAll(const gfx::Transform& content_to_target_transform,
-                             gfx::Size content_bounds,
-                             gfx::Rect visible_content_rect,
-                             gfx::Rect clip_rect,
+                             const gfx::Size& content_bounds,
+                             const gfx::Rect& visible_content_rect,
+                             const gfx::Rect& clip_rect,
                              bool is_clipped,
                              float opacity,
-                             SkXfermode::Mode blend_mode) {
+                             SkXfermode::Mode blend_mode,
+                             int sorting_context_id) {
   this->content_to_target_transform = content_to_target_transform;
   this->content_bounds = content_bounds;
   this->visible_content_rect = visible_content_rect;
@@ -41,6 +42,7 @@ void SharedQuadState::SetAll(const gfx::Transform& content_to_target_transform,
   this->is_clipped = is_clipped;
   this->opacity = opacity;
   this->blend_mode = blend_mode;
+  this->sorting_context_id = sorting_context_id;
 }
 
 scoped_ptr<base::Value> SharedQuadState::AsValue() const {
diff --git a/chromium/cc/quads/shared_quad_state.h b/chromium/cc/quads/shared_quad_state.h
index b70d4a11fb9..30a1e25b3d3 100644
--- a/chromium/cc/quads/shared_quad_state.h
+++ b/chromium/cc/quads/shared_quad_state.h
@@ -17,20 +17,26 @@ class Value;
 
 namespace cc {
 
+// SharedQuadState holds a set of properties that are common across multiple
+// DrawQuads. It's purely an optimization - the properties behave in exactly the
+// same way as if they were replicated on each DrawQuad. A given SharedQuadState
+// can only be shared by DrawQuads that are adjacent in their RenderPass'
+// QuadList.
 class CC_EXPORT SharedQuadState {
  public:
-  static scoped_ptr<SharedQuadState> Create();
+  SharedQuadState();
   ~SharedQuadState();
 
-  scoped_ptr<SharedQuadState> Copy() const;
+  void CopyFrom(const SharedQuadState* other);
 
   void SetAll(const gfx::Transform& content_to_target_transform,
-              gfx::Size content_bounds,
-              gfx::Rect visible_content_rect,
-              gfx::Rect clip_rect,
+              const gfx::Size& content_bounds,
+              const gfx::Rect& visible_content_rect,
+              const gfx::Rect& clip_rect,
               bool is_clipped,
               float opacity,
-              SkXfermode::Mode blend_mode);
+              SkXfermode::Mode blend_mode,
+              int sorting_context_id);
   scoped_ptr<base::Value> AsValue() const;
 
   // Transforms from quad's original content space to its target content space.
@@ -44,9 +50,7 @@ class CC_EXPORT SharedQuadState {
   bool is_clipped;
   float opacity;
   SkXfermode::Mode blend_mode;
-
- private:
-  SharedQuadState();
+  int sorting_context_id;
 };
 
 }  // namespace cc
diff --git a/chromium/cc/quads/solid_color_draw_quad.cc b/chromium/cc/quads/solid_color_draw_quad.cc
index ae3b9142209..7c0b554dcc8 100644
--- a/chromium/cc/quads/solid_color_draw_quad.cc
+++ b/chromium/cc/quads/solid_color_draw_quad.cc
@@ -17,11 +17,11 @@ scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() {
 }
 
 void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                                gfx::Rect rect,
+                                const gfx::Rect& rect,
+                                const gfx::Rect& visible_rect,
                                 SkColor color,
                                 bool force_anti_aliasing_off) {
   gfx::Rect opaque_rect = SkColorGetA(color) == 255 ? rect : gfx::Rect();
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
                    visible_rect, needs_blending);
@@ -30,9 +30,9 @@ void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                                gfx::Rect rect,
-                                gfx::Rect opaque_rect,
-                                gfx::Rect visible_rect,
+                                const gfx::Rect& rect,
+                                const gfx::Rect& opaque_rect,
+                                const gfx::Rect& visible_rect,
                                 bool needs_blending,
                                 SkColor color,
                                 bool force_anti_aliasing_off) {
diff --git a/chromium/cc/quads/solid_color_draw_quad.h b/chromium/cc/quads/solid_color_draw_quad.h
index 2c41243409e..4b8b9a3ae1b 100644
--- a/chromium/cc/quads/solid_color_draw_quad.h
+++ b/chromium/cc/quads/solid_color_draw_quad.h
@@ -17,14 +17,15 @@ class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
   static scoped_ptr<SolidColorDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
               SkColor color,
               bool force_anti_aliasing_off);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               SkColor color,
               bool force_anti_aliasing_off);
diff --git a/chromium/cc/quads/stream_video_draw_quad.cc b/chromium/cc/quads/stream_video_draw_quad.cc
index c239256ac51..a9a75bcf130 100644
--- a/chromium/cc/quads/stream_video_draw_quad.cc
+++ b/chromium/cc/quads/stream_video_draw_quad.cc
@@ -17,11 +17,11 @@ scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::Create() {
 }
 
 void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                                 gfx::Rect rect,
-                                 gfx::Rect opaque_rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& opaque_rect,
+                                 const gfx::Rect& visible_rect,
                                  unsigned resource_id,
                                  const gfx::Transform& matrix) {
-  gfx::Rect visible_rect = rect;
   bool needs_blending = false;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
                    opaque_rect, visible_rect, needs_blending);
@@ -30,9 +30,9 @@ void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                                 gfx::Rect rect,
-                                 gfx::Rect opaque_rect,
-                                 gfx::Rect visible_rect,
+                                 const gfx::Rect& rect,
+                                 const gfx::Rect& opaque_rect,
+                                 const gfx::Rect& visible_rect,
                                  bool needs_blending,
                                  unsigned resource_id,
                                  const gfx::Transform& matrix) {
diff --git a/chromium/cc/quads/stream_video_draw_quad.h b/chromium/cc/quads/stream_video_draw_quad.h
index e610f4333ce..bc85325cc83 100644
--- a/chromium/cc/quads/stream_video_draw_quad.h
+++ b/chromium/cc/quads/stream_video_draw_quad.h
@@ -17,15 +17,16 @@ class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
   static scoped_ptr<StreamVideoDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               unsigned resource_id,
               const gfx::Transform& matrix);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               unsigned resource_id,
               const gfx::Transform& matrix);
diff --git a/chromium/cc/quads/surface_draw_quad.cc b/chromium/cc/quads/surface_draw_quad.cc
new file mode 100644
index 00000000000..8591261c2de
--- /dev/null
+++ b/chromium/cc/quads/surface_draw_quad.cc
@@ -0,0 +1,54 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cc/quads/surface_draw_quad.h"
+
+#include "base/logging.h"
+#include "base/values.h"
+
+namespace cc {
+
+SurfaceDrawQuad::SurfaceDrawQuad() {
+}
+
+scoped_ptr<SurfaceDrawQuad> SurfaceDrawQuad::Create() {
+  return make_scoped_ptr(new SurfaceDrawQuad);
+}
+
+void SurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& visible_rect,
+                             SurfaceId surface_id) {
+  gfx::Rect opaque_rect;
+  bool needs_blending = false;
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::SURFACE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->surface_id = surface_id;
+}
+
+void SurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect,
+                             bool needs_blending,
+                             SurfaceId surface_id) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::SURFACE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->surface_id = surface_id;
+}
+
+void SurfaceDrawQuad::IterateResources(
+    const ResourceIteratorCallback& callback) {}
+
+const SurfaceDrawQuad* SurfaceDrawQuad::MaterialCast(const DrawQuad* quad) {
+  DCHECK_EQ(quad->material, DrawQuad::SURFACE_CONTENT);
+  return static_cast<const SurfaceDrawQuad*>(quad);
+}
+
+void SurfaceDrawQuad::ExtendValue(base::DictionaryValue* value) const {
+  value->SetInteger("surface_id", surface_id.id);
+}
+
+
+}  // namespace cc
diff --git a/chromium/cc/quads/surface_draw_quad.h b/chromium/cc/quads/surface_draw_quad.h
new file mode 100644
index 00000000000..e182ea3c286
--- /dev/null
+++ b/chromium/cc/quads/surface_draw_quad.h
@@ -0,0 +1,45 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CC_QUADS_SURFACE_DRAW_QUAD_H_
+#define CC_QUADS_SURFACE_DRAW_QUAD_H_
+
+#include "base/memory/scoped_ptr.h"
+#include "cc/base/cc_export.h"
+#include "cc/quads/draw_quad.h"
+#include "cc/surfaces/surface_id.h"
+
+namespace cc {
+
+class CC_EXPORT SurfaceDrawQuad : public DrawQuad {
+ public:
+  static scoped_ptr<SurfaceDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              const gfx::Rect& rect,
+              const gfx::Rect& visible_rect,
+              SurfaceId surface_id);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
+              bool needs_blending,
+              SurfaceId surface_id);
+
+  SurfaceId surface_id;
+
+  virtual void IterateResources(const ResourceIteratorCallback& callback)
+      OVERRIDE;
+
+  static const SurfaceDrawQuad* MaterialCast(const DrawQuad* quad);
+
+ private:
+  SurfaceDrawQuad();
+  virtual void ExtendValue(base::DictionaryValue* value) const OVERRIDE;
+};
+
+}  // namespace cc
+
+#endif  // CC_QUADS_SURFACE_DRAW_QUAD_H_
diff --git a/chromium/cc/quads/texture_draw_quad.cc b/chromium/cc/quads/texture_draw_quad.cc
index 191dcc43e7f..fd57feb1ec8 100644
--- a/chromium/cc/quads/texture_draw_quad.cc
+++ b/chromium/cc/quads/texture_draw_quad.cc
@@ -27,14 +27,16 @@ scoped_ptr<TextureDrawQuad> TextureDrawQuad::Create() {
 }
 
 void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                             gfx::Rect rect, gfx::Rect opaque_rect,
-                             unsigned resource_id, bool premultiplied_alpha,
-                             gfx::PointF uv_top_left,
-                             gfx::PointF uv_bottom_right,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect,
+                             unsigned resource_id,
+                             bool premultiplied_alpha,
+                             const gfx::PointF& uv_top_left,
+                             const gfx::PointF& uv_bottom_right,
                              SkColor background_color,
                              const float vertex_opacity[4],
                              bool flipped) {
-  gfx::Rect visible_rect = rect;
   bool needs_blending = vertex_opacity[0] != 1.0f || vertex_opacity[1] != 1.0f
       || vertex_opacity[2] != 1.0f || vertex_opacity[3] != 1.0f;
   DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect,
@@ -52,11 +54,12 @@ void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
 }
 
 void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                             gfx::Rect rect, gfx::Rect opaque_rect,
-                             gfx::Rect visible_rect, bool needs_blending,
+                             const gfx::Rect& rect,
+                             const gfx::Rect& opaque_rect,
+                             const gfx::Rect& visible_rect, bool needs_blending,
                              unsigned resource_id, bool premultiplied_alpha,
-                             gfx::PointF uv_top_left,
-                             gfx::PointF uv_bottom_right,
+                             const gfx::PointF& uv_top_left,
+                             const gfx::PointF& uv_bottom_right,
                              SkColor background_color,
                              const float vertex_opacity[4],
                              bool flipped) {
@@ -90,7 +93,7 @@ void TextureDrawQuad::ExtendValue(base::DictionaryValue* value) const {
   value->Set("uv_top_left", MathUtil::AsValue(uv_top_left).release());
   value->Set("uv_bottom_right", MathUtil::AsValue(uv_bottom_right).release());
   value->SetInteger("background_color", background_color);
-  scoped_ptr<ListValue> vertex_opacity_value(new ListValue);
+  scoped_ptr<base::ListValue> vertex_opacity_value(new base::ListValue);
   for (size_t i = 0; i < 4; ++i)
     vertex_opacity_value->AppendDouble(vertex_opacity[i]);
   value->Set("vertex_opacity", vertex_opacity_value.release());
diff --git a/chromium/cc/quads/texture_draw_quad.h b/chromium/cc/quads/texture_draw_quad.h
index 4aa4d7a1642..7fba63493b3 100644
--- a/chromium/cc/quads/texture_draw_quad.h
+++ b/chromium/cc/quads/texture_draw_quad.h
@@ -17,25 +17,26 @@ class CC_EXPORT TextureDrawQuad : public DrawQuad {
   static scoped_ptr<TextureDrawQuad> Create();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               unsigned resource_id,
               bool premultiplied_alpha,
-              gfx::PointF uv_top_left,
-              gfx::PointF uv_bottom_right,
+              const gfx::PointF& uv_top_left,
+              const gfx::PointF& uv_bottom_right,
               SkColor background_color,
               const float vertex_opacity[4],
               bool flipped);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               unsigned resource_id,
               bool premultiplied_alpha,
-              gfx::PointF uv_top_left,
-              gfx::PointF uv_bottom_right,
+              const gfx::PointF& uv_top_left,
+              const gfx::PointF& uv_bottom_right,
               SkColor background_color,
               const float vertex_opacity[4],
               bool flipped);
diff --git a/chromium/cc/quads/tile_draw_quad.cc b/chromium/cc/quads/tile_draw_quad.cc
index 3ff98095e9f..6e286077ffb 100644
--- a/chromium/cc/quads/tile_draw_quad.cc
+++ b/chromium/cc/quads/tile_draw_quad.cc
@@ -22,26 +22,32 @@ scoped_ptr<TileDrawQuad> TileDrawQuad::Create() {
 }
 
 void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                          gfx::Rect rect,
-                          gfx::Rect opaque_rect,
+                          const gfx::Rect& rect,
+                          const gfx::Rect& opaque_rect,
+                          const gfx::Rect& visible_rect,
                           unsigned resource_id,
                           const gfx::RectF& tex_coord_rect,
-                          gfx::Size texture_size,
+                          const gfx::Size& texture_size,
                           bool swizzle_contents) {
-  ContentDrawQuadBase::SetNew(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
-                              opaque_rect, tex_coord_rect, texture_size,
+  ContentDrawQuadBase::SetNew(shared_quad_state,
+                              DrawQuad::TILED_CONTENT,
+                              rect,
+                              opaque_rect,
+                              visible_rect,
+                              tex_coord_rect,
+                              texture_size,
                               swizzle_contents);
   this->resource_id = resource_id;
 }
 
 void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
-                          gfx::Rect rect,
-                          gfx::Rect opaque_rect,
-                          gfx::Rect visible_rect,
+                          const gfx::Rect& rect,
+                          const gfx::Rect& opaque_rect,
+                          const gfx::Rect& visible_rect,
                           bool needs_blending,
                           unsigned resource_id,
                           const gfx::RectF& tex_coord_rect,
-                          gfx::Size texture_size,
+                          const gfx::Size& texture_size,
                           bool swizzle_contents) {
   ContentDrawQuadBase::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
                               opaque_rect, visible_rect, needs_blending,
diff --git a/chromium/cc/quads/tile_draw_quad.h b/chromium/cc/quads/tile_draw_quad.h
index 6da1e54a952..71911ead67e 100644
--- a/chromium/cc/quads/tile_draw_quad.h
+++ b/chromium/cc/quads/tile_draw_quad.h
@@ -15,21 +15,22 @@ class CC_EXPORT TileDrawQuad : public ContentDrawQuadBase {
   virtual ~TileDrawQuad();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               unsigned resource_id,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               bool swizzle_contents);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
               unsigned resource_id,
               const gfx::RectF& tex_coord_rect,
-              gfx::Size texture_size,
+              const gfx::Size& texture_size,
               bool swizzle_contents);
 
   unsigned resource_id;
diff --git a/chromium/cc/quads/yuv_video_draw_quad.cc b/chromium/cc/quads/yuv_video_draw_quad.cc
index ecdc78fdcb3..bb8ec739060 100644
--- a/chromium/cc/quads/yuv_video_draw_quad.cc
+++ b/chromium/cc/quads/yuv_video_draw_quad.cc
@@ -22,41 +22,45 @@ scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::Create() {
 }
 
 void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
-                              gfx::Rect rect,
-                              gfx::Rect opaque_rect,
-                              gfx::SizeF tex_scale,
+                              const gfx::Rect& rect,
+                              const gfx::Rect& opaque_rect,
+                              const gfx::Rect& visible_rect,
+                              const 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) {
-  gfx::Rect visible_rect = rect;
+                              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);
-  this->tex_scale = tex_scale;
+  this->tex_coord_rect = tex_coord_rect;
   this->y_plane_resource_id = y_plane_resource_id;
   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,
-                              gfx::Rect rect,
-                              gfx::Rect opaque_rect,
-                              gfx::Rect visible_rect,
+                              const gfx::Rect& rect,
+                              const gfx::Rect& opaque_rect,
+                              const gfx::Rect& visible_rect,
                               bool needs_blending,
-                              gfx::SizeF tex_scale,
+                              const 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) {
+                              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_scale = tex_scale;
+  this->tex_coord_rect = tex_coord_rect;
   this->y_plane_resource_id = y_plane_resource_id;
   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(
@@ -75,7 +79,7 @@ const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
 }
 
 void YUVVideoDrawQuad::ExtendValue(base::DictionaryValue* value) const {
-  value->Set("tex_scale", MathUtil::AsValue(tex_scale).release());
+  value->Set("tex_coord_rect", MathUtil::AsValue(tex_coord_rect).release());
   value->SetInteger("y_plane_resource_id", y_plane_resource_id);
   value->SetInteger("u_plane_resource_id", u_plane_resource_id);
   value->SetInteger("v_plane_resource_id", v_plane_resource_id);
diff --git a/chromium/cc/quads/yuv_video_draw_quad.h b/chromium/cc/quads/yuv_video_draw_quad.h
index aa750fa8ba9..c95681ffa56 100644
--- a/chromium/cc/quads/yuv_video_draw_quad.h
+++ b/chromium/cc/quads/yuv_video_draw_quad.h
@@ -15,35 +15,45 @@ 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();
 
   void SetNew(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::SizeF tex_scale,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
+              const 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);
+              unsigned a_plane_resource_id,
+              ColorSpace color_space);
 
   void SetAll(const SharedQuadState* shared_quad_state,
-              gfx::Rect rect,
-              gfx::Rect opaque_rect,
-              gfx::Rect visible_rect,
+              const gfx::Rect& rect,
+              const gfx::Rect& opaque_rect,
+              const gfx::Rect& visible_rect,
               bool needs_blending,
-              gfx::SizeF tex_scale,
+              const 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);
+              unsigned a_plane_resource_id,
+              ColorSpace color_space);
 
-  gfx::SizeF tex_scale;
+  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;