Create SharedQuadState on RenderPass

Instead of creating SharedQuadState on layers and pass ownership around,
create SharedQuadState on RenderPass and only pass the raw pointer to
layers. Also let QuadCuller hold pointer to RenderPass instead of two
points to DrawQuadList and SharedQuadStateList that is owned by
RenderPass.

BUG=344962
TEST=cc_unittests

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

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

20 files changed, 75 insertions, 79 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 4556db6..f59e1f2 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -319,8 +319,8 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
   if (!ShowDebugBorders())
     return;
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
 
   SkColor color;
   float border_width;
@@ -407,8 +407,8 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
 
     if (delegated_quad->shared_quad_state != delegated_shared_quad_state) {
       delegated_shared_quad_state = delegated_quad->shared_quad_state;
-      output_shared_quad_state = quad_sink->UseSharedQuadState(
-          delegated_shared_quad_state->Copy());
+      output_shared_quad_state = quad_sink->CreateSharedQuadState();
+      output_shared_quad_state->CopyFrom(delegated_shared_quad_state);
 
       bool is_root_delegated_render_pass =
           delegated_render_pass == render_passes_in_draw_order_.back();
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 7578e22..bf4b088 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -541,9 +541,8 @@ class DelegatedRendererLayerImplTestTransform
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
-      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
-      SharedQuadState* shared_quad_state = quad_sink.UseSharedQuadState(
-          SharedQuadState::Create());
+      MockQuadCuller quad_sink(pass);
+      SharedQuadState* shared_quad_state = quad_sink.CreateSharedQuadState();
       shared_quad_state->SetAll(child_pass_transform,
                                 child_pass_content_bounds,
                                 child_pass_rect,
@@ -583,9 +582,8 @@ class DelegatedRendererLayerImplTestTransform
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
-    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
-    SharedQuadState* shared_quad_state =
-        quad_sink.UseSharedQuadState(SharedQuadState::Create());
+    MockQuadCuller quad_sink(pass);
+    SharedQuadState* shared_quad_state = quad_sink.CreateSharedQuadState();
     shared_quad_state->SetAll(root_pass_transform,
                               root_pass_content_bounds,
                               root_pass_rect,
@@ -972,9 +970,8 @@ class DelegatedRendererLayerImplTestClip
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
-      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
-      SharedQuadState* shared_quad_state =
-          quad_sink.UseSharedQuadState(SharedQuadState::Create());
+      MockQuadCuller quad_sink(pass);
+      SharedQuadState* shared_quad_state = quad_sink.CreateSharedQuadState();
       shared_quad_state->SetAll(child_pass_transform,
                                 child_pass_content_bounds,
                                 child_pass_rect,
@@ -1012,9 +1009,8 @@ class DelegatedRendererLayerImplTestClip
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
-    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
-    SharedQuadState* shared_quad_state =
-        quad_sink.UseSharedQuadState(SharedQuadState::Create());
+    MockQuadCuller quad_sink(pass);
+    SharedQuadState* shared_quad_state = quad_sink.CreateSharedQuadState();
     shared_quad_state->SetAll(root_pass_transform,
                               root_pass_content_bounds,
                               root_pass_rect,
diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index 957ad9a..6149a06 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc
@@ -110,8 +110,8 @@ void HeadsUpDisplayLayerImpl::AppendQuads(QuadSink* quad_sink,
   if (!hud_resource_->id())
     return;
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
 
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 4176c26..6d94c91 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -66,8 +66,9 @@ bool IOSurfaceLayerImpl::WillDraw(DrawMode draw_mode,
 
 void IOSurfaceLayerImpl::AppendQuads(QuadSink* quad_sink,
                                      AppendQuadsData* append_quads_data) {
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect quad_rect(content_bounds());
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 855f43d..fd5ea31 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -243,8 +243,7 @@ void LayerImpl::ClearRenderSurfaceLayerList() {
     draw_properties_.render_surface->layer_list().clear();
 }
 
-scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
-  scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
+void LayerImpl::PopulateSharedQuadState(SharedQuadState* state) const {
   state->SetAll(draw_properties_.target_space_transform,
                 draw_properties_.content_bounds,
                 draw_properties_.visible_content_rect,
@@ -252,7 +251,6 @@ scoped_ptr<SharedQuadState> LayerImpl::CreateSharedQuadState() const {
                 draw_properties_.is_clipped,
                 draw_properties_.opacity,
                 blend_mode_);
-  return state.Pass();
 }
 
 bool LayerImpl::WillDraw(DrawMode draw_mode,
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index e712b7e..e84c669 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -158,7 +158,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
 
   LayerTreeImpl* layer_tree_impl() const { return layer_tree_impl_; }
 
-  scoped_ptr<SharedQuadState> CreateSharedQuadState() const;
+  void PopulateSharedQuadState(SharedQuadState* state) const;
   // WillDraw must be called before AppendQuads. If WillDraw returns false,
   // AppendQuads and DidDraw will not be called. If WillDraw returns true,
   // DidDraw is guaranteed to be called before another WillDraw or before
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index 95c286f..990310b 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -96,8 +96,9 @@ void NinePatchLayerImpl::CheckGeometryLimitations() {
 void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
                                      AppendQuadsData* append_quads_data) {
   CheckGeometryLimitations();
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   if (!ui_resource_id_)
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index e4677f7..ac6ce4a 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -78,8 +78,9 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   gfx::Rect bounds_rect(bounds());
   gfx::Rect content_bounds_rect(content_bounds());
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect thumb_quad_rect = ComputeThumbQuadRect();
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 36e754f..1d71e07 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -138,8 +138,8 @@ void PictureLayerImpl::AppendQuads(QuadSink* quad_sink,
   gfx::Rect rect(visible_content_rect());
   gfx::Rect content_rect(content_bounds());
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
 
   if (current_draw_mode_ == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     AppendDebugBorderQuad(
diff --git a/cc/layers/quad_sink.h b/cc/layers/quad_sink.h
index 7312781..0b503e4 100644
--- a/cc/layers/quad_sink.h
+++ b/cc/layers/quad_sink.h
@@ -24,10 +24,9 @@ class CC_EXPORT QuadSink {
   virtual ~QuadSink() {}
 
   // Call this to add a SharedQuadState before appending quads that refer to it.
-  // Returns a pointer to the given SharedQuadState for convenience, that can be
-  // set on the quads to append.
-  virtual SharedQuadState* UseSharedQuadState(
-      scoped_ptr<SharedQuadState> shared_quad_state) = 0;
+  // Returns a pointer to the given SharedQuadState, that can be set on the
+  // quads to append.
+  virtual SharedQuadState* CreateSharedQuadState() = 0;
 
   virtual gfx::Rect UnoccludedContentRect(
       const gfx::Rect& content_rect,
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index fa7dcb8..3bce76f 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -150,8 +150,7 @@ void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
   if (visible_content_rect.IsEmpty())
     return;
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(SharedQuadState::Create());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
   shared_quad_state->SetAll(draw_transform,
                             content_rect_.size(),
                             content_rect_,
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index 7056b1d0..47ce276 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -107,17 +107,16 @@ TEST(RenderSurfaceTest, SanityCheckSurfaceCreatesCorrectSharedQuadState) {
   render_surface->SetClipRect(clip_rect);
   render_surface->SetDrawOpacity(1.f);
 
-  QuadList quad_list;
-  SharedQuadStateList shared_state_list;
-  MockQuadCuller mock_quad_culler(&quad_list, &shared_state_list);
+  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  MockQuadCuller mock_quad_culler(render_pass.get());
   AppendQuadsData append_quads_data;
 
   bool for_replica = false;
   render_surface->AppendQuads(
       &mock_quad_culler, &append_quads_data, for_replica, RenderPass::Id(2, 0));
 
-  ASSERT_EQ(1u, shared_state_list.size());
-  SharedQuadState* shared_quad_state = shared_state_list[0];
+  ASSERT_EQ(1u, render_pass->shared_quad_state_list.size());
+  SharedQuadState* shared_quad_state = render_pass->shared_quad_state_list[0];
 
   EXPECT_EQ(
       30.0,
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 2708af9..e60edd1 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -24,8 +24,9 @@ scoped_ptr<LayerImpl> SolidColorLayerImpl::CreateLayerImpl(
 
 void SolidColorLayerImpl::AppendQuads(QuadSink* quad_sink,
                                       AppendQuadsData* append_quads_data) {
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   // We create a series of smaller quads instead of just one large one so that
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.cc b/cc/layers/solid_color_scrollbar_layer_impl.cc
index f579ea6..24c54e4 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -94,8 +94,9 @@ bool SolidColorScrollbarLayerImpl::IsThumbResizable() const {
 
 void SolidColorScrollbarLayerImpl::AppendQuads(QuadSink* quad_sink,
                            AppendQuadsData* append_quads_data) {
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect thumb_quad_rect(ComputeThumbQuadRect());
diff --git a/cc/layers/surface_layer_impl.cc b/cc/layers/surface_layer_impl.cc
index 2f98805..3bfae2d 100644
--- a/cc/layers/surface_layer_impl.cc
+++ b/cc/layers/surface_layer_impl.cc
@@ -37,8 +37,9 @@ void SurfaceLayerImpl::PushPropertiesTo(LayerImpl* layer) {
 
 void SurfaceLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   if (!surface_id_)
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 9cd94a3..5e65d72 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -143,8 +143,9 @@ void TextureLayerImpl::AppendQuads(QuadSink* quad_sink,
                                    AppendQuadsData* append_quads_data) {
   DCHECK(external_texture_resource_ || valid_texture_copy_);
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   SkColor bg_color = blend_background_color_ ?
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index cc95a04..a510883 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -158,8 +158,9 @@ void TiledLayerImpl::AppendQuads(QuadSink* quad_sink,
   DCHECK(!visible_content_rect().IsEmpty());
 
   gfx::Rect content_rect = visible_content_rect();
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   int left, top, right, bottom;
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index a92d024..2b18fff 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -67,8 +67,7 @@ class TiledLayerImplTest : public testing::Test {
     return layer.Pass();
   }
 
-  void GetQuads(QuadList* quads,
-                SharedQuadStateList* shared_states,
+  void GetQuads(RenderPass* render_pass,
                 const gfx::Size& tile_size,
                 const gfx::Size& layer_size,
                 LayerTilingData::BorderTexelOption border_texel_option,
@@ -78,7 +77,7 @@ class TiledLayerImplTest : public testing::Test {
     layer->draw_properties().visible_content_rect = visible_content_rect;
     layer->SetBounds(layer_size);
 
-    MockQuadCuller quad_culler(quads, shared_states);
+    MockQuadCuller quad_culler(render_pass);
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
   }
@@ -200,15 +199,14 @@ class TiledLayerImplBorderTest : public TiledLayerImplTest {
   void CoverageVisibleRectOnTileBoundaries(
       LayerTilingData::BorderTexelOption borders) {
     gfx::Size layer_size(1000, 1000);
-    QuadList quads;
-    SharedQuadStateList shared_states;
-    GetQuads(&quads,
-             &shared_states,
+    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+    GetQuads(render_pass.get(),
              gfx::Size(100, 100),
              layer_size,
              borders,
              gfx::Rect(layer_size));
-    LayerTestCommon::VerifyQuadsExactlyCoverRect(quads, gfx::Rect(layer_size));
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
+                                                 gfx::Rect(layer_size));
   }
 
   void CoverageVisibleRectIntersectsTiles(
@@ -219,30 +217,28 @@ class TiledLayerImplBorderTest : public TiledLayerImplTest {
     gfx::Rect visible_content_rect = gfx::BoundingRect(top_left, bottom_right);
 
     gfx::Size layer_size(250, 250);
-    QuadList quads;
-    SharedQuadStateList shared_states;
-    GetQuads(&quads,
-             &shared_states,
+    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+    GetQuads(render_pass.get(),
              gfx::Size(50, 50),
              gfx::Size(250, 250),
              LayerTilingData::NO_BORDER_TEXELS,
              visible_content_rect);
-    LayerTestCommon::VerifyQuadsExactlyCoverRect(quads, visible_content_rect);
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
+                                                 visible_content_rect);
   }
 
   void CoverageVisibleRectIntersectsBounds(
       LayerTilingData::BorderTexelOption borders) {
     gfx::Size layer_size(220, 210);
     gfx::Rect visible_content_rect(layer_size);
-    QuadList quads;
-    SharedQuadStateList shared_states;
-    GetQuads(&quads,
-             &shared_states,
+    scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+    GetQuads(render_pass.get(),
              gfx::Size(100, 100),
              layer_size,
              LayerTilingData::NO_BORDER_TEXELS,
              visible_content_rect);
-    LayerTestCommon::VerifyQuadsExactlyCoverRect(quads, visible_content_rect);
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(render_pass->quad_list,
+                                                 visible_content_rect);
   }
 };
 WITH_AND_WITHOUT_BORDER_TEST(CoverageVisibleRectOnTileBoundaries);
@@ -254,17 +250,16 @@ WITH_AND_WITHOUT_BORDER_TEST(CoverageVisibleRectIntersectsBounds);
 TEST_F(TiledLayerImplTest, TextureInfoForLayerNoBorders) {
   gfx::Size tile_size(50, 50);
   gfx::Size layer_size(250, 250);
-  QuadList quads;
-  SharedQuadStateList shared_states;
-  GetQuads(&quads,
-           &shared_states,
+  scoped_ptr<RenderPass> render_pass = RenderPass::Create();
+  GetQuads(render_pass.get(),
            tile_size,
            layer_size,
            LayerTilingData::NO_BORDER_TEXELS,
            gfx::Rect(layer_size));
 
-  for (size_t i = 0; i < quads.size(); ++i) {
-    const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]);
+  for (size_t i = 0; i < render_pass->quad_list.size(); ++i) {
+    const TileDrawQuad* quad =
+        TileDrawQuad::MaterialCast(render_pass->quad_list[i]);
 
     EXPECT_NE(0u, quad->resource_id) << LayerTestCommon::quad_string << i;
     EXPECT_EQ(gfx::RectF(gfx::PointF(), tile_size), quad->tex_coord_rect)
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 33392af..a5b563f 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -93,8 +93,9 @@ bool UIResourceLayerImpl::WillDraw(DrawMode draw_mode,
 
 void UIResourceLayerImpl::AppendQuads(QuadSink* quad_sink,
                                      AppendQuadsData* append_quads_data) {
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   if (!ui_resource_id_)
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index 2002116..dad3159 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -128,8 +128,9 @@ void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
                                  AppendQuadsData* append_quads_data) {
   DCHECK(frame_.get());
 
-  SharedQuadState* shared_quad_state =
-      quad_sink->UseSharedQuadState(CreateSharedQuadState());
+  SharedQuadState* shared_quad_state = quad_sink->CreateSharedQuadState();
+  PopulateSharedQuadState(shared_quad_state);
+
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect quad_rect(content_bounds());