cc: Rename cc classes and members to match filenames

cc/threaded_unittest.h

 // 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.
 
 #ifndef CCThreadedTest_h
 #define CCThreadedTest_h
 
 #include "CCLayerTreeHost.h"
 #include "CCLayerTreeHostImpl.h"
 #include "CCScopedThreadProxy.h"
 #include "base/hash_tables.h"
 #include "cc/test/compositor_fake_web_graphics_context_3d.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebAnimationDelegate.h>
 #include <public/WebThread.h>
 
 namespace cc {
-class CCLayerImpl;
-class CCLayerTreeHost;
-class CCLayerTreeHostClient;
-class CCLayerTreeHostImpl;
+class LayerImpl;
+class LayerTreeHost;
+class LayerTreeHostClient;
+class LayerTreeHostImpl;
 class GraphicsContext3D;
 }
 
 namespace WebKitTests {
 
 // Used by test stubs to notify the test when something interesting happens.
 class TestHooks : public WebKit::WebAnimationDelegate {
 public:
-    virtual void beginCommitOnCCThread(cc::CCLayerTreeHostImpl*) { }
-    virtual void commitCompleteOnCCThread(cc::CCLayerTreeHostImpl*) { }
-    virtual bool prepareToDrawOnCCThread(cc::CCLayerTreeHostImpl*);
-    virtual void drawLayersOnCCThread(cc::CCLayerTreeHostImpl*) { }
-    virtual void animateLayers(cc::CCLayerTreeHostImpl*, double monotonicTime) { }
-    virtual void willAnimateLayers(cc::CCLayerTreeHostImpl*, double monotonicTime) { }
+    virtual void beginCommitOnThread(cc::LayerTreeHostImpl*) { }
+    virtual void commitCompleteOnThread(cc::LayerTreeHostImpl*) { }
+    virtual bool prepareToDrawOnThread(cc::LayerTreeHostImpl*);
+    virtual void drawLayersOnThread(cc::LayerTreeHostImpl*) { }
+    virtual void animateLayers(cc::LayerTreeHostImpl*, double monotonicTime) { }
+    virtual void willAnimateLayers(cc::LayerTreeHostImpl*, double monotonicTime) { }
     virtual void applyScrollAndScale(const cc::IntSize&, float) { }
     virtual void animate(double monotonicTime) { }
     virtual void layout() { }
     virtual void didRecreateOutputSurface(bool succeeded) { }
     virtual void didAddAnimation() { }
     virtual void didCommit() { }
     virtual void didCommitAndDrawFrame() { }
     virtual void scheduleComposite() { }
 
     // Implementation of WebAnimationDelegate
     virtual void notifyAnimationStarted(double time) OVERRIDE { }
     virtual void notifyAnimationFinished(double time) OVERRIDE { }
 
     virtual scoped_ptr<WebKit::WebCompositorOutputSurface> createOutputSurface();
 };
 
 class TimeoutTask;
 class BeginTask;
 
-class MockCCLayerTreeHostClient : public cc::CCLayerTreeHostClient {
+class MockLayerImplTreeHostClient : public cc::LayerTreeHostClient {
 };
 
-// The CCThreadedTests runs with the main loop running. It instantiates a single MockLayerTreeHost and associated
-// MockLayerTreeHostImpl/MockLayerTreeHostClient.
+// The ThreadedTests runs with the main loop running. It instantiates a single MockLayerTreeHost and associated
+// MockLayerTreeHostImpl/ThreadedMockLayerTreeHostClient.
 //
 // beginTest() is called once the main message loop is running and the layer tree host is initialized.
 //
-// Key stages of the drawing loop, e.g. drawing or commiting, redirect to CCThreadedTest methods of similar names.
+// Key stages of the drawing loop, e.g. drawing or commiting, redirect to ThreadedTest methods of similar names.
 // To track the commit process, override these functions.
 //
 // The test continues until someone calls endTest. endTest can be called on any thread, but be aware that
 // ending the test is an asynchronous process.
-class CCThreadedTest : public testing::Test, public TestHooks {
+class ThreadedTest : public testing::Test, public TestHooks {
 public:
-    virtual ~CCThreadedTest();
+    virtual ~ThreadedTest();
 
     virtual void afterTest() = 0;
     virtual void beginTest() = 0;
 
     void endTest();
     void endTestAfterDelay(int delayMilliseconds);
 
     void postSetNeedsAnimateToMainThread();
     void postAddAnimationToMainThread();
     void postAddInstantAnimationToMainThread();
     void postSetNeedsCommitToMainThread();
     void postAcquireLayerTextures();
     void postSetNeedsRedrawToMainThread();
     void postSetNeedsAnimateAndCommitToMainThread();
     void postSetVisibleToMainThread(bool visible);
     void postDidAddAnimationToMainThread();
 
     void doBeginTest();
     void timeout();
 
     void clearTimeout() { m_timeoutTask = 0; }
 
-    cc::CCLayerTreeHost* layerTreeHost() { return m_layerTreeHost.get(); }
+    cc::LayerTreeHost* layerTreeHost() { return m_layerTreeHost.get(); }
 
 protected:
-    CCThreadedTest();
+    ThreadedTest();
 
-    virtual void initializeSettings(cc::CCLayerTreeSettings&) { }
+    virtual void initializeSettings(cc::LayerTreeSettings&) { }
 
     virtual void scheduleComposite() OVERRIDE;
 
     void realEndTest();
 
     void dispatchSetNeedsAnimate();
     void dispatchAddInstantAnimation();
     void dispatchAddAnimation();
     void dispatchSetNeedsAnimateAndCommit();
     void dispatchSetNeedsCommit();
     void dispatchAcquireLayerTextures();
     void dispatchSetNeedsRedraw();
     void dispatchSetVisible(bool);
     void dispatchComposite();
     void dispatchDidAddAnimation();
 
     virtual void runTest(bool threaded);
     WebKit::WebThread* webThread() const { return m_webThread.get(); }
 
-    cc::CCLayerTreeSettings m_settings;
-    scoped_ptr<MockCCLayerTreeHostClient> m_client;
-    scoped_ptr<cc::CCLayerTreeHost> m_layerTreeHost;
+    cc::LayerTreeSettings m_settings;
+    scoped_ptr<MockLayerImplTreeHostClient> m_client;
+    scoped_ptr<cc::LayerTreeHost> m_layerTreeHost;
 
 protected:
-    RefPtr<cc::CCScopedThreadProxy> m_mainThreadProxy;
+    RefPtr<cc::ScopedThreadProxy> m_mainThreadProxy;
 
 private:
     bool m_beginning;
     bool m_endWhenBeginReturns;
     bool m_timedOut;
     bool m_finished;
     bool m_scheduled;
     bool m_started;
 
     scoped_ptr<WebKit::WebThread> m_webThread;
     TimeoutTask* m_timeoutTask;
     BeginTask* m_beginTask;
 };
 
-class CCThreadedTestThreadOnly : public CCThreadedTest {
+class ThreadedTestThreadOnly : public ThreadedTest {
 public:
     void runTestThreaded()
     {
-        CCThreadedTest::runTest(true);
+        ThreadedTest::runTest(true);
     }
 };
 
-// Adapts CCLayerTreeHostImpl for test. Runs real code, then invokes test hooks.
-class MockLayerTreeHostImpl : public cc::CCLayerTreeHostImpl {
+// Adapts LayerTreeHostImpl for test. Runs real code, then invokes test hooks.
+class MockLayerTreeHostImpl : public cc::LayerTreeHostImpl {
 public:
-    static scoped_ptr<MockLayerTreeHostImpl> create(TestHooks*, const cc::CCLayerTreeSettings&, cc::CCLayerTreeHostImplClient*);
+    static scoped_ptr<MockLayerTreeHostImpl> create(TestHooks*, const cc::LayerTreeSettings&, cc::LayerTreeHostImplClient*);
 
     virtual void beginCommit() OVERRIDE;
     virtual void commitComplete() OVERRIDE;
     virtual bool prepareToDraw(FrameData&) OVERRIDE;
     virtual void drawLayers(const FrameData&) OVERRIDE;
 
     // Make these public.
-    typedef std::vector<cc::CCLayerImpl*> CCLayerList;
-    using CCLayerTreeHostImpl::calculateRenderSurfaceLayerList;
+    typedef std::vector<cc::LayerImpl*> LayerList;
+    using LayerTreeHostImpl::calculateRenderSurfaceLayerList;
 
 protected:
     virtual void animateLayers(double monotonicTime, double wallClockTime) OVERRIDE;
     virtual base::TimeDelta lowFrequencyAnimationInterval() const OVERRIDE;
 
 private:
-    MockLayerTreeHostImpl(TestHooks*, const cc::CCLayerTreeSettings&, cc::CCLayerTreeHostImplClient*);
+    MockLayerTreeHostImpl(TestHooks*, const cc::LayerTreeSettings&, cc::LayerTreeHostImplClient*);
 
     TestHooks* m_testHooks;
 };
 
 class CompositorFakeWebGraphicsContext3DWithTextureTracking : public WebKit::CompositorFakeWebGraphicsContext3D {
 public:
     static scoped_ptr<CompositorFakeWebGraphicsContext3DWithTextureTracking> create(Attributes);
     virtual ~CompositorFakeWebGraphicsContext3DWithTextureTracking();
 
     virtual WebKit::WebGLId createTexture();
@@ skipping 23 matching lines @@
     TEST_F(TEST_FIXTURE_NAME, runSingleThread)            \
     {                                                     \
         runTest(false);                                   \
     }                                                     \
     TEST_F(TEST_FIXTURE_NAME, runMultiThread)             \
     {                                                     \
         runTest(true);                                    \
     }
 
 #endif // CCThreadedTest_h