cc: Rename cc classes and members to match filenames

cc/texture_update_controller_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 "config.h"
 
 #include "CCTextureUpdateController.h"
 
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "cc/test/fake_web_graphics_context_3d.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/test/web_compositor_initializer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebThread.h>
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
 using testing::Test;
 
 
 namespace {
 
 const int kFlushPeriodFull = 4;
 const int kFlushPeriodPartial = kFlushPeriodFull;
 
-class CCTextureUpdateControllerTest;
+class TextureUpdateControllerTest;
 
 class WebGraphicsContext3DForUploadTest : public FakeWebGraphicsContext3D {
 public:
-    WebGraphicsContext3DForUploadTest(CCTextureUpdateControllerTest *test)
+    WebGraphicsContext3DForUploadTest(TextureUpdateControllerTest *test)
         : m_test(test)
         , m_supportShallowFlush(true)
     { }
 
     virtual void flush(void);
     virtual void shallowFlushCHROMIUM(void);
     virtual GrGLInterface* onCreateGrGLInterface() { return 0; }
 
     virtual WebString getString(WGC3Denum name)
     {
         if (m_supportShallowFlush)
             return WebString("GL_CHROMIUM_shallow_flush");
         return WebString("");
     }
 
 private:
-    CCTextureUpdateControllerTest* m_test;
+    TextureUpdateControllerTest* m_test;
     bool m_supportShallowFlush;
 };
 
 
 class TextureUploaderForUploadTest : public FakeTextureUploader {
 public:
-    TextureUploaderForUploadTest(CCTextureUpdateControllerTest *test) : m_test(test) { }
+    TextureUploaderForUploadTest(TextureUpdateControllerTest *test) : m_test(test) { }
 
-    virtual void uploadTexture(cc::CCResourceProvider*, Parameters) OVERRIDE;
+    virtual void uploadTexture(cc::ResourceProvider*, Parameters) OVERRIDE;
 
 private:
-    CCTextureUpdateControllerTest* m_test;
+    TextureUpdateControllerTest* m_test;
 };
 
-class CCTextureUpdateControllerTest : public Test {
+class TextureUpdateControllerTest : public Test {
 public:
-    CCTextureUpdateControllerTest()
-        : m_queue(make_scoped_ptr(new CCTextureUpdateQueue))
+    TextureUpdateControllerTest()
+        : m_queue(make_scoped_ptr(new TextureUpdateQueue))
         , m_uploader(this)
         , m_compositorInitializer(m_thread.get())
         , m_fullUploadCountExpected(0)
         , m_partialCountExpected(0)
         , m_totalUploadCountExpected(0)
         , m_maxUploadCountPerUpdate(0)
         , m_numConsecutiveFlushes(0)
         , m_numDanglingUploads(0)
         , m_numTotalUploads(0)
         , m_numTotalFlushes(0)
@@ skipping 22 matching lines @@
         m_numConsecutiveFlushes = 0;
         m_numDanglingUploads++;
         m_numTotalUploads++;
     }
 
 protected:
     virtual void SetUp()
     {
         m_context = FakeWebCompositorOutputSurface::create(scoped_ptr<WebKit::WebGraphicsContext3D>(new WebGraphicsContext3DForUploadTest(this)));
         DebugScopedSetImplThread implThread;
-        m_resourceProvider = CCResourceProvider::create(m_context.get());
+        m_resourceProvider = ResourceProvider::create(m_context.get());
         for (int i = 0; i < 4; i++)
-          m_textures[i] = CCPrioritizedTexture::create(
+          m_textures[i] = PrioritizedTexture::create(
               NULL, IntSize(256, 256), GL_RGBA);
     }
 
 
     void appendFullUploadsOfIndexedTextureToUpdateQueue(int count, int textureIndex)
     {
         m_fullUploadCountExpected += count;
         m_totalUploadCountExpected += count;
 
         const IntRect rect(0, 0, 300, 150);
@@ skipping 23 matching lines @@
         appendPartialUploadsOfIndexedTextureToUpdateQueue(count, 0);
     }
 
     void setMaxUploadCountPerUpdate(int count)
     {
         m_maxUploadCountPerUpdate = count;
     }
 
     void updateTextures()
     {
-        scoped_ptr<CCTextureUpdateController> updateController =
-            CCTextureUpdateController::create(
+        scoped_ptr<TextureUpdateController> updateController =
+            TextureUpdateController::create(
                 NULL,
-                CCProxy::implThread(),
+                Proxy::implThread(),
                 m_queue.Pass(),
                 m_resourceProvider.get(),
                 &m_uploader);
         updateController->finalize();
     }
 
 protected:
-    // Classes required to interact and test the CCTextureUpdateController
-    scoped_ptr<CCGraphicsContext> m_context;
-    scoped_ptr<CCResourceProvider> m_resourceProvider;
-    scoped_ptr<CCTextureUpdateQueue> m_queue;
-    scoped_ptr<CCPrioritizedTexture> m_textures[4];
+    // Classes required to interact and test the TextureUpdateController
+    scoped_ptr<GraphicsContext> m_context;
+    scoped_ptr<ResourceProvider> m_resourceProvider;
+    scoped_ptr<TextureUpdateQueue> m_queue;
+    scoped_ptr<PrioritizedTexture> m_textures[4];
     TextureUploaderForUploadTest m_uploader;
     scoped_ptr<WebThread> m_thread;
     WebCompositorInitializer m_compositorInitializer;
 
 
     // Properties / expectations of this test
     int m_fullUploadCountExpected;
     int m_partialCountExpected;
     int m_totalUploadCountExpected;
     int m_maxUploadCountPerUpdate;
 
     // Dynamic properties of this test
     int m_numConsecutiveFlushes;
     int m_numDanglingUploads;
     int m_numTotalUploads;
     int m_numTotalFlushes;
 };
 
 void WebGraphicsContext3DForUploadTest::flush(void)
 {
     m_test->onFlush();
 }
 
 void WebGraphicsContext3DForUploadTest::shallowFlushCHROMIUM(void)
 {
     m_test->onFlush();
 }
 
-void TextureUploaderForUploadTest::uploadTexture(cc::CCResourceProvider*, Parameters)
+void TextureUploaderForUploadTest::uploadTexture(cc::ResourceProvider*, Parameters)
 {
     m_test->onUpload();
 }
 
 // ZERO UPLOADS TESTS
-TEST_F(CCTextureUpdateControllerTest, ZeroUploads)
+TEST_F(TextureUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(0, m_numTotalFlushes);
     EXPECT_EQ(0, m_numTotalUploads);
 }
 
 
 // ONE UPLOAD TESTS
-TEST_F(CCTextureUpdateControllerTest, OneFullUpload)
+TEST_F(TextureUpdateControllerTest, OneFullUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(1, m_numTotalFlushes);
     EXPECT_EQ(1, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(CCTextureUpdateControllerTest, OnePartialUpload)
+TEST_F(TextureUpdateControllerTest, OnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(1, m_numTotalFlushes);
     EXPECT_EQ(1, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(CCTextureUpdateControllerTest, OneFullOnePartialUpload)
+TEST_F(TextureUpdateControllerTest, OneFullOnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(1);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(1, m_numTotalFlushes);
     EXPECT_EQ(2, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
 
 // This class of tests upload a number of textures that is a multiple of the flush period.
 const int fullUploadFlushMultipler = 7;
 const int fullCount = fullUploadFlushMultipler * kFlushPeriodFull;
 
 const int partialUploadFlushMultipler = 11;
 const int partialCount = partialUploadFlushMultipler * kFlushPeriodPartial;
 
-TEST_F(CCTextureUpdateControllerTest, ManyFullUploads)
+TEST_F(TextureUpdateControllerTest, ManyFullUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(0);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(fullUploadFlushMultipler, m_numTotalFlushes);
     EXPECT_EQ(fullCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(CCTextureUpdateControllerTest, ManyPartialUploads)
+TEST_F(TextureUpdateControllerTest, ManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(partialCount);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(partialUploadFlushMultipler, m_numTotalFlushes);
     EXPECT_EQ(partialCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-TEST_F(CCTextureUpdateControllerTest, ManyFullManyPartialUploads)
+TEST_F(TextureUpdateControllerTest, ManyFullManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(partialCount);
     DebugScopedSetImplThread implThread;
     updateTextures();
 
     EXPECT_EQ(fullUploadFlushMultipler + partialUploadFlushMultipler, m_numTotalFlushes);
     EXPECT_EQ(fullCount + partialCount, m_numTotalUploads);
     EXPECT_EQ(0, m_numDanglingUploads) << "Last upload wasn't followed by a flush.";
 }
 
-class FakeCCTextureUpdateControllerClient : public cc::CCTextureUpdateControllerClient {
+class FakeTextureUpdateControllerClient : public cc::TextureUpdateControllerClient {
 public:
-    FakeCCTextureUpdateControllerClient() { reset(); }
+    FakeTextureUpdateControllerClient() { reset(); }
     void reset() { m_readyToFinalizeCalled = false; }
     bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
     virtual void readyToFinalizeTextureUpdates() OVERRIDE { m_readyToFinalizeCalled = true; }
 
 protected:
     bool m_readyToFinalizeCalled;
 };
 
-class FakeCCTextureUpdateController : public cc::CCTextureUpdateController {
+class FakeTextureUpdateController : public cc::TextureUpdateController {
 public:
-    static scoped_ptr<FakeCCTextureUpdateController> create(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, scoped_ptr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
+    static scoped_ptr<FakeTextureUpdateController> create(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider, TextureUploader* uploader)
     {
-        return make_scoped_ptr(new FakeCCTextureUpdateController(client, thread, queue.Pass(), resourceProvider, uploader));
+        return make_scoped_ptr(new FakeTextureUpdateController(client, thread, queue.Pass(), resourceProvider, uploader));
     }
 
     void setNow(base::TimeTicks time) { m_now = time; }
     virtual base::TimeTicks now() const OVERRIDE { return m_now; }
     void setUpdateMoreTexturesTime(base::TimeDelta time) { m_updateMoreTexturesTime = time; }
     virtual base::TimeDelta updateMoreTexturesTime() const OVERRIDE { return m_updateMoreTexturesTime; }
     void setUpdateMoreTexturesSize(size_t size) { m_updateMoreTexturesSize = size; }
     virtual size_t updateMoreTexturesSize() const OVERRIDE { return m_updateMoreTexturesSize; }
 
 protected:
-    FakeCCTextureUpdateController(cc::CCTextureUpdateControllerClient* client, cc::CCThread* thread, scoped_ptr<CCTextureUpdateQueue> queue, CCResourceProvider* resourceProvider, TextureUploader* uploader)
-        : cc::CCTextureUpdateController(client, thread, queue.Pass(), resourceProvider, uploader)
+    FakeTextureUpdateController(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider, TextureUploader* uploader)
+        : cc::TextureUpdateController(client, thread, queue.Pass(), resourceProvider, uploader)
         , m_updateMoreTexturesSize(0) { }
 
     base::TimeTicks m_now;
     base::TimeDelta m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
-static void runPendingTask(FakeCCThread* thread, FakeCCTextureUpdateController* controller)
+static void runPendingTask(FakeThread* thread, FakeTextureUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setNow(controller->now() + base::TimeDelta::FromMilliseconds(thread->pendingDelayMs()));
     thread->runPendingTask();
 }
 
-TEST_F(CCTextureUpdateControllerTest, UpdateMoreTextures)
+TEST_F(TextureUpdateControllerTest, UpdateMoreTextures)
 {
-    FakeCCTextureUpdateControllerClient client;
-    FakeCCThread thread;
+    FakeTextureUpdateControllerClient client;
+    FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(3);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    scoped_ptr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
+    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Not enough time for any updates.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(90));
     EXPECT_FALSE(thread.hasPendingTask());
@@ skipping 14 matching lines @@
     // Enough time for 2 updates.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(220));
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(3, m_numTotalUploads);
 }
 
-TEST_F(CCTextureUpdateControllerTest, NoMoreUpdates)
+TEST_F(TextureUpdateControllerTest, NoMoreUpdates)
 {
-    FakeCCTextureUpdateControllerClient client;
-    FakeCCThread thread;
+    FakeTextureUpdateControllerClient client;
+    FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    scoped_ptr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
+    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for 3 updates but only 2 necessary.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(310));
     runPendingTask(&thread, controller.get());
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(100));
     controller->setUpdateMoreTexturesSize(1);
     // Enough time for updates but no more updates left.
     controller->performMoreUpdates(
         controller->now() + base::TimeDelta::FromMilliseconds(310));
     // 0-delay task used to call readyToFinalizeTextureUpdates().
     runPendingTask(&thread, controller.get());
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
-TEST_F(CCTextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
+TEST_F(TextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
-    FakeCCTextureUpdateControllerClient client;
-    FakeCCThread thread;
+    FakeTextureUpdateControllerClient client;
+    FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThread implThread;
-    scoped_ptr<FakeCCTextureUpdateController> controller(FakeCCTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
+    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get(), &m_uploader));
 
     controller->setNow(
         controller->now() + base::TimeDelta::FromMilliseconds(1));
     controller->setUpdateMoreTexturesTime(
         base::TimeDelta::FromMilliseconds(500));
     controller->setUpdateMoreTexturesSize(1);
 
     for (int i = 0; i < 100; i++) {
         if (client.readyToFinalizeCalled())
             break;
 
         // Not enough time for any updates.
         controller->performMoreUpdates(
             controller->now() + base::TimeDelta::FromMilliseconds(400));
 
         if (thread.hasPendingTask())
             runPendingTask(&thread, controller.get());
     }
 
     EXPECT_FALSE(thread.hasPendingTask());
     EXPECT_TRUE(client.readyToFinalizeCalled());
     EXPECT_EQ(2, m_numTotalUploads);
 }
 
 } // namespace