Update Mojo surfaces type converters to use RP for generating DQ and SQS

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 23 matching lines @@
 
 TEST(SurfaceLibTest, Color) {
   SkColor arbitrary_color = SK_ColorMAGENTA;
   SkColor round_trip = surfaces::Color::From(arbitrary_color).To<SkColor>();
   EXPECT_EQ(arbitrary_color, round_trip);
 }
 
 class SurfaceLibQuadTest : public testing::Test {
  public:
   SurfaceLibQuadTest()
-      : sqs(new cc::SharedQuadState),
-        rect(5, 7, 13, 19),
+      : rect(5, 7, 13, 19),
         opaque_rect(rect),
         visible_rect(9, 11, 5, 7),
         needs_blending(false) {}
 
  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(new cc::SolidColorDrawQuad);
+  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  cc::SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+  cc::SolidColorDrawQuad* color_quad =
+      render_pass->CreateAndAppendDrawQuad<cc::SolidColorDrawQuad>();
   SkColor arbitrary_color = SK_ColorGREEN;
   bool force_anti_aliasing_off = true;
-  color_quad->SetAll(sqs.get(),
+  color_quad->SetAll(sqs,
                      rect,
                      opaque_rect,
                      visible_rect,
                      needs_blending,
                      arbitrary_color,
                      force_anti_aliasing_off);
 
-  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(color_quad.get());
-  surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
+  surfaces::QuadPtr mojo_quad =
+      surfaces::Quad::From(*(render_pass->quad_list.back()));
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(surfaces::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);
   surfaces::SolidColorQuadStatePtr& mojo_color_state =
       mojo_quad->solid_color_quad_state;
   EXPECT_EQ(surfaces::Color::From(arbitrary_color), mojo_color_state->color);
   EXPECT_EQ(force_anti_aliasing_off, mojo_color_state->force_anti_aliasing_off);
-
-  scoped_ptr<cc::DrawQuad> round_trip_quad =
-      ConvertTo(mojo_quad.Pass(), sqs.get());
-  EXPECT_EQ(rect, round_trip_quad->rect);
-  EXPECT_EQ(opaque_rect, round_trip_quad->opaque_rect);
-  EXPECT_EQ(visible_rect, round_trip_quad->visible_rect);
-  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(new cc::SurfaceDrawQuad);
+  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  cc::SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
+  cc::SurfaceDrawQuad* surface_quad =
+      render_pass->CreateAndAppendDrawQuad<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);
+      sqs, rect, opaque_rect, visible_rect, needs_blending, arbitrary_id);
+
+  surfaces::QuadPtr mojo_quad =
+      surfaces::Quad::From(*(render_pass->quad_list.back()));
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(surfaces::MATERIAL_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(new cc::TextureDrawQuad);
+  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  cc::SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();

[jamesr, 2014/07/17 20:25:24]

nit: you could probably move these two lines into the SurfaceLibQuadTest fixture
since that's a base class of the type this function ends up being in and make
the different SurfaceLibQuadTest instances simple

+  cc::TextureDrawQuad* texture_quad =
+      render_pass->CreateAndAppendDrawQuad<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(),
+  texture_quad->SetAll(sqs,
                        rect,
                        opaque_rect,
                        visible_rect,
                        needs_blending,
                        resource_id,
                        premultiplied_alpha,
                        uv_top_left,
                        uv_bottom_right,
                        background_color,
                        vertex_opacity,
                        flipped);
 
-  cc::DrawQuad* base_ptr = static_cast<cc::DrawQuad*>(texture_quad.get());
-  surfaces::QuadPtr mojo_quad = surfaces::Quad::From(*base_ptr);
+  surfaces::QuadPtr mojo_quad =
+      surfaces::Quad::From(*(render_pass->quad_list.back()));
   ASSERT_FALSE(mojo_quad.is_null());
   EXPECT_EQ(surfaces::MATERIAL_TEXTURE_CONTENT, mojo_quad->material);
   ASSERT_TRUE(mojo_quad->texture_quad_state);
   surfaces::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(surfaces::Color::From(background_color),
             mojo_texture_state->background_color);
   for (size_t i = 0; i < 4; ++i) {
     EXPECT_EQ(vertex_opacity[i], mojo_texture_state->vertex_opacity[i]) << i;
   }
   EXPECT_EQ(flipped, mojo_texture_state->flipped);
-
-  scoped_ptr<cc::DrawQuad> round_trip_quad =
-      ConvertTo(mojo_quad.Pass(), sqs.get());
-  ASSERT_EQ(cc::DrawQuad::TEXTURE_CONTENT, round_trip_quad->material);
-  const cc::TextureDrawQuad* round_trip_surface_quad =
-      cc::TextureDrawQuad::MaterialCast(round_trip_quad.get());
-  EXPECT_EQ(resource_id, round_trip_surface_quad->resource_id);
-  EXPECT_EQ(premultiplied_alpha, round_trip_surface_quad->premultiplied_alpha);
-  EXPECT_EQ(uv_top_left, round_trip_surface_quad->uv_top_left);
-  EXPECT_EQ(uv_bottom_right, round_trip_surface_quad->uv_bottom_right);
-  EXPECT_EQ(background_color, round_trip_surface_quad->background_color);
-  for (size_t i = 0; i < 4; ++i) {
-    EXPECT_EQ(vertex_opacity[i], round_trip_surface_quad->vertex_opacity[i])
-        << i;
-  }
-  EXPECT_EQ(flipped, round_trip_surface_quad->flipped);
 }
 
 TEST(SurfaceLibTest, SharedQuadState) {
   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);
+  scoped_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
+  cc::SharedQuadState* sqs = render_pass->CreateAndAppendSharedQuadState();
   sqs->SetAll(content_to_target_transform,
               content_bounds,
               visible_content_rect,
               clip_rect,
               is_clipped,
               opacity,
               blend_mode,
               sorting_context_id);
 
   surfaces::SharedQuadStatePtr mojo_sqs = surfaces::SharedQuadState::From(*sqs);
   ASSERT_FALSE(mojo_sqs.is_null());
   EXPECT_EQ(Transform::From(content_to_target_transform),
             mojo_sqs->content_to_target_transform);
   EXPECT_EQ(Size::From(content_bounds), mojo_sqs->content_bounds);
   EXPECT_EQ(Rect::From(visible_content_rect), mojo_sqs->visible_content_rect);
   EXPECT_EQ(Rect::From(clip_rect), mojo_sqs->clip_rect);
   EXPECT_EQ(is_clipped, mojo_sqs->is_clipped);
   EXPECT_EQ(opacity, mojo_sqs->opacity);
   EXPECT_EQ(sorting_context_id, mojo_sqs->sorting_context_id);
-
-  scoped_ptr<cc::SharedQuadState> round_trip_sqs = ConvertTo(mojo_sqs.Pass());
-  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);
 }
 
 TEST_F(SurfaceLibQuadTest, RenderPass) {
   scoped_ptr<cc::RenderPass> pass = cc::RenderPass::Create();
   cc::RenderPass::Id pass_id(1, 6);
   gfx::Rect output_rect(4, 9, 13, 71);
   gfx::Rect damage_rect(9, 17, 41, 45);
   gfx::Transform transform_to_root_target;
   transform_to_root_target.SkewY(43.0);
   bool has_transparent_background = false;
   pass->SetAll(pass_id,

[weiliangc, 2014/07/17 21:27:10]

If set up SharedQuadState in SurfaceLibQuadTest, this test would fail because in
RenderPass SetAll() there is a DCHECK for no quad or SQS has been added yet.

So kill DCHECK or only setup RenderPass in SurfaceLibQuadTest?

[jamesr, 2014/07/17 21:29:36]

Or move this test out of the SurfaceLibQuadTest fixture and just make it be a
SurfaceLibTest.  The only thing it gets from the fixture are the default values
of rect/opaque_rect/etc, which aren't that important

                output_rect,
                damage_rect,
                transform_to_root_target,
                has_transparent_background);
 
   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);
@@ skipping 16 matching lines @@
   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);
 
+  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);
+
+  cc::TextureDrawQuad* texture_quad =
+      pass->CreateAndAppendDrawQuad<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,
+                       rect,
+                       opaque_rect,
+                       visible_rect,
+                       needs_blending,
+                       resource_id,
+                       premultiplied_alpha,
+                       uv_top_left,
+                       uv_bottom_right,
+                       background_color,
+                       vertex_opacity,
+                       flipped);
+
   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());
-  ASSERT_EQ(1u, mojo_pass->quads.size());
+  ASSERT_EQ(3u, mojo_pass->quads.size());
   EXPECT_EQ(0, mojo_pass->quads[0]->shared_quad_state_index);
 
   scoped_ptr<cc::RenderPass> round_trip_pass = ConvertTo(mojo_pass.Pass());
   EXPECT_EQ(pass_id, round_trip_pass->id);
   EXPECT_EQ(output_rect, round_trip_pass->output_rect);
   EXPECT_EQ(damage_rect, round_trip_pass->damage_rect);
   EXPECT_EQ(transform_to_root_target,
             round_trip_pass->transform_to_root_target);
   EXPECT_EQ(has_transparent_background,
             round_trip_pass->has_transparent_background);
   ASSERT_EQ(1u, round_trip_pass->shared_quad_state_list.size());
-  ASSERT_EQ(1u, round_trip_pass->quad_list.size());
+  ASSERT_EQ(3u, round_trip_pass->quad_list.size());
   EXPECT_EQ(round_trip_pass->shared_quad_state_list.front(),
-            round_trip_pass->quad_list[0]->shared_quad_state);
+            round_trip_pass->quad_list.front()->shared_quad_state);
+
+  cc::SharedQuadState* round_trip_sqs =
+      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();
+  // 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);
+  const cc::SolidColorDrawQuad* round_trip_color_quad =
+      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);
+  const cc::SurfaceDrawQuad* round_trip_surface_quad =
+      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);
+  const cc::TextureDrawQuad* round_trip_texture_quad =
+      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);
 }
 
 TEST(SurfaceLibTest, Mailbox) {
   gpu::Mailbox mailbox;
   mailbox.Generate();
 
   surfaces::MailboxPtr mojo_mailbox = surfaces::Mailbox::From(mailbox);
   EXPECT_EQ(0, memcmp(mailbox.name, mojo_mailbox->name.storage().data(), 64));
 
   gpu::Mailbox round_trip_mailbox = mojo_mailbox.To<gpu::Mailbox>();
@@ skipping 82 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