cc: Rename TextureUpdate to ResourceUpdate.

cc/resource_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 "cc/texture_update_controller.h"
+#include "cc/resource_update_controller.h"
 
 #include "cc/single_thread_proxy.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 TextureUpdateControllerTest;
+class ResourceUpdateControllerTest;
 
 class WebGraphicsContext3DForUploadTest : public FakeWebGraphicsContext3D {
 public:
-    WebGraphicsContext3DForUploadTest(TextureUpdateControllerTest *test)
+    WebGraphicsContext3DForUploadTest(ResourceUpdateControllerTest *test)
         : m_test(test)
         , m_supportShallowFlush(true)
     { }
 
     virtual void flush(void);
     virtual void shallowFlushCHROMIUM(void);
     virtual void texSubImage2D(WGC3Denum target,
                                WGC3Dint level,
                                WGC3Dint xoffset,
                                WGC3Dint yoffset,
                                WGC3Dsizei width,
                                WGC3Dsizei height,
                                WGC3Denum format,
                                WGC3Denum type,
                                const void* pixels);
     virtual GrGLInterface* onCreateGrGLInterface() { return 0; }
 
     virtual WebString getString(WGC3Denum name)
     {
         if (m_supportShallowFlush)
             return WebString("GL_CHROMIUM_shallow_flush");
         return WebString("");
     }
 
 private:
-    TextureUpdateControllerTest* m_test;
+    ResourceUpdateControllerTest* m_test;
     bool m_supportShallowFlush;
 };
 
 
-class TextureUpdateControllerTest : public Test {
+class ResourceUpdateControllerTest : public Test {
 public:
-    TextureUpdateControllerTest()
-        : m_queue(make_scoped_ptr(new TextureUpdateQueue))
+    ResourceUpdateControllerTest()
+        : m_queue(make_scoped_ptr(new ResourceUpdateQueue))
         , m_textureManager(PrioritizedTextureManager::create(60*1024*1024, 1024, Renderer::ContentPool))
         , 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)
     {
     }
 
-    ~TextureUpdateControllerTest()
+    ~ResourceUpdateControllerTest()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
             implThreadAndMainThreadBlocked;
         m_textureManager->clearAllMemory(m_resourceProvider.get());
     }
 
 public:
     void onFlush()
     {
         // Check for back-to-back flushes.
@@ skipping 73 matching lines @@
 
     void setMaxUploadCountPerUpdate(int count)
     {
         m_maxUploadCountPerUpdate = count;
     }
 
     void updateTextures()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
             implThreadAndMainThreadBlocked;
-        scoped_ptr<TextureUpdateController> updateController =
-            TextureUpdateController::create(
+        scoped_ptr<ResourceUpdateController> updateController =
+            ResourceUpdateController::create(
                 NULL,
                 Proxy::implThread(),
                 m_queue.Pass(),
                 m_resourceProvider.get());
         updateController->finalize();
     }
 
 protected:
-    // Classes required to interact and test the TextureUpdateController
+    // Classes required to interact and test the ResourceUpdateController
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
-    scoped_ptr<TextureUpdateQueue> m_queue;
+    scoped_ptr<ResourceUpdateQueue> m_queue;
     scoped_ptr<PrioritizedTexture> m_textures[4];
     scoped_ptr<WebThread> m_thread;
     WebCompositorInitializer m_compositorInitializer;
     scoped_ptr<PrioritizedTextureManager> m_textureManager;
     SkBitmap m_bitmap;
 
     // Properties / expectations of this test
     int m_fullUploadCountExpected;
     int m_partialCountExpected;
     int m_totalUploadCountExpected;
@@ skipping 23 matching lines @@
                                                       WGC3Dsizei width,
                                                       WGC3Dsizei height,
                                                       WGC3Denum format,
                                                       WGC3Denum type,
                                                       const void* pixels)
 {
     m_test->onUpload();
 }
 
 // ZERO UPLOADS TESTS
-TEST_F(TextureUpdateControllerTest, ZeroUploads)
+TEST_F(ResourceUpdateControllerTest, ZeroUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(0);
     updateTextures();
 
     EXPECT_EQ(0, m_numTotalFlushes);
     EXPECT_EQ(0, m_numTotalUploads);
 }
 
 
 // ONE UPLOAD TESTS
-TEST_F(TextureUpdateControllerTest, OneFullUpload)
+TEST_F(ResourceUpdateControllerTest, OneFullUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(0);
     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(TextureUpdateControllerTest, OnePartialUpload)
+TEST_F(ResourceUpdateControllerTest, OnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(1);
     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(TextureUpdateControllerTest, OneFullOnePartialUpload)
+TEST_F(ResourceUpdateControllerTest, OneFullOnePartialUpload)
 {
     appendFullUploadsToUpdateQueue(1);
     appendPartialUploadsToUpdateQueue(1);
     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(TextureUpdateControllerTest, ManyFullUploads)
+TEST_F(ResourceUpdateControllerTest, ManyFullUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(0);
     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(TextureUpdateControllerTest, ManyPartialUploads)
+TEST_F(ResourceUpdateControllerTest, ManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(0);
     appendPartialUploadsToUpdateQueue(partialCount);
     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(TextureUpdateControllerTest, ManyFullManyPartialUploads)
+TEST_F(ResourceUpdateControllerTest, ManyFullManyPartialUploads)
 {
     appendFullUploadsToUpdateQueue(fullCount);
     appendPartialUploadsToUpdateQueue(partialCount);
     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 FakeTextureUpdateControllerClient : public cc::TextureUpdateControllerClient {
+class FakeResourceUpdateControllerClient : public cc::ResourceUpdateControllerClient {
 public:
-    FakeTextureUpdateControllerClient() { reset(); }
+    FakeResourceUpdateControllerClient() { reset(); }
     void reset() { m_readyToFinalizeCalled = false; }
     bool readyToFinalizeCalled() const { return m_readyToFinalizeCalled; }
 
     virtual void readyToFinalizeTextureUpdates() OVERRIDE { m_readyToFinalizeCalled = true; }
 
 protected:
     bool m_readyToFinalizeCalled;
 };
 
-class FakeTextureUpdateController : public cc::TextureUpdateController {
+class FakeResourceUpdateController : public cc::ResourceUpdateController {
 public:
-    static scoped_ptr<FakeTextureUpdateController> create(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
+    static scoped_ptr<FakeResourceUpdateController> create(cc::ResourceUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
     {
-        return make_scoped_ptr(new FakeTextureUpdateController(client, thread, queue.Pass(), resourceProvider));
+        return make_scoped_ptr(new FakeResourceUpdateController(client, thread, queue.Pass(), resourceProvider));
     }
 
     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:
-    FakeTextureUpdateController(cc::TextureUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<TextureUpdateQueue> queue, ResourceProvider* resourceProvider)
-        : cc::TextureUpdateController(client, thread, queue.Pass(), resourceProvider)
+    FakeResourceUpdateController(cc::ResourceUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
+        : cc::ResourceUpdateController(client, thread, queue.Pass(), resourceProvider)
         , m_updateMoreTexturesSize(0) { }
 
     base::TimeTicks m_now;
     base::TimeDelta m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
-static void runPendingTask(FakeThread* thread, FakeTextureUpdateController* controller)
+static void runPendingTask(FakeThread* thread, FakeResourceUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setNow(controller->now() + base::TimeDelta::FromMilliseconds(thread->pendingDelayMs()));
     thread->runPendingTask();
 }
 
-TEST_F(TextureUpdateControllerTest, UpdateMoreTextures)
+TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(3);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     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(TextureUpdateControllerTest, NoMoreUpdates)
+TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     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(TextureUpdateControllerTest, UpdatesCompleteInFiniteTime)
+TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
-    FakeTextureUpdateControllerClient client;
+    FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
         implThreadAndMainThreadBlocked;
-    scoped_ptr<FakeTextureUpdateController> controller(FakeTextureUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
+    scoped_ptr<FakeResourceUpdateController> controller(FakeResourceUpdateController::create(&client, &thread, m_queue.Pass(), m_resourceProvider.get()));
 
     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