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 @@
       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 @@
     }
 
     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 @@
                                 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 @@
                               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 @@
         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 @@
                                 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 @@
                               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 @@
         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 @@
   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 @@
                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 @@
   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 @@
                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 @@
 
   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 86fa415b..3f4ee4c7 100644
--- a/cc/layers/nine_patch_layer_impl.cc
+++ b/cc/layers/nine_patch_layer_impl.cc
@@ -212,12 +212,12 @@
   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 @@
                  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 @@
                  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 @@
                  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 @@
                  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 @@
                  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 @@
                  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 @@
                  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 @@
                  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 @@
                    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 @@
   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 @@
                  SK_ColorTRANSPARENT,
                  opacity,
                  flipped);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
   }
 
   gfx::Rect track_quad_rect = content_bounds_rect;
@@ -119,7 +119,8 @@
   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 @@
                  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..6b753f9b 100644
--- a/cc/layers/picture_layer_impl.cc
+++ b/cc/layers/picture_layer_impl.cc
@@ -186,7 +186,8 @@
     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 @@
                  quad_content_rect,
                  max_contents_scale,
                  pile_);
-    render_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
     append_quads_data->num_missing_tiles++;
     return;
   }
@@ -239,8 +239,8 @@
         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 @@
                                 visible_geometry_rect,
                                 color,
                                 width);
-      render_pass->AppendDrawQuad(debug_border_quad.PassAs<DrawQuad>());
     }
   }
 
@@ -271,7 +270,6 @@
     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 @@
           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 @@
                        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 @@
               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 @@
                        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 @@
       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 0133b388..04a4da4 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -172,11 +172,10 @@
                       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 @@
   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 @@
                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 4f0d6dbe..a88c53e 100644
--- a/cc/layers/solid_color_layer_impl.cc
+++ b/cc/layers/solid_color_layer_impl.cc
@@ -48,13 +48,13 @@
       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 e6180948..54fc1191 100644
--- a/cc/layers/solid_color_scrollbar_layer_impl.cc
+++ b/cc/layers/solid_color_scrollbar_layer_impl.cc
@@ -111,10 +111,10 @@
   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 @@
   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..a61190c9 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -163,7 +163,8 @@
   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 @@
                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 f02c9e53..c68d9f29 100644
--- a/cc/layers/tiled_layer_impl.cc
+++ b/cc/layers/tiled_layer_impl.cc
@@ -186,14 +186,13 @@
           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 @@
           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 @@
       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 @@
                    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 7b06a3ee..03851bd 100644
--- a/cc/layers/ui_resource_layer_impl.cc
+++ b/cc/layers/ui_resource_layer_impl.cc
@@ -126,7 +126,8 @@
   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 @@
                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 bb46a84c..7b4234c 100644
--- a/cc/layers/video_layer_impl.cc
+++ b/cc/layers/video_layer_impl.cc
@@ -169,7 +169,8 @@
       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 @@
                            SK_ColorTRANSPARENT,
                            opacity,
                            flipped);
-      render_pass->AppendDrawQuad(texture_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::YUV_RESOURCE: {
@@ -194,7 +194,8 @@
               : 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 @@
           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 @@
       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 @@
                            SK_ColorTRANSPARENT,
                            opacity,
                            flipped);
-      render_pass->AppendDrawQuad(texture_quad.PassAs<DrawQuad>());
       break;
     }
     case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: {
@@ -239,8 +239,8 @@
         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 @@
           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 @@
                               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 @@
     // 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 @@
                                     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 1803eb31..2de24974 100644
--- a/cc/quads/draw_quad.h
+++ b/cc/quads/draw_quad.h
@@ -48,6 +48,8 @@
 
   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..61fcb255 100644
--- a/cc/quads/render_pass.cc
+++ b/cc/quads/render_pass.cc
@@ -174,12 +174,4 @@
   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 @@
   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 @@
                             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 @@
                        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 @@
                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 @@
                        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 @@
                        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 @@
                        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 @@
                        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 @@
                gfx::RectF(),
                FilterOperations(),
                FilterOperations());
-  to_pass->AppendDrawQuad(quad.PassAs<DrawQuad>());
 }
 
 void AddRenderPassQuad(TestRenderPass* to_pass,
@@ -125,7 +122,8 @@
                        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 @@
                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 1c62fb1f..de1e8ffc 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -647,13 +647,13 @@
     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 @@
     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 @@
         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 dc7b106ca..90c0a57 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -3497,7 +3497,8 @@
         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 @@
     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 @@
     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: