Use RenderPass to create DrawQuad in unittests

cc/output/overlay_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/base/scoped_ptr_vector.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
@@ skipping 111 matching lines @@
   TextureMailbox mailbox =
       TextureMailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
   mailbox.set_allow_overlay(true);
   scoped_ptr<SingleReleaseCallback> release_callback =
       SingleReleaseCallback::Create(base::Bind(&MailboxReleased));
 
   return resource_provider->CreateResourceFromTextureMailbox(
       mailbox, release_callback.Pass());
 }
 
-scoped_ptr<TextureDrawQuad> CreateCandidateQuad(
-    ResourceProvider* resource_provider,
-    const SharedQuadState* shared_quad_state) {
+TextureDrawQuad* CreateCandidateQuad(ResourceProvider* resource_provider,
+                                     const SharedQuadState* shared_quad_state,
+                                     RenderPass* render_pass) {
   ResourceProvider::ResourceId resource_id = CreateResource(resource_provider);
   bool premultiplied_alpha = false;
   bool flipped = false;
   float vertex_opacity[4] = {1.0f, 1.0f, 1.0f, 1.0f};
 
-  scoped_ptr<TextureDrawQuad> overlay_quad = TextureDrawQuad::Create();
+  TextureDrawQuad* overlay_quad =
+      render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>();
   overlay_quad->SetNew(shared_quad_state,
                        kOverlayRect,
                        kOverlayRect,
                        kOverlayRect,
                        resource_id,
                        premultiplied_alpha,
                        kUVTopLeft,
                        kUVBottomRight,
                        SK_ColorTRANSPARENT,
                        vertex_opacity,
                        flipped);
 
-  return overlay_quad.Pass();
+  return overlay_quad;
 }
 
-scoped_ptr<DrawQuad> CreateCheckeredQuad(
-    ResourceProvider* resource_provider,
-    const SharedQuadState* shared_quad_state) {
-  scoped_ptr<CheckerboardDrawQuad> checkerboard_quad =
-      CheckerboardDrawQuad::Create();
+void CreateCheckeredQuad(ResourceProvider* resource_provider,
+                         const SharedQuadState* shared_quad_state,
+                         RenderPass* render_pass) {
+  CheckerboardDrawQuad* checkerboard_quad =
+      render_pass->CreateAndAppendDrawQuad<CheckerboardDrawQuad>();
   checkerboard_quad->SetNew(
       shared_quad_state, kOverlayRect, kOverlayRect, SkColor());
-  return checkerboard_quad.PassAs<DrawQuad>();
 }
 
 static void CompareRenderPassLists(const RenderPassList& expected_list,
                                    const RenderPassList& actual_list) {
   EXPECT_EQ(expected_list.size(), actual_list.size());
   for (size_t i = 0; i < actual_list.size(); ++i) {
     RenderPass* expected = expected_list[i];
     RenderPass* actual = actual_list[i];
 
     EXPECT_EQ(expected->id, actual->id);
@@ skipping 68 matching lines @@
   scoped_refptr<TestContextProvider> provider_;
   scoped_ptr<OverlayOutputSurface> output_surface_;
   FakeOutputSurfaceClient client_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<SingleOverlayProcessor> overlay_processor_;
 };
 
 TEST_F(SingleOverlayOnTopTest, SuccessfullOverlay) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> original_quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  TextureDrawQuad* original_quad =
+      CreateCandidateQuad(resource_provider_.get(),
+                          pass->shared_quad_state_list.back(),
+                          pass.get());
+  unsigned original_resource_id = original_quad->resource_id;
 
-  pass->quad_list.push_back(
-      original_quad->Copy(pass->shared_quad_state_list.back()));
   // Add something behind it.
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
 
   ASSERT_EQ(1U, pass_list.size());
   ASSERT_EQ(2U, candidate_list.size());
 
   RenderPass* main_pass = pass_list.back();
   // Check that the quad is gone.
   EXPECT_EQ(2U, main_pass->quad_list.size());
   const QuadList& quad_list = main_pass->quad_list;
   for (QuadList::ConstBackToFrontIterator it = quad_list.BackToFrontBegin();
        it != quad_list.BackToFrontEnd();
        ++it) {
     EXPECT_NE(DrawQuad::TEXTURE_CONTENT, (*it)->material);
   }
 
   // Check that the right resource id got extracted.
-  EXPECT_EQ(original_quad->resource_id, candidate_list.back().resource_id);
+  EXPECT_EQ(original_resource_id, candidate_list.back().resource_id);
 }
 
 TEST_F(SingleOverlayOnTopTest, NoCandidates) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   RenderPassList original_pass_list;
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
 }
 
 TEST_F(SingleOverlayOnTopTest, OccludedCandidates) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
-  pass->quad_list.push_back(
-      CreateCandidateQuad(resource_provider_.get(),
-                          pass->shared_quad_state_list.back())
-          .PassAs<DrawQuad>());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   RenderPassList original_pass_list;
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(0U, candidate_list.size());
   // There should be nothing new here.
   CompareRenderPassLists(pass_list, original_pass_list);
 }
 
 // Test with multiple render passes.
 TEST_F(SingleOverlayOnTopTest, MultipleRenderPasses) {
   RenderPassList pass_list;
   pass_list.push_back(CreateRenderPass());
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> original_quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
-  pass->quad_list.push_back(
-      original_quad->Copy(pass->shared_quad_state_list.back()));
   // Add something behind it.
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   pass_list.push_back(pass.Pass());
 
   RenderPassList original_pass_list;
   RenderPass::CopyAll(pass_list, &original_pass_list);
 
   // Check for potential candidates.
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(2U, candidate_list.size());
 
   // This should be the same.
   ASSERT_EQ(2U, pass_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectPremultipliedAlpha) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  TextureDrawQuad* quad =
+      CreateCandidateQuad(resource_provider_.get(),
+                          pass->shared_quad_state_list.back(),
+                          pass.get());
   quad->premultiplied_alpha = true;
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   EXPECT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBlending) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  TextureDrawQuad* quad =
+      CreateCandidateQuad(resource_provider_.get(),
+                          pass->shared_quad_state_list.back(),
+                          pass.get());
   quad->needs_blending = true;
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBackgroundColor) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  TextureDrawQuad* quad =
+      CreateCandidateQuad(resource_provider_.get(),
+                          pass->shared_quad_state_list.back(),
+                          pass.get());
   quad->background_color = SK_ColorBLACK;
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectBlendMode) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
   pass->shared_quad_state_list.back()->blend_mode = SkXfermode::kScreen_Mode;
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectOpacity) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
   pass->shared_quad_state_list.back()->opacity = 0.5f;
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 TEST_F(SingleOverlayOnTopTest, RejectTransform) {
   scoped_ptr<RenderPass> pass = CreateRenderPass();
-  scoped_ptr<TextureDrawQuad> quad = CreateCandidateQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
   pass->shared_quad_state_list.back()->content_to_target_transform.Scale(2.f,
                                                                          2.f);
 
-  pass->quad_list.push_back(quad.PassAs<DrawQuad>());
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
   OverlayCandidateList candidate_list;
   overlay_processor_->ProcessForOverlays(&pass_list, &candidate_list);
   ASSERT_EQ(1U, pass_list.size());
   EXPECT_EQ(0U, candidate_list.size());
 }
 
 class OverlayInfoRendererGL : public GLRenderer {
  public:
@@ skipping 86 matching lines @@
 };
 
 TEST_F(GLRendererWithOverlaysTest, OverlayQuadNotDrawn) {
   bool use_validator = true;
   Init(use_validator);
   renderer_->set_expect_overlays(true);
   gfx::Rect viewport_rect(16, 16);
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
 
-  pass->quad_list.push_back(
-      CreateCandidateQuad(resource_provider_.get(),
-                          pass->shared_quad_state_list.back())
-          .PassAs<DrawQuad>());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // Candidate pass was taken out and extra skipped pass added,
   // so only draw 2 quads.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(2);
   EXPECT_CALL(scheduler_,
               Schedule(1,
                        gfx::OVERLAY_TRANSFORM_NONE,
                        _,
                        kOverlayRect,
                        BoundingRect(kUVTopLeft, kUVBottomRight))).Times(1);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
   SwapBuffers();
 
   Mock::VerifyAndClearExpectations(renderer_.get());
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 TEST_F(GLRendererWithOverlaysTest, OccludedQuadDrawn) {
   bool use_validator = true;
   Init(use_validator);
   renderer_->set_expect_overlays(false);
   gfx::Rect viewport_rect(16, 16);
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
 
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
-  pass->quad_list.push_back(
-      CreateCandidateQuad(resource_provider_.get(),
-                          pass->shared_quad_state_list.back())
-          .PassAs<DrawQuad>());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // 3 quads in the pass, all should draw.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
   SwapBuffers();
 
   Mock::VerifyAndClearExpectations(renderer_.get());
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 TEST_F(GLRendererWithOverlaysTest, NoValidatorNoOverlay) {
   bool use_validator = false;
   Init(use_validator);
   renderer_->set_expect_overlays(false);
   gfx::Rect viewport_rect(16, 16);
 
   scoped_ptr<RenderPass> pass = CreateRenderPass();
 
-  pass->quad_list.push_back(
-      CreateCandidateQuad(resource_provider_.get(),
-                          pass->shared_quad_state_list.back())
-          .PassAs<DrawQuad>());
+  CreateCandidateQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
-  pass->quad_list.push_back(CreateCheckeredQuad(
-      resource_provider_.get(), pass->shared_quad_state_list.back()));
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
+  CreateCheckeredQuad(resource_provider_.get(),
+                      pass->shared_quad_state_list.back(),
+                      pass.get());
 
   RenderPassList pass_list;
   pass_list.push_back(pass.Pass());
 
   // Should see no overlays.
   EXPECT_CALL(*renderer_, DoDrawQuad(_, _)).Times(3);
   EXPECT_CALL(scheduler_, Schedule(_, _, _, _, _)).Times(0);
   renderer_->DrawFrame(&pass_list, 1.f, viewport_rect, viewport_rect, false);
 
   SwapBuffers();
@@ skipping 77 matching lines @@
   renderer_->set_expect_overlays(false);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc