Removed QuadSink and MockQuadCuller

cc/layers/tiled_layer_impl_unittest.cc

 // Copyright 2012 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/tiled_layer_impl.h"
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/layer_test_common.h"
-#include "cc/test/mock_quad_culler.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class TiledLayerImplTest : public testing::Test {
  public:
   TiledLayerImplTest() : host_impl_(&proxy_, &shared_bitmap_manager_) {}
@@ skipping 45 matching lines @@
                 const gfx::Size& tile_size,
                 const gfx::Size& layer_size,
                 LayerTilingData::BorderTexelOption border_texel_option,
                 const gfx::Rect& visible_content_rect) {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, border_texel_option);
     layer->draw_properties().visible_content_rect = visible_content_rect;
     layer->SetBounds(layer_size);
 
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
-    MockQuadCuller quad_culler(render_pass, &occlusion_tracker);
     AppendQuadsData data;
-    layer->AppendQuads(&quad_culler, &data);
+    layer->AppendQuads(render_pass, occlusion_tracker, &data);
   }
 
  protected:
   FakeImplProxy proxy_;
   TestSharedBitmapManager shared_bitmap_manager_;
   FakeLayerTreeHostImpl host_impl_;
 };
 
 TEST_F(TiledLayerImplTest, EmptyQuadList) {
   gfx::Size tile_size(90, 90);
   int num_tiles_x = 8;
   int num_tiles_y = 4;
   gfx::Size layer_size(tile_size.width() * num_tiles_x,
                        tile_size.height() * num_tiles_y);
 
   // Verify default layer does creates quads
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     AppendQuadsData data;
     EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
-    layer->AppendQuads(&quad_culler, &data);
+    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
     layer->DidDraw(NULL);
     unsigned num_tiles = num_tiles_x * num_tiles_y;
-    EXPECT_EQ(quad_culler.quad_list().size(), num_tiles);
+    EXPECT_EQ(render_pass->quad_list.size(), num_tiles);
   }
 
   // Layer with empty visible layer rect produces no quads
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
     layer->draw_properties().visible_content_rect = gfx::Rect();
 
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     EXPECT_FALSE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
   }
 
   // Layer with non-intersecting visible layer rect produces no quads
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
     gfx::Rect outside_bounds(-100, -100, 50, 50);
     layer->draw_properties().visible_content_rect = outside_bounds;
 
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     AppendQuadsData data;
     EXPECT_TRUE(layer->WillDraw(DRAW_MODE_HARDWARE, NULL));
-    layer->AppendQuads(&quad_culler, &data);
+    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
     layer->DidDraw(NULL);
-    EXPECT_EQ(quad_culler.quad_list().size(), 0u);
+    EXPECT_EQ(render_pass->quad_list.size(), 0u);
   }
 
   // Layer with skips draw produces no quads
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
     layer->set_skips_draw(true);
 
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     AppendQuadsData data;
-    layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quad_list().size(), 0u);
+    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    EXPECT_EQ(render_pass->quad_list.size(), 0u);
   }
 }
 
 TEST_F(TiledLayerImplTest, Checkerboarding) {
   gfx::Size tile_size(10, 10);
   int num_tiles_x = 2;
   int num_tiles_y = 2;
   gfx::Size layer_size(tile_size.width() * num_tiles_x,
                        tile_size.height() * num_tiles_y);
 
   scoped_ptr<TiledLayerImpl> layer =
       CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
   // No checkerboarding
   {
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     AppendQuadsData data;
-    layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quad_list().size(), 4u);
+    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
+    EXPECT_EQ(render_pass->quad_list.size(), 4u);
     EXPECT_EQ(0u, data.num_missing_tiles);
 
-    for (size_t i = 0; i < quad_culler.quad_list().size(); ++i)
-      EXPECT_EQ(quad_culler.quad_list()[i]->material, DrawQuad::TILED_CONTENT);
+    for (size_t i = 0; i < render_pass->quad_list.size(); ++i)
+      EXPECT_EQ(render_pass->quad_list[i]->material, DrawQuad::TILED_CONTENT);
   }
 
   for (int i = 0; i < num_tiles_x; ++i)
     for (int j = 0; j < num_tiles_y; ++j)
       layer->PushTileProperties(i, j, 0, gfx::Rect(), false);
 
   // All checkerboarding
   {
     MockOcclusionTracker<LayerImpl> occlusion_tracker;
     scoped_ptr<RenderPass> render_pass = RenderPass::Create();
-    MockQuadCuller quad_culler(render_pass.get(), &occlusion_tracker);
 
     AppendQuadsData data;
-    layer->AppendQuads(&quad_culler, &data);
+    layer->AppendQuads(render_pass.get(), occlusion_tracker, &data);
     EXPECT_LT(0u, data.num_missing_tiles);
-    EXPECT_EQ(quad_culler.quad_list().size(), 4u);
-    for (size_t i = 0; i < quad_culler.quad_list().size(); ++i)
-      EXPECT_NE(quad_culler.quad_list()[i]->material, DrawQuad::TILED_CONTENT);
+    EXPECT_EQ(render_pass->quad_list.size(), 4u);
+    for (size_t i = 0; i < render_pass->quad_list.size(); ++i)
+      EXPECT_NE(render_pass->quad_list[i]->material, DrawQuad::TILED_CONTENT);
   }
 }
 
 // Test with both border texels and without.
 #define WITH_AND_WITHOUT_BORDER_TEST(text_fixture_name)                        \
   TEST_F(TiledLayerImplBorderTest, text_fixture_name##NoBorders) {             \
     text_fixture_name(LayerTilingData::NO_BORDER_TEXELS);                      \
   }                                                                            \
   TEST_F(TiledLayerImplBorderTest, text_fixture_name##HasBorders) {            \
     text_fixture_name(LayerTilingData::HAS_BORDER_TEXELS);                     \
@@ skipping 174 matching lines @@
         occluded,
         &partially_occluded_count);
     // The layer outputs one quad, which is partially occluded.
     EXPECT_EQ(100u - 10u, impl.quad_list().size());
     EXPECT_EQ(10u + 10u, partially_occluded_count);
   }
 }
 
 }  // namespace
 }  // namespace cc