cc: Turn SharedQuadState into a struct-like class similar to DrawQuads.

SharedQuadState was a struct previously, but required all the data to be passed
to its create() method. This makes the Create() method take no parameters, as
DrawQuads work now. And we add a SetAll() method, similar again to DrawQuad.

We remove the "id" value from ShardQuadState. This shouldn't be needed for
serialization. We can instead just use the pointers in the quads as an id
directly, and compare them against each other to see when we need to create a
new shared quad state. This is sufficient since all quads that share an
instance of SharedQuadState are appended to be adjacent in the quad list.

Covered by existing tests.

TBR=aelias
BUG=152337
Depends on: https://codereview.chromium.org/11411050

Review URL: https://chromiumcodereview.appspot.com/11416088

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

cc/delegated_renderer_layer_impl.cc

@@ -144,7 +144,7 @@ void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, Appen
 
         if (quad->shared_quad_state != currentSharedQuadState) {
             currentSharedQuadState = quad->shared_quad_state;
-            copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->copy());
+            copiedSharedQuadState = quadSink.useSharedQuadState(currentSharedQuadState->Copy());
             bool targetIsFromDelegatedRendererLayer = appendQuadsData.renderPassId.layerId == id();
             if (!targetIsFromDelegatedRendererLayer) {
               // Should be the root render pass.
@@ -152,8 +152,8 @@ void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, Appen
               // This layer must be drawing to a renderTarget other than itself.
               DCHECK(renderTarget() != this);
 
-              copiedSharedQuadState->clippedRectInTarget = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clippedRectInTarget);
-              copiedSharedQuadState->quadTransform = copiedSharedQuadState->quadTransform * drawTransform();
+              copiedSharedQuadState->content_to_target_transform = copiedSharedQuadState->content_to_target_transform * drawTransform();
+              copiedSharedQuadState->clipped_rect_in_target = MathUtil::mapClippedRect(drawTransform(), copiedSharedQuadState->clipped_rect_in_target);
               copiedSharedQuadState->opacity *= drawOpacity();
             }
         }

cc/delegated_renderer_layer_impl_unittest.cc

@@ -78,7 +78,8 @@ static SolidColorDrawQuad* addQuad(TestRenderPass* pass, gfx::Rect rect, SkColor
 {
     MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
     AppendQuadsData data(pass->id());
-    SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1));
+    SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
+    sharedState->SetAll(WebTransformationMatrix(), rect, rect, 1);
     scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
     quad->SetNew(sharedState, rect, color);
     SolidColorDrawQuad* quadPtr = quad.get();
@@ -91,7 +92,8 @@ static void addRenderPassQuad(TestRenderPass* toPass, TestRenderPass* contributi
     MockQuadCuller quadSink(toPass->quadList(), toPass->sharedQuadStateList());
     AppendQuadsData data(toPass->id());
     gfx::Rect outputRect = contributingPass->outputRect();
-    SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), outputRect, outputRect, 1));
+    SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
+    sharedState->SetAll(WebTransformationMatrix(), outputRect, outputRect, 1);
     scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
     quad->SetNew(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0);
     quadSink.append(quad.PassAs<DrawQuad>(), data);
@@ -404,7 +406,8 @@ public:
         TestRenderPass* pass = addRenderPass(delegatedRenderPasses, RenderPass::Id(9, 6), passRect, WebTransformationMatrix());
         MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
         AppendQuadsData data(pass->id());
-        SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), passRect, passRect, 1));
+        SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::Create());
+        sharedState->SetAll(WebTransformationMatrix(), passRect, passRect, 1);
         scoped_ptr<SolidColorDrawQuad> colorQuad;
 
         colorQuad = SolidColorDrawQuad::Create();
@@ -462,10 +465,10 @@ TEST_F(DelegatedRendererLayerImplTestSharedData, SharedData)
     EXPECT_EQ(sharedState, quadList[3]->shared_quad_state);
 
     // The state should be transformed only once.
-    EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clippedRectInTarget);
+    EXPECT_RECT_EQ(gfx::Rect(30, 30, 50, 50), sharedState->clipped_rect_in_target);
     WebTransformationMatrix expected;
     expected.translate(30, 30);
-    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->quadTransform);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(expected, sharedState->content_to_target_transform);
 }
 
 }  // namespace

cc/draw_quad.h

@@ -35,9 +35,9 @@ class CC_EXPORT DrawQuad {
       const SharedQuadState* copied_shared_quad_state) const;
 
   // TODO(danakj): Chromify or remove these SharedQuadState helpers.
-  const WebKit::WebTransformationMatrix& quadTransform() const { return shared_quad_state->quadTransform; }
-  gfx::Rect visibleContentRect() const { return shared_quad_state->visibleContentRect; }
-  gfx::Rect clippedRectInTarget() const { return shared_quad_state->clippedRectInTarget; }
+  const WebKit::WebTransformationMatrix& quadTransform() const { return shared_quad_state->content_to_target_transform; }
+  gfx::Rect visibleContentRect() const { return shared_quad_state->visible_content_rect; }
+  gfx::Rect clippedRectInTarget() const { return shared_quad_state->clipped_rect_in_target; }
   float opacity() const { return shared_quad_state->opacity; }
 
   Material material;

cc/draw_quad_unittest.cc

@@ -28,16 +28,14 @@ TEST(DrawQuadTest, copySharedQuadState)
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 0.25;
-    int id = 3;
 
-    scoped_ptr<SharedQuadState> state(SharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity));
-    state->id = id;
+    scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
+    state->SetAll(quadTransform, visibleContentRect, clippedRectInTarget, opacity);
 
-    scoped_ptr<SharedQuadState> copy(state->copy());
-    EXPECT_EQ(id, copy->id);
-    EXPECT_EQ(quadTransform, copy->quadTransform);
-    EXPECT_RECT_EQ(visibleContentRect, copy->visibleContentRect);
-    EXPECT_RECT_EQ(clippedRectInTarget, copy->clippedRectInTarget);
+    scoped_ptr<SharedQuadState> copy(state->Copy());
+    EXPECT_EQ(quadTransform, copy->content_to_target_transform);
+    EXPECT_RECT_EQ(visibleContentRect, copy->visible_content_rect);
+    EXPECT_RECT_EQ(clippedRectInTarget, copy->clipped_rect_in_target);
     EXPECT_EQ(opacity, copy->opacity);
 }
 
@@ -47,10 +45,9 @@ scoped_ptr<SharedQuadState> createSharedQuadState()
     gfx::Rect visibleContentRect(10, 12, 14, 16);
     gfx::Rect clippedRectInTarget(19, 21, 23, 25);
     float opacity = 1;
-    int id = 3;
 
-    scoped_ptr<SharedQuadState> state(SharedQuadState::create(quadTransform, visibleContentRect, clippedRectInTarget, opacity));
-    state->id = id;
+    scoped_ptr<SharedQuadState> state(SharedQuadState::Create());
+    state->SetAll(quadTransform, visibleContentRect, clippedRectInTarget, opacity);
     return state.Pass();
 }
 
@@ -66,8 +63,7 @@ void compareDrawQuad(DrawQuad* quad, DrawQuad* copy, SharedQuadState* copyShared
 
 #define CREATE_SHARED_STATE() \
     scoped_ptr<SharedQuadState> sharedState(createSharedQuadState()); \
-    scoped_ptr<SharedQuadState> copySharedState(sharedState->copy()); \
-    copySharedState->id = 5;
+    scoped_ptr<SharedQuadState> copySharedState(sharedState->Copy()); \
 
 #define QUAD_DATA \
     gfx::Rect quadRect(30, 40, 50, 60); \

cc/layer_impl.cc

@@ -124,7 +124,9 @@ bool LayerImpl::descendantDrawsContent()
 
 scoped_ptr<SharedQuadState> LayerImpl::createSharedQuadState() const
 {
-    return SharedQuadState::create(m_drawTransform, m_visibleContentRect, m_drawableContentRect, m_drawOpacity);
+  scoped_ptr<SharedQuadState> state = SharedQuadState::Create();
+  state->SetAll(m_drawTransform, m_visibleContentRect, m_drawableContentRect, m_drawOpacity);
+  return state.Pass();
 }
 
 void LayerImpl::willDraw(ResourceProvider*)

cc/layer_tree_host_impl.cc

@@ -466,10 +466,8 @@ bool LayerTreeHostImpl::calculateRenderPasses(FrameData& frame)
 
 #ifndef NDEBUG
     for (size_t i = 0; i < frame.renderPasses.size(); ++i) {
-        for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j) {
+        for (size_t j = 0; j < frame.renderPasses[i]->quadList().size(); ++j)
             DCHECK(frame.renderPasses[i]->quadList()[j]->shared_quad_state);
-            DCHECK_GE(frame.renderPasses[i]->quadList()[j]->shared_quad_state->id, 0);
-        }
         DCHECK(frame.renderPassesById.contains(frame.renderPasses[i]->id()));
     }
 #endif

cc/layer_tree_host_impl_unittest.cc

@@ -2715,7 +2715,8 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid
     ResourceProvider::ResourceId resourceId = provider->createResource(0, gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), WebTransformationMatrix());
-    scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1);
+    scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
+    sharedState->SetAll(WebTransformationMatrix(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), 1);
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
 
@@ -4189,7 +4190,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
     renderer->clearCachedTextures();
 
     // One shared state for all quads - we don't need the correct details
-    testData.sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1.0);
+    testData.sharedQuadState = SharedQuadState::Create();
+    testData.sharedQuadState->SetAll(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1.0);
 
     const char* currentChar = testScript;
 

cc/quad_culler.cc

@@ -31,8 +31,6 @@ QuadCuller::QuadCuller(QuadList& quadList, SharedQuadStateList& sharedQuadStateL
 
 SharedQuadState* QuadCuller::useSharedQuadState(scoped_ptr<SharedQuadState> sharedQuadState)
 {
-    sharedQuadState->id = m_sharedQuadStateList.size();
-
     // FIXME: If all quads are culled for the sharedQuadState, we can drop it from the list.
     m_currentSharedQuadState = sharedQuadState.get();
     m_sharedQuadStateList.append(sharedQuadState.Pass());

cc/quad_sink.h

@@ -11,9 +11,9 @@
 namespace cc {
 
 class DrawQuad;
+class SharedQuadState;
 
 struct AppendQuadsData;
-struct SharedQuadState;
 
 class CC_EXPORT QuadSink {
 public:

cc/render_pass.cc

@@ -90,10 +90,14 @@ void RenderPass::appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBac
     // Manually create the quad state for the gutter quads, as the root layer
     // doesn't have any bounds and so can't generate this itself.
     // FIXME: Make the gutter quads generated by the solid color layer (make it smarter about generating quads to fill unoccluded areas).
+
+    DCHECK(rootLayer->screenSpaceTransform().isInvertible());
+
     gfx::Rect rootTargetRect = rootLayer->renderSurface()->contentRect();
     float opacity = 1;
-    SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::create(rootLayer->drawTransform(), rootTargetRect, rootTargetRect, opacity));
-    DCHECK(rootLayer->screenSpaceTransform().isInvertible());
+    SharedQuadState* sharedQuadState = quadCuller.useSharedQuadState(SharedQuadState::Create());
+    sharedQuadState->SetAll(rootLayer->drawTransform(), rootTargetRect, rootTargetRect, opacity);
+
     WebTransformationMatrix transformToLayerSpace = rootLayer->screenSpaceTransform().inverse();
     for (Region::Iterator fillRects(fillRegion); fillRects.has_rect(); fillRects.next()) {
         // The root layer transform is composed of translations and scales only, no perspective, so mapping is sufficient.

cc/render_pass_unittest.cc

@@ -61,7 +61,9 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
     pass->setFilter(filter);
 
     // Stick a quad in the pass, this should not get copied.
-    pass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1));
+    scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
+    sharedState->SetAll(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1);
+    pass->sharedQuadStateList().append(sharedState.Pass());
 
     scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
     checkerboardQuad->SetNew(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor());

cc/render_surface_impl.cc

@@ -198,7 +198,8 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
 
     gfx::Rect clippedRectInTarget = computeClippedRectInTarget(m_owningLayer);
     const WebTransformationMatrix& drawTransform = forReplica ? m_replicaDrawTransform : m_drawTransform;
-    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(SharedQuadState::create(drawTransform, m_contentRect, clippedRectInTarget, m_drawOpacity).Pass());
+    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(SharedQuadState::Create());
+    sharedQuadState->SetAll(drawTransform, m_contentRect, clippedRectInTarget, m_drawOpacity);
 
     if (m_owningLayer->showDebugBorders()) {
         SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor();

cc/render_surface_unittest.cc

@@ -103,9 +103,9 @@ TEST(RenderSurfaceTest, sanityCheckSurfaceCreatesCorrectSharedQuadState)
     ASSERT_EQ(1u, sharedStateList.size());
     SharedQuadState* sharedQuadState = sharedStateList[0];
 
-    EXPECT_EQ(30, sharedQuadState->quadTransform.m41());
-    EXPECT_EQ(40, sharedQuadState->quadTransform.m42());
-    EXPECT_RECT_EQ(contentRect, gfx::Rect(sharedQuadState->visibleContentRect));
+    EXPECT_EQ(30, sharedQuadState->content_to_target_transform.m41());
+    EXPECT_EQ(40, sharedQuadState->content_to_target_transform.m42());
+    EXPECT_RECT_EQ(contentRect, gfx::Rect(sharedQuadState->visible_content_rect));
     EXPECT_EQ(1, sharedQuadState->opacity);
 }
 

cc/shared_quad_state.cc

@@ -6,25 +6,25 @@
 
 namespace cc {
 
-scoped_ptr<SharedQuadState> SharedQuadState::create(const WebKit::WebTransformationMatrix& quadTransform, const gfx::Rect& visibleContentRect, const gfx::Rect& clippedRectInTarget, float opacity)
-{
-    return make_scoped_ptr(new SharedQuadState(quadTransform, visibleContentRect, clippedRectInTarget, opacity));
+SharedQuadState::SharedQuadState() : opacity(0) {}
+
+scoped_ptr<SharedQuadState> SharedQuadState::Create() {
+  return make_scoped_ptr(new SharedQuadState);
 }
 
-SharedQuadState::SharedQuadState(const WebKit::WebTransformationMatrix& quadTransform, const gfx::Rect& visibleContentRect, const gfx::Rect& clippedRectInTarget, float opacity)
-    : id(-1)
-    , quadTransform(quadTransform)
-    , visibleContentRect(visibleContentRect)
-    , clippedRectInTarget(clippedRectInTarget)
-    , opacity(opacity)
-{
+scoped_ptr<SharedQuadState> SharedQuadState::Copy() const {
+  return make_scoped_ptr(new SharedQuadState(*this));
 }
 
-scoped_ptr<SharedQuadState> SharedQuadState::copy() const
-{
-    scoped_ptr<SharedQuadState> copiedState(create(quadTransform, visibleContentRect, clippedRectInTarget, opacity));
-    copiedState->id = id;
-    return copiedState.Pass();
+void SharedQuadState::SetAll(
+    const WebKit::WebTransformationMatrix& content_to_target_transform,
+    const gfx::Rect& visible_content_rect,
+    const gfx::Rect& clipped_rect_in_target,
+    float opacity) {
+  this->content_to_target_transform = content_to_target_transform;
+  this->visible_content_rect = visible_content_rect;
+  this->clipped_rect_in_target = clipped_rect_in_target;
+  this->opacity = opacity;
 }
 
 }  // namespace cc

cc/shared_quad_state.h

@@ -12,20 +12,26 @@
 
 namespace cc {
 
-struct CC_EXPORT SharedQuadState {
-    int id;
+class CC_EXPORT SharedQuadState {
+ public:
+  static scoped_ptr<SharedQuadState> Create();
 
-    // Transforms from quad's original content space to its target content space.
-    WebKit::WebTransformationMatrix quadTransform;
-    // This rect lives in the content space for the quad's originating layer.
-    gfx::Rect visibleContentRect;
-    gfx::Rect clippedRectInTarget;
-    float opacity;
+  scoped_ptr<SharedQuadState> Copy() const;
 
-    static scoped_ptr<SharedQuadState> create(const WebKit::WebTransformationMatrix& quadTransform, const gfx::Rect& visibleContentRect, const gfx::Rect& clippedRectInTarget, float opacity);
-    SharedQuadState(const WebKit::WebTransformationMatrix& quadTransform, const gfx::Rect& visibleContentRect, const gfx::Rect& clippedRectInTarget, float opacity);
+  void SetAll(const WebKit::WebTransformationMatrix& content_to_target_transform,
+              const gfx::Rect& visible_content_rect,
+              const gfx::Rect& clipped_rect_in_target,
+              float opacity);
 
-    scoped_ptr<SharedQuadState> copy() const;
+  // Transforms from quad's original content space to its target content space.
+  WebKit::WebTransformationMatrix content_to_target_transform;
+  // This rect lives in the content space for the quad's originating layer.
+  gfx::Rect visible_content_rect;
+  gfx::Rect clipped_rect_in_target;
+  float opacity;
+
+ private:
+  SharedQuadState();
 };
 
 }

cc/software_renderer_unittest.cc

@@ -66,7 +66,8 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
 
     initializeRenderer();
 
-    scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
+    scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
+    sharedQuadState->SetAll(WebTransformationMatrix(), outerRect, outerRect, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
     scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
@@ -125,7 +126,8 @@ TEST_F(SoftwareRendererTest, tileQuad)
 
     gfx::Rect rect = gfx::Rect(gfx::Point(), deviceViewportSize());
 
-    scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
+    scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
+    sharedQuadState->SetAll(WebTransformationMatrix(), outerRect, outerRect, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), WebTransformationMatrix());
     scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();

cc/test/layer_test_common.cc

@@ -38,7 +38,7 @@ void verifyQuadsExactlyCoverRect(const cc::QuadList& quads,
 
     for (size_t i = 0; i < quads.size(); ++i) {
         cc::DrawQuad* quad = quads[i];
-        gfx::RectF quadRectF = cc::MathUtil::mapClippedRect(quad->shared_quad_state->quadTransform, gfx::RectF(quad->rect));
+        gfx::RectF quadRectF = cc::MathUtil::mapClippedRect(quad->quadTransform(), gfx::RectF(quad->rect));
 
         // Before testing for exact coverage in the integer world, assert that rounding
         // will not round the rect incorrectly.

cc/test/mock_quad_culler.cc

@@ -33,8 +33,6 @@ bool MockQuadCuller::append(scoped_ptr<DrawQuad> drawQuad, AppendQuadsData&)
 
 SharedQuadState* MockQuadCuller::useSharedQuadState(scoped_ptr<SharedQuadState> sharedQuadState)
 {
-    sharedQuadState->id = m_activeSharedQuadStateList.size();
-
     SharedQuadState* rawPtr = sharedQuadState.get();
     m_activeSharedQuadStateList.append(sharedQuadState.Pass());
     return rawPtr;

cc/test/render_pass_test_common.cc

@@ -27,7 +27,8 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
     gfx::Rect rect(0, 0, 100, 100);
     gfx::Rect opaqueRect(10, 10, 80, 80);
     cc::ResourceProvider::ResourceId textureResource = resourceProvider->createResourceFromExternalTexture(1);
-    scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1);
+    scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::Create();
+    sharedState->SetAll(WebTransformationMatrix(), rect, rect, 1);
 
     scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create();
     checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED);