Removed QuadSink and MockQuadCuller

cc/layers/picture_layer_impl_unittest.cc

 // Copyright 2013 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/layers/picture_layer_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/layers/picture_layer.h"
+#include "cc/quads/draw_quad.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_picture_layer_impl.h"
 #include "cc/test/fake_picture_pile_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/impl_side_painting_settings.h"
 #include "cc/test/layer_test_common.h"
-#include "cc/test/mock_quad_culler.h"
 #include "cc/test/test_shared_bitmap_manager.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/size_conversions.h"
 
 namespace cc {
 namespace {
 
@@ skipping 1171 matching lines @@
 
   // Verify the tiles are not larger than the context's max texture size.
   Tile* tile = pending_layer_->tilings()->tiling_at(0)->AllTilesForTesting()[0];
   EXPECT_GE(140, tile->content_rect().width());
   EXPECT_GE(140, tile->content_rect().height());
 }
 
 TEST_F(PictureLayerImplTest, DisallowTileDrawQuads) {
   MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-  MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1300, 1900);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
 
   gfx::Rect layer_invalidation(150, 200, 30, 180);
   Region invalidation(layer_invalidation);
   AddDefaultTilingsWithInvalidation(invalidation);
 
   AppendQuadsData data;
   active_layer_->WillDraw(DRAW_MODE_RESOURCELESS_SOFTWARE, NULL);
-  active_layer_->AppendQuads(&quad_culler, &data);
+  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
   active_layer_->DidDraw(NULL);
 
-  ASSERT_EQ(1U, quad_culler.quad_list().size());
-  EXPECT_EQ(DrawQuad::PICTURE_CONTENT, quad_culler.quad_list()[0]->material);
+  ASSERT_EQ(1U, render_pass->quad_list.size());
+  EXPECT_EQ(DrawQuad::PICTURE_CONTENT, render_pass->quad_list[0]->material);
 }
 
 TEST_F(PictureLayerImplTest, MarkRequiredNullTiles) {
   gfx::Size tile_size(100, 100);
   gfx::Size layer_bounds(1000, 1000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateEmptyPile(tile_size, layer_bounds);
   // Layers with entirely empty piles can't get tilings.
   pending_pile->AddRecordingAt(0, 0);
@@ skipping 1461 matching lines @@
                                     2.7f,  // device scale
                                     3.2f,  // page scale
                                     1.f,   // maximum animation scale
                                     false);
   EXPECT_EQ(1u, pending_layer_->tilings()->num_tilings());
 }
 
 TEST_F(PictureLayerImplTest, SharedQuadStateContainsMaxTilingScale) {
   MockOcclusionTracker<LayerImpl> occlusion_tracker;
   scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-  MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
   gfx::Size tile_size(400, 400);
   gfx::Size layer_bounds(1000, 2000);
 
   scoped_refptr<FakePicturePileImpl> pending_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
   scoped_refptr<FakePicturePileImpl> active_pile =
       FakePicturePileImpl::CreateFilledPile(tile_size, layer_bounds);
 
   SetupTrees(pending_pile, active_pile);
 
   SetupDrawPropertiesAndUpdateTiles(pending_layer_, 2.5f, 1.f, 1.f, 1.f, false);
   host_impl_.pending_tree()->UpdateDrawProperties();
 
   active_layer_->draw_properties().visible_content_rect =
       gfx::Rect(layer_bounds);
   host_impl_.active_tree()->UpdateDrawProperties();
 
   float max_contents_scale = active_layer_->MaximumTilingContentsScale();
   gfx::Transform scaled_draw_transform = active_layer_->draw_transform();
   scaled_draw_transform.Scale(SK_MScalar1 / max_contents_scale,
                               SK_MScalar1 / max_contents_scale);
 
   AppendQuadsData data;
-  active_layer_->AppendQuads(&quad_culler, &data);
+  active_layer_->AppendQuads(render_pass.get(), occlusion_tracker, &data);
 
   // SharedQuadState should have be of size 1, as we are doing AppenQuad once.
-  EXPECT_EQ(1u, quad_culler.shared_quad_state_list().size());
+  EXPECT_EQ(1u, render_pass->shared_quad_state_list.size());
   // The content_to_target_transform should be scaled by the
   // MaximumTilingContentsScale on the layer.
   EXPECT_EQ(scaled_draw_transform.ToString(),
-            quad_culler.shared_quad_state_list()[0]
+            render_pass->shared_quad_state_list[0]
                 ->content_to_target_transform.ToString());
   // The content_bounds should be scaled by the
   // MaximumTilingContentsScale on the layer.
   EXPECT_EQ(gfx::Size(2500u, 5000u).ToString(),
-            quad_culler.shared_quad_state_list()[0]->content_bounds.ToString());
+            render_pass->shared_quad_state_list[0]->content_bounds.ToString());
   // The visible_content_rect should be scaled by the
   // MaximumTilingContentsScale on the layer.
   EXPECT_EQ(
       gfx::Rect(0u, 0u, 2500u, 5000u).ToString(),
-      quad_culler.shared_quad_state_list()[0]->visible_content_rect.ToString());
+      render_pass->shared_quad_state_list[0]->visible_content_rect.ToString());
 }
 
 TEST_F(PictureLayerImplTest, UpdateTilesForMasksWithNoVisibleContent) {
   gfx::Size tile_size(400, 400);
   gfx::Size bounds(100000, 100);
 
   host_impl_.CreatePendingTree();
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_.pending_tree(), 1);
 
@@ skipping 29 matching lines @@
 
   host_impl_.pending_tree()->SetRootLayer(root.Pass());
 
   EXPECT_FALSE(pending_mask_content->tilings());
   host_impl_.pending_tree()->UpdateDrawProperties();
   EXPECT_NE(0u, pending_mask_content->num_tilings());
 }
 
 }  // namespace
 }  // namespace cc