cc: Chromify MockQuadCuller

NOTRY=true
R=danakj@chromium.org
BUG=none


Review URL: https://chromiumcodereview.appspot.com/12549028

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189622 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 80 insertions, 79 deletions

diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index a091a30..3a40b4eb 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -494,7 +494,7 @@ class DelegatedRendererLayerImplTestTransform
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
-      MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
+      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state = quad_sink.UseSharedQuadState(
           SharedQuadState::Create());
@@ -529,7 +529,7 @@ class DelegatedRendererLayerImplTestTransform
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
-    MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
+    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.UseSharedQuadState(SharedQuadState::Create());
@@ -891,7 +891,7 @@ class DelegatedRendererLayerImplTestClip
           RenderPass::Id(10, 7),
           child_pass_rect,
           gfx::Transform());
-      MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
+      MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
       AppendQuadsData data(pass->id);
       SharedQuadState* shared_quad_state =
           quad_sink.UseSharedQuadState(SharedQuadState::Create());
@@ -924,7 +924,7 @@ class DelegatedRendererLayerImplTestClip
         RenderPass::Id(9, 6),
         root_pass_rect,
         gfx::Transform());
-    MockQuadCuller quad_sink(pass->quad_list, pass->shared_quad_state_list);
+    MockQuadCuller quad_sink(&pass->quad_list, &pass->shared_quad_state_list);
     AppendQuadsData data(pass->id);
     SharedQuadState* shared_quad_state =
         quad_sink.UseSharedQuadState(SharedQuadState::Create());
diff --git a/cc/layers/nine_patch_layer_impl_unittest.cc b/cc/layers/nine_patch_layer_impl_unittest.cc
index b4af387..8034505 100644
--- a/cc/layers/nine_patch_layer_impl_unittest.cc
+++ b/cc/layers/nine_patch_layer_impl_unittest.cc
@@ -59,7 +59,7 @@ TEST(NinePatchLayerImplTest, verifyDrawQuads)
     layer->AppendQuads(&quadCuller, &data);
 
     // Verify quad rects
-    const QuadList& quads = quadCuller.quadList();
+    const QuadList& quads = quadCuller.quad_list();
     EXPECT_EQ(8, quads.size());
     Region remaining(visibleContentRect);
     for (size_t i = 0; i < quads.size(); ++i) {
@@ -114,7 +114,7 @@ TEST(NinePatchLayerImplTest, verifyDrawQuadsForSqueezedLayer)
     layer->AppendQuads(&quadCuller, &data);
 
     // Verify corner rects fill the layer and don't overlap
-    const QuadList& quads = quadCuller.quadList();
+    const QuadList& quads = quadCuller.quad_list();
     EXPECT_EQ(4, quads.size());
     Region filled;
     for (size_t i = 0; i < quads.size(); ++i) {
diff --git a/cc/layers/render_surface_unittest.cc b/cc/layers/render_surface_unittest.cc
index 30d9480..4c21ca6e 100644
--- a/cc/layers/render_surface_unittest.cc
+++ b/cc/layers/render_surface_unittest.cc
@@ -97,7 +97,7 @@ TEST(RenderSurfaceTest, sanityCheckSurfaceCreatesCorrectSharedQuadState)
 
     QuadList quadList;
     SharedQuadStateList sharedStateList;
-    MockQuadCuller mockQuadCuller(quadList, sharedStateList);
+    MockQuadCuller mockQuadCuller(&quadList, &sharedStateList);
     AppendQuadsData appendQuadsData;
 
     bool forReplica = false;
diff --git a/cc/layers/scrollbar_layer_unittest.cc b/cc/layers/scrollbar_layer_unittest.cc
index 0e46b67..bf48c0d 100644
--- a/cc/layers/scrollbar_layer_unittest.cc
+++ b/cc/layers/scrollbar_layer_unittest.cc
@@ -170,7 +170,7 @@ TEST(ScrollbarLayerTest, solidColorDrawQuads)
         AppendQuadsData data;
         scrollbarLayerImpl->AppendQuads(&quadCuller, &data);
 
-        const QuadList& quads = quadCuller.quadList();
+        const QuadList& quads = quadCuller.quad_list();
         ASSERT_EQ(1, quads.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
         EXPECT_RECT_EQ(gfx::Rect(1, 0, 4, 3), quads[0]->rect);
@@ -184,7 +184,7 @@ TEST(ScrollbarLayerTest, solidColorDrawQuads)
         AppendQuadsData data;
         scrollbarLayerImpl->AppendQuads(&quadCuller, &data);
 
-        const QuadList& quads = quadCuller.quadList();
+        const QuadList& quads = quadCuller.quad_list();
         ASSERT_EQ(1, quads.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
         EXPECT_RECT_EQ(gfx::Rect(2, 0, 8, 6), quads[0]->rect);
@@ -201,7 +201,7 @@ TEST(ScrollbarLayerTest, solidColorDrawQuads)
         AppendQuadsData data;
         scrollbarLayerImpl->AppendQuads(&quadCuller, &data);
 
-        const QuadList& quads = quadCuller.quadList();
+        const QuadList& quads = quadCuller.quad_list();
         ASSERT_EQ(1, quads.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, quads[0]->material);
         EXPECT_RECT_EQ(gfx::Rect(4, 0, 2, 3), quads[0]->rect);
diff --git a/cc/layers/solid_color_layer_impl_unittest.cc b/cc/layers/solid_color_layer_impl_unittest.cc
index 12796fa..7b86c31 100644
--- a/cc/layers/solid_color_layer_impl_unittest.cc
+++ b/cc/layers/solid_color_layer_impl_unittest.cc
@@ -38,7 +38,7 @@ TEST(SolidColorLayerImplTest, VerifyTilingCompleteAndNoOverlap) {
   AppendQuadsData data;
   layer->AppendQuads(&quad_culler, &data);
 
-  LayerTestCommon::VerifyQuadsExactlyCoverRect(quad_culler.quadList(),
+  LayerTestCommon::VerifyQuadsExactlyCoverRect(quad_culler.quad_list(),
                                                visible_content_rect);
 }
 
@@ -63,8 +63,8 @@ TEST(SolidColorLayerImplTest, VerifyCorrectBackgroundColorInQuad) {
   AppendQuadsData data;
   layer->AppendQuads(&quad_culler, &data);
 
-  ASSERT_EQ(quad_culler.quadList().size(), 1U);
-  EXPECT_EQ(SolidColorDrawQuad::MaterialCast(quad_culler.quadList()[0])->color,
+  ASSERT_EQ(quad_culler.quad_list().size(), 1U);
+  EXPECT_EQ(SolidColorDrawQuad::MaterialCast(quad_culler.quad_list()[0])->color,
             test_color);
 }
 
@@ -89,9 +89,9 @@ TEST(SolidColorLayerImplTest, VerifyCorrectOpacityInQuad) {
   AppendQuadsData data;
   layer->AppendQuads(&quad_culler, &data);
 
-  ASSERT_EQ(quad_culler.quadList().size(), 1U);
+  ASSERT_EQ(quad_culler.quad_list().size(), 1U);
   EXPECT_EQ(opacity,
-            SolidColorDrawQuad::MaterialCast(quad_culler.quadList()[0])
+            SolidColorDrawQuad::MaterialCast(quad_culler.quad_list()[0])
                 ->opacity());
 }
 
@@ -132,9 +132,9 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     AppendQuadsData data;
     layer_impl->AppendQuads(&quad_culler, &data);
 
-    ASSERT_EQ(quad_culler.quadList().size(), 1U);
+    ASSERT_EQ(quad_culler.quad_list().size(), 1U);
     EXPECT_EQ(visible_content_rect.ToString(),
-              quad_culler.quadList()[0]->opaque_rect.ToString());
+              quad_culler.quad_list()[0]->opaque_rect.ToString());
   }
 
   EXPECT_TRUE(layer->contents_opaque());
@@ -156,9 +156,9 @@ TEST(SolidColorLayerImplTest, VerifyOpaqueRect) {
     AppendQuadsData data;
     layer_impl->AppendQuads(&quad_culler, &data);
 
-    ASSERT_EQ(quad_culler.quadList().size(), 1U);
+    ASSERT_EQ(quad_culler.quad_list().size(), 1U);
     EXPECT_EQ(gfx::Rect().ToString(),
-              quad_culler.quadList()[0]->opaque_rect.ToString());
+              quad_culler.quad_list()[0]->opaque_rect.ToString());
   }
 }
 
diff --git a/cc/layers/tiled_layer_impl_unittest.cc b/cc/layers/tiled_layer_impl_unittest.cc
index 0d1b87f..0345cc0 100644
--- a/cc/layers/tiled_layer_impl_unittest.cc
+++ b/cc/layers/tiled_layer_impl_unittest.cc
@@ -65,7 +65,7 @@ class TiledLayerImplTest : public testing::Test {
     layer->draw_properties().visible_content_rect = visible_content_rect;
     layer->SetBounds(layer_size);
 
-    MockQuadCuller quad_culler(*quads, *shared_states);
+    MockQuadCuller quad_culler(quads, shared_states);
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
   }
@@ -90,7 +90,7 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
     unsigned num_tiles = num_tiles_x * num_tiles_y;
-    EXPECT_EQ(quad_culler.quadList().size(), num_tiles);
+    EXPECT_EQ(quad_culler.quad_list().size(), num_tiles);
   }
 
   // Layer with empty visible layer rect produces no quads
@@ -102,7 +102,7 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quadList().size(), 0u);
+    EXPECT_EQ(quad_culler.quad_list().size(), 0u);
   }
 
   // Layer with non-intersecting visible layer rect produces no quads
@@ -116,7 +116,7 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quadList().size(), 0u);
+    EXPECT_EQ(quad_culler.quad_list().size(), 0u);
   }
 
   // Layer with skips draw produces no quads
@@ -128,7 +128,7 @@ TEST_F(TiledLayerImplTest, EmptyQuadList) {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quadList().size(), 0u);
+    EXPECT_EQ(quad_culler.quad_list().size(), 0u);
   }
 }
 
@@ -147,11 +147,11 @@ TEST_F(TiledLayerImplTest, Checkerboarding) {
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
-    EXPECT_EQ(quad_culler.quadList().size(), 4u);
+    EXPECT_EQ(quad_culler.quad_list().size(), 4u);
     EXPECT_EQ(0u, data.numMissingTiles);
 
-    for (size_t i = 0; i < quad_culler.quadList().size(); ++i)
-      EXPECT_EQ(quad_culler.quadList()[i]->material, DrawQuad::TILED_CONTENT);
+    for (size_t i = 0; i < quad_culler.quad_list().size(); ++i)
+      EXPECT_EQ(quad_culler.quad_list()[i]->material, DrawQuad::TILED_CONTENT);
   }
 
   for (int i = 0; i < num_tiles_x; ++i)
@@ -164,9 +164,9 @@ TEST_F(TiledLayerImplTest, Checkerboarding) {
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
     EXPECT_LT(0u, data.numMissingTiles);
-    EXPECT_EQ(quad_culler.quadList().size(), 4u);
-    for (size_t i = 0; i < quad_culler.quadList().size(); ++i)
-      EXPECT_NE(quad_culler.quadList()[i]->material, DrawQuad::TILED_CONTENT);
+    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);
   }
 }
 
diff --git a/cc/test/mock_quad_culler.cc b/cc/test/mock_quad_culler.cc
index 0759ba5..f9924c8 100644
--- a/cc/test/mock_quad_culler.cc
+++ b/cc/test/mock_quad_culler.cc
@@ -9,35 +9,30 @@
 namespace cc {
 
 MockQuadCuller::MockQuadCuller()
-    : m_activeQuadList(m_quadListStorage)
-    , m_activeSharedQuadStateList(m_sharedQuadStateStorage)
-{
+    : active_quad_list_(&quad_list_storage_),
+      active_shared_quad_state_list_(&shared_quad_state_storage_) {}
+
+MockQuadCuller::MockQuadCuller(
+    QuadList* external_quad_list,
+    SharedQuadStateList* external_shared_quad_state_list)
+    : active_quad_list_(external_quad_list),
+      active_shared_quad_state_list_(external_shared_quad_state_list) {}
+
+MockQuadCuller::~MockQuadCuller() {}
+
+bool MockQuadCuller::Append(scoped_ptr<DrawQuad> draw_quad, AppendQuadsData*) {
+  if (!draw_quad->rect.IsEmpty()) {
+    active_quad_list_->push_back(draw_quad.Pass());
+    return true;
+  }
+  return false;
 }
 
-MockQuadCuller::MockQuadCuller(QuadList& externalQuadList, SharedQuadStateList& externalSharedQuadStateList)
-    : m_activeQuadList(externalQuadList)
-    , m_activeSharedQuadStateList(externalSharedQuadStateList)
-{
-}
-
-MockQuadCuller::~MockQuadCuller()
-{
-}
-
-bool MockQuadCuller::Append(scoped_ptr<DrawQuad> drawQuad, AppendQuadsData*)
-{
-    if (!drawQuad->rect.IsEmpty()) {
-        m_activeQuadList.push_back(drawQuad.Pass());
-        return true;
-    }
-    return false;
-}
-
-SharedQuadState* MockQuadCuller::UseSharedQuadState(scoped_ptr<SharedQuadState> sharedQuadState)
-{
-    SharedQuadState* rawPtr = sharedQuadState.get();
-    m_activeSharedQuadStateList.push_back(sharedQuadState.Pass());
-    return rawPtr;
+SharedQuadState* MockQuadCuller::UseSharedQuadState(
+    scoped_ptr<SharedQuadState> shared_quad_state) {
+  SharedQuadState* raw_ptr = shared_quad_state.get();
+  active_shared_quad_state_list_->push_back(shared_quad_state.Pass());
+  return raw_ptr;
 }
 
 }  // namespace cc
diff --git a/cc/test/mock_quad_culler.h b/cc/test/mock_quad_culler.h
index ac413e4..4b9ef1e 100644
--- a/cc/test/mock_quad_culler.h
+++ b/cc/test/mock_quad_culler.h
@@ -13,24 +13,29 @@
 namespace cc {
 
 class MockQuadCuller : public QuadSink {
-public:
-    MockQuadCuller();
-    virtual ~MockQuadCuller();
-
-    MockQuadCuller(QuadList& externalQuadList, SharedQuadStateList& externalSharedQuadStateList);
-
-    virtual bool Append(scoped_ptr<DrawQuad> draw_quad, AppendQuadsData* append_quads_data) OVERRIDE;
-
-    virtual SharedQuadState* UseSharedQuadState(scoped_ptr<SharedQuadState> shared_quad_state) OVERRIDE;
-
-    const QuadList& quadList() const { return m_activeQuadList; };
-    const SharedQuadStateList& sharedQuadStateList() const { return m_activeSharedQuadStateList; };
-
-private:
-    QuadList& m_activeQuadList;
-    QuadList m_quadListStorage;
-    SharedQuadStateList& m_activeSharedQuadStateList;
-    SharedQuadStateList m_sharedQuadStateStorage;
+ public:
+  MockQuadCuller();
+  virtual ~MockQuadCuller();
+
+  MockQuadCuller(QuadList* external_quad_list,
+                 SharedQuadStateList* external_shared_quad_state_list);
+
+  // QuadSink interface.
+  virtual bool Append(scoped_ptr<DrawQuad> draw_quad,
+                      AppendQuadsData* append_quads_data) OVERRIDE;
+  virtual SharedQuadState* UseSharedQuadState(
+      scoped_ptr<SharedQuadState> shared_quad_state) OVERRIDE;
+
+  const QuadList& quad_list() const { return *active_quad_list_; }
+  const SharedQuadStateList& shared_quad_state_list() const {
+    return *active_shared_quad_state_list_;
+  }
+
+ private:
+  QuadList* active_quad_list_;
+  QuadList quad_list_storage_;
+  SharedQuadStateList* active_shared_quad_state_list_;
+  SharedQuadStateList shared_quad_state_storage_;
 };
 
 }  // namespace cc
diff --git a/cc/test/render_pass_test_utils.cc b/cc/test/render_pass_test_utils.cc
index d232f7d..f803b4c 100644
--- a/cc/test/render_pass_test_utils.cc
+++ b/cc/test/render_pass_test_utils.cc
@@ -29,7 +29,7 @@ TestRenderPass* addRenderPass(RenderPassList& passList,
 SolidColorDrawQuad* addQuad(TestRenderPass* pass,
                             const gfx::Rect& rect,
                             SkColor color) {
-  MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
+  MockQuadCuller quadSink(&pass->quad_list, &pass->shared_quad_state_list);
   AppendQuadsData data(pass->id);
   SharedQuadState* sharedState =
       quadSink.UseSharedQuadState(SharedQuadState::Create());
@@ -44,7 +44,7 @@ SolidColorDrawQuad* addQuad(TestRenderPass* pass,
 SolidColorDrawQuad* addClippedQuad(TestRenderPass* pass,
                                    const gfx::Rect& rect,
                                    SkColor color) {
-  MockQuadCuller quadSink(pass->quad_list, pass->shared_quad_state_list);
+  MockQuadCuller quadSink(&pass->quad_list, &pass->shared_quad_state_list);
   AppendQuadsData data(pass->id);
   SharedQuadState* sharedState =
       quadSink.UseSharedQuadState(SharedQuadState::Create());
@@ -58,12 +58,13 @@ SolidColorDrawQuad* addClippedQuad(TestRenderPass* pass,
 
 void addRenderPassQuad(TestRenderPass* toPass,
                        TestRenderPass* contributingPass) {
-  MockQuadCuller quadSink(toPass->quad_list, toPass->shared_quad_state_list);
+  MockQuadCuller quadSink(&toPass->quad_list, &toPass->shared_quad_state_list);
   AppendQuadsData data(toPass->id);
   gfx::Rect outputRect = contributingPass->output_rect;
   SharedQuadState* sharedState =
       quadSink.UseSharedQuadState(SharedQuadState::Create());
-  sharedState->SetAll(gfx::Transform(), outputRect.size(), outputRect, outputRect, false, 1);
+  sharedState->SetAll(
+      gfx::Transform(), outputRect.size(), outputRect, outputRect, false, 1);
   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
   quad->SetNew(sharedState, outputRect, contributingPass->id, false, 0,
                outputRect, gfx::RectF(), WebKit::WebFilterOperations(),