Make DrawQuad constructors public, rm DQ::Create() function

mojo/services/public/cpp/surfaces/tests/surface_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/quads/render_pass.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
@@ skipping 38 matching lines @@
 
  protected:
   scoped_ptr<cc::SharedQuadState> sqs;
   gfx::Rect rect;
   gfx::Rect opaque_rect;
   gfx::Rect visible_rect;
   bool needs_blending;
 };
 
 TEST_F(SurfaceLibQuadTest, ColorQuad) {
-  scoped_ptr<cc::SolidColorDrawQuad> color_quad =
-      cc::SolidColorDrawQuad::Create();
+  scoped_ptr<cc::SolidColorDrawQuad> color_quad(new cc::SolidColorDrawQuad);
   SkColor arbitrary_color = SK_ColorGREEN;
   bool force_anti_aliasing_off = true;
   color_quad->SetAll(sqs.get(),
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
 
@@ skipping 19 matching lines @@
   EXPECT_EQ(needs_blending, round_trip_quad->needs_blending);
   ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, round_trip_quad->material);
   const cc::SolidColorDrawQuad* round_trip_color_quad =
       cc::SolidColorDrawQuad::MaterialCast(round_trip_quad.get());
   EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
   EXPECT_EQ(force_anti_aliasing_off,
             round_trip_color_quad->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
-  scoped_ptr<cc::SurfaceDrawQuad> surface_quad = cc::SurfaceDrawQuad::Create();
+  scoped_ptr<cc::SurfaceDrawQuad> surface_quad(new cc::SurfaceDrawQuad);
   cc::SurfaceId arbitrary_id(5);
   surface_quad->SetAll(
       sqs.get(), rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
   cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(surface_quad.get());
   surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(surfaces::SURFACE_CONTENT, mojo_quad->material);
   ASSERT_TRUE(mojo_quad->surface_quad_state);
   surfaces::SurfaceQuadStatePtr& mojo_surface_state =
       mojo_quad->surface_quad_state;
   EXPECT_EQ(surfaces::SurfaceId::From(arbitrary_id),
             mojo_surface_state->surface);
 
   scoped_ptr<cc::DrawQuad> round_trip_quad =
       ConvertTo(mojo_quad.Pass(), sqs.get());
   ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, round_trip_quad->material);
   const cc::SurfaceDrawQuad* round_trip_surface_quad =
       cc::SurfaceDrawQuad::MaterialCast(round_trip_quad.get());
   EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuad) {
-  scoped_ptr<cc::TextureDrawQuad> texture_quad = cc::TextureDrawQuad::Create();
+  scoped_ptr<cc::TextureDrawQuad> texture_quad(new cc::TextureDrawQuad);
   unsigned resource_id = 9;
   bool premultiplied_alpha = true;
   gfx::PointF uv_top_left(1.7f, 2.1f);
   gfx::PointF uv_bottom_right(-7.f, 16.3f);
   SkColor background_color = SK_ColorYELLOW;
   float vertex_opacity[4] = {0.1f, 0.5f, 0.4f, 0.8f};
   bool flipped = false;
   texture_quad->SetAll(sqs.get(),
                        rect,
                        opaque_rect,
@@ skipping 100 matching lines @@
 
   gfx::Transform content_to_target_transform;
   content_to_target_transform.Scale3d(0.3f, 0.7f, 0.9f);
   gfx::Size content_bounds(57, 39);
   gfx::Rect visible_content_rect(3, 7, 28, 42);
   gfx::Rect clip_rect(9, 12, 21, 31);
   bool is_clipped = true;
   float opacity = 0.65f;
   int sorting_context_id = 13;
   SkXfermode::Mode blend_mode = SkXfermode::kSrcOver_Mode;
-  scoped_ptr<cc::SharedQuadState> sqs(new cc::SharedQuadState);
+  cc::SharedQuadState* sqs = pass->CreateAndAppendSharedQuadState();
   sqs->SetAll(content_to_target_transform,
               content_bounds,
               visible_content_rect,
               clip_rect,
               is_clipped,
               opacity,
               blend_mode,
               sorting_context_id);
-  pass->shared_quad_state_list.push_back(sqs.Pass());
 
-  scoped_ptr<cc::SolidColorDrawQuad> color_quad =
-      cc::SolidColorDrawQuad::Create();
+  cc::SolidColorDrawQuad* color_quad =
+      pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
   SkColor arbitrary_color = SK_ColorGREEN;
   bool force_anti_aliasing_off = true;
   color_quad->SetAll(pass->shared_quad_state_list.back(),
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
-  pass->quad_list.push_back(color_quad.PassAs<cc::DrawQuad>());
 
   surfaces::PassPtr mojo_pass = surfaces::Pass::From(*pass);
   ASSERT_FALSE(mojo_pass.is_null());
   EXPECT_EQ(6, mojo_pass->id);
   EXPECT_EQ(Rect::From(output_rect), mojo_pass->output_rect);
   EXPECT_EQ(Rect::From(damage_rect), mojo_pass->damage_rect);
   EXPECT_EQ(Transform::From(transform_to_root_target),
             mojo_pass->transform_to_root_target);
   EXPECT_EQ(has_transparent_background, mojo_pass->has_transparent_background);
   ASSERT_EQ(1u, mojo_pass->shared_quad_states.size());
@@ skipping 107 matching lines @@
   cc::ReturnedResource round_trip_resource =
       mojo_resource.To<cc::ReturnedResource>();
   EXPECT_EQ(id, round_trip_resource.id);
   EXPECT_EQ(sync_point, round_trip_resource.sync_point);
   EXPECT_EQ(count, round_trip_resource.count);
   EXPECT_EQ(lost, round_trip_resource.lost);
 }
 
 }  // namespace
 }  // namespace mojo