Create DrawQuad in RenderPass and only give out raw pointer to layers

Instead of each layer calling Create function on DrawQuad and pass
ownership around, create DrawQuad in RenderPass and only pass the raw
pointer to layers.

BUG=344962
TEST=cc_unittests

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

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

23 files changed, 136 insertions, 169 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl.cc b/cc/layers/delegated_renderer_layer_impl.cc
index 30a7b01..e110ff7 100644
--- a/cc/layers/delegated_renderer_layer_impl.cc
+++ b/cc/layers/delegated_renderer_layer_impl.cc
@@ -354,32 +354,32 @@ void DelegatedRendererLayerImpl::AppendRainbowDebugBorder(
       break;
 
     if (!top.IsEmpty()) {
-      scoped_ptr<SolidColorDrawQuad> top_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* top_quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       top_quad->SetNew(
           shared_quad_state, top, top, colors[i % kNumColors], false);
-      render_pass->AppendDrawQuad(top_quad.PassAs<DrawQuad>());
 
-      scoped_ptr<SolidColorDrawQuad> bottom_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* bottom_quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       bottom_quad->SetNew(shared_quad_state,
                           bottom,
                           bottom,
                           colors[kNumColors - 1 - (i % kNumColors)],
                           false);
-      render_pass->AppendDrawQuad(bottom_quad.PassAs<DrawQuad>());
     }
     if (!left.IsEmpty()) {
-      scoped_ptr<SolidColorDrawQuad> left_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* left_quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       left_quad->SetNew(shared_quad_state,
                         left,
                         left,
                         colors[kNumColors - 1 - (i % kNumColors)],
                         false);
-      render_pass->AppendDrawQuad(left_quad.PassAs<DrawQuad>());
 
-      scoped_ptr<SolidColorDrawQuad> right_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* right_quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       right_quad->SetNew(
           shared_quad_state, right, right, colors[i % kNumColors], false);
-      render_pass->AppendDrawQuad(right_quad.PassAs<DrawQuad>());
     }
   }
 }
@@ -468,7 +468,7 @@ void DelegatedRendererLayerImpl::AppendRenderPassQuads(
     }
 
     if (output_quad)
-      render_pass->AppendDrawQuad(output_quad.Pass());
+      render_pass->quad_list.push_back(output_quad.Pass());
   }
 }
 
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index 57523a9..30eecc4 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -532,22 +532,20 @@ class DelegatedRendererLayerImplTestTransform
                                 SkXfermode::kSrcOver_Mode,
                                 0);
 
-      scoped_ptr<SolidColorDrawQuad> color_quad;
-      color_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* color_quad;
+      color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(shared_quad_state,
                          gfx::Rect(20, 20, 3, 7),
                          gfx::Rect(20, 20, 3, 7),
                          1u,
                          false);
-      pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-      color_quad = SolidColorDrawQuad::Create();
+      color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(shared_quad_state,
                          gfx::Rect(23, 20, 4, 7),
                          gfx::Rect(23, 20, 4, 7),
                          1u,
                          false);
-      pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
     }
 
     gfx::Size root_pass_content_bounds(100, 100);
@@ -573,8 +571,8 @@ class DelegatedRendererLayerImplTestTransform
                               SkXfermode::kSrcOver_Mode,
                               0);
 
-    scoped_ptr<RenderPassDrawQuad> render_pass_quad =
-        RenderPassDrawQuad::Create();
+    RenderPassDrawQuad* render_pass_quad =
+        pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     render_pass_quad->SetNew(
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // quad_rect
@@ -586,40 +584,35 @@ class DelegatedRendererLayerImplTestTransform
         gfx::RectF(),           // mask_uv_rect
         FilterOperations(),     // filters
         FilterOperations());    // background_filters
-    pass->AppendDrawQuad(render_pass_quad.PassAs<DrawQuad>());
 
-    scoped_ptr<SolidColorDrawQuad> color_quad;
-    color_quad = SolidColorDrawQuad::Create();
+    SolidColorDrawQuad* color_quad;
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(0, 0, 10, 10),
                        gfx::Rect(0, 0, 10, 10),
                        1u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(0, 10, 10, 10),
                        gfx::Rect(0, 10, 10, 10),
                        2u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 0, 10, 10),
                        gfx::Rect(10, 0, 10, 10),
                        3u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         delegated_device_scale_factor_, &delegated_render_passes);
@@ -977,22 +970,20 @@ class DelegatedRendererLayerImplTestClip
                                 SkXfermode::kSrcOver_Mode,
                                 0);
 
-      scoped_ptr<SolidColorDrawQuad> color_quad;
-      color_quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* color_quad;
+      color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(shared_quad_state,
                          gfx::Rect(20, 20, 3, 7),
                          gfx::Rect(20, 20, 3, 7),
                          1u,
                          false);
-      pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-      color_quad = SolidColorDrawQuad::Create();
+      color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       color_quad->SetNew(shared_quad_state,
                          gfx::Rect(23, 20, 4, 7),
                          gfx::Rect(23, 20, 4, 7),
                          1u,
                          false);
-      pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
     }
 
     gfx::Size root_pass_content_bounds(50, 50);
@@ -1016,8 +1007,8 @@ class DelegatedRendererLayerImplTestClip
                               SkXfermode::kSrcOver_Mode,
                               0);
 
-    scoped_ptr<RenderPassDrawQuad> render_pass_quad =
-        RenderPassDrawQuad::Create();
+    RenderPassDrawQuad* render_pass_quad =
+        pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
     render_pass_quad->SetNew(
         shared_quad_state,
         gfx::Rect(5, 5, 7, 7),  // quad_rect
@@ -1029,40 +1020,35 @@ class DelegatedRendererLayerImplTestClip
         gfx::RectF(),           // mask_uv_rect
         FilterOperations(),     // filters
         FilterOperations());    // background_filters
-    pass->AppendDrawQuad(render_pass_quad.PassAs<DrawQuad>());
 
-    scoped_ptr<SolidColorDrawQuad> color_quad;
-    color_quad = SolidColorDrawQuad::Create();
+    SolidColorDrawQuad* color_quad;
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(0, 0, 10, 10),
                        gfx::Rect(0, 0, 10, 10),
                        1u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(0, 10, 10, 10),
                        gfx::Rect(0, 10, 10, 10),
                        2u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 0, 10, 10),
                        gfx::Rect(10, 0, 10, 10),
                        3u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
-    color_quad = SolidColorDrawQuad::Create();
+    color_quad = pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     color_quad->SetNew(shared_quad_state,
                        gfx::Rect(10, 10, 10, 10),
                        gfx::Rect(10, 10, 10, 10),
                        4u,
                        false);
-    pass->AppendDrawQuad(color_quad.PassAs<DrawQuad>());
 
     delegated_renderer_layer->SetFrameDataForRenderPasses(
         1.f, &delegated_render_passes);
diff --git a/cc/layers/heads_up_display_layer_impl.cc b/cc/layers/heads_up_display_layer_impl.cc
index a77095a..c031bd4 100644
--- a/cc/layers/heads_up_display_layer_impl.cc
+++ b/cc/layers/heads_up_display_layer_impl.cc
@@ -123,7 +123,8 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
   gfx::PointF uv_bottom_right(1.f, 1.f);
   const float vertex_opacity[] = { 1.f, 1.f, 1.f, 1.f };
   bool flipped = false;
-  scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+  TextureDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,
@@ -135,7 +136,6 @@ void HeadsUpDisplayLayerImpl::AppendQuads(
                SK_ColorTRANSPARENT,
                vertex_opacity,
                flipped);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void HeadsUpDisplayLayerImpl::UpdateHudTexture(
diff --git a/cc/layers/io_surface_layer_impl.cc b/cc/layers/io_surface_layer_impl.cc
index 8f6c46c..a741cde 100644
--- a/cc/layers/io_surface_layer_impl.cc
+++ b/cc/layers/io_surface_layer_impl.cc
@@ -82,7 +82,8 @@ void IOSurfaceLayerImpl::AppendQuads(
   if (visible_quad_rect.IsEmpty())
     return;
 
-  scoped_ptr<IOSurfaceDrawQuad> quad = IOSurfaceDrawQuad::Create();
+  IOSurfaceDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,
@@ -90,7 +91,6 @@ void IOSurfaceLayerImpl::AppendQuads(
                io_surface_size_,
                io_surface_resource_id_,
                IOSurfaceDrawQuad::FLIPPED);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void IOSurfaceLayerImpl::ReleaseResources() {
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 231f4aa..a5ae060 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -313,11 +313,10 @@ void LayerImpl::AppendDebugBorderQuad(RenderPass* render_pass,
 
   gfx::Rect quad_rect(content_bounds);
   gfx::Rect visible_quad_rect(quad_rect);
-  scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
-      DebugBorderDrawQuad::Create();
+  DebugBorderDrawQuad* debug_border_quad =
+      render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
   debug_border_quad->SetNew(
       shared_quad_state, quad_rect, visible_quad_rect, color, width);
-  render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
 }
 
 bool LayerImpl::HasDelegatedContent() const {
diff --git a/cc/layers/nine_patch_layer_impl.cc b/cc/layers/nine_patch_layer_impl.cc
index 86fa415..3f4ee4c 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -212,12 +212,12 @@ void NinePatchLayerImpl::AppendQuads(
   gfx::Rect opaque_rect;
   gfx::Rect visible_rect;
   const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-  scoped_ptr<TextureDrawQuad> quad;
 
   visible_rect =
       occlusion_tracker.UnoccludedContentRect(layer_top_left, draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_top_left,
                  opaque_rect,
@@ -229,13 +229,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect = occlusion_tracker.UnoccludedContentRect(layer_top_right,
                                                          draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_top_right,
                  opaque_rect,
@@ -247,13 +247,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect = occlusion_tracker.UnoccludedContentRect(layer_bottom_left,
                                                          draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_bottom_left,
                  opaque_rect,
@@ -265,13 +265,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect = occlusion_tracker.UnoccludedContentRect(layer_bottom_right,
                                                          draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_bottom_right,
                  opaque_rect,
@@ -283,13 +283,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect =
       occlusion_tracker.UnoccludedContentRect(layer_top, draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_top,
                  opaque_rect,
@@ -301,13 +301,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect =
       occlusion_tracker.UnoccludedContentRect(layer_left, draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_left,
                  opaque_rect,
@@ -319,13 +319,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect =
       occlusion_tracker.UnoccludedContentRect(layer_right, draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_right,
                  opaque_rect,
@@ -337,13 +337,13 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   visible_rect =
       occlusion_tracker.UnoccludedContentRect(layer_bottom, draw_transform());
   if (!visible_rect.IsEmpty()) {
-    quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  layer_bottom,
                  opaque_rect,
@@ -355,14 +355,14 @@ void NinePatchLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  vertex_opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   if (fill_center_) {
     visible_rect =
         occlusion_tracker.UnoccludedContentRect(layer_center, draw_transform());
     if (!visible_rect.IsEmpty()) {
-      quad = TextureDrawQuad::Create();
+      TextureDrawQuad* quad =
+          render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
       quad->SetNew(shared_quad_state,
                    layer_center,
                    opaque_rect,
@@ -374,7 +374,6 @@ void NinePatchLayerImpl::AppendQuads(
                    SK_ColorTRANSPARENT,
                    vertex_opacity,
                    flipped);
-      render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     }
   }
 }
diff --git a/cc/layers/painted_scrollbar_layer_impl.cc b/cc/layers/painted_scrollbar_layer_impl.cc
index 1335b32..b77b604 100644
--- a/cc/layers/painted_scrollbar_layer_impl.cc
+++ b/cc/layers/painted_scrollbar_layer_impl.cc
@@ -98,7 +98,8 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   if (thumb_resource_id && !visible_thumb_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect;
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  thumb_quad_rect,
                  opaque_rect,
@@ -110,7 +111,6 @@ void PaintedScrollbarLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   gfx::Rect track_quad_rect = content_bounds_rect;
@@ -119,7 +119,8 @@ void PaintedScrollbarLayerImpl::AppendQuads(
   if (track_resource_id && !visible_track_quad_rect.IsEmpty()) {
     gfx::Rect opaque_rect(contents_opaque() ? track_quad_rect : gfx::Rect());
     const float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
-    scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+    TextureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  track_quad_rect,
                  opaque_rect,
@@ -131,7 +132,6 @@ void PaintedScrollbarLayerImpl::AppendQuads(
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 }
 
diff --git a/cc/layers/picture_layer_impl.cc b/cc/layers/picture_layer_impl.cc
index 248391c..6b753f9 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -186,7 +186,8 @@ void PictureLayerImpl::AppendQuads(
     gfx::RectF texture_rect = gfx::RectF(texture_size);
     gfx::Rect quad_content_rect = rect;
 
-    scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+    PictureDrawQuad* quad =
+        render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
     quad->SetNew(shared_quad_state,
                  geometry_rect,
                  opaque_rect,
@@ -197,7 +198,6 @@ void PictureLayerImpl::AppendQuads(
                  quad_content_rect,
                  max_contents_scale,
                  pile_);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     append_quads_data->num_missing_tiles++;
     return;
   }
@@ -239,8 +239,8 @@ void PictureLayerImpl::AppendQuads(
         width = DebugColors::MissingTileBorderWidth(layer_tree_impl());
       }
 
-      scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
-          DebugBorderDrawQuad::Create();
+      DebugBorderDrawQuad* debug_border_quad =
+          render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
       gfx::Rect geometry_rect = iter.geometry_rect();
       gfx::Rect visible_geometry_rect = geometry_rect;
       debug_border_quad->SetNew(shared_quad_state,
@@ -248,7 +248,6 @@ void PictureLayerImpl::AppendQuads(
                                 visible_geometry_rect,
                                 color,
                                 width);
-      render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
     }
   }
 
@@ -271,7 +270,6 @@ void PictureLayerImpl::AppendQuads(
     append_quads_data->visible_content_area +=
         visible_geometry_rect.width() * visible_geometry_rect.height();
 
-    scoped_ptr<DrawQuad> draw_quad;
     if (*iter && iter->IsReadyToDraw()) {
       const ManagedTileState::TileVersion& tile_version =
           iter->GetTileVersionForDrawing();
@@ -284,7 +282,8 @@ void PictureLayerImpl::AppendQuads(
           if (iter->contents_scale() != ideal_contents_scale_)
             append_quads_data->had_incomplete_tile = true;
 
-          scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+          TileDrawQuad* quad =
+              render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        opaque_rect,
@@ -293,7 +292,6 @@ void PictureLayerImpl::AppendQuads(
                        texture_rect,
                        iter.texture_size(),
                        tile_version.contents_swizzled());
-          draw_quad = quad.PassAs<DrawQuad>();
           break;
         }
         case ManagedTileState::TileVersion::PICTURE_PILE_MODE: {
@@ -312,7 +310,8 @@ void PictureLayerImpl::AppendQuads(
               layer_tree_impl()->resource_provider();
           ResourceFormat format =
               resource_provider->memory_efficient_texture_format();
-          scoped_ptr<PictureDrawQuad> quad = PictureDrawQuad::Create();
+          PictureDrawQuad* quad =
+              render_pass->CreateAndAppendDrawQuad<PictureDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        opaque_rect,
@@ -323,38 +322,35 @@ void PictureLayerImpl::AppendQuads(
                        iter->content_rect(),
                        iter->contents_scale(),
                        pile_);
-          draw_quad = quad.PassAs<DrawQuad>();
           break;
         }
         case ManagedTileState::TileVersion::SOLID_COLOR_MODE: {
-          scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+          SolidColorDrawQuad* quad =
+              render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
           quad->SetNew(shared_quad_state,
                        geometry_rect,
                        visible_geometry_rect,
                        tile_version.get_solid_color(),
                        false);
-          draw_quad = quad.PassAs<DrawQuad>();
           break;
         }
       }
-    }
-
-    if (!draw_quad) {
+    } else {
       if (draw_checkerboard_for_missing_tiles()) {
-        scoped_ptr<CheckerboardDrawQuad> quad = CheckerboardDrawQuad::Create();
+        CheckerboardDrawQuad* quad =
+            render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
         SkColor color = DebugColors::DefaultCheckerboardColor();
         quad->SetNew(
             shared_quad_state, geometry_rect, visible_geometry_rect, color);
-        render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
       } else {
         SkColor color = SafeOpaqueBackgroundColor();
-        scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+        SolidColorDrawQuad* quad =
+            render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
         quad->SetNew(shared_quad_state,
                      geometry_rect,
                      visible_geometry_rect,
                      color,
                      false);
-        render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
       }
 
       append_quads_data->num_missing_tiles++;
@@ -365,8 +361,6 @@ void PictureLayerImpl::AppendQuads(
       continue;
     }
 
-    render_pass->AppendDrawQuad(draw_quad.Pass());
-
     if (iter->priority(ACTIVE_TREE).resolution != HIGH_RESOLUTION) {
       append_quads_data->approximated_visible_content_area +=
           visible_geometry_rect.width() * visible_geometry_rect.height();
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index 0133b38..04a4da4 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -172,11 +172,10 @@ void RenderSurfaceImpl::AppendQuads(
                       owning_layer_->layer_tree_impl()) :
                   DebugColors::SurfaceBorderWidth(
                       owning_layer_->layer_tree_impl());
-    scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
-        DebugBorderDrawQuad::Create();
+    DebugBorderDrawQuad* debug_border_quad =
+        render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
     debug_border_quad->SetNew(
         shared_quad_state, content_rect_, visible_content_rect, color, width);
-    render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
   }
 
   // TODO(shawnsingh): By using the same RenderSurfaceImpl for both the content
@@ -225,7 +224,8 @@ void RenderSurfaceImpl::AppendQuads(
   gfx::Rect contents_changed_since_last_frame =
       ContentsChanged() ? content_rect_ : gfx::Rect();
 
-  scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+  RenderPassDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state,
                content_rect_,
                visible_content_rect,
@@ -236,7 +236,6 @@ void RenderSurfaceImpl::AppendQuads(
                mask_uv_rect,
                owning_layer_->filters(),
                owning_layer_->background_filters());
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc
diff --git a/cc/layers/solid_color_layer_impl.cc b/cc/layers/solid_color_layer_impl.cc
index 4f0d6db..a88c53e 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -48,13 +48,13 @@ void SolidColorLayerImpl::AppendQuads(
       if (visible_quad_rect.IsEmpty())
         continue;
 
-      scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
       quad->SetNew(shared_quad_state,
                    quad_rect,
                    visible_quad_rect,
                    background_color(),
                    false);
-      render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     }
   }
 }
diff --git a/cc/layers/solid_color_scrollbar_layer_impl.cc b/cc/layers/solid_color_scrollbar_layer_impl.cc
index e618094..54fc119 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -111,10 +111,10 @@ void SolidColorScrollbarLayerImpl::AppendQuads(
   if (visible_quad_rect.IsEmpty())
     return;
 
-  scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad->SetNew(
       shared_quad_state, thumb_quad_rect, visible_quad_rect, color_, false);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc
diff --git a/cc/layers/surface_layer_impl.cc b/cc/layers/surface_layer_impl.cc
index 6ef2431..80c6da0 100644
--- a/cc/layers/surface_layer_impl.cc
+++ b/cc/layers/surface_layer_impl.cc
@@ -50,14 +50,14 @@ void SurfaceLayerImpl::AppendQuads(
   if (surface_id_.is_null())
     return;
 
-  scoped_ptr<SurfaceDrawQuad> quad = SurfaceDrawQuad::Create();
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect visible_quad_rect = occlusion_tracker.UnoccludedContentRect(
       quad_rect, draw_properties().target_space_transform);
   if (visible_quad_rect.IsEmpty())
     return;
+  SurfaceDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   quad->SetNew(shared_quad_state, quad_rect, visible_quad_rect, surface_id_);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void SurfaceLayerImpl::GetDebugBorderProperties(SkColor* color,
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index d29b23b..a61190c 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -163,7 +163,8 @@ void TextureLayerImpl::AppendQuads(
   if (visible_quad_rect.IsEmpty())
     return;
 
-  scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+  TextureDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   ResourceProvider::ResourceId id =
       valid_texture_copy_ ? texture_copy_->id() : external_texture_resource_;
   quad->SetNew(shared_quad_state,
@@ -177,7 +178,6 @@ void TextureLayerImpl::AppendQuads(
                bg_color,
                vertex_opacity_,
                flipped_);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 Region TextureLayerImpl::VisibleContentOpaqueRegion() const {
diff --git a/cc/layers/tiled_layer_impl.cc b/cc/layers/tiled_layer_impl.cc
index f02c9e5..c68d9f2 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -186,14 +186,13 @@ void TiledLayerImpl::AppendQuads(
           border_color = DebugColors::HighResTileBorderColor();
           border_width = DebugColors::HighResTileBorderWidth(layer_tree_impl());
         }
-        scoped_ptr<DebugBorderDrawQuad> debug_border_quad =
-            DebugBorderDrawQuad::Create();
+        DebugBorderDrawQuad* debug_border_quad =
+            render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
         debug_border_quad->SetNew(shared_quad_state,
                                   tile_rect,
                                   visible_tile_rect,
                                   border_color,
                                   border_width);
-        render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
       }
     }
   }
@@ -227,11 +226,10 @@ void TiledLayerImpl::AppendQuads(
           checker_color = DebugColors::DefaultCheckerboardColor();
         }
 
-        scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
-            CheckerboardDrawQuad::Create();
+        CheckerboardDrawQuad* checkerboard_quad =
+            render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
         checkerboard_quad->SetNew(
             shared_quad_state, tile_rect, visible_tile_rect, checker_color);
-        render_pass->AppendDrawQuad(checkerboard_quad.PassAs<DrawQuad>());
         append_quads_data->num_missing_tiles++;
         continue;
       }
@@ -251,7 +249,7 @@ void TiledLayerImpl::AppendQuads(
       float tile_height = static_cast<float>(tiler_->tile_size().height());
       gfx::Size texture_size(tile_width, tile_height);
 
-      scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
+      TileDrawQuad* quad = render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
       quad->SetNew(shared_quad_state,
                    tile_rect,
                    tile_opaque_rect,
@@ -260,7 +258,6 @@ void TiledLayerImpl::AppendQuads(
                    tex_coord_rect,
                    texture_size,
                    tile->contents_swizzled());
-      render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     }
   }
 }
diff --git a/cc/layers/ui_resource_layer_impl.cc b/cc/layers/ui_resource_layer_impl.cc
index 7b06a3e..03851bd 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -126,7 +126,8 @@ void UIResourceLayerImpl::AppendQuads(
   if (visible_quad_rect.IsEmpty())
     return;
 
-  scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
+  TextureDrawQuad* quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   quad->SetNew(shared_quad_state,
                quad_rect,
                opaque_rect,
@@ -138,7 +139,6 @@ void UIResourceLayerImpl::AppendQuads(
                SK_ColorTRANSPARENT,
                vertex_opacity_,
                flipped);
-  render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 const char* UIResourceLayerImpl::LayerTypeAsString() const {
diff --git a/cc/layers/video_layer_impl.cc b/cc/layers/video_layer_impl.cc
index bb46a84..7b4234c 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -169,7 +169,8 @@ void VideoLayerImpl::AppendQuads(
       gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
-      scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create();
+      TextureDrawQuad* texture_quad =
+          render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
       texture_quad->SetNew(shared_quad_state,
                            quad_rect,
                            opaque_rect,
@@ -181,7 +182,6 @@ void VideoLayerImpl::AppendQuads(
                            SK_ColorTRANSPARENT,
                            opacity,
                            flipped);
-      render_pass->AppendDrawQuad(texture_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::YUV_RESOURCE: {
@@ -194,7 +194,8 @@ void VideoLayerImpl::AppendQuads(
               : YUVVideoDrawQuad::REC_601;
       gfx::RectF tex_coord_rect(
           tex_x_offset, tex_y_offset, tex_width_scale, tex_height_scale);
-      scoped_ptr<YUVVideoDrawQuad> yuv_video_quad = YUVVideoDrawQuad::Create();
+      YUVVideoDrawQuad* yuv_video_quad =
+          render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>();
       yuv_video_quad->SetNew(
           shared_quad_state,
           quad_rect,
@@ -206,7 +207,6 @@ void VideoLayerImpl::AppendQuads(
           frame_resources_[2],
           frame_resources_.size() > 3 ? frame_resources_[3] : 0,
           color_space);
-      render_pass->AppendDrawQuad(yuv_video_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::RGB_RESOURCE: {
@@ -218,7 +218,8 @@ void VideoLayerImpl::AppendQuads(
       gfx::PointF uv_bottom_right(tex_width_scale, tex_height_scale);
       float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
       bool flipped = false;
-      scoped_ptr<TextureDrawQuad> texture_quad = TextureDrawQuad::Create();
+      TextureDrawQuad* texture_quad =
+          render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
       texture_quad->SetNew(shared_quad_state,
                            quad_rect,
                            opaque_rect,
@@ -230,7 +231,6 @@ void VideoLayerImpl::AppendQuads(
                            SK_ColorTRANSPARENT,
                            opacity,
                            flipped);
-      render_pass->AppendDrawQuad(texture_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
@@ -239,8 +239,8 @@ void VideoLayerImpl::AppendQuads(
         break;
       gfx::Transform scale;
       scale.Scale(tex_width_scale, tex_height_scale);
-      scoped_ptr<StreamVideoDrawQuad> stream_video_quad =
-          StreamVideoDrawQuad::Create();
+      StreamVideoDrawQuad* stream_video_quad =
+          render_pass->CreateAndAppendDrawQuad<StreamVideoDrawQuad>();
       stream_video_quad->SetNew(
           shared_quad_state,
           quad_rect,
@@ -248,15 +248,14 @@ void VideoLayerImpl::AppendQuads(
           visible_quad_rect,
           frame_resources_[0],
           scale * provider_client_impl_->stream_texture_matrix());
-      render_pass->AppendDrawQuad(stream_video_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::IO_SURFACE: {
       DCHECK_EQ(frame_resources_.size(), 1u);
       if (frame_resources_.size() < 1u)
         break;
-      scoped_ptr<IOSurfaceDrawQuad> io_surface_quad =
-          IOSurfaceDrawQuad::Create();
+      IOSurfaceDrawQuad* io_surface_quad =
+          render_pass->CreateAndAppendDrawQuad<IOSurfaceDrawQuad>();
       io_surface_quad->SetNew(shared_quad_state,
                               quad_rect,
                               opaque_rect,
@@ -264,7 +263,6 @@ void VideoLayerImpl::AppendQuads(
                               visible_rect.size(),
                               frame_resources_[0],
                               IOSurfaceDrawQuad::UNFLIPPED);
-      render_pass->AppendDrawQuad(io_surface_quad.PassAs<DrawQuad>());
       break;
     }
 #if defined(VIDEO_HOLE)
@@ -276,8 +274,8 @@ void VideoLayerImpl::AppendQuads(
     // ycheo@chromium.org
     case VideoFrameExternalResources::HOLE: {
       DCHECK_EQ(frame_resources_.size(), 0u);
-      scoped_ptr<SolidColorDrawQuad> solid_color_draw_quad =
-          SolidColorDrawQuad::Create();
+      SolidColorDrawQuad* solid_color_draw_quad =
+          render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
 
       // Create a solid color quad with transparent black and force no
       // blending / no anti-aliasing.
@@ -289,7 +287,6 @@ void VideoLayerImpl::AppendQuads(
                                     false,
                                     SK_ColorTRANSPARENT,
                                     true);
-      render_pass->AppendDrawQuad(solid_color_draw_quad.PassAs<DrawQuad>());
       break;
     }
 #endif  // defined(VIDEO_HOLE)
diff --git a/cc/quads/draw_quad.h b/cc/quads/draw_quad.h
index 1803eb3..2de24974 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -48,6 +48,8 @@ class CC_EXPORT DrawQuad {
 
   virtual ~DrawQuad();
 
+  // TODO(weiliangc): DrawQuad need to be allocated on RenderPass. This function
+  // need to be moved to RenderPass.
   scoped_ptr<DrawQuad> Copy(
       const SharedQuadState* copied_shared_quad_state) const;
 
diff --git a/cc/quads/render_pass.cc b/cc/quads/render_pass.cc
index 5c12422..61fcb25 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -174,12 +174,4 @@ SharedQuadState* RenderPass::CreateAndAppendSharedQuadState() {
   return shared_quad_state_list.back();
 }
 
-void RenderPass::AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad) {
-  DCHECK(!shared_quad_state_list.empty());
-  DCHECK(!draw_quad->rect.IsEmpty());
-  DCHECK(!draw_quad->visible_rect.IsEmpty());
-
-  quad_list.push_back(draw_quad.Pass());
-}
-
 }  // namespace cc
diff --git a/cc/quads/render_pass.h b/cc/quads/render_pass.h
index 778a714..ce5a90e 100644
--- a/cc/quads/render_pass.h
+++ b/cc/quads/render_pass.h
@@ -89,7 +89,12 @@ class CC_EXPORT RenderPass {
   scoped_ptr<base::Value> AsValue() const;
 
   SharedQuadState* CreateAndAppendSharedQuadState();
-  void AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad);
+  template <typename DrawQuadType>
+  DrawQuadType* CreateAndAppendDrawQuad() {
+    scoped_ptr<DrawQuadType> draw_quad = DrawQuadType::Create();
+    quad_list.push_back(draw_quad.template PassAs<DrawQuad>());
+    return static_cast<DrawQuadType*>(quad_list.back());
+  }
 
   // Uniquely identifies the render pass in the compositor's current frame.
   Id id;
diff --git a/cc/surfaces/surface_aggregator_test_helpers.cc b/cc/surfaces/surface_aggregator_test_helpers.cc
index 63a39af..d843369 100644
--- a/cc/surfaces/surface_aggregator_test_helpers.cc
+++ b/cc/surfaces/surface_aggregator_test_helpers.cc
@@ -43,13 +43,13 @@ void AddTestSurfaceQuad(TestRenderPass* pass,
                             blend_mode,
                             0);
 
-  scoped_ptr<SurfaceDrawQuad> surface_quad = SurfaceDrawQuad::Create();
+  SurfaceDrawQuad* surface_quad =
+      pass->CreateAndAppendDrawQuad<SurfaceDrawQuad>();
   gfx::Rect quad_rect = gfx::Rect(surface_size);
   surface_quad->SetNew(pass->shared_quad_state_list.back(),
                        gfx::Rect(surface_size),
                        gfx::Rect(surface_size),
                        surface_id);
-  pass->quad_list.push_back(surface_quad.PassAs<DrawQuad>());
 }
 void AddTestRenderPassQuad(TestRenderPass* pass,
                            RenderPass::Id render_pass_id) {
@@ -63,7 +63,8 @@ void AddTestRenderPassQuad(TestRenderPass* pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+  RenderPassDrawQuad* quad =
+      pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state,
                output_rect,
                output_rect,
@@ -74,7 +75,6 @@ void AddTestRenderPassQuad(TestRenderPass* pass,
                gfx::RectF(),
                FilterOperations(),
                FilterOperations());
-  pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void AddQuadInPass(TestRenderPass* pass, Quad desc) {
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index 5e85298..5925a2b 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -38,11 +38,10 @@ SolidColorDrawQuad* AddQuad(TestRenderPass* pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* quad =
+      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad->SetNew(shared_state, rect, rect, color, false);
-  SolidColorDrawQuad* quad_ptr = quad.get();
-  pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
-  return quad_ptr;
+  return quad;
 }
 
 SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
@@ -57,11 +56,10 @@ SolidColorDrawQuad* AddClippedQuad(TestRenderPass* pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* quad =
+      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad->SetNew(shared_state, rect, rect, color, false);
-  SolidColorDrawQuad* quad_ptr = quad.get();
-  pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
-  return quad_ptr;
+  return quad;
 }
 
 SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
@@ -77,11 +75,10 @@ SolidColorDrawQuad* AddTransformedQuad(TestRenderPass* pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+  SolidColorDrawQuad* quad =
+      pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
   quad->SetNew(shared_state, rect, rect, color, false);
-  SolidColorDrawQuad* quad_ptr = quad.get();
-  pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
-  return quad_ptr;
+  return quad;
 }
 
 void AddRenderPassQuad(TestRenderPass* to_pass,
@@ -96,7 +93,8 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+  RenderPassDrawQuad* quad =
+      to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state,
                output_rect,
                output_rect,
@@ -107,7 +105,6 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                gfx::RectF(),
                FilterOperations(),
                FilterOperations());
-  to_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void AddRenderPassQuad(TestRenderPass* to_pass,
@@ -125,7 +122,8 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                        1,
                        SkXfermode::kSrcOver_Mode,
                        0);
-  scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
+  RenderPassDrawQuad* quad =
+      to_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_state,
                output_rect,
                output_rect,
@@ -136,7 +134,6 @@ void AddRenderPassQuad(TestRenderPass* to_pass,
                gfx::RectF(),
                filters,
                FilterOperations());
-  to_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 }  // namespace cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 1c62fb1..de1e8ff 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -647,13 +647,13 @@ static void AppendQuadsToFillScreen(
     gfx::Rect visible_screen_space_rect = screen_space_rect;
     // Skip the quad culler and just append the quads directly to avoid
     // occlusion checks.
-    scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::Create();
+    SolidColorDrawQuad* quad =
+        target_render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     quad->SetNew(shared_quad_state,
                  screen_space_rect,
                  visible_screen_space_rect,
                  screen_background_color,
                  false);
-    target_render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
   for (Region::Iterator fill_rects(overhang_region);
        fill_rects.has_rect();
@@ -662,7 +662,8 @@ static void AppendQuadsToFillScreen(
     gfx::Rect screen_space_rect = fill_rects.rect();
     gfx::Rect opaque_screen_space_rect = screen_space_rect;
     gfx::Rect visible_screen_space_rect = screen_space_rect;
-    scoped_ptr<TextureDrawQuad> tex_quad = TextureDrawQuad::Create();
+    TextureDrawQuad* tex_quad =
+        target_render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
     const float vertex_opacity[4] = {1.f, 1.f, 1.f, 1.f};
     tex_quad->SetNew(
         shared_quad_state,
@@ -681,7 +682,6 @@ static void AppendQuadsToFillScreen(
         screen_background_color,
         vertex_opacity,
         false);
-    target_render_pass->AppendDrawQuad(tex_quad.PassAs<DrawQuad>());
   }
 }
 
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index dc7b106..90c0a57 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -3497,7 +3497,8 @@ class BlendStateCheckLayer : public LayerImpl {
         render_pass->CreateAndAppendSharedQuadState();
     PopulateSharedQuadState(shared_quad_state);
 
-    scoped_ptr<TileDrawQuad> test_blending_draw_quad = TileDrawQuad::Create();
+    TileDrawQuad* test_blending_draw_quad =
+        render_pass->CreateAndAppendDrawQuad<TileDrawQuad>();
     test_blending_draw_quad->SetNew(shared_quad_state,
                                     quad_rect_,
                                     opaque_rect,
@@ -3509,7 +3510,6 @@ class BlendStateCheckLayer : public LayerImpl {
     test_blending_draw_quad->visible_rect = quad_visible_rect_;
     EXPECT_EQ(blend_, test_blending_draw_quad->ShouldDrawWithBlending());
     EXPECT_EQ(has_render_surface_, !!render_surface());
-    render_pass->AppendDrawQuad(test_blending_draw_quad.PassAs<DrawQuad>());
   }
 
   void SetExpectation(bool blend, bool has_render_surface) {
@@ -4251,10 +4251,10 @@ class FakeLayerWithQuads : public LayerImpl {
     SkColor gray = SkColorSetRGB(100, 100, 100);
     gfx::Rect quad_rect(content_bounds());
     gfx::Rect visible_quad_rect(quad_rect);
-    scoped_ptr<SolidColorDrawQuad> my_quad = SolidColorDrawQuad::Create();
+    SolidColorDrawQuad* my_quad =
+        render_pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>();
     my_quad->SetNew(
         shared_quad_state, quad_rect, visible_quad_rect, gray, false);
-    render_pass->AppendDrawQuad(my_quad.PassAs<DrawQuad>());
   }
 
  private: