Use custom ListContainer to allocate DrawQuads

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/render_pass_draw_quad.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"
 #include "mojo/services/public/cpp/geometry/geometry_type_converters.h"
 #include "mojo/services/public/cpp/surfaces/surfaces_type_converters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkXfermode.h"
@@ skipping 46 matching lines @@
   SkColor arbitrary_color = SK_ColorGREEN;
   bool force_anti_aliasing_off = true;
   color_quad->SetAll(sqs,
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
 
-  QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(color_quad);
+  QuadPtr mojo_quad = Quad::From(*base_ptr);

[danakj, 2014/09/23 17:59:38]

james previously said you can do something like:

QuadPtr mojo_quad = Quad::From<cc::DrawQuad>(color_quad);

[weiliangc, 2014/09/24 20:14:35]

Sorry, my bad.

Done.

   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(MATERIAL_SOLID_COLOR, mojo_quad->material);
   EXPECT_EQ(Rect::From(rect), mojo_quad->rect);
   EXPECT_EQ(Rect::From(opaque_rect), mojo_quad->opaque_rect);
   EXPECT_EQ(Rect::From(visible_rect), mojo_quad->visible_rect);
   EXPECT_EQ(needs_blending, mojo_quad->needs_blending);
   ASSERT_TRUE(mojo_quad->solid_color_quad_state);
   SolidColorQuadStatePtr& mojo_color_state = mojo_quad->solid_color_quad_state;
   EXPECT_EQ(Color::From(arbitrary_color), mojo_color_state->color);
   EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);
 }
 
 TEST_F(SurfaceLibQuadTest, SurfaceQuad) {
   cc::SurfaceDrawQuad* surface_quad =
       pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
   cc::SurfaceId arbitrary_id(5);
   surface_quad->SetAll(
       sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
 
-  QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(surface_quad);
+  QuadPtr mojo_quad = Quad::From(*base_ptr);
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(MATERIAL_SURFACE_CONTENT, mojo_quad->material);
   ASSERT_TRUE(mojo_quad->surface_quad_state);
   SurfaceQuadStatePtr& mojo_surface_state = mojo_quad->surface_quad_state;
   EXPECT_EQ(SurfaceId::From(arbitrary_id),
             mojo_surface_state->surface);
 }
 
 TEST_F(SurfaceLibQuadTest, TextureQuad) {
   cc::TextureDrawQuad* texture_quad =
@@ skipping 11 matching lines @@
                        visible_rect,
                        needs_blending,
                        resource_id,
                        premultiplied_alpha,
                        uv_top_left,
                        uv_bottom_right,
                        background_color,
                        vertex_opacity,
                        flipped);
 
-  QuadPtr mojo_quad = Quad::From(*(pass->quad_list.back()));
+  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(texture_quad);
+  QuadPtr mojo_quad = Quad::From(*base_ptr);
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(MATERIAL_TEXTURE_CONTENT, mojo_quad->material);
   ASSERT_TRUE(mojo_quad->texture_quad_state);
   TextureQuadStatePtr& mojo_texture_state = mojo_quad->texture_quad_state;
   EXPECT_EQ(resource_id, mojo_texture_state->resource_id);
   EXPECT_EQ(premultiplied_alpha, mojo_texture_state->premultiplied_alpha);
   EXPECT_EQ(PointF::From(uv_top_left), mojo_texture_state->uv_top_left);
   EXPECT_EQ(PointF::From(uv_bottom_right), mojo_texture_state->uv_bottom_right);
   EXPECT_EQ(Color::From(background_color),
             mojo_texture_state->background_color);
@@ skipping 175 matching lines @@
       round_trip_pass->shared_quad_state_list.front();
   EXPECT_EQ(content_to_target_transform,
             round_trip_sqs->content_to_target_transform);
   EXPECT_EQ(content_bounds, round_trip_sqs->content_bounds);
   EXPECT_EQ(visible_content_rect, round_trip_sqs->visible_content_rect);
   EXPECT_EQ(clip_rect, round_trip_sqs->clip_rect);
   EXPECT_EQ(is_clipped, round_trip_sqs->is_clipped);
   EXPECT_EQ(opacity, round_trip_sqs->opacity);
   EXPECT_EQ(sorting_context_id, round_trip_sqs->sorting_context_id);
 
-  cc::QuadList::iterator dq_iter = round_trip_pass->quad_list.begin();
+  cc::QuadList::Iterator dq_iter = round_trip_pass->quad_list.begin();
   // First is solid color quad.
-  ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, (*dq_iter)->material);
-  EXPECT_EQ(rect, (*dq_iter)->rect);
-  EXPECT_EQ(opaque_rect, (*dq_iter)->opaque_rect);
-  EXPECT_EQ(visible_rect, (*dq_iter)->visible_rect);
-  EXPECT_EQ(needs_blending, (*dq_iter)->needs_blending);
+  ASSERT_EQ(cc::DrawQuad::SOLID_COLOR, dq_iter->material);
+  EXPECT_EQ(rect, dq_iter->rect);
+  EXPECT_EQ(opaque_rect, dq_iter->opaque_rect);
+  EXPECT_EQ(visible_rect, dq_iter->visible_rect);
+  EXPECT_EQ(needs_blending, dq_iter->needs_blending);
   const cc::SolidColorDrawQuad* round_trip_color_quad =
-      cc::SolidColorDrawQuad::MaterialCast(*dq_iter);
+      cc::SolidColorDrawQuad::MaterialCast(&*dq_iter);
   EXPECT_EQ(arbitrary_color, round_trip_color_quad->color);
   EXPECT_EQ(force_anti_aliasing_off,
             round_trip_color_quad->force_anti_aliasing_off);
 
   ++dq_iter;
   // Second is surface quad.
-  ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, (*dq_iter)->material);
+  ASSERT_EQ(cc::DrawQuad::SURFACE_CONTENT, dq_iter->material);
   const cc::SurfaceDrawQuad* round_trip_surface_quad =
-      cc::SurfaceDrawQuad::MaterialCast(*dq_iter);
+      cc::SurfaceDrawQuad::MaterialCast(&*dq_iter);
   EXPECT_EQ(arbitrary_id, round_trip_surface_quad->surface_id);
 
   ++dq_iter;
   // Third is texture quad.
-  ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, (*dq_iter)->material);
+  ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, dq_iter->material);
   const cc::TextureDrawQuad* round_trip_texture_quad =
-      cc::TextureDrawQuad::MaterialCast(*dq_iter);
+      cc::TextureDrawQuad::MaterialCast(&*dq_iter);
   EXPECT_EQ(resource_id, round_trip_texture_quad->resource_id);
   EXPECT_EQ(premultiplied_alpha, round_trip_texture_quad->premultiplied_alpha);
   EXPECT_EQ(uv_top_left, round_trip_texture_quad->uv_top_left);
   EXPECT_EQ(uv_bottom_right, round_trip_texture_quad->uv_bottom_right);
   EXPECT_EQ(background_color, round_trip_texture_quad->background_color);
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], round_trip_texture_quad->vertex_opacity[i])
         << i;
   }
   EXPECT_EQ(flipped, round_trip_texture_quad->flipped);
@@ skipping 96 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