cc: Rename MockContentLayerClient to FakeContentLayerClient and move to cc/test/

cc/layer_tree_host_unittest.cc

 // Copyright 2011 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 "config.h"
 
 #include "cc/layer_tree_host.h"
 
 #include "base/synchronization/lock.h"
 #include "cc/content_layer.h"
 #include "cc/content_layer_client.h"
 #include "cc/graphics_context.h"
 #include "cc/layer_tree_host_impl.h"
 #include "cc/settings.h"
 #include "cc/single_thread_proxy.h"
+#include "cc/test/fake_content_layer_client.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_test_common.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/resource_update_queue.h"
 #include "cc/timing_function.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "ui/gfx/point_conversions.h"
@@ skipping 1182 matching lines @@
 private:
     TestOpacityChangeLayerDelegate m_testOpacityChangeDelegate;
     scoped_refptr<ContentLayerWithUpdateTracking> m_updateCheckLayer;
 };
 
 TEST_F(LayerTreeHostTestOpacityChange, runMultiThread)
 {
     runTest(true);
 }
 
-class MockContentLayerClient : public ContentLayerClient {
-public:
-    bool drawsContent() const { return true; }
-    MOCK_CONST_METHOD0(preserves3D, bool());
-    void paintContents(SkCanvas*, const gfx::Rect&, gfx::RectF&) OVERRIDE { }
-    void notifySyncRequired() { }
-};
-
 class NoScaleContentLayer : public ContentLayer {
 public:
     static scoped_refptr<NoScaleContentLayer> create(ContentLayerClient* client) { return make_scoped_refptr(new NoScaleContentLayer(client)); }
 
     virtual gfx::Size contentBounds() const OVERRIDE { return bounds(); }
     virtual float contentsScaleX() const OVERRIDE { return 1.0; }
     virtual float contentsScaleY() const OVERRIDE { return 1.0; }
 
 private:
     explicit NoScaleContentLayer(ContentLayerClient* client)
@@ skipping 26 matching lines @@
     virtual void afterTest() OVERRIDE
     {
         // update() should have been called once, proving that the layer was not skipped.
         EXPECT_EQ(1, m_updateCheckLayer->paintContentsCount());
 
         // clear m_updateCheckLayer so LayerTreeHost dies.
         m_updateCheckLayer = NULL;
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<ContentLayerWithUpdateTracking> m_updateCheckLayer;
 };
 
 TEST_F(LayerTreeHostTestDoNotSkipLayersWithAnimatedOpacity, runMultiThread)
 {
     runTest(true);
 }
 
 
 class LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers : public LayerTreeHostTest {
@@ skipping 88 matching lines @@
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
         m_rootLayer = NULL;
         m_childLayer = NULL;
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<NoScaleContentLayer> m_rootLayer;
     scoped_refptr<ContentLayer> m_childLayer;
 };
 
 // Test is flaky - http://crbug.com/148490
 TEST_F(LayerTreeHostTestDeviceScaleFactorScalesViewportAndLayers, DISABLED_runMultiThread)
 {
     runTest(true);
 }
 
@@ skipping 68 matching lines @@
     virtual void layout() OVERRIDE
     {
         m_layer->setNeedsDisplay();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<ContentLayerWithUpdateTracking> m_layer;
 };
 
 TEST_F(LayerTreeHostTestAtomicCommit, runMultiThread)
 {
     runTest(true);
 }
 
 static void setLayerPropertiesForTesting(Layer* layer, Layer* parent, const WebTransformationMatrix& transform, const gfx::PointF& anchor, const gfx::PointF& position, const gfx::Size& bounds, bool opaque)
 {
@@ skipping 126 matching lines @@
             NOTREACHED();
             break;
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<ContentLayerWithUpdateTracking> m_parent;
     scoped_refptr<ContentLayerWithUpdateTracking> m_child;
     int m_numCommits;
 };
 
 TEST_F(LayerTreeHostTestAtomicCommitWithPartialUpdate, runMultiThread)
 {
     runTest(true);
 }
 
@@ skipping 564 matching lines @@
     }
 
     virtual void beginTest() OVERRIDE
     {
         gfx::Size viewportSize(10, 10);
         gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
 
-        m_rootScrollLayer = ContentLayer::create(&m_mockDelegate);
+        m_rootScrollLayer = ContentLayer::create(&m_fakeDelegate);
         m_rootScrollLayer->setBounds(gfx::Size(110, 110));
 
         m_rootScrollLayer->setPosition(gfx::PointF(0, 0));
         m_rootScrollLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
         m_rootScrollLayer->setMaxScrollOffset(gfx::Vector2d(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
-        m_childLayer = ContentLayer::create(&m_mockDelegate);
+        m_childLayer = ContentLayer::create(&m_fakeDelegate);
         m_childLayer->setLayerScrollClient(this);
         m_childLayer->setBounds(gfx::Size(110, 110));
 
         // The scrolls will happen at 5, 5. If they are treated like device pixels, then
         // they will be at 2.5, 2.5 in logical pixels, and will miss this layer.
         m_childLayer->setPosition(gfx::PointF(5, 5));
         m_childLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_childLayer->setIsDrawable(true);
         m_childLayer->setScrollable(true);
@@ skipping 84 matching lines @@
     }
 
 private:
     float m_deviceScaleFactor;
     gfx::Vector2d m_initialScroll;
     gfx::Vector2d m_secondScroll;
     gfx::Vector2d m_scrollAmount;
     int m_rootScrolls;
     gfx::Vector2d m_finalScrollOffset;
 
-    MockContentLayerClient m_mockDelegate;
+    FakeContentLayerClient m_fakeDelegate;
     scoped_refptr<Layer> m_rootScrollLayer;
     scoped_refptr<Layer> m_childLayer;
 };
 
 class LayerTreeHostTestScrollChildLayerNormalDpi : public LayerTreeHostTestScrollChildLayer {
 public:
     LayerTreeHostTestScrollChildLayerNormalDpi() : LayerTreeHostTestScrollChildLayer(1) { }
 };
 
 TEST_F(LayerTreeHostTestScrollChildLayerNormalDpi, runMultiThread)
@@ skipping 23 matching lines @@
     }
 
     virtual void beginTest() OVERRIDE
     {
         gfx::Size viewportSize(10, 10);
         gfx::Size deviceViewportSize = gfx::ToCeiledSize(viewportSize.Scale(m_deviceScaleFactor));
         m_layerTreeHost->setViewportSize(viewportSize, deviceViewportSize);
 
         m_layerTreeHost->setDeviceScaleFactor(m_deviceScaleFactor);
 
-        m_rootScrollLayer = ContentLayer::create(&m_mockDelegate);
+        m_rootScrollLayer = ContentLayer::create(&m_fakeDelegate);
         m_rootScrollLayer->setBounds(gfx::Size(110, 110));
 
         m_rootScrollLayer->setPosition(gfx::PointF(0, 0));
         m_rootScrollLayer->setAnchorPoint(gfx::PointF(0, 0));
 
         m_rootScrollLayer->setIsDrawable(true);
         m_rootScrollLayer->setScrollable(true);
         m_rootScrollLayer->setMaxScrollOffset(gfx::Vector2d(100, 100));
         m_layerTreeHost->rootLayer()->addChild(m_rootScrollLayer);
 
@@ skipping 68 matching lines @@
         EXPECT_EQ(2, m_rootScrolls);
     }
 
 private:
     float m_deviceScaleFactor;
     gfx::Vector2d m_initialScroll;
     gfx::Vector2d m_secondScroll;
     gfx::Vector2d m_scrollAmount;
     int m_rootScrolls;
 
-    MockContentLayerClient m_mockDelegate;
+    FakeContentLayerClient m_fakeDelegate;
     scoped_refptr<Layer> m_rootScrollLayer;
 };
 
 class LayerTreeHostTestScrollRootScrollLayerNormalDpi : public LayerTreeHostTestScrollRootScrollLayer {
 public:
     LayerTreeHostTestScrollRootScrollLayerNormalDpi() : LayerTreeHostTestScrollRootScrollLayer(1) { }
 };
 
 TEST_F(LayerTreeHostTestScrollRootScrollLayerNormalDpi, runMultiThread)
 {
@@ skipping 28 matching lines @@
     virtual void afterTest() OVERRIDE
     {
     }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackCleanup)
 
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit()
-        : m_rootLayer(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
-        , m_surfaceLayer1(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
-        , m_replicaLayer1(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
-        , m_surfaceLayer2(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
-        , m_replicaLayer2(ContentLayerWithUpdateTracking::create(&m_mockDelegate))
+        : m_rootLayer(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
+        , m_surfaceLayer1(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
+        , m_replicaLayer1(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
+        , m_surfaceLayer2(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
+        , m_replicaLayer2(ContentLayerWithUpdateTracking::create(&m_fakeDelegate))
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(100, 100), gfx::Size(100, 100));
 
         m_rootLayer->setBounds(gfx::Size(100, 100));
         m_surfaceLayer1->setBounds(gfx::Size(100, 100));
         m_surfaceLayer1->setForceRenderSurface(true);
@@ skipping 44 matching lines @@
 
         // Clear layer references so LayerTreeHost dies.
         m_rootLayer = NULL;
         m_surfaceLayer1 = NULL;
         m_replicaLayer1 = NULL;
         m_surfaceLayer2 = NULL;
         m_replicaLayer2 = NULL;
     }
 
 private:
-    MockContentLayerClient m_mockDelegate;
+    FakeContentLayerClient m_fakeDelegate;
     scoped_refptr<ContentLayerWithUpdateTracking> m_rootLayer;
     scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer1;
     scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer1;
     scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer2;
     scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer2;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit)
 
 class EvictionTestLayer : public Layer {
@@ skipping 198 matching lines @@
             NOTREACHED();
             break;
         }
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<EvictionTestLayer> m_layer;
     LayerTreeHostImpl* m_implForEvictTextures;
     int m_numCommits;
 };
 
 TEST_F(LayerTreeHostTestEvictTextures, runMultiThread)
 {
     runTest(true);
 }
 
@@ skipping 65 matching lines @@
     {
         EXPECT_TRUE(succeeded);
         endTest();
     }
 
     virtual void afterTest() OVERRIDE
     {
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<EvictionTestLayer> m_layer;
     LayerTreeHostImpl* m_implForEvictTextures;
     int m_numCommits;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestLostContextAfterEvictTextures)
 
 class CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext : public WebKit::CompositorFakeWebGraphicsContext3D {
 public:
     static scoped_ptr<CompositorFakeWebGraphicsContext3DWithEndQueryCausingLostContext> create(Attributes attrs)
@@ skipping 68 matching lines @@
         m_parent->setNeedsDisplay();
         for (int i = 0; i < m_numChildren; i++)
             m_children[i]->setNeedsDisplay();
     }
 
     virtual void afterTest()
     {
     }
 
 private:
-    MockContentLayerClient m_client;
+    FakeContentLayerClient m_client;
     scoped_refptr<ContentLayerWithUpdateTracking> m_parent;
     int m_numChildren;
     std::vector<scoped_refptr<ContentLayerWithUpdateTracking> > m_children;
 };
 
 TEST_F(LayerTreeHostTestLostContextWhileUpdatingResources, runMultiThread)
 {
     runTest(true);
 }
 
@@ skipping 53 matching lines @@
         : m_numCommitComplete(0)
         , m_numDrawLayers(0)
     {
     }
 
     virtual void beginTest() OVERRIDE
     {
         m_layerTreeHost->setViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
         m_layerTreeHost->rootLayer()->setBounds(gfx::Size(10, 10));
 
-        m_contentLayer = ContentLayer::create(&m_mockDelegate);
+        m_contentLayer = ContentLayer::create(&m_fakeDelegate);
         m_contentLayer->setBounds(gfx::Size(10, 10));
         m_contentLayer->setPosition(gfx::PointF(0, 0));
         m_contentLayer->setAnchorPoint(gfx::PointF(0, 0));
         m_contentLayer->setIsDrawable(true);
         m_layerTreeHost->rootLayer()->addChild(m_contentLayer);
 
         postSetNeedsCommitToMainThread();
     }
 
     virtual void didCommit() OVERRIDE
@@ skipping 17 matching lines @@
     virtual void afterTest() OVERRIDE
     {
         // Check that we didn't commit twice between first and second draw.
         EXPECT_EQ(1, m_numCommitComplete);
 
         // Clear layer references so LayerTreeHost dies.
         m_contentLayer = NULL;
     }
 
 private:
-    MockContentLayerClient m_mockDelegate;
+    FakeContentLayerClient m_fakeDelegate;
     scoped_refptr<Layer> m_contentLayer;
     int m_numCommitComplete;
     int m_numDrawLayers;
 };
 
 TEST_F(LayerTreeHostTestContinuousInvalidate, runMultiThread)
 {
     runTest(true);
 }
 
@@ skipping 139 matching lines @@
     int m_numCommitsDeferred;
     int m_numCompleteCommits;
 };
 
 TEST_F(LayerTreeHostTestDeferCommits, runMultiThread)
 {
     runTest(true);
 }
 
 }  // anonymous namespace