cc: Make the DrawQuad subclasses into a struct-like classes.

I've replaced the create() and constructor on each class with a SetNew() method:

  void SetNew(const SharedQuadState* shared_quad_state,
              gfx::Rect rect,
              ...);

This method sets everything in the base class, based on the subclass'
interpretation of the minimal parameters given to it. This is used when
creating a new quad of this type - hence the name. The "..." represents
all the quad-type-specific arguments.

I've also added a new SetAll() method, that takes all of the data held by this
quad type, and simply passes on the appropriate things to the super class:

  void SetAll(const SharedQuadState* shared_quad_state,
              gfx::Rect rect,
              gfx::Rect opaque_rect,
              gfx::Rect visible_rect,
              bool needs_blending,
              ...);

This method is used for deserializing, or other cases where you have all the
data for the quad well defined, and want to set every field at once. The
"..." represents all the quad-type-specific arguments.

Added tests for SetAll() in cc_unittests:DrawQuadTest.*

TBR=aelias
BUG=152337

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

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

45 files changed, 1220 insertions, 646 deletions

diff --git a/cc/checkerboard_draw_quad.cc b/cc/checkerboard_draw_quad.cc
index 892d2bd..9dca587 100644
--- a/cc/checkerboard_draw_quad.cc
+++ b/cc/checkerboard_draw_quad.cc
@@ -8,24 +8,38 @@
 
 namespace cc {
 
-scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
-{
-    return make_scoped_ptr(new CheckerboardDrawQuad(sharedQuadState, quadRect, color));
+CheckerboardDrawQuad::CheckerboardDrawQuad() : color(0) {}
+
+scoped_ptr<CheckerboardDrawQuad> CheckerboardDrawQuad::Create() {
+  return make_scoped_ptr(new CheckerboardDrawQuad);
+}
+
+void CheckerboardDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                  gfx::Rect 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);
+  this->color = color;
 }
 
-CheckerboardDrawQuad::CheckerboardDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
-    : m_color(color)
-{
-    gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect();
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::CHECKERBOARD, quadRect, opaqueRect, visibleRect, needsBlending);
+void CheckerboardDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                                  gfx::Rect rect,
+                                  gfx::Rect opaque_rect,
+                                  gfx::Rect visible_rect,
+                                  bool needs_blending,
+                                  SkColor color) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::CHECKERBOARD, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->color = color;
 }
 
-const CheckerboardDrawQuad* CheckerboardDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::CHECKERBOARD);
-    return static_cast<const CheckerboardDrawQuad*>(quad);
+const CheckerboardDrawQuad* CheckerboardDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::CHECKERBOARD);
+  return static_cast<const CheckerboardDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/checkerboard_draw_quad.h b/cc/checkerboard_draw_quad.h
index 2306c1c..5f1c83e 100644
--- a/cc/checkerboard_draw_quad.h
+++ b/cc/checkerboard_draw_quad.h
@@ -13,16 +13,25 @@
 namespace cc {
 
 class CC_EXPORT CheckerboardDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<CheckerboardDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor);
+ public:
+  static scoped_ptr<CheckerboardDrawQuad> Create();
 
-    SkColor color() const { return m_color; };
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              SkColor color);
 
-    static const CheckerboardDrawQuad* materialCast(const DrawQuad*);
-private:
-    CheckerboardDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor);
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              SkColor color);
 
-    SkColor m_color;
+  SkColor color;
+
+  static const CheckerboardDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  CheckerboardDrawQuad();
 };
 
 }
diff --git a/cc/debug_border_draw_quad.cc b/cc/debug_border_draw_quad.cc
index 8009128..fba8b92 100644
--- a/cc/debug_border_draw_quad.cc
+++ b/cc/debug_border_draw_quad.cc
@@ -8,25 +8,45 @@
 
 namespace cc {
 
-scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width)
-{
-    return make_scoped_ptr(new DebugBorderDrawQuad(sharedQuadState, quadRect, color, width));
+DebugBorderDrawQuad::DebugBorderDrawQuad()
+    : color(0),
+      width(0) {
 }
 
-DebugBorderDrawQuad::DebugBorderDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color, int width)
-    : m_color(color)
-    , m_width(width)
-{
-    gfx::Rect opaqueRect;
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = SkColorGetA(m_color) < 255;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::DEBUG_BORDER, quadRect, opaqueRect, visibleRect, needsBlending);
+scoped_ptr<DebugBorderDrawQuad> DebugBorderDrawQuad::Create() {
+  return make_scoped_ptr(new DebugBorderDrawQuad);
 }
 
-const DebugBorderDrawQuad* DebugBorderDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::DEBUG_BORDER);
-    return static_cast<const DebugBorderDrawQuad*>(quad);
+void DebugBorderDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                 gfx::Rect 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);
+  this->color = color;
+  this->width = width;
+}
+
+void DebugBorderDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                                 gfx::Rect rect,
+                                 gfx::Rect opaque_rect,
+                                 gfx::Rect visible_rect,
+                                 bool needs_blending,
+                                 SkColor color,
+                                 int width) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::DEBUG_BORDER, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->color = color;
+  this->width = width;
+}
+
+const DebugBorderDrawQuad* DebugBorderDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::DEBUG_BORDER);
+  return static_cast<const DebugBorderDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/debug_border_draw_quad.h b/cc/debug_border_draw_quad.h
index daee5b0..96dcec3 100644
--- a/cc/debug_border_draw_quad.h
+++ b/cc/debug_border_draw_quad.h
@@ -13,18 +13,28 @@
 namespace cc {
 
 class CC_EXPORT DebugBorderDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<DebugBorderDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor, int width);
-
-    SkColor color() const { return m_color; };
-    int width() const { return m_width; }
-
-    static const DebugBorderDrawQuad* materialCast(const DrawQuad*);
-private:
-    DebugBorderDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor, int width);
-
-    SkColor m_color;
-    int m_width;
+ public:
+  static scoped_ptr<DebugBorderDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              SkColor color,
+              int width);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              SkColor color,
+              int width);
+
+  SkColor color;
+  int width;
+
+  static const DebugBorderDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  DebugBorderDrawQuad();
 };
 
 }
diff --git a/cc/delegated_renderer_layer_impl.cc b/cc/delegated_renderer_layer_impl.cc
index e8d3b06..38a4c54 100644
--- a/cc/delegated_renderer_layer_impl.cc
+++ b/cc/delegated_renderer_layer_impl.cc
@@ -163,11 +163,11 @@ void DelegatedRendererLayerImpl::appendRenderPassQuads(QuadSink& quadSink, Appen
         if (quad->material != DrawQuad::RENDER_PASS)
             copyQuad = quad->Copy(copiedSharedQuadState);
         else {
-            RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::materialCast(quad)->renderPassId();
+            RenderPass::Id contributingDelegatedRenderPassId = RenderPassDrawQuad::MaterialCast(quad)->render_pass_id;
             RenderPass::Id contributingRenderPassId = convertDelegatedRenderPassId(contributingDelegatedRenderPassId);
             DCHECK(contributingRenderPassId != appendQuadsData.renderPassId);
 
-            copyQuad = RenderPassDrawQuad::materialCast(quad)->copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
+            copyQuad = RenderPassDrawQuad::MaterialCast(quad)->Copy(copiedSharedQuadState, contributingRenderPassId).PassAs<DrawQuad>();
         }
         DCHECK(copyQuad.get());
 
diff --git a/cc/delegated_renderer_layer_impl_unittest.cc b/cc/delegated_renderer_layer_impl_unittest.cc
index 3240101..63816f20 100644
--- a/cc/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/delegated_renderer_layer_impl_unittest.cc
@@ -79,7 +79,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));
-    scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(sharedState, rect, color);
+    scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+    quad->SetNew(sharedState, rect, color);
     SolidColorDrawQuad* quadPtr = quad.get();
     quadSink.append(quad.PassAs<DrawQuad>(), data);
     return quadPtr;
@@ -91,7 +92,8 @@ static void addRenderPassQuad(TestRenderPass* toPass, TestRenderPass* contributi
     AppendQuadsData data(toPass->id());
     gfx::Rect outputRect = contributingPass->outputRect();
     SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), outputRect, outputRect, 1));
-    scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(sharedState, outputRect, contributingPass->id(), false, 0, outputRect, 0, 0, 0, 0);
+    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);
 }
 
@@ -403,10 +405,24 @@ public:
         MockQuadCuller quadSink(pass->quadList(), pass->sharedQuadStateList());
         AppendQuadsData data(pass->id());
         SharedQuadState* sharedState = quadSink.useSharedQuadState(SharedQuadState::create(WebTransformationMatrix(), passRect, passRect, 1));
-        quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 0, 10, 10), 1u).PassAs<DrawQuad>(), data);
-        quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(0, 10, 10, 10), 2u).PassAs<DrawQuad>(), data);
-        quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 0, 10, 10), 3u).PassAs<DrawQuad>(), data);
-        quadSink.append(SolidColorDrawQuad::create(sharedState, gfx::Rect(10, 10, 10, 10), 4u).PassAs<DrawQuad>(), data);
+        scoped_ptr<SolidColorDrawQuad> colorQuad;
+
+        colorQuad = SolidColorDrawQuad::Create();
+        colorQuad->SetNew(sharedState, gfx::Rect(0, 0, 10, 10), 1u);
+        quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
+
+        colorQuad = SolidColorDrawQuad::Create();
+        colorQuad->SetNew(sharedState, gfx::Rect(0, 10, 10, 10), 2u);
+        quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
+
+        colorQuad = SolidColorDrawQuad::Create();
+        colorQuad->SetNew(sharedState, gfx::Rect(10, 0, 10, 10), 3u);
+        quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
+
+        colorQuad = SolidColorDrawQuad::Create();
+        colorQuad->SetNew(sharedState, gfx::Rect(10, 10, 10, 10), 4u);
+        quadSink.append(colorQuad.PassAs<DrawQuad>(), data);
+
         delegatedRendererLayer->setRenderPasses(delegatedRenderPasses);
 
         // The RenderPasses should be taken by the layer.
diff --git a/cc/draw_quad.cc b/cc/draw_quad.cc
index c052748..47f9aa0 100644
--- a/cc/draw_quad.cc
+++ b/cc/draw_quad.cc
@@ -18,7 +18,7 @@
 namespace {
 
 template<typename T> T* TypedCopy(const cc::DrawQuad* other) {
-    return new T(*T::materialCast(other));
+  return new T(*T::MaterialCast(other));
 }
 
 }
diff --git a/cc/draw_quad_unittest.cc b/cc/draw_quad_unittest.cc
index 94b7ad5..f0544e4 100644
--- a/cc/draw_quad_unittest.cc
+++ b/cc/draw_quad_unittest.cc
@@ -71,82 +71,162 @@ void compareDrawQuad(DrawQuad* quad, DrawQuad* copy, SharedQuadState* copyShared
 
 #define QUAD_DATA \
     gfx::Rect quadRect(30, 40, 50, 60); \
-    gfx::Rect quadVisibleRect(40, 50, 30, 20);
-
-#define SETUP_AND_COPY_QUAD(Type, quad) \
-    quad->visible_rect = quadVisibleRect; \
-    scoped_ptr<DrawQuad> copy(quad->Copy(copySharedState.get())); \
-    compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
-    const Type* copyQuad = Type::materialCast(copy.get());
-
-#define SETUP_AND_COPY_QUAD_1(Type, quad, a) \
-    quad->visible_rect = quadVisibleRect; \
-    scoped_ptr<DrawQuad> copy(quad->copy(copySharedState.get(), a));    \
-    compareDrawQuad(quad.get(), copy.get(), copySharedState.get()); \
-    const Type* copyQuad = Type::materialCast(copy.get());
-
-#define CREATE_QUAD_0(Type) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect)); \
-    SETUP_AND_COPY_QUAD(Type, quad); \
-    UNUSED_PARAM(copyQuad);
-
-#define CREATE_QUAD_1(Type, a) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_2(Type, a, b) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_3(Type, a, b, c) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_4(Type, a, b, c, d) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_5(Type, a, b, c, d, e) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_6(Type, a, b, c, d, e, f) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_7(Type, a, b, c, d, e, f, g) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_8(Type, a, b, c, d, e, f, g, h) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
-
-#define CREATE_QUAD_8_1(Type, a, b, c, d, e, f, g, h, copyA) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h)); \
-    SETUP_AND_COPY_QUAD_1(Type, quad, copyA);
-
-#define CREATE_QUAD_9(Type, a, b, c, d, e, f, g, h, i) \
-    QUAD_DATA \
-    scoped_ptr<Type> quad(Type::create(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i)); \
-    SETUP_AND_COPY_QUAD(Type, quad);
+    gfx::Rect quadVisibleRect(40, 50, 30, 20); \
+    gfx::Rect quadOpaqueRect(60, 55, 10, 10); \
+    bool needsBlending = true;
+
+#define SETUP_AND_COPY_QUAD_NEW(Type, quad) \
+    scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get())); \
+    compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \
+    const Type* copyQuad = Type::MaterialCast(copyNew.get());
+
+#define SETUP_AND_COPY_QUAD_ALL(Type, quad) \
+    scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get())); \
+    compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \
+    copyQuad = Type::MaterialCast(copyAll.get());
+
+#define SETUP_AND_COPY_QUAD_NEW_1(Type, quad, a) \
+    scoped_ptr<DrawQuad> copyNew(quadNew->Copy(copySharedState.get(), a));  \
+    compareDrawQuad(quadNew.get(), copyNew.get(), copySharedState.get()); \
+    const Type* copyQuad = Type::MaterialCast(copyNew.get());
+
+#define SETUP_AND_COPY_QUAD_ALL_1(Type, quad, a) \
+    scoped_ptr<DrawQuad> copyAll(quadAll->Copy(copySharedState.get(), a)); \
+    compareDrawQuad(quadAll.get(), copyAll.get(), copySharedState.get()); \
+    copyQuad = Type::MaterialCast(copyAll.get());
+
+#define CREATE_QUAD_1_NEW(Type, a) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_1_ALL(Type, a) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_2_NEW(Type, a, b) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_2_ALL(Type, a, b) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_3_NEW(Type, a, b, c) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_3_ALL(Type, a, b, c) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_4_NEW(Type, a, b, c, d) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_4_ALL(Type, a, b, c, d) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_5_NEW(Type, a, b, c, d, e) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_5_ALL(Type, a, b, c, d, e) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_6_NEW(Type, a, b, c, d, e, f) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_6_ALL(Type, a, b, c, d, e, f) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_7_NEW(Type, a, b, c, d, e, f, g) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_7_ALL(Type, a, b, c, d, e, f, g) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_8_NEW(Type, a, b, c, d, e, f, g, h) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_8_ALL(Type, a, b, c, d, e, f, g, h) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
+
+#define CREATE_QUAD_8_NEW_1(Type, a, b, c, d, e, f, g, h, copyA) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h); } \
+    SETUP_AND_COPY_QUAD_NEW_1(Type, quadNew, copyA);
+
+#define CREATE_QUAD_8_ALL_1(Type, a, b, c, d, e, f, g, h, copyA) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h); } \
+    SETUP_AND_COPY_QUAD_ALL_1(Type, quadAll, copyA);
+
+#define CREATE_QUAD_9_NEW(Type, a, b, c, d, e, f, g, h, i) \
+    scoped_ptr<Type> quadNew(Type::Create()); \
+    { QUAD_DATA \
+      quadNew->SetNew(sharedState.get(), quadRect, a, b, c, d, e, f, g, h, i); } \
+    SETUP_AND_COPY_QUAD_NEW(Type, quadNew);
+
+#define CREATE_QUAD_9_ALL(Type, a, b, c, d, e, f, g, h, i) \
+    scoped_ptr<Type> quadAll(Type::Create()); \
+    { QUAD_DATA \
+      quadAll->SetAll(sharedState.get(), quadRect, quadOpaqueRect, quadVisibleRect, needsBlending, a, b, c, d, e, f, g, h, i); } \
+    SETUP_AND_COPY_QUAD_ALL(Type, quadAll);
 
 TEST(DrawQuadTest, copyCheckerboardDrawQuad)
 {
     SkColor color = 0xfabb0011;
     CREATE_SHARED_STATE();
-    CREATE_QUAD_1(CheckerboardDrawQuad, color);
-    EXPECT_EQ(color, copyQuad->color());
+
+    CREATE_QUAD_1_NEW(CheckerboardDrawQuad, color);
+    EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
+
+    CREATE_QUAD_1_ALL(CheckerboardDrawQuad, color);
+    EXPECT_EQ(DrawQuad::CHECKERBOARD, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
 }
 
 TEST(DrawQuadTest, copyDebugBorderDrawQuad)
@@ -154,9 +234,16 @@ TEST(DrawQuadTest, copyDebugBorderDrawQuad)
     SkColor color = 0xfabb0011;
     int width = 99;
     CREATE_SHARED_STATE();
-    CREATE_QUAD_2(DebugBorderDrawQuad, color, width);
-    EXPECT_EQ(color, copyQuad->color());
-    EXPECT_EQ(width, copyQuad->width());
+
+    CREATE_QUAD_2_NEW(DebugBorderDrawQuad, color, width);
+    EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
+    EXPECT_EQ(width, copyQuad->width);
+
+    CREATE_QUAD_2_ALL(DebugBorderDrawQuad, color, width);
+    EXPECT_EQ(DrawQuad::DEBUG_BORDER, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
+    EXPECT_EQ(width, copyQuad->width);
 }
 
 TEST(DrawQuadTest, copyIOSurfaceDrawQuad)
@@ -164,14 +251,21 @@ TEST(DrawQuadTest, copyIOSurfaceDrawQuad)
     gfx::Rect opaqueRect(3, 7, 10, 12);
     gfx::Size size(58, 95);
     unsigned textureId = 72;
-    IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::Unflipped;
-
+    IOSurfaceDrawQuad::Orientation orientation = IOSurfaceDrawQuad::UNFLIPPED;
     CREATE_SHARED_STATE();
-    CREATE_QUAD_4(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
+
+    CREATE_QUAD_4_NEW(IOSurfaceDrawQuad, opaqueRect, size, textureId, orientation);
+    EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
-    EXPECT_EQ(size, copyQuad->ioSurfaceSize());
-    EXPECT_EQ(textureId, copyQuad->ioSurfaceTextureId());
-    EXPECT_EQ(orientation, copyQuad->orientation());
+    EXPECT_EQ(size, copyQuad->io_surface_size);
+    EXPECT_EQ(textureId, copyQuad->io_surface_texture_id);
+    EXPECT_EQ(orientation, copyQuad->orientation);
+
+    CREATE_QUAD_3_ALL(IOSurfaceDrawQuad, size, textureId, orientation);
+    EXPECT_EQ(DrawQuad::IO_SURFACE_CONTENT, copyQuad->material);
+    EXPECT_EQ(size, copyQuad->io_surface_size);
+    EXPECT_EQ(textureId, copyQuad->io_surface_texture_id);
+    EXPECT_EQ(orientation, copyQuad->orientation);
 }
 
 TEST(DrawQuadTest, copyRenderPassDrawQuad)
@@ -186,26 +280,43 @@ TEST(DrawQuadTest, copyRenderPassDrawQuad)
     float maskTexCoordOffsetY = -21;
 
     RenderPass::Id copiedRenderPassId(235, 11);
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_8_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
-    EXPECT_EQ(copiedRenderPassId, copyQuad->renderPassId());
-    EXPECT_EQ(isReplica, copyQuad->isReplica());
-    EXPECT_EQ(maskResourceId, copyQuad->maskResourceId());
-    EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contentsChangedSinceLastFrame());
-    EXPECT_EQ(maskTexCoordScaleX, copyQuad->maskTexCoordScaleX());
-    EXPECT_EQ(maskTexCoordScaleY, copyQuad->maskTexCoordScaleY());
-    EXPECT_EQ(maskTexCoordOffsetX, copyQuad->maskTexCoordOffsetX());
-    EXPECT_EQ(maskTexCoordOffsetY, copyQuad->maskTexCoordOffsetY());
+
+    CREATE_QUAD_8_NEW_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
+    EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material);
+    EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id);
+    EXPECT_EQ(isReplica, copyQuad->is_replica);
+    EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id);
+    EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame);
+    EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x);
+    EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y);
+    EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x);
+    EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y);
+
+    CREATE_QUAD_8_ALL_1(RenderPassDrawQuad, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY, copiedRenderPassId);
+    EXPECT_EQ(DrawQuad::RENDER_PASS, copyQuad->material);
+    EXPECT_EQ(copiedRenderPassId, copyQuad->render_pass_id);
+    EXPECT_EQ(isReplica, copyQuad->is_replica);
+    EXPECT_EQ(maskResourceId, copyQuad->mask_resource_id);
+    EXPECT_RECT_EQ(contentsChangedSinceLastFrame, copyQuad->contents_changed_since_last_frame);
+    EXPECT_EQ(maskTexCoordScaleX, copyQuad->mask_tex_coord_scale_x);
+    EXPECT_EQ(maskTexCoordScaleY, copyQuad->mask_tex_coord_scale_y);
+    EXPECT_EQ(maskTexCoordOffsetX, copyQuad->mask_tex_coord_offset_x);
+    EXPECT_EQ(maskTexCoordOffsetY, copyQuad->mask_tex_coord_offset_y);
 }
 
 TEST(DrawQuadTest, copySolidColorDrawQuad)
 {
     SkColor color = 0x49494949;
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_1(SolidColorDrawQuad, color);
-    EXPECT_EQ(color, copyQuad->color());
+
+    CREATE_QUAD_1_NEW(SolidColorDrawQuad, color);
+    EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
+
+    CREATE_QUAD_1_ALL(SolidColorDrawQuad, color);
+    EXPECT_EQ(DrawQuad::SOLID_COLOR, copyQuad->material);
+    EXPECT_EQ(color, copyQuad->color);
 }
 
 TEST(DrawQuadTest, copyStreamVideoDrawQuad)
@@ -213,12 +324,18 @@ TEST(DrawQuadTest, copyStreamVideoDrawQuad)
     gfx::Rect opaqueRect(3, 7, 10, 12);
     unsigned textureId = 64;
     WebTransformationMatrix matrix(0.5, 1, 0.25, 0.75, 0, 1);
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_3(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
+
+    CREATE_QUAD_3_NEW(StreamVideoDrawQuad, opaqueRect, textureId, matrix);
+    EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
-    EXPECT_EQ(textureId, copyQuad->textureId());
-    EXPECT_EQ(matrix, copyQuad->matrix());
+    EXPECT_EQ(textureId, copyQuad->texture_id);
+    EXPECT_EQ(matrix, copyQuad->matrix);
+
+    CREATE_QUAD_2_ALL(StreamVideoDrawQuad, textureId, matrix);
+    EXPECT_EQ(DrawQuad::STREAM_VIDEO_CONTENT, copyQuad->material);
+    EXPECT_EQ(textureId, copyQuad->texture_id);
+    EXPECT_EQ(matrix, copyQuad->matrix);
 }
 
 TEST(DrawQuadTest, copyTextureDrawQuad)
@@ -228,14 +345,22 @@ TEST(DrawQuadTest, copyTextureDrawQuad)
     bool premultipliedAlpha = true;
     gfx::RectF uvRect(0.5, 224, -51, 36);
     bool flipped = true;
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_5(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped);
+
+    CREATE_QUAD_5_NEW(TextureDrawQuad, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped);
+    EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
-    EXPECT_EQ(resourceId, copyQuad->resourceId());
-    EXPECT_EQ(premultipliedAlpha, copyQuad->premultipliedAlpha());
-    EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uvRect());
-    EXPECT_EQ(flipped, copyQuad->flipped());
+    EXPECT_EQ(resourceId, copyQuad->resource_id);
+    EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha);
+    EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect);
+    EXPECT_EQ(flipped, copyQuad->flipped);
+
+    CREATE_QUAD_4_ALL(TextureDrawQuad, resourceId, premultipliedAlpha, uvRect, flipped);
+    EXPECT_EQ(DrawQuad::TEXTURE_CONTENT, copyQuad->material);
+    EXPECT_EQ(resourceId, copyQuad->resource_id);
+    EXPECT_EQ(premultipliedAlpha, copyQuad->premultiplied_alpha);
+    EXPECT_FLOAT_RECT_EQ(uvRect, copyQuad->uv_rect);
+    EXPECT_EQ(flipped, copyQuad->flipped);
 }
 
 TEST(DrawQuadTest, copyTileDrawQuad)
@@ -249,18 +374,30 @@ TEST(DrawQuadTest, copyTileDrawQuad)
     bool topEdgeAA = true;
     bool rightEdgeAA = false;
     bool bottomEdgeAA = true;
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_9(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+
+    CREATE_QUAD_9_NEW(TileDrawQuad, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
-    EXPECT_EQ(resourceId, copyQuad->resourceId());
-    EXPECT_EQ(texCoordRect, copyQuad->texCoordRect());
-    EXPECT_EQ(textureSize, copyQuad->textureSize());
-    EXPECT_EQ(swizzleContents, copyQuad->swizzleContents());
-    EXPECT_EQ(leftEdgeAA, copyQuad->leftEdgeAA());
-    EXPECT_EQ(topEdgeAA, copyQuad->topEdgeAA());
-    EXPECT_EQ(rightEdgeAA, copyQuad->rightEdgeAA());
-    EXPECT_EQ(bottomEdgeAA, copyQuad->bottomEdgeAA());
+    EXPECT_EQ(resourceId, copyQuad->resource_id);
+    EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
+    EXPECT_EQ(textureSize, copyQuad->texture_size);
+    EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
+    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
+    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
+    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
+    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
+
+    CREATE_QUAD_8_ALL(TileDrawQuad, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+    EXPECT_EQ(DrawQuad::TILED_CONTENT, copyQuad->material);
+    EXPECT_EQ(resourceId, copyQuad->resource_id);
+    EXPECT_EQ(texCoordRect, copyQuad->tex_coord_rect);
+    EXPECT_EQ(textureSize, copyQuad->texture_size);
+    EXPECT_EQ(swizzleContents, copyQuad->swizzle_contents);
+    EXPECT_EQ(leftEdgeAA, copyQuad->left_edge_aa);
+    EXPECT_EQ(topEdgeAA, copyQuad->top_edge_aa);
+    EXPECT_EQ(rightEdgeAA, copyQuad->right_edge_aa);
+    EXPECT_EQ(bottomEdgeAA, copyQuad->bottom_edge_aa);
 }
 
 TEST(DrawQuadTest, copyYUVVideoDrawQuad)
@@ -279,20 +416,34 @@ TEST(DrawQuadTest, copyYUVVideoDrawQuad)
     vPlane.resourceId = 4;
     vPlane.size = gfx::Size(456, 486);
     vPlane.format = 46;
-
     CREATE_SHARED_STATE();
-    CREATE_QUAD_5(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
+
+    CREATE_QUAD_5_NEW(YUVVideoDrawQuad, opaqueRect, texScale, yPlane, uPlane, vPlane);
+    EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material);
     EXPECT_RECT_EQ(opaqueRect, copyQuad->opaque_rect);
-    EXPECT_EQ(texScale, copyQuad->texScale());
-    EXPECT_EQ(yPlane.resourceId, copyQuad->yPlane().resourceId);
-    EXPECT_EQ(yPlane.size, copyQuad->yPlane().size);
-    EXPECT_EQ(yPlane.format, copyQuad->yPlane().format);
-    EXPECT_EQ(uPlane.resourceId, copyQuad->uPlane().resourceId);
-    EXPECT_EQ(uPlane.size, copyQuad->uPlane().size);
-    EXPECT_EQ(uPlane.format, copyQuad->uPlane().format);
-    EXPECT_EQ(vPlane.resourceId, copyQuad->vPlane().resourceId);
-    EXPECT_EQ(vPlane.size, copyQuad->vPlane().size);
-    EXPECT_EQ(vPlane.format, copyQuad->vPlane().format);
+    EXPECT_EQ(texScale, copyQuad->tex_scale);
+    EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId);
+    EXPECT_EQ(yPlane.size, copyQuad->y_plane.size);
+    EXPECT_EQ(yPlane.format, copyQuad->y_plane.format);
+    EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId);
+    EXPECT_EQ(uPlane.size, copyQuad->u_plane.size);
+    EXPECT_EQ(uPlane.format, copyQuad->u_plane.format);
+    EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId);
+    EXPECT_EQ(vPlane.size, copyQuad->v_plane.size);
+    EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
+
+    CREATE_QUAD_4_ALL(YUVVideoDrawQuad, texScale, yPlane, uPlane, vPlane);
+    EXPECT_EQ(DrawQuad::YUV_VIDEO_CONTENT, copyQuad->material);
+    EXPECT_EQ(texScale, copyQuad->tex_scale);
+    EXPECT_EQ(yPlane.resourceId, copyQuad->y_plane.resourceId);
+    EXPECT_EQ(yPlane.size, copyQuad->y_plane.size);
+    EXPECT_EQ(yPlane.format, copyQuad->y_plane.format);
+    EXPECT_EQ(uPlane.resourceId, copyQuad->u_plane.resourceId);
+    EXPECT_EQ(uPlane.size, copyQuad->u_plane.size);
+    EXPECT_EQ(uPlane.format, copyQuad->u_plane.format);
+    EXPECT_EQ(vPlane.resourceId, copyQuad->v_plane.resourceId);
+    EXPECT_EQ(vPlane.size, copyQuad->v_plane.size);
+    EXPECT_EQ(vPlane.format, copyQuad->v_plane.format);
 }
 
 }  // namespace
diff --git a/cc/gl_renderer.cc b/cc/gl_renderer.cc
index af67acf..e4e8034 100644
--- a/cc/gl_renderer.cc
+++ b/cc/gl_renderer.cc
@@ -262,31 +262,31 @@ void GLRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
         NOTREACHED();
         break;
     case DrawQuad::CHECKERBOARD:
-        drawCheckerboardQuad(frame, CheckerboardDrawQuad::materialCast(quad));
+        drawCheckerboardQuad(frame, CheckerboardDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::DEBUG_BORDER:
-        drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
+        drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::IO_SURFACE_CONTENT:
-        drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::materialCast(quad));
+        drawIOSurfaceQuad(frame, IOSurfaceDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::RENDER_PASS:
-        drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
+        drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::SOLID_COLOR:
-        drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
+        drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::STREAM_VIDEO_CONTENT:
-        drawStreamVideoQuad(frame, StreamVideoDrawQuad::materialCast(quad));
+        drawStreamVideoQuad(frame, StreamVideoDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::TEXTURE_CONTENT:
-        drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
+        drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::TILED_CONTENT:
-        drawTileQuad(frame, TileDrawQuad::materialCast(quad));
+        drawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::YUV_VIDEO_CONTENT:
-        drawYUVVideoQuad(frame, YUVVideoDrawQuad::materialCast(quad));
+        drawYUVVideoQuad(frame, YUVVideoDrawQuad::MaterialCast(quad));
         break;
     }
 }
@@ -297,7 +297,7 @@ void GLRenderer::drawCheckerboardQuad(const DrawingFrame& frame, const Checkerbo
     DCHECK(program && (program->initialized() || isContextLost()));
     GLC(context(), context()->useProgram(program->program()));
 
-    SkColor color = quad->color();
+    SkColor color = quad->color;
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), SkColorGetR(color) / 255.0, SkColorGetG(color) / 255.0, SkColorGetB(color) / 255.0, 1));
 
     const int checkerboardWidth = 16;
@@ -331,12 +331,12 @@ void GLRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const DebugBorde
     GLRenderer::toGLMatrix(&glMatrix[0], frame.projectionMatrix * renderMatrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().matrixLocation(), 1, false, &glMatrix[0]));
 
-    SkColor color = quad->color();
+    SkColor color = quad->color;
     float alpha = SkColorGetA(color) / 255.0;
 
     GLC(context(), context()->uniform4f(program->fragmentShader().colorLocation(), (SkColorGetR(color) / 255.0) * alpha, (SkColorGetG(color) / 255.0) * alpha, (SkColorGetB(color) / 255.0) * alpha, alpha));
 
-    GLC(context(), context()->lineWidth(quad->width()));
+    GLC(context(), context()->lineWidth(quad->width));
 
     // The indices for the line are stored in the same array as the triangle indices.
     GLC(context(), context()->drawElements(GL_LINE_LOOP, 4, GL_UNSIGNED_SHORT, 6 * sizeof(unsigned short)));
@@ -504,11 +504,11 @@ scoped_ptr<ScopedResource> GLRenderer::drawBackgroundFilters(
 
 void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
-    CachedResource* contentsTexture = m_renderPassTextures.get(quad->renderPassId());
+    CachedResource* contentsTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentsTexture || !contentsTexture->id())
         return;
 
-    const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
+    const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id);
     DCHECK(renderPass);
     if (!renderPass)
         return;
@@ -566,8 +566,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
 
     scoped_ptr<ResourceProvider::ScopedReadLockGL> maskResourceLock;
     unsigned maskTextureId = 0;
-    if (quad->maskResourceId()) {
-        maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->maskResourceId()));
+    if (quad->mask_resource_id) {
+        maskResourceLock.reset(new ResourceProvider::ScopedReadLockGL(m_resourceProvider, quad->mask_resource_id));
         maskTextureId = maskResourceLock->textureId();
     }
 
@@ -627,8 +627,8 @@ void GLRenderer::drawRenderPassQuad(DrawingFrame& frame, const RenderPassDrawQua
         DCHECK(shaderMaskTexCoordOffsetLocation != 1);
         GLC(context(), context()->activeTexture(GL_TEXTURE1));
         GLC(context(), context()->uniform1i(shaderMaskSamplerLocation, 1));
-        GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->maskTexCoordScaleX(), quad->maskTexCoordScaleY()));
-        GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->maskTexCoordOffsetX(), quad->maskTexCoordOffsetY()));
+        GLC(context(), context()->uniform2f(shaderMaskTexCoordScaleLocation, quad->mask_tex_coord_scale_x, quad->mask_tex_coord_scale_y));
+        GLC(context(), context()->uniform2f(shaderMaskTexCoordOffsetLocation, quad->mask_tex_coord_offset_x, quad->mask_tex_coord_offset_y));
         context()->bindTexture(GL_TEXTURE_2D, maskTextureId);
         GLC(context(), context()->activeTexture(GL_TEXTURE0));
     }
@@ -659,7 +659,7 @@ void GLRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorD
     const SolidColorProgram* program = solidColorProgram();
     GLC(context(), context()->useProgram(program->program()));
 
-    SkColor color = quad->color();
+    SkColor color = quad->color;
     float opacity = quad->opacity();
     float alpha = (SkColorGetA(color) / 255.0) * opacity;
 
@@ -697,7 +697,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
 {
     gfx::Rect tileRect = quad->visible_rect;
 
-    gfx::RectF texCoordRect = quad->texCoordRect();
+    gfx::RectF texCoordRect = quad->tex_coord_rect;
     float texToGeomScaleX = quad->rect.width() / texCoordRect.width();
     float texToGeomScaleY = quad->rect.height() / texCoordRect.height();
 
@@ -737,7 +737,7 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     float vertexTexScaleY = tileRect.height() / clampGeomRect.height();
 
     // Map to normalized texture coordinates.
-    const gfx::Size& textureSize = quad->textureSize();
+    const gfx::Size& textureSize = quad->texture_size;
     float fragmentTexTranslateX = clampTexRect.x() / textureSize.width();
     float fragmentTexTranslateY = clampTexRect.y() / textureSize.height();
     float fragmentTexScaleX = clampTexRect.width() / textureSize.width();
@@ -756,19 +756,19 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
     TileProgramUniforms uniforms;
     // For now, we simply skip anti-aliasing with the quad is clipped. This only happens
     // on perspective transformed layers that go partially behind the camera.
-    if (quad->isAntialiased() && !clipped) {
-        if (quad->swizzleContents())
+    if (quad->IsAntialiased() && !clipped) {
+        if (quad->swizzle_contents)
             tileUniformLocation(tileProgramSwizzleAA(), uniforms);
         else
             tileUniformLocation(tileProgramAA(), uniforms);
     } else {
         if (quad->ShouldDrawWithBlending()) {
-            if (quad->swizzleContents())
+            if (quad->swizzle_contents)
                 tileUniformLocation(tileProgramSwizzle(), uniforms);
             else
                 tileUniformLocation(tileProgram(), uniforms);
         } else {
-            if (quad->swizzleContents())
+            if (quad->swizzle_contents)
                 tileUniformLocation(tileProgramSwizzleOpaque(), uniforms);
             else
                 tileUniformLocation(tileProgramOpaque(), uniforms);
@@ -777,10 +777,10 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
 
     GLC(context(), context()->useProgram(uniforms.program));
     GLC(context(), context()->uniform1i(uniforms.samplerLocation, 0));
-    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id);
     GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId()));
 
-    bool useAA = !clipped && quad->isAntialiased();
+    bool useAA = !clipped && quad->IsAntialiased();
     if (useAA) {
         LayerQuad deviceLayerBounds = LayerQuad(gfx::QuadF(deviceLayerQuad.BoundingBox()));
         deviceLayerBounds.inflateAntiAliasingDistance();
@@ -817,13 +817,13 @@ void GLRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* qua
         LayerQuad::Edge rightEdge(topRight, bottomRight);
 
         // Only apply anti-aliasing to edges not clipped by culling or scissoring.
-        if (quad->topEdgeAA() && tileRect.y() == quad->rect.y())
+        if (quad->top_edge_aa && tileRect.y() == quad->rect.y())
             topEdge = deviceLayerEdges.top();
-        if (quad->leftEdgeAA() && tileRect.x() == quad->rect.x())
+        if (quad->left_edge_aa && tileRect.x() == quad->rect.x())
             leftEdge = deviceLayerEdges.left();
-        if (quad->rightEdgeAA() && tileRect.right() == quad->rect.right())
+        if (quad->right_edge_aa && tileRect.right() == quad->rect.right())
             rightEdge = deviceLayerEdges.right();
-        if (quad->bottomEdgeAA() && tileRect.bottom() == quad->rect.bottom())
+        if (quad->bottom_edge_aa && tileRect.bottom() == quad->rect.bottom())
             bottomEdge = deviceLayerEdges.bottom();
 
         float sign = gfx::QuadF(tileRect).IsCounterClockwise() ? -1 : 1;
@@ -878,9 +878,9 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ
     const VideoYUVProgram* program = videoYUVProgram();
     DCHECK(program && (program->initialized() || isContextLost()));
 
-    const VideoLayerImpl::FramePlane& yPlane = quad->yPlane();
-    const VideoLayerImpl::FramePlane& uPlane = quad->uPlane();
-    const VideoLayerImpl::FramePlane& vPlane = quad->vPlane();
+    const VideoLayerImpl::FramePlane& yPlane = quad->y_plane;
+    const VideoLayerImpl::FramePlane& uPlane = quad->u_plane;
+    const VideoLayerImpl::FramePlane& vPlane = quad->v_plane;
 
     ResourceProvider::ScopedReadLockGL yPlaneLock(m_resourceProvider, yPlane.resourceId);
     ResourceProvider::ScopedReadLockGL uPlaneLock(m_resourceProvider, uPlane.resourceId);
@@ -894,7 +894,7 @@ void GLRenderer::drawYUVVideoQuad(const DrawingFrame& frame, const YUVVideoDrawQ
 
     GLC(context(), context()->useProgram(program->program()));
 
-    GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->texScale().width(), quad->texScale().height()));
+    GLC(context(), context()->uniform2f(program->vertexShader().texScaleLocation(), quad->tex_scale.width(), quad->tex_scale.height()));
     GLC(context(), context()->uniform1i(program->fragmentShader().yTextureLocation(), 1));
     GLC(context(), context()->uniform1i(program->fragmentShader().uTextureLocation(), 2));
     GLC(context(), context()->uniform1i(program->fragmentShader().vTextureLocation(), 3));
@@ -937,10 +937,10 @@ void GLRenderer::drawStreamVideoQuad(const DrawingFrame& frame, const StreamVide
     const VideoStreamTextureProgram* program = videoStreamTextureProgram();
     GLC(context(), context()->useProgram(program->program()));
 
-    toGLMatrix(&glMatrix[0], quad->matrix());
+    toGLMatrix(&glMatrix[0], quad->matrix);
     GLC(context(), context()->uniformMatrix4fv(program->vertexShader().texMatrixLocation(), 1, false, glMatrix));
 
-    GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->textureId()));
+    GLC(context(), context()->bindTexture(GL_TEXTURE_EXTERNAL_OES, quad->texture_id));
 
     GLC(context(), context()->uniform1i(program->fragmentShader().samplerLocation(), 0));
 
@@ -977,19 +977,19 @@ struct TexTransformTextureProgramBinding : TextureProgramBinding {
 void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
     TexTransformTextureProgramBinding binding;
-    if (quad->flipped())
+    if (quad->flipped)
         binding.set(textureProgramFlip(), context());
     else
         binding.set(textureProgram(), context());
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
-    const gfx::RectF& uvRect = quad->uvRect();
+    const gfx::RectF& uvRect = quad->uv_rect;
     GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
 
-    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockGL quadResourceLock(m_resourceProvider, quad->resource_id);
     GLC(context(), context()->bindTexture(GL_TEXTURE_2D, quadResourceLock.textureId()));
 
-    if (!quad->premultipliedAlpha()) {
+    if (!quad->premultiplied_alpha) {
         // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA)
         // will never cause the alpha channel to be set to anything less than 1.0 if it is
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
@@ -1004,7 +1004,7 @@ void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQua
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
 
-    if (!quad->premultipliedAlpha())
+    if (!quad->premultiplied_alpha)
         GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 }
 
@@ -1015,12 +1015,12 @@ void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDra
 
     GLC(context(), context()->useProgram(binding.programId));
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
-    if (quad->orientation() == IOSurfaceDrawQuad::Flipped)
-        GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->ioSurfaceSize().height(), quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height() * -1.0));
+    if (quad->orientation == IOSurfaceDrawQuad::FLIPPED)
+        GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->io_surface_size.height(), quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0));
     else
-        GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->ioSurfaceSize().width(), quad->ioSurfaceSize().height()));
+        GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->io_surface_size.width(), quad->io_surface_size.height()));
 
-    GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->ioSurfaceTextureId()));
+    GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->io_surface_texture_id));
 
     setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
diff --git a/cc/heads_up_display_layer_impl.cc b/cc/heads_up_display_layer_impl.cc
index 7ede4b1..4faf682 100644
--- a/cc/heads_up_display_layer_impl.cc
+++ b/cc/heads_up_display_layer_impl.cc
@@ -95,7 +95,9 @@ void HeadsUpDisplayLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& a
     bool premultipliedAlpha = true;
     gfx::RectF uvRect(0, 0, 1, 1);
     bool flipped = false;
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_hudTexture->id(), premultipliedAlpha, uvRect, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void HeadsUpDisplayLayerImpl::updateHudTexture(ResourceProvider* resourceProvider)
diff --git a/cc/io_surface_draw_quad.cc b/cc/io_surface_draw_quad.cc
index 35ab66e..4851df1 100644
--- a/cc/io_surface_draw_quad.cc
+++ b/cc/io_surface_draw_quad.cc
@@ -8,25 +8,49 @@
 
 namespace cc {
 
-scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation)
-{
-    return make_scoped_ptr(new IOSurfaceDrawQuad(sharedQuadState, quadRect, opaqueRect, ioSurfaceSize, ioSurfaceTextureId, orientation));
+IOSurfaceDrawQuad::IOSurfaceDrawQuad()
+    : io_surface_texture_id(0),
+      orientation(FLIPPED) {
 }
 
-IOSurfaceDrawQuad::IOSurfaceDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation orientation)
-    : m_ioSurfaceSize(ioSurfaceSize)
-    , m_ioSurfaceTextureId(ioSurfaceTextureId)
-    , m_orientation(orientation)
-{
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::IO_SURFACE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
+scoped_ptr<IOSurfaceDrawQuad> IOSurfaceDrawQuad::Create() {
+  return make_scoped_ptr(new IOSurfaceDrawQuad);
 }
 
-const IOSurfaceDrawQuad* IOSurfaceDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT);
-    return static_cast<const IOSurfaceDrawQuad*>(quad);
+void IOSurfaceDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                               gfx::Rect rect,
+                               gfx::Rect opaque_rect,
+                               gfx::Size io_surface_size,
+                               unsigned io_surface_texture_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); 
+  this->io_surface_size = io_surface_size;
+  this->io_surface_texture_id = io_surface_texture_id;
+  this->orientation = orientation;
+}
+
+void IOSurfaceDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                               gfx::Rect rect,
+                               gfx::Rect opaque_rect,
+                               gfx::Rect visible_rect,
+                               bool needs_blending,
+                               gfx::Size io_surface_size,
+                               unsigned io_surface_texture_id,
+                               Orientation orientation) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::IO_SURFACE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->io_surface_size = io_surface_size;
+  this->io_surface_texture_id = io_surface_texture_id;
+  this->orientation = orientation;
+}
+
+const IOSurfaceDrawQuad* IOSurfaceDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::IO_SURFACE_CONTENT);
+  return static_cast<const IOSurfaceDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/io_surface_draw_quad.h b/cc/io_surface_draw_quad.h
index 432960c..2bce6b7 100644
--- a/cc/io_surface_draw_quad.h
+++ b/cc/io_surface_draw_quad.h
@@ -13,25 +13,37 @@
 namespace cc {
 
 class CC_EXPORT IOSurfaceDrawQuad : public DrawQuad {
-public:
-    enum Orientation {
-      Flipped,
-      Unflipped
-    };
-
-    static scoped_ptr<IOSurfaceDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation);
-
-    gfx::Size ioSurfaceSize() const { return m_ioSurfaceSize; }
-    unsigned ioSurfaceTextureId() const { return m_ioSurfaceTextureId; }
-    Orientation orientation() const { return m_orientation; }
-
-    static const IOSurfaceDrawQuad* materialCast(const DrawQuad*);
-private:
-    IOSurfaceDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, const gfx::Size& ioSurfaceSize, unsigned ioSurfaceTextureId, Orientation);
-
-    gfx::Size m_ioSurfaceSize;
-    unsigned m_ioSurfaceTextureId;
-    Orientation m_orientation;
+ public:
+  enum Orientation {
+    FLIPPED,
+    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,
+              unsigned io_surface_texture_id,
+              Orientation orientation);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              gfx::Size io_surface_size,
+              unsigned io_surface_texture_id,
+              Orientation orientation);
+
+  gfx::Size io_surface_size;
+  unsigned io_surface_texture_id;
+  Orientation orientation;
+
+  static const IOSurfaceDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  IOSurfaceDrawQuad();
 };
 
 }
diff --git a/cc/io_surface_layer_impl.cc b/cc/io_surface_layer_impl.cc
index 6d3abcb..bcf0072 100644
--- a/cc/io_surface_layer_impl.cc
+++ b/cc/io_surface_layer_impl.cc
@@ -79,7 +79,9 @@ void IOSurfaceLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
 
     gfx::Rect quadRect(gfx::Point(), contentBounds());
     gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
-    quadSink.append(IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<IOSurfaceDrawQuad> quad = IOSurfaceDrawQuad::Create();
+    quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_ioSurfaceSize, m_ioSurfaceTextureId, IOSurfaceDrawQuad::FLIPPED);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void IOSurfaceLayerImpl::dumpLayerProperties(std::string* str, int indent) const
diff --git a/cc/layer_impl.cc b/cc/layer_impl.cc
index 70992f4..4927e74 100644
--- a/cc/layer_impl.cc
+++ b/cc/layer_impl.cc
@@ -179,7 +179,9 @@ void LayerImpl::appendDebugBorderQuad(QuadSink& quadList, const SharedQuadState*
     getDebugBorderProperties(&color, &width);
 
     gfx::Rect contentRect(gfx::Point(), contentBounds());
-    quadList.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect, color, width).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
+    debugBorderQuad->SetNew(sharedQuadState, contentRect, color, width);
+    quadList.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 bool LayerImpl::hasContributingDelegatedRenderPasses() const
diff --git a/cc/layer_tree_host_impl.cc b/cc/layer_tree_host_impl.cc
index b558568..e305b88 100644
--- a/cc/layer_tree_host_impl.cc
+++ b/cc/layer_tree_host_impl.cc
@@ -564,19 +564,19 @@ static void removeRenderPassesRecursive(RenderPass::Id removeRenderPassId, Layer
         if (currentQuad->material != DrawQuad::RENDER_PASS)
             continue;
 
-        RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId();
+        RenderPass::Id nextRemoveRenderPassId = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id;
         removeRenderPassesRecursive(nextRemoveRenderPassId, frame);
     }
 }
 
 bool LayerTreeHostImpl::CullRenderPassesWithCachedTextures::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData&) const
 {
-    return quad.contentsChangedSinceLastFrame().IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.renderPassId());
+    return quad.contents_changed_since_last_frame.IsEmpty() && m_renderer.haveCachedResourcesForRenderPassId(quad.render_pass_id);
 }
 
 bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(const RenderPassDrawQuad& quad, const FrameData& frame) const
 {
-    const RenderPass* renderPass = findRenderPassById(quad.renderPassId(), frame);
+    const RenderPass* renderPass = findRenderPassById(quad.render_pass_id, frame);
     const RenderPassList& renderPasses = frame.renderPasses;
     RenderPassList::const_iterator foundPass = std::find(renderPasses.begin(), renderPasses.end(), renderPass);
 
@@ -592,7 +592,7 @@ bool LayerTreeHostImpl::CullRenderPassesWithNoQuads::shouldRemoveRenderPass(cons
         if (currentQuad->material != DrawQuad::RENDER_PASS)
             return false;
 
-        const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::materialCast(currentQuad)->renderPassId(), frame);
+        const RenderPass* contributingPass = findRenderPassById(RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id, frame);
         RenderPassList::const_iterator foundContributingPass = std::find(renderPasses.begin(), renderPasses.end(), contributingPass);
         if (foundContributingPass != renderPasses.end())
             return false;
@@ -629,7 +629,7 @@ void LayerTreeHostImpl::removeRenderPasses(RenderPassCuller culler, FrameData& f
             // change. So, capture the iterator position from the end of the
             // list, and restore it after the change.
             int positionFromEnd = frame.renderPasses.size() - it;
-            removeRenderPassesRecursive(renderPassQuad->renderPassId(), frame);
+            removeRenderPassesRecursive(renderPassQuad->render_pass_id, frame);
             it = frame.renderPasses.size() - positionFromEnd;
             DCHECK(it >= 0);
         }
diff --git a/cc/layer_tree_host_impl_unittest.cc b/cc/layer_tree_host_impl_unittest.cc
index 35017a4..6b7463c 100644
--- a/cc/layer_tree_host_impl_unittest.cc
+++ b/cc/layer_tree_host_impl_unittest.cc
@@ -1602,7 +1602,8 @@ public:
             opaqueRect = m_opaqueContentRect;
 
         SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
+        scoped_ptr<TileDrawQuad> testBlendingDrawQuad = TileDrawQuad::Create();
+        testBlendingDrawQuad->SetNew(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, gfx::RectF(0, 0, 1, 1), gfx::Size(1, 1), false, false, false, false, false);
         testBlendingDrawQuad->visible_rect = m_quadVisibleRect;
         EXPECT_EQ(m_blend, testBlendingDrawQuad->ShouldDrawWithBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
@@ -2105,7 +2106,8 @@ public:
 
         SkColor gray = SkColorSetRGB(100, 100, 100);
         gfx::Rect quadRect(gfx::Point(0, 0), contentBounds());
-        scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::create(sharedQuadState, quadRect, gray);
+        scoped_ptr<SolidColorDrawQuad> myQuad = SolidColorDrawQuad::Create();
+        myQuad->SetNew(sharedQuadState, quadRect, gray);
         quadSink.append(myQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
@@ -2714,7 +2716,8 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid
 
     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<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), false);
+    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);
 
     pass->appendSharedQuadState(sharedState.Pass());
     pass->appendQuad(quad.PassAs<DrawQuad>());
@@ -3158,8 +3161,8 @@ TEST_P(LayerTreeHostImplTest, textureCachingWithClipping)
         EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), frame.renderPasses[0]->outputRect());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        EXPECT_FALSE(quad->contentsChangedSinceLastFrame().IsEmpty());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        EXPECT_FALSE(quad->contents_changed_since_last_frame.IsEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
@@ -3816,8 +3819,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_FALSE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3834,8 +3837,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3853,8 +3856,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3874,8 +3877,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_FALSE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3901,8 +3904,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         // Was our surface evicted?
@@ -3922,8 +3925,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3943,8 +3946,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCaching)
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -3975,8 +3978,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_FALSE(targetPass->damageRect().IsEmpty());
 
         EXPECT_FALSE(frame.renderPasses[0]->damageRect().IsEmpty());
@@ -4017,8 +4020,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -4038,8 +4041,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quadList()[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_FALSE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -4065,8 +4068,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
         EXPECT_EQ(1U, frame.renderPasses[1]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[1]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         // Was our surface evicted?
@@ -4104,8 +4107,8 @@ TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
         EXPECT_EQ(1U, frame.renderPasses[0]->quadList().size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quadList()[0]->material);
-        const RenderPassDrawQuad* quad = RenderPassDrawQuad::materialCast(frame.renderPasses[0]->quadList()[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->renderPassId());
+        const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quadList()[0]);
+        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
         EXPECT_TRUE(targetPass->damageRect().IsEmpty());
 
         myHostImpl->drawLayers(frame);
@@ -4212,7 +4215,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
-                scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
+                scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+                quad->SetNew(testData.sharedQuadState.get(), gfx::Rect(0, 0, 10, 10), SK_ColorWHITE);
                 
                 renderPass->appendQuad(quad.PassAs<DrawQuad>());
                 currentChar++;
@@ -4254,7 +4258,8 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
 
                 gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1);
                 gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect();
-                scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
+                scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+                quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
                 renderPass->appendQuad(quad.PassAs<DrawQuad>());
             }
         }
@@ -4284,9 +4289,9 @@ void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buf
                 pos++;
                 break;
             case DrawQuad::RENDER_PASS:
-                *pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().layerId;
+                *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.layerId;
                 pos++;
-                *pos = RenderPassDrawQuad::materialCast(currentQuad)->renderPassId().index;
+                *pos = RenderPassDrawQuad::MaterialCast(currentQuad)->render_pass_id.index;
                 pos++;
                 break;
             default:
diff --git a/cc/nine_patch_layer_impl.cc b/cc/nine_patch_layer_impl.cc
index 5da260d..c386670 100644
--- a/cc/nine_patch_layer_impl.cc
+++ b/cc/nine_patch_layer_impl.cc
@@ -86,15 +86,39 @@ void NinePatchLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
     // Nothing is opaque here.
     // TODO(danakj): Should we look at the SkBitmaps to determine opaqueness?
     gfx::Rect opaqueRect;
+    scoped_ptr<TextureDrawQuad> quad;
 
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped).PassAs<DrawQuad>(), appendQuadsData);
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped).PassAs<DrawQuad>(), appendQuadsData);
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, topLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvTopLeft, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, topRight, opaqueRect, m_resourceId, premultipliedAlpha, uvTopRight, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, bottomLeft, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomLeft, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, bottomRight, opaqueRect, m_resourceId, premultipliedAlpha, uvBottomRight, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, top, opaqueRect, m_resourceId, premultipliedAlpha, uvTop, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, left, opaqueRect, m_resourceId, premultipliedAlpha, uvLeft, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, right, opaqueRect, m_resourceId, premultipliedAlpha, uvRight, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+
+    quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, bottom, opaqueRect, m_resourceId, premultipliedAlpha, uvBottom, flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void NinePatchLayerImpl::didDraw(ResourceProvider* resourceProvider)
diff --git a/cc/nine_patch_layer_impl_unittest.cc b/cc/nine_patch_layer_impl_unittest.cc
index b24f569..e63f25c 100644
--- a/cc/nine_patch_layer_impl_unittest.cc
+++ b/cc/nine_patch_layer_impl_unittest.cc
@@ -75,8 +75,8 @@ TEST(NinePatchLayerImplTest, verifyDrawQuads)
     Region texRemaining(bitmapRect);
     for (size_t i = 0; i < quads.size(); ++i) {
         DrawQuad* quad = quads[i];
-        const TextureDrawQuad* texQuad = TextureDrawQuad::materialCast(quad);
-        gfx::RectF texRect = texQuad->uvRect();
+        const TextureDrawQuad* texQuad = TextureDrawQuad::MaterialCast(quad);
+        gfx::RectF texRect = texQuad->uv_rect;
         texRect.Scale(bitmapSize.width(), bitmapSize.height());
         texRemaining.Subtract(Region(ToRoundedIntRect(texRect)));
     }
diff --git a/cc/picture_layer_impl.cc b/cc/picture_layer_impl.cc
index 658c68f..5c1d8e8 100644
--- a/cc/picture_layer_impl.cc
+++ b/cc/picture_layer_impl.cc
@@ -61,18 +61,19 @@ void PictureLayerImpl::appendQuads(QuadSink& quadSink,
     bool outside_right_edge = geometry_rect.right() == content_rect.right();
     bool outside_bottom_edge = geometry_rect.bottom() == content_rect.bottom();
 
-    quadSink.append(TileDrawQuad::create(
-        sharedQuadState,
-        geometry_rect,
-        opaque_rect,
-        resource,
-        texture_rect,
-        iter.texture_size(),
-        iter->contents_swizzled(),
-        outside_left_edge && useAA,
-        outside_top_edge && useAA,
-        outside_right_edge && useAA,
-        outside_bottom_edge && useAA).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+    quad->SetNew(sharedQuadState,
+                 geometry_rect,
+                 opaque_rect,
+                 resource,
+                 texture_rect,
+                 iter.texture_size(),
+                 iter->contents_swizzled(),
+                 outside_left_edge && useAA,
+                 outside_top_edge && useAA,
+                 outside_right_edge && useAA,
+                 outside_bottom_edge && useAA);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
   }
 }
 
diff --git a/cc/quad_culler.cc b/cc/quad_culler.cc
index 5ac52ae..fe2072a 100644
--- a/cc/quad_culler.cc
+++ b/cc/quad_culler.cc
@@ -53,7 +53,9 @@ static inline bool appendQuadInternal(scoped_ptr<DrawQuad> drawQuad, const gfx::
         if (createDebugBorderQuads && !drawQuad->IsDebugQuad() && drawQuad->visible_rect != drawQuad->rect) {
             SkColor color = DebugColors::CulledTileBorderColor();
             float width = DebugColors::CulledTileBorderWidth(layer ? layer->layerTreeHostImpl() : NULL);
-            quadList.append(DebugBorderDrawQuad::create(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width).PassAs<DrawQuad>());
+            scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
+            debugBorderQuad->SetNew(drawQuad->shared_quad_state, drawQuad->visible_rect, color, width);
+            quadList.append(debugBorderQuad.PassAs<DrawQuad>());
         }
 
         // Pass the quad after we're done using it.
diff --git a/cc/render_pass.cc b/cc/render_pass.cc
index 01d7877..ac8dea4 100644
--- a/cc/render_pass.cc
+++ b/cc/render_pass.cc
@@ -99,7 +99,9 @@ void RenderPass::appendQuadsToFillScreen(LayerImpl* rootLayer, SkColor screenBac
         // The root layer transform is composed of translations and scales only, no perspective, so mapping is sufficient.
         gfx::Rect layerRect = MathUtil::mapClippedRect(transformToLayerSpace, fillRects.rect());
         // Skip the quad culler and just append the quads directly to avoid occlusion checks.
-        m_quadList.append(SolidColorDrawQuad::create(sharedQuadState, layerRect, screenBackgroundColor).PassAs<DrawQuad>());
+        scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+        quad->SetNew(sharedQuadState, layerRect, screenBackgroundColor);
+        m_quadList.append(quad.PassAs<DrawQuad>());
     }
 }
 
diff --git a/cc/render_pass_draw_quad.cc b/cc/render_pass_draw_quad.cc
index 6a06825..937a621 100644
--- a/cc/render_pass_draw_quad.cc
+++ b/cc/render_pass_draw_quad.cc
@@ -6,42 +6,89 @@
 
 namespace cc {
 
-scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, const ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY)
-{
-    return make_scoped_ptr(new RenderPassDrawQuad(sharedQuadState, quadRect, renderPassId, isReplica, maskResourceId, contentsChangedSinceLastFrame, maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY));
+RenderPassDrawQuad::RenderPassDrawQuad()
+    : render_pass_id(RenderPass::Id(-1, -1)),
+      is_replica(false),
+      mask_resource_id(-1),
+      mask_tex_coord_scale_x(0),
+      mask_tex_coord_scale_y(0),
+      mask_tex_coord_offset_x(0),
+      mask_tex_coord_offset_y(0) {
 }
 
-RenderPassDrawQuad::RenderPassDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY)
-    : m_renderPassId(renderPassId)
-    , m_isReplica(isReplica)
-    , m_maskResourceId(maskResourceId)
-    , m_contentsChangedSinceLastFrame(contentsChangedSinceLastFrame)
-    , m_maskTexCoordScaleX(maskTexCoordScaleX)
-    , m_maskTexCoordScaleY(maskTexCoordScaleY)
-    , m_maskTexCoordOffsetX(maskTexCoordOffsetX)
-    , m_maskTexCoordOffsetY(maskTexCoordOffsetY)
-{
-    DCHECK(m_renderPassId.layerId > 0);
-    DCHECK(m_renderPassId.index >= 0);
-
-    gfx::Rect opaqueRect;
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::RENDER_PASS, quadRect, opaqueRect, visibleRect, needsBlending);
+scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Create() {
+    return make_scoped_ptr(new RenderPassDrawQuad);
 }
 
-const RenderPassDrawQuad* RenderPassDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::RENDER_PASS);
-    return static_cast<const RenderPassDrawQuad*>(quad);
+scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::Copy(
+    const SharedQuadState* copied_shared_quad_state,
+    RenderPass::Id copied_render_pass_id) const {
+  scoped_ptr<RenderPassDrawQuad> copy_quad(new RenderPassDrawQuad(*MaterialCast(this)));
+  copy_quad->shared_quad_state = copied_shared_quad_state;
+  copy_quad->render_pass_id = copied_render_pass_id;
+  return copy_quad.Pass();
 }
 
-scoped_ptr<RenderPassDrawQuad> RenderPassDrawQuad::copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const
-{
-    scoped_ptr<RenderPassDrawQuad> copyQuad(new RenderPassDrawQuad(*materialCast(this)));
-    copyQuad->shared_quad_state = copiedSharedQuadState;
-    copyQuad->m_renderPassId = copiedRenderPassId;
-    return copyQuad.Pass();
+void RenderPassDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                gfx::Rect rect,
+                                RenderPass::Id render_pass_id,
+                                bool is_replica,
+                                ResourceProvider::ResourceId mask_resource_id,
+                                gfx::Rect contents_changed_since_last_frame,
+                                float mask_tex_coord_scale_x,
+                                float mask_tex_coord_scale_y,
+                                float mask_tex_coord_offset_x,
+                                float mask_tex_coord_offset_y) {
+  DCHECK(render_pass_id.layerId > 0);
+  DCHECK(render_pass_id.index >= 0);
+
+  gfx::Rect opaque_rect;
+  gfx::Rect visible_rect = rect;
+  bool needs_blending = false;
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->render_pass_id = render_pass_id;
+  this->is_replica = is_replica;
+  this->mask_resource_id = mask_resource_id;
+  this->contents_changed_since_last_frame = contents_changed_since_last_frame;
+  this->mask_tex_coord_scale_x = mask_tex_coord_scale_x;
+  this->mask_tex_coord_scale_y = mask_tex_coord_scale_y;
+  this->mask_tex_coord_offset_x = mask_tex_coord_offset_x;
+  this->mask_tex_coord_offset_y = mask_tex_coord_offset_y;
+}
+
+void RenderPassDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                                gfx::Rect rect,
+                                gfx::Rect opaque_rect,
+                                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,
+                                float mask_tex_coord_scale_x,
+                                float mask_tex_coord_scale_y,
+                                float mask_tex_coord_offset_x,
+                                float mask_tex_coord_offset_y) {
+  DCHECK(render_pass_id.layerId > 0);
+  DCHECK(render_pass_id.index >= 0);
+
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::RENDER_PASS, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->render_pass_id = render_pass_id;
+  this->is_replica = is_replica;
+  this->mask_resource_id = mask_resource_id;
+  this->contents_changed_since_last_frame = contents_changed_since_last_frame;
+  this->mask_tex_coord_scale_x = mask_tex_coord_scale_x;
+  this->mask_tex_coord_scale_y = mask_tex_coord_scale_y;
+  this->mask_tex_coord_offset_x = mask_tex_coord_offset_x;
+  this->mask_tex_coord_offset_y = mask_tex_coord_offset_y;
+}
+
+const RenderPassDrawQuad* RenderPassDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::RENDER_PASS);
+  return static_cast<const RenderPassDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/render_pass_draw_quad.h b/cc/render_pass_draw_quad.h
index f58a7ec9..b4c7c75 100644
--- a/cc/render_pass_draw_quad.h
+++ b/cc/render_pass_draw_quad.h
@@ -15,33 +15,51 @@
 namespace cc {
 
 class CC_EXPORT RenderPassDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<RenderPassDrawQuad> create(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY);
+ public:
+  static scoped_ptr<RenderPassDrawQuad> Create();
 
-    RenderPass::Id renderPassId() const { return m_renderPassId; }
-    bool isReplica() const { return m_isReplica; }
-    ResourceProvider::ResourceId maskResourceId() const { return m_maskResourceId; }
-    const gfx::Rect& contentsChangedSinceLastFrame() const { return m_contentsChangedSinceLastFrame; }
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              RenderPass::Id render_pass_id,
+              bool is_replica,
+              ResourceProvider::ResourceId mask_resource_id,
+              gfx::Rect contents_changed_since_last_frame,
+              float mask_tex_coord_scale_x,
+              float mask_tex_coord_scale_y,
+              float mask_tex_coord_offset_x,
+              float mask_tex_coord_offset_y);
 
-    static const RenderPassDrawQuad* materialCast(const DrawQuad*);
-    float maskTexCoordScaleX() const { return m_maskTexCoordScaleX; }
-    float maskTexCoordScaleY() const { return m_maskTexCoordScaleY; }
-    float maskTexCoordOffsetX() const { return m_maskTexCoordOffsetX; }
-    float maskTexCoordOffsetY() const { return m_maskTexCoordOffsetY; }
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              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,
+              float mask_tex_coord_scale_x,
+              float mask_tex_coord_scale_y,
+              float mask_tex_coord_offset_x,
+              float mask_tex_coord_offset_y);
 
-    scoped_ptr<RenderPassDrawQuad> copy(const SharedQuadState* copiedSharedQuadState, RenderPass::Id copiedRenderPassId) const;
+  scoped_ptr<RenderPassDrawQuad> Copy(
+      const SharedQuadState* copied_shared_quad_state,
+      RenderPass::Id copied_render_pass_id) const;
 
+  RenderPass::Id render_pass_id;
+  bool is_replica;
+  ResourceProvider::ResourceId mask_resource_id;
+  gfx::Rect contents_changed_since_last_frame;
+  // TODO(danakj): Make these a tex_coord_rect like TileDrawQuad.
+  float mask_tex_coord_scale_x;
+  float mask_tex_coord_scale_y;
+  float mask_tex_coord_offset_x;
+  float mask_tex_coord_offset_y;
+
+  static const RenderPassDrawQuad* MaterialCast(const DrawQuad*);
 private:
-    RenderPassDrawQuad(const SharedQuadState*, const gfx::Rect&, RenderPass::Id renderPassId, bool isReplica, ResourceProvider::ResourceId maskResourceId, const gfx::Rect& contentsChangedSinceLastFrame, float maskTexCoordScaleX, float maskTexCoordScaleY, float maskTexCoordOffsetX, float maskTexCoordOffsetY);
-
-    RenderPass::Id m_renderPassId;
-    bool m_isReplica;
-    ResourceProvider::ResourceId m_maskResourceId;
-    gfx::Rect m_contentsChangedSinceLastFrame;
-    float m_maskTexCoordScaleX;
-    float m_maskTexCoordScaleY;
-    float m_maskTexCoordOffsetX;
-    float m_maskTexCoordOffsetY;
+  RenderPassDrawQuad();
 };
 
 }
diff --git a/cc/render_pass_unittest.cc b/cc/render_pass_unittest.cc
index 2ba9624..6666986 100644
--- a/cc/render_pass_unittest.cc
+++ b/cc/render_pass_unittest.cc
@@ -62,7 +62,10 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
 
     // Stick a quad in the pass, this should not get copied.
     pass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1));
-    pass->quadList().append(CheckerboardDrawQuad::create(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor()).PassAs<DrawQuad>());
+
+    scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
+    checkerboardQuad->SetNew(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor());
+    pass->quadList().append(checkerboardQuad.PassAs<DrawQuad>());
 
     RenderPass::Id newId(63, 4);
 
diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc
index 3f3d3d1..83be66da 100644
--- a/cc/render_surface_impl.cc
+++ b/cc/render_surface_impl.cc
@@ -203,7 +203,9 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
     if (m_owningLayer->showDebugBorders()) {
         SkColor color = forReplica ? DebugColors::SurfaceReplicaBorderColor() : DebugColors::SurfaceBorderColor();
         float width = forReplica ? DebugColors::SurfaceReplicaBorderWidth(m_owningLayer->layerTreeHostImpl()) : DebugColors::SurfaceBorderWidth(m_owningLayer->layerTreeHostImpl());
-        quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, contentRect(), color, width).PassAs<DrawQuad>(), appendQuadsData);
+        scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
+        debugBorderQuad->SetNew(sharedQuadState, contentRect(), color, width);
+        quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
     // FIXME: By using the same RenderSurfaceImpl for both the content and its reflection,
@@ -236,8 +238,10 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
     ResourceProvider::ResourceId maskResourceId = maskLayer ? maskLayer->contentsResourceId() : 0;
     gfx::Rect contentsChangedSinceLastFrame = contentsChanged() ? m_contentRect : gfx::Rect();
 
-    quadSink.append(RenderPassDrawQuad::create(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
-                                               maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+    quad->SetNew(sharedQuadState, contentRect(), renderPassId, forReplica, maskResourceId, contentsChangedSinceLastFrame,
+                 maskTexCoordScaleX, maskTexCoordScaleY, maskTexCoordOffsetX, maskTexCoordOffsetY);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 }  // namespace cc
diff --git a/cc/scrollbar_layer_impl.cc b/cc/scrollbar_layer_impl.cc
index 2b82529..5b6968dc 100644
--- a/cc/scrollbar_layer_impl.cc
+++ b/cc/scrollbar_layer_impl.cc
@@ -97,7 +97,8 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
     if (m_thumbResourceId && !thumbRect.isEmpty()) {
         gfx::Rect quadRect(scrollbarLayerRectToContentRect(thumbRect));
         gfx::Rect opaqueRect;
-        scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped);
+        scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+        quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_thumbResourceId, premultipledAlpha, uvRect, flipped);
         quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
@@ -108,7 +109,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
     if (m_foreTrackResourceId && !foreTrackRect.isEmpty()) {
         gfx::Rect quadRect(scrollbarLayerRectToContentRect(foreTrackRect));
         gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
-        quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped).PassAs<DrawQuad>(), appendQuadsData);
+        scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+        quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_foreTrackResourceId, premultipledAlpha, toUVRect(foreTrackRect, boundsRect), flipped);
+        quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
     }
 
     // Order matters here: since the back track texture is being drawn to the entire contents rect, we must append it after the thumb and
@@ -116,7 +119,9 @@ void ScrollbarLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& append
     if (!contentBoundsRect.IsEmpty()) {
         gfx::Rect quadRect(contentBoundsRect);
         gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
-        quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped).PassAs<DrawQuad>(), appendQuadsData);
+        scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+        quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_backTrackResourceId, premultipledAlpha, uvRect, flipped);
+        quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
     }
 }
 
diff --git a/cc/software_renderer.cc b/cc/software_renderer.cc
index e22ecec..d6a3905 100644
--- a/cc/software_renderer.cc
+++ b/cc/software_renderer.cc
@@ -189,19 +189,19 @@ void SoftwareRenderer::drawQuad(DrawingFrame& frame, const DrawQuad* quad)
 
     switch (quad->material) {
     case DrawQuad::DEBUG_BORDER:
-        drawDebugBorderQuad(frame, DebugBorderDrawQuad::materialCast(quad));
+        drawDebugBorderQuad(frame, DebugBorderDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::SOLID_COLOR:
-        drawSolidColorQuad(frame, SolidColorDrawQuad::materialCast(quad));
+        drawSolidColorQuad(frame, SolidColorDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::TEXTURE_CONTENT:
-        drawTextureQuad(frame, TextureDrawQuad::materialCast(quad));
+        drawTextureQuad(frame, TextureDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::TILED_CONTENT:
-        drawTileQuad(frame, TileDrawQuad::materialCast(quad));
+        drawTileQuad(frame, TileDrawQuad::MaterialCast(quad));
         break;
     case DrawQuad::RENDER_PASS:
-        drawRenderPassQuad(frame, RenderPassDrawQuad::materialCast(quad));
+        drawRenderPassQuad(frame, RenderPassDrawQuad::MaterialCast(quad));
         break;
     default:
         drawUnsupportedQuad(frame, quad);
@@ -220,33 +220,33 @@ void SoftwareRenderer::drawDebugBorderQuad(const DrawingFrame& frame, const Debu
     m_skCurrentCanvas->getTotalMatrix().mapPoints(transformedVertices, vertices, 4);
     m_skCurrentCanvas->resetMatrix();
 
-    m_skCurrentPaint.setColor(quad->color());
-    m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
+    m_skCurrentPaint.setColor(quad->color);
+    m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color));
     m_skCurrentPaint.setStyle(SkPaint::kStroke_Style);
-    m_skCurrentPaint.setStrokeWidth(quad->width());
+    m_skCurrentPaint.setStrokeWidth(quad->width);
     m_skCurrentCanvas->drawPoints(SkCanvas::kPolygon_PointMode, 4, transformedVertices, m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawSolidColorQuad(const DrawingFrame& frame, const SolidColorDrawQuad* quad)
 {
-    m_skCurrentPaint.setColor(quad->color());
-    m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color()));
+    m_skCurrentPaint.setColor(quad->color);
+    m_skCurrentPaint.setAlpha(quad->opacity() * SkColorGetA(quad->color));
     m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
 void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
-    if (!isSoftwareResource(quad->resourceId())) {
+    if (!isSoftwareResource(quad->resource_id)) {
         drawUnsupportedQuad(frame, quad);
         return;
     }
 
     // FIXME: Add support for non-premultiplied alpha.
-    ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
+    ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id);
     const SkBitmap* bitmap = lock.skBitmap();
-    gfx::RectF uvRect = gfx::ScaleRect(quad->uvRect(), bitmap->width(), bitmap->height());
+    gfx::RectF uvRect = gfx::ScaleRect(quad->uv_rect, bitmap->width(), bitmap->height());
     SkRect skUvRect = gfx::RectFToSkRect(uvRect);
-    if (quad->flipped())
+    if (quad->flipped)
         m_skCurrentCanvas->scale(1, -1);
     m_skCurrentCanvas->drawBitmapRectToRect(*bitmap, &skUvRect,
                                             gfx::RectFToSkRect(quadVertexRect()),
@@ -255,10 +255,10 @@ void SoftwareRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureD
 
 void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQuad* quad)
 {
-    DCHECK(isSoftwareResource(quad->resourceId()));
-    ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resourceId());
+    DCHECK(isSoftwareResource(quad->resource_id));
+    ResourceProvider::ScopedReadLockSoftware lock(m_resourceProvider, quad->resource_id);
 
-    SkRect uvRect = gfx::RectFToSkRect(quad->texCoordRect());
+    SkRect uvRect = gfx::RectFToSkRect(quad->tex_coord_rect);
     m_skCurrentPaint.setFilterBitmap(true);
     m_skCurrentCanvas->drawBitmapRectToRect(*lock.skBitmap(), &uvRect,
                                             gfx::RectFToSkRect(quadVertexRect()),
@@ -267,11 +267,11 @@ void SoftwareRenderer::drawTileQuad(const DrawingFrame& frame, const TileDrawQua
 
 void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const RenderPassDrawQuad* quad)
 {
-    CachedResource* contentTexture = m_renderPassTextures.get(quad->renderPassId());
+    CachedResource* contentTexture = m_renderPassTextures.get(quad->render_pass_id);
     if (!contentTexture || !contentTexture->id())
         return;
 
-    const RenderPass* renderPass = frame.renderPassesById->get(quad->renderPassId());
+    const RenderPass* renderPass = frame.renderPassesById->get(quad->render_pass_id);
     DCHECK(renderPass);
     if (!renderPass)
         return;
@@ -299,16 +299,16 @@ void SoftwareRenderer::drawRenderPassQuad(const DrawingFrame& frame, const Rende
     if (filter)
         m_skCurrentPaint.setImageFilter(filter);
 
-    if (quad->maskResourceId()) {
-        ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->maskResourceId());
+    if (quad->mask_resource_id) {
+        ResourceProvider::ScopedReadLockSoftware maskLock(m_resourceProvider, quad->mask_resource_id);
 
         const SkBitmap* mask = maskLock.skBitmap();
 
         SkRect maskRect = SkRect::MakeXYWH(
-            quad->maskTexCoordOffsetX() * mask->width(),
-            quad->maskTexCoordOffsetY() * mask->height(),
-            quad->maskTexCoordScaleX() * mask->width(),
-            quad->maskTexCoordScaleY() * mask->height());
+            quad->mask_tex_coord_offset_x * mask->width(),
+            quad->mask_tex_coord_offset_y * mask->height(),
+            quad->mask_tex_coord_scale_x * mask->width(),
+            quad->mask_tex_coord_scale_y * mask->height());
 
         SkMatrix maskMat;
         maskMat.setRectToRect(maskRect, destRect, SkMatrix::kFill_ScaleToFit);
diff --git a/cc/software_renderer_unittest.cc b/cc/software_renderer_unittest.cc
index 0051336..234a6f0 100644
--- a/cc/software_renderer_unittest.cc
+++ b/cc/software_renderer_unittest.cc
@@ -69,10 +69,12 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
-    scoped_ptr<DrawQuad> outerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), outerRect, SK_ColorYELLOW).PassAs<DrawQuad>();
-    scoped_ptr<DrawQuad> innerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), innerRect, SK_ColorCYAN).PassAs<DrawQuad>();
-    rootRenderPass->appendQuad(innerQuad.Pass());
-    rootRenderPass->appendQuad(outerQuad.Pass());
+    scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
+    outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
+    scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create();
+    innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN);
+    rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
+    rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
 
     RenderPassList list;
     RenderPassIdHashMap hashmap;
@@ -126,10 +128,12 @@ TEST_F(SoftwareRendererTest, tileQuad)
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(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<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false).PassAs<DrawQuad>();
-    scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false).PassAs<DrawQuad>();
-    rootRenderPass->appendQuad(innerQuad.Pass());
-    rootRenderPass->appendQuad(outerQuad.Pass());
+    scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
+    outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false);
+    scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
+    innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false);
+    rootRenderPass->appendQuad(innerQuad.PassAs<DrawQuad>());
+    rootRenderPass->appendQuad(outerQuad.PassAs<DrawQuad>());
 
     RenderPassList list;
     RenderPassIdHashMap hashmap;
diff --git a/cc/solid_color_draw_quad.cc b/cc/solid_color_draw_quad.cc
index d6daad2..54a9b75 100644
--- a/cc/solid_color_draw_quad.cc
+++ b/cc/solid_color_draw_quad.cc
@@ -8,24 +8,38 @@
 
 namespace cc {
 
-scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
-{
-    return make_scoped_ptr(new SolidColorDrawQuad(sharedQuadState, quadRect, color));
+SolidColorDrawQuad::SolidColorDrawQuad() : color(0) {}
+
+scoped_ptr<SolidColorDrawQuad> SolidColorDrawQuad::Create() {
+  return make_scoped_ptr(new SolidColorDrawQuad);
+}
+
+void SolidColorDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                gfx::Rect 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::SOLID_COLOR, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->color = color;
 }
 
-SolidColorDrawQuad::SolidColorDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, SkColor color)
-    : m_color(color)
-{
-    gfx::Rect opaqueRect = SkColorGetA(m_color) == 255 ? quadRect : gfx::Rect();
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::SOLID_COLOR, quadRect, opaqueRect, visibleRect, needsBlending);
+void SolidColorDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                                gfx::Rect rect,
+                                gfx::Rect opaque_rect,
+                                gfx::Rect visible_rect,
+                                bool needs_blending,
+                                SkColor color) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::SOLID_COLOR, rect, opaque_rect,
+                   visible_rect, needs_blending);
+  this->color = color;
 }
 
-const SolidColorDrawQuad* SolidColorDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::SOLID_COLOR);
-    return static_cast<const SolidColorDrawQuad*>(quad);
+const SolidColorDrawQuad* SolidColorDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::SOLID_COLOR);
+  return static_cast<const SolidColorDrawQuad*>(quad);
 }
 
 }  // namespacec cc
diff --git a/cc/solid_color_draw_quad.h b/cc/solid_color_draw_quad.h
index e816936..c8dd0c0 100644
--- a/cc/solid_color_draw_quad.h
+++ b/cc/solid_color_draw_quad.h
@@ -13,16 +13,25 @@
 namespace cc {
 
 class CC_EXPORT SolidColorDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<SolidColorDrawQuad> create(const SharedQuadState*, const gfx::Rect&, SkColor);
+ public:
+  static scoped_ptr<SolidColorDrawQuad> Create();
 
-    SkColor color() const { return m_color; };
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              SkColor color);
 
-    static const SolidColorDrawQuad* materialCast(const DrawQuad*);
-private:
-    SolidColorDrawQuad(const SharedQuadState*, const gfx::Rect&, SkColor);
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              SkColor color);
 
-    SkColor m_color;
+  SkColor color;
+
+  static const SolidColorDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  SolidColorDrawQuad();
 };
 
 }
diff --git a/cc/solid_color_layer_impl.cc b/cc/solid_color_layer_impl.cc
index cf11f86..fb4429f 100644
--- a/cc/solid_color_layer_impl.cc
+++ b/cc/solid_color_layer_impl.cc
@@ -33,7 +33,9 @@ void SolidColorLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appen
     for (int x = 0; x < width; x += m_tileSize) {
         for (int y = 0; y < height; y += m_tileSize) {
             gfx::Rect solidTileRect(x, y, std::min(width - x, m_tileSize), std::min(height - y, m_tileSize));
-            quadSink.append(SolidColorDrawQuad::create(sharedQuadState, solidTileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
+            scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+            quad->SetNew(sharedQuadState, solidTileRect, backgroundColor());
+            quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
diff --git a/cc/solid_color_layer_impl_unittest.cc b/cc/solid_color_layer_impl_unittest.cc
index bf289e5..5cb4ebd 100644
--- a/cc/solid_color_layer_impl_unittest.cc
+++ b/cc/solid_color_layer_impl_unittest.cc
@@ -57,7 +57,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectBackgroundColorInQuad)
     layer->appendQuads(quadCuller, data);
 
     ASSERT_EQ(quadCuller.quadList().size(), 1U);
-    EXPECT_EQ(SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->color(), testColor);
+    EXPECT_EQ(SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->color, testColor);
 }
 
 TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad)
@@ -80,7 +80,7 @@ TEST(SolidColorLayerImplTest, verifyCorrectOpacityInQuad)
     layer->appendQuads(quadCuller, data);
 
     ASSERT_EQ(quadCuller.quadList().size(), 1U);
-    EXPECT_EQ(opacity, SolidColorDrawQuad::materialCast(quadCuller.quadList()[0])->opacity());
+    EXPECT_EQ(opacity, SolidColorDrawQuad::MaterialCast(quadCuller.quadList()[0])->opacity());
 }
 
 TEST(SolidColorLayerImplTest, verifyOpaqueRect)
diff --git a/cc/stream_video_draw_quad.cc b/cc/stream_video_draw_quad.cc
index 24ef430..0286a19 100644
--- a/cc/stream_video_draw_quad.cc
+++ b/cc/stream_video_draw_quad.cc
@@ -8,24 +8,42 @@
 
 namespace cc {
 
-scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix)
-{
-    return make_scoped_ptr(new StreamVideoDrawQuad(sharedQuadState, quadRect, opaqueRect, textureId, matrix));
+StreamVideoDrawQuad::StreamVideoDrawQuad() : texture_id(0) {}
+
+scoped_ptr<StreamVideoDrawQuad> StreamVideoDrawQuad::Create() {
+  return make_scoped_ptr(new StreamVideoDrawQuad);
+}
+
+void StreamVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                                 gfx::Rect rect,
+                                 gfx::Rect opaque_rect,
+                                 unsigned texture_id,
+                                 const WebKit::WebTransformationMatrix& 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);
+  this->texture_id = texture_id;
+  this->matrix = matrix;
 }
 
-StreamVideoDrawQuad::StreamVideoDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix& matrix)
-    : m_textureId(textureId)
-    , m_matrix(matrix)
-{
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::STREAM_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
+void StreamVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                                 gfx::Rect rect,
+                                 gfx::Rect opaque_rect,
+                                 gfx::Rect visible_rect,
+                                 bool needs_blending,
+                                 unsigned texture_id,
+                                 const WebKit::WebTransformationMatrix& matrix) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::STREAM_VIDEO_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->texture_id = texture_id;
+  this->matrix = matrix;
 }
 
-const StreamVideoDrawQuad* StreamVideoDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT);
-    return static_cast<const StreamVideoDrawQuad*>(quad);
+const StreamVideoDrawQuad* StreamVideoDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::STREAM_VIDEO_CONTENT);
+  return static_cast<const StreamVideoDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/stream_video_draw_quad.h b/cc/stream_video_draw_quad.h
index 508a001..9e6154b 100644
--- a/cc/stream_video_draw_quad.h
+++ b/cc/stream_video_draw_quad.h
@@ -13,18 +13,29 @@
 namespace cc {
 
 class CC_EXPORT StreamVideoDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<StreamVideoDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&);
-
-    unsigned textureId() const { return m_textureId; }
-    const WebKit::WebTransformationMatrix& matrix() const { return m_matrix; }
-
-    static const StreamVideoDrawQuad* materialCast(const DrawQuad*);
-private:
-    StreamVideoDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned textureId, const WebKit::WebTransformationMatrix&);
-
-    unsigned m_textureId;
-    WebKit::WebTransformationMatrix m_matrix;
+ public:
+  static scoped_ptr<StreamVideoDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              unsigned texture_id,
+              const WebKit::WebTransformationMatrix& matrix);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              unsigned texture_id,
+              const WebKit::WebTransformationMatrix& matrix);
+
+  unsigned texture_id;
+  WebKit::WebTransformationMatrix matrix;
+
+  static const StreamVideoDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  StreamVideoDrawQuad();
 };
 
 }
diff --git a/cc/test/render_pass_test_common.cc b/cc/test/render_pass_test_common.cc
index f8f2e22..5c83150 100644
--- a/cc/test/render_pass_test_common.cc
+++ b/cc/test/render_pass_test_common.cc
@@ -29,18 +29,37 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
     cc::ResourceProvider::ResourceId textureResource = resourceProvider->createResourceFromExternalTexture(1);
     scoped_ptr<cc::SharedQuadState> sharedState = cc::SharedQuadState::create(WebTransformationMatrix(), rect, rect, 1);
 
-    appendQuad(cc::CheckerboardDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>());
-    appendQuad(cc::DebugBorderDrawQuad::create(sharedState.get(), rect, SK_ColorRED, 1).Pass().PassAs<DrawQuad>());
-    appendQuad(cc::IOSurfaceDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::Flipped).PassAs<DrawQuad>());
+    scoped_ptr<cc::CheckerboardDrawQuad> checkerboardQuad = cc::CheckerboardDrawQuad::Create();
+    checkerboardQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
+    appendQuad(checkerboardQuad.PassAs<DrawQuad>());
 
-    cc::RenderPass::Id passId(1, 1);
-    appendQuad(cc::RenderPassDrawQuad::create(sharedState.get(), rect, passId, false, 0, rect, 0, 0, 0, 0).PassAs<DrawQuad>());
+    scoped_ptr<cc::DebugBorderDrawQuad> debugBorderQuad = cc::DebugBorderDrawQuad::Create();
+    debugBorderQuad->SetNew(sharedState.get(), rect, SK_ColorRED, 1);
+    appendQuad(debugBorderQuad.PassAs<DrawQuad>());
 
-    appendQuad(cc::SolidColorDrawQuad::create(sharedState.get(), rect, SK_ColorRED).PassAs<DrawQuad>());
-    appendQuad(cc::StreamVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix()).PassAs<DrawQuad>());
-    appendQuad(cc::TextureDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false).PassAs<DrawQuad>());
+    scoped_ptr<cc::IOSurfaceDrawQuad> ioSurfaceQuad = cc::IOSurfaceDrawQuad::Create();
+    ioSurfaceQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(50, 50), 1, cc::IOSurfaceDrawQuad::FLIPPED);
+    appendQuad(ioSurfaceQuad.PassAs<DrawQuad>());
 
-    appendQuad(cc::TileDrawQuad::create(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false).PassAs<DrawQuad>());
+    scoped_ptr<cc::RenderPassDrawQuad> renderPassQuad = cc::RenderPassDrawQuad::Create();
+    renderPassQuad->SetNew(sharedState.get(), rect, cc::RenderPass::Id(1, 1), false, 0, rect, 0, 0, 0, 0);
+    appendQuad(renderPassQuad.PassAs<DrawQuad>());
+
+    scoped_ptr<cc::SolidColorDrawQuad> solidColorQuad = cc::SolidColorDrawQuad::Create();
+    solidColorQuad->SetNew(sharedState.get(), rect, SK_ColorRED);
+    appendQuad(solidColorQuad.PassAs<DrawQuad>());
+
+    scoped_ptr<cc::StreamVideoDrawQuad> streamVideoQuad = cc::StreamVideoDrawQuad::Create();
+    streamVideoQuad->SetNew(sharedState.get(), rect, opaqueRect, 1, WebKit::WebTransformationMatrix());
+    appendQuad(streamVideoQuad.PassAs<DrawQuad>());
+
+    scoped_ptr<cc::TextureDrawQuad> textureQuad = cc::TextureDrawQuad::Create();
+    textureQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, false, rect, false);
+    appendQuad(textureQuad.PassAs<DrawQuad>());
+
+    scoped_ptr<cc::TileDrawQuad> tileQuad = cc::TileDrawQuad::Create();
+    tileQuad->SetNew(sharedState.get(), rect, opaqueRect, textureResource, gfx::RectF(0, 0, 100, 100), gfx::Size(100, 100), false, false, false, false, false);
+    appendQuad(tileQuad.PassAs<DrawQuad>());
 
     cc::VideoLayerImpl::FramePlane planes[3];
     for (int i = 0; i < 3; ++i) {
@@ -48,7 +67,10 @@ void TestRenderPass::appendOneOfEveryQuadType(cc::ResourceProvider* resourceProv
         planes[i].size = gfx::Size(100, 100);
         planes[i].format = GL_LUMINANCE;
     }
-    appendQuad(cc::YUVVideoDrawQuad::create(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]).PassAs<DrawQuad>());
+    scoped_ptr<cc::YUVVideoDrawQuad> yuvQuad = cc::YUVVideoDrawQuad::Create();
+    yuvQuad->SetNew(sharedState.get(), rect, opaqueRect, gfx::Size(100, 100), planes[0], planes[1], planes[2]);
+    appendQuad(yuvQuad.PassAs<DrawQuad>());
+
     appendSharedQuadState(sharedState.Pass());
 }
 
diff --git a/cc/texture_draw_quad.cc b/cc/texture_draw_quad.cc
index 65ea410..d552c39 100644
--- a/cc/texture_draw_quad.cc
+++ b/cc/texture_draw_quad.cc
@@ -8,26 +8,54 @@
 
 namespace cc {
 
-scoped_ptr<TextureDrawQuad> TextureDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped)
-{
-    return make_scoped_ptr(new TextureDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, premultipliedAlpha, uvRect, flipped));
+TextureDrawQuad::TextureDrawQuad()
+    : resource_id(0),
+      premultiplied_alpha(false),
+      flipped(false) {
 }
 
-TextureDrawQuad::TextureDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped)
-    : m_resourceId(resourceId)
-    , m_premultipliedAlpha(premultipliedAlpha)
-    , m_uvRect(uvRect)
-    , m_flipped(flipped)
-{
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::TEXTURE_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
+scoped_ptr<TextureDrawQuad> TextureDrawQuad::Create() {
+  return make_scoped_ptr(new TextureDrawQuad);
 }
 
-const TextureDrawQuad* TextureDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT);
-    return static_cast<const TextureDrawQuad*>(quad);
+void TextureDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                             gfx::Rect rect,
+                             gfx::Rect opaque_rect,
+                             unsigned resource_id,
+                             bool premultiplied_alpha,
+                             const gfx::RectF& uv_rect,
+                             bool flipped) {
+  gfx::Rect visible_rect = rect;
+  bool needs_blending = false;
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->resource_id = resource_id;
+  this->premultiplied_alpha = premultiplied_alpha;
+  this->uv_rect = uv_rect;
+  this->flipped = flipped;
+}
+
+void TextureDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                             gfx::Rect rect,
+                             gfx::Rect opaque_rect,
+                             gfx::Rect visible_rect,
+                             bool needs_blending,
+                             unsigned resource_id,
+                             bool premultiplied_alpha,
+                             const gfx::RectF& uv_rect,
+                             bool flipped) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::TEXTURE_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->resource_id = resource_id;
+  this->premultiplied_alpha = premultiplied_alpha;
+  this->uv_rect = uv_rect;
+  this->flipped = flipped;
+}
+
+const TextureDrawQuad* TextureDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::TEXTURE_CONTENT);
+  return static_cast<const TextureDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/texture_draw_quad.h b/cc/texture_draw_quad.h
index 5a6d3f3..177febf 100644
--- a/cc/texture_draw_quad.h
+++ b/cc/texture_draw_quad.h
@@ -13,22 +13,35 @@
 namespace cc {
 
 class CC_EXPORT TextureDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<TextureDrawQuad> create(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped);
-    gfx::RectF uvRect() const { return m_uvRect; }
-
-    unsigned resourceId() const { return m_resourceId; }
-    bool premultipliedAlpha() const { return  m_premultipliedAlpha; }
-    bool flipped() const { return m_flipped; }
-
-    static const TextureDrawQuad* materialCast(const DrawQuad*);
-private:
-    TextureDrawQuad(const SharedQuadState*, const gfx::Rect&, const gfx::Rect& opaqueRect, unsigned resourceId, bool premultipliedAlpha, const gfx::RectF& uvRect, bool flipped);
-
-    unsigned m_resourceId;
-    bool m_premultipliedAlpha;
-    gfx::RectF m_uvRect;
-    bool m_flipped;
+ public:
+  static scoped_ptr<TextureDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              unsigned resource_id,
+              bool premultiplied_alpha,
+              const gfx::RectF& uv_rect,
+              bool flipped);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              unsigned resource_id,
+              bool premultiplied_alpha,
+              const gfx::RectF& uv_rect,
+              bool flipped);
+
+  unsigned resource_id;
+  bool premultiplied_alpha;
+  gfx::RectF uv_rect;
+  bool flipped;
+
+  static const TextureDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  TextureDrawQuad();
 };
 
 }
diff --git a/cc/texture_layer_impl.cc b/cc/texture_layer_impl.cc
index 81c58cc..e8a6874 100644
--- a/cc/texture_layer_impl.cc
+++ b/cc/texture_layer_impl.cc
@@ -43,7 +43,9 @@ void TextureLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQu
 
     gfx::Rect quadRect(gfx::Point(), contentBounds());
     gfx::Rect opaqueRect(contentsOpaque() ? quadRect : gfx::Rect());
-    quadSink.append(TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped).PassAs<DrawQuad>(), appendQuadsData);
+    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+    quad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, m_premultipliedAlpha, m_uvRect, m_flipped);
+    quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
 }
 
 void TextureLayerImpl::didDraw(ResourceProvider* resourceProvider)
diff --git a/cc/tile_draw_quad.cc b/cc/tile_draw_quad.cc
index 1f2e9f5..965bb03 100644
--- a/cc/tile_draw_quad.cc
+++ b/cc/tile_draw_quad.cc
@@ -9,30 +9,76 @@
 
 namespace cc {
 
-scoped_ptr<TileDrawQuad> TileDrawQuad::create(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
-{
-    return make_scoped_ptr(new TileDrawQuad(sharedQuadState, quadRect, opaqueRect, resourceId, texCoordRect, textureSize, swizzleContents, leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA));
+TileDrawQuad::TileDrawQuad()
+    : resource_id(0),
+      swizzle_contents(false),
+      left_edge_aa(false),
+      top_edge_aa(false),
+      right_edge_aa(false),
+      bottom_edge_aa(false) {
 }
 
-TileDrawQuad::TileDrawQuad(const SharedQuadState* sharedQuadState, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA)
-    : m_resourceId(resourceId)
-    , m_texCoordRect(texCoordRect)
-    , m_textureSize(textureSize)
-    , m_swizzleContents(swizzleContents)
-    , m_leftEdgeAA(leftEdgeAA)
-    , m_topEdgeAA(topEdgeAA)
-    , m_rightEdgeAA(rightEdgeAA)
-    , m_bottomEdgeAA(bottomEdgeAA)
-{
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = isAntialiased();
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::TILED_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
+scoped_ptr<TileDrawQuad> TileDrawQuad::Create() {
+    return make_scoped_ptr(new TileDrawQuad);
 }
 
-const TileDrawQuad* TileDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::TILED_CONTENT);
-    return static_cast<const TileDrawQuad*>(quad);
+void TileDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                          gfx::Rect rect,
+                          gfx::Rect opaque_rect,
+                          unsigned resource_id,
+                          const gfx::RectF& tex_coord_rect,
+                          gfx::Size texture_size,
+                          bool swizzle_contents,
+                          bool left_edge_aa,
+                          bool top_edge_aa,
+                          bool right_edge_aa,
+                          bool bottom_edge_aa) {
+  gfx::Rect visible_rect = rect;
+  bool needs_blending = false;
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->resource_id = resource_id;
+  this->tex_coord_rect = tex_coord_rect;
+  this->texture_size = texture_size;
+  this->swizzle_contents = swizzle_contents;
+  this->left_edge_aa = left_edge_aa;
+  this->top_edge_aa = top_edge_aa;
+  this->right_edge_aa = right_edge_aa;
+  this->bottom_edge_aa = bottom_edge_aa;
+
+  // Override needs_blending after initializing the quad.
+  this->needs_blending = IsAntialiased();
+}
+
+void TileDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                          gfx::Rect rect,
+                          gfx::Rect opaque_rect,
+                          gfx::Rect visible_rect,
+                          bool needs_blending,
+                          unsigned resource_id,
+                          const gfx::RectF& tex_coord_rect,
+                          gfx::Size texture_size,
+                          bool swizzle_contents,
+                          bool left_edge_aa,
+                          bool top_edge_aa,
+                          bool right_edge_aa,
+                          bool bottom_edge_aa) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::TILED_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->resource_id = resource_id;
+  this->tex_coord_rect = tex_coord_rect;
+  this->texture_size = texture_size;
+  this->swizzle_contents = swizzle_contents;
+  this->left_edge_aa = left_edge_aa;
+  this->top_edge_aa = top_edge_aa;
+  this->right_edge_aa = right_edge_aa;
+  this->bottom_edge_aa = bottom_edge_aa;
+}
+
+const TileDrawQuad* TileDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::TILED_CONTENT);
+  return static_cast<const TileDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/tile_draw_quad.h b/cc/tile_draw_quad.h
index dccf8bc..ae41d4ab 100644
--- a/cc/tile_draw_quad.h
+++ b/cc/tile_draw_quad.h
@@ -15,35 +15,54 @@
 namespace cc {
 
 class CC_EXPORT TileDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<TileDrawQuad> create(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
-
-    unsigned resourceId() const { return m_resourceId; }
-    gfx::RectF texCoordRect() const { return m_texCoordRect; }
-    gfx::Size textureSize() const { return m_textureSize; }
-    bool swizzleContents() const { return m_swizzleContents; }
-
-    // TODO(danakj): Stick the data used to compute these things in the quad
-    // instead so the parent compositor can decide to use AA on its own.
-    bool leftEdgeAA() const { return m_leftEdgeAA; }
-    bool topEdgeAA() const { return m_topEdgeAA; }
-    bool rightEdgeAA() const { return m_rightEdgeAA; }
-    bool bottomEdgeAA() const { return m_bottomEdgeAA; }
-
-    bool isAntialiased() const { return leftEdgeAA() || topEdgeAA() || rightEdgeAA() || bottomEdgeAA(); }
-
-    static const TileDrawQuad* materialCast(const DrawQuad*);
-private:
-    TileDrawQuad(const SharedQuadState*, const gfx::Rect& quadRect, const gfx::Rect& opaqueRect, unsigned resourceId, const gfx::RectF& texCoordRect, const gfx::Size& textureSize, bool swizzleContents, bool leftEdgeAA, bool topEdgeAA, bool rightEdgeAA, bool bottomEdgeAA);
-
-    unsigned m_resourceId;
-    gfx::RectF m_texCoordRect;
-    gfx::Size m_textureSize;
-    bool m_swizzleContents;
-    bool m_leftEdgeAA;
-    bool m_topEdgeAA;
-    bool m_rightEdgeAA;
-    bool m_bottomEdgeAA;
+ public:
+  static scoped_ptr<TileDrawQuad> Create();
+
+  void SetNew(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              unsigned resource_id,
+              const gfx::RectF& tex_coord_rect,
+              gfx::Size texture_size,
+              bool swizzle_contents,
+              bool left_edge_aa,
+              bool top_edge_aa,
+              bool right_edge_aa,
+              bool bottom_edge_aa);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              unsigned resource_id,
+              const gfx::RectF& tex_coord_rect,
+              gfx::Size texture_size,
+              bool swizzle_contents,
+              bool left_edge_aa,
+              bool top_edge_aa,
+              bool right_edge_aa,
+              bool bottom_edge_aa);
+
+  unsigned resource_id;
+  gfx::RectF tex_coord_rect;
+  gfx::Size texture_size;
+  bool swizzle_contents;
+
+  // TODO(danakj): Stick the data used to compute these things in the quad
+  // instead so the parent compositor can decide to use AA on its own.
+  bool left_edge_aa;
+  bool top_edge_aa;
+  bool right_edge_aa;
+  bool bottom_edge_aa;
+
+  bool IsAntialiased() const {
+    return left_edge_aa || top_edge_aa || right_edge_aa || bottom_edge_aa;
+  }
+
+  static const TileDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  TileDrawQuad();
 };
 
 }
diff --git a/cc/tiled_layer_impl.cc b/cc/tiled_layer_impl.cc
index 3773542..ff4eaa3 100644
--- a/cc/tiled_layer_impl.cc
+++ b/cc/tiled_layer_impl.cc
@@ -133,7 +133,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
                     borderColor = DebugColors::TileBorderColor();
                     borderWidth = DebugColors::TileBorderWidth(layerTreeHostImpl());
                 }
-                quadSink.append(DebugBorderDrawQuad::create(sharedQuadState, tileRect, borderColor, borderWidth).PassAs<DrawQuad>(), appendQuadsData);
+                scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
+                debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth);
+                quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
             }
         }
     }
@@ -160,9 +162,14 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
                     else
                         checkerColor = kTileCheckerboardColor;
 
-                    appendQuadsData.hadMissingTiles |= quadSink.append(CheckerboardDrawQuad::create(sharedQuadState, tileRect, checkerColor).PassAs<DrawQuad>(), appendQuadsData);
-                } else
-                    appendQuadsData.hadMissingTiles |= quadSink.append(SolidColorDrawQuad::create(sharedQuadState, tileRect, backgroundColor()).PassAs<DrawQuad>(), appendQuadsData);
+                    scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
+                    checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor);
+                    appendQuadsData.hadMissingTiles |= quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData);
+                } else {
+                    scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create();
+                    solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor());
+                    appendQuadsData.hadMissingTiles |= quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData);
+                }
                 continue;
             }
 
@@ -188,7 +195,9 @@ void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
             bool rightEdgeAA = i == m_tiler->numTilesX() - 1 && useAA;
             bool bottomEdgeAA = j == m_tiler->numTilesY() - 1 && useAA;
 
-            quadSink.append(TileDrawQuad::create(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA).PassAs<DrawQuad>(), appendQuadsData);
+            scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+            quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled(), leftEdgeAA, topEdgeAA, rightEdgeAA, bottomEdgeAA);
+            quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
diff --git a/cc/tiled_layer_impl_unittest.cc b/cc/tiled_layer_impl_unittest.cc
index c501dff..2771a87 100644
--- a/cc/tiled_layer_impl_unittest.cc
+++ b/cc/tiled_layer_impl_unittest.cc
@@ -199,11 +199,11 @@ TEST(TiledLayerImplTest, textureInfoForLayerNoBorders)
     getQuads(quads, sharedStates, tileSize, layerSize, LayerTilingData::NoBorderTexels, gfx::Rect(gfx::Point(), layerSize));
 
     for (size_t i = 0; i < quads.size(); ++i) {
-        const TileDrawQuad* quad = TileDrawQuad::materialCast(quads[i]);
+        const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]);
 
-        EXPECT_NE(quad->resourceId(), 0u) << quadString << i;
-        EXPECT_EQ(quad->texCoordRect(), gfx::RectF(gfx::PointF(), tileSize)) << quadString << i;
-        EXPECT_EQ(quad->textureSize(), tileSize) << quadString << i;
+        EXPECT_NE(0u, quad->resource_id) << quadString << i;
+        EXPECT_EQ(gfx::RectF(gfx::PointF(), tileSize), quad->tex_coord_rect) << quadString << i;
+        EXPECT_EQ(tileSize, quad->texture_size) << quadString << i;
         EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect) << quadString << i;
     }
 }
diff --git a/cc/video_layer_impl.cc b/cc/video_layer_impl.cc
index 68a424c..49c493c 100644
--- a/cc/video_layer_impl.cc
+++ b/cc/video_layer_impl.cc
@@ -217,8 +217,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
         const FramePlane& uPlane = m_framePlanes[media::VideoFrame::kUPlane];
         const FramePlane& vPlane = m_framePlanes[media::VideoFrame::kVPlane];
         gfx::SizeF texScale(texWidthScale, texHeightScale);
-        scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::create(
-            sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
+        scoped_ptr<YUVVideoDrawQuad> yuvVideoQuad = YUVVideoDrawQuad::Create();
+        yuvVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, texScale, yPlane, uPlane, vPlane);
         quadSink.append(yuvVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
@@ -228,7 +228,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
         bool premultipliedAlpha = true;
         gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale);
         bool flipped = false;
-        scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped);
+        scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
+        textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, plane.resourceId, premultipliedAlpha, uvRect, flipped);
         quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
@@ -237,13 +238,15 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
         bool premultipliedAlpha = true;
         gfx::RectF uvRect(0, 0, texWidthScale, texHeightScale);
         bool flipped = false;
-        scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::create(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped);
+        scoped_ptr<TextureDrawQuad> textureQuad = TextureDrawQuad::Create();
+        textureQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_externalTextureResource, premultipliedAlpha, uvRect, flipped);
         quadSink.append(textureQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
     case GL_TEXTURE_RECTANGLE_ARB: {
         gfx::Size visibleSize(visibleRect.width(), visibleRect.height());
-        scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::create(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::Unflipped);
+        scoped_ptr<IOSurfaceDrawQuad> ioSurfaceQuad = IOSurfaceDrawQuad::Create();
+        ioSurfaceQuad->SetNew(sharedQuadState, quadRect, opaqueRect, visibleSize, m_frame->texture_id(), IOSurfaceDrawQuad::UNFLIPPED);
         quadSink.append(ioSurfaceQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
@@ -251,10 +254,8 @@ void VideoLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuad
         // StreamTexture hardware decoder.
         WebKit::WebTransformationMatrix transform(m_streamTextureMatrix);
         transform.scaleNonUniform(texWidthScale, texHeightScale);
-        scoped_ptr<StreamVideoDrawQuad> streamVideoQuad =
-            StreamVideoDrawQuad::create(sharedQuadState, quadRect, opaqueRect,
-                                        m_frame->texture_id(),
-                                        transform);
+        scoped_ptr<StreamVideoDrawQuad> streamVideoQuad = StreamVideoDrawQuad::Create();
+        streamVideoQuad->SetNew(sharedQuadState, quadRect, opaqueRect, m_frame->texture_id(), transform);
         quadSink.append(streamVideoQuad.PassAs<DrawQuad>(), appendQuadsData);
         break;
     }
diff --git a/cc/yuv_video_draw_quad.cc b/cc/yuv_video_draw_quad.cc
index 5e3bb6f..dcb4369 100644
--- a/cc/yuv_video_draw_quad.cc
+++ b/cc/yuv_video_draw_quad.cc
@@ -8,46 +8,51 @@
 
 namespace cc {
 
-scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::create(
-    const SharedQuadState* sharedQuadState,
-    const gfx::Rect& quadRect,
-    const gfx::Rect& opaqueRect,
-    const gfx::SizeF& texScale,
-    const VideoLayerImpl::FramePlane& yPlane,
-    const VideoLayerImpl::FramePlane& uPlane,
-    const VideoLayerImpl::FramePlane& vPlane)
-{
-    return make_scoped_ptr(new YUVVideoDrawQuad(sharedQuadState,
-                                                quadRect, opaqueRect, texScale,
-                                                yPlane, uPlane, vPlane));
+YUVVideoDrawQuad::YUVVideoDrawQuad() {}
+YUVVideoDrawQuad::~YUVVideoDrawQuad() {}
+
+scoped_ptr<YUVVideoDrawQuad> YUVVideoDrawQuad::Create() {
+    return make_scoped_ptr(new YUVVideoDrawQuad);
 }
 
-YUVVideoDrawQuad::YUVVideoDrawQuad(
-    const SharedQuadState* sharedQuadState,
-    const gfx::Rect& quadRect,
-    const gfx::Rect& opaqueRect,
-    const gfx::SizeF& texScale,
-    const VideoLayerImpl::FramePlane& yPlane,
-    const VideoLayerImpl::FramePlane& uPlane,
-    const VideoLayerImpl::FramePlane& vPlane)
-    : m_texScale(texScale)
-    , m_yPlane(yPlane)
-    , m_uPlane(uPlane)
-    , m_vPlane(vPlane)
-{
-    gfx::Rect visibleRect = quadRect;
-    bool needsBlending = false;
-    DrawQuad::SetAll(sharedQuadState, DrawQuad::YUV_VIDEO_CONTENT, quadRect, opaqueRect, visibleRect, needsBlending);
+void YUVVideoDrawQuad::SetNew(const SharedQuadState* shared_quad_state,
+                              gfx::Rect rect,
+                              gfx::Rect opaque_rect,
+                              gfx::SizeF tex_scale,
+                              const VideoLayerImpl::FramePlane& y_plane,
+                              const VideoLayerImpl::FramePlane& u_plane,
+                              const VideoLayerImpl::FramePlane& v_plane) {
+  gfx::Rect visible_rect = rect;
+  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->y_plane = y_plane;
+  this->u_plane = u_plane;
+  this->v_plane = v_plane;
 }
 
-YUVVideoDrawQuad::~YUVVideoDrawQuad()
-{
+void YUVVideoDrawQuad::SetAll(const SharedQuadState* shared_quad_state,
+                              gfx::Rect rect,
+                              gfx::Rect opaque_rect,
+                              gfx::Rect visible_rect,
+                              bool needs_blending,
+                              gfx::SizeF tex_scale,
+                              const VideoLayerImpl::FramePlane& y_plane,
+                              const VideoLayerImpl::FramePlane& u_plane,
+                              const VideoLayerImpl::FramePlane& v_plane) {
+  DrawQuad::SetAll(shared_quad_state, DrawQuad::YUV_VIDEO_CONTENT, rect,
+                   opaque_rect, visible_rect, needs_blending);
+  this->tex_scale = tex_scale;
+  this->y_plane = y_plane;
+  this->u_plane = u_plane;
+  this->v_plane = v_plane;
 }
 
-const YUVVideoDrawQuad* YUVVideoDrawQuad::materialCast(const DrawQuad* quad)
-{
-    DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT);
-    return static_cast<const YUVVideoDrawQuad*>(quad);
+const YUVVideoDrawQuad* YUVVideoDrawQuad::MaterialCast(
+    const DrawQuad* quad) {
+  DCHECK(quad->material == DrawQuad::YUV_VIDEO_CONTENT);
+  return static_cast<const YUVVideoDrawQuad*>(quad);
 }
 
 }  // namespace cc
diff --git a/cc/yuv_video_draw_quad.h b/cc/yuv_video_draw_quad.h
index e923b68..9f03d99 100644
--- a/cc/yuv_video_draw_quad.h
+++ b/cc/yuv_video_draw_quad.h
@@ -14,39 +14,37 @@
 namespace cc {
 
 class CC_EXPORT YUVVideoDrawQuad : public DrawQuad {
-public:
-    static scoped_ptr<YUVVideoDrawQuad> create(
-        const SharedQuadState* sharedQuadState,
-        const gfx::Rect& quadRect,
-        const gfx::Rect& opaqueRect,
-        const gfx::SizeF& texScale,
-        const VideoLayerImpl::FramePlane& yPlane,
-        const VideoLayerImpl::FramePlane& uPlane,
-        const VideoLayerImpl::FramePlane& vPlane);
-
-    virtual ~YUVVideoDrawQuad();
-
-    const gfx::SizeF& texScale() const { return m_texScale; }
-
-    const VideoLayerImpl::FramePlane& yPlane() const { return m_yPlane; }
-    const VideoLayerImpl::FramePlane& uPlane() const { return m_uPlane; }
-    const VideoLayerImpl::FramePlane& vPlane() const { return m_vPlane; }
-
-    static const YUVVideoDrawQuad* materialCast(const DrawQuad*);
-private:
-    YUVVideoDrawQuad(
-        const SharedQuadState* sharedQuadState,
-        const gfx::Rect& quadRect,
-        const gfx::Rect& opaqueRect,
-        const gfx::SizeF& texScale,
-        const VideoLayerImpl::FramePlane& yPlane,
-        const VideoLayerImpl::FramePlane& uPlane,
-        const VideoLayerImpl::FramePlane& vPlane);
-
-    gfx::SizeF m_texScale;
-    VideoLayerImpl::FramePlane m_yPlane;
-    VideoLayerImpl::FramePlane m_uPlane;
-    VideoLayerImpl::FramePlane m_vPlane;
+ public:
+  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 VideoLayerImpl::FramePlane& y_plane,
+              const VideoLayerImpl::FramePlane& u_plane,
+              const VideoLayerImpl::FramePlane& v_plane);
+
+  void SetAll(const SharedQuadState* shared_quad_state,
+              gfx::Rect rect,
+              gfx::Rect opaque_rect,
+              gfx::Rect visible_rect,
+              bool needs_blending,
+              gfx::SizeF tex_scale,
+              const VideoLayerImpl::FramePlane& y_plane,
+              const VideoLayerImpl::FramePlane& u_plane,
+              const VideoLayerImpl::FramePlane& v_plane);
+
+  gfx::SizeF tex_scale;
+  VideoLayerImpl::FramePlane y_plane;
+  VideoLayerImpl::FramePlane u_plane;
+  VideoLayerImpl::FramePlane v_plane;
+
+  static const YUVVideoDrawQuad* MaterialCast(const DrawQuad*);
+ private:
+  YUVVideoDrawQuad();
 };
 
 }