Remove static thread pointers from CC

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/resource_update_controller.h"
 
 #include "cc/single_thread_proxy.h" // For DebugScopedSetImplThread
+#include "cc/test/fake_proxy.h"
 #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 "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
 using namespace cc;
 using namespace WebKit;
 using namespace WebKitTests;
@@ skipping 37 matching lines @@
 
 private:
     ResourceUpdateControllerTest* m_test;
     bool m_supportShallowFlush;
 };
 
 
 class ResourceUpdateControllerTest : public Test {
 public:
     ResourceUpdateControllerTest()
-        : m_queue(make_scoped_ptr(new ResourceUpdateQueue))
-        , m_resourceManager(PrioritizedResourceManager::create(60*1024*1024, 1024, Renderer::ContentPool))
+        : m_proxy(scoped_ptr<Thread>(NULL))
+        , m_queue(make_scoped_ptr(new ResourceUpdateQueue))
+        , m_resourceManager(PrioritizedResourceManager::create(60*1024*1024, 1024, Renderer::ContentPool, &m_proxy))
         , m_fullUploadCountExpected(0)
         , m_partialCountExpected(0)
         , m_totalUploadCountExpected(0)
         , m_maxUploadCountPerUpdate(0)
         , m_numConsecutiveFlushes(0)
         , m_numDanglingUploads(0)
         , m_numTotalUploads(0)
         , m_numTotalFlushes(0)
         , m_queryResultsAvailable(0)
     {
     }
 
     ~ResourceUpdateControllerTest()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
-            implThreadAndMainThreadBlocked;
+            implThreadAndMainThreadBlocked(&m_proxy);
         m_resourceManager->clearAllMemory(m_resourceProvider.get());
     }
 
 public:
     void onFlush()
     {
         // Check for back-to-back flushes.
         EXPECT_EQ(0, m_numConsecutiveFlushes) << "Back-to-back flushes detected.";
 
         m_numDanglingUploads = 0;
@@ skipping 31 matching lines @@
         m_bitmap.allocPixels();
 
         for (int i = 0; i < 4; i++) {
             m_textures[i] = PrioritizedResource::create(
                 m_resourceManager.get(), gfx::Size(300, 150), GL_RGBA);
             m_textures[i]->setRequestPriority(
                 PriorityCalculator::visiblePriority(true));
         }
         m_resourceManager->prioritizeTextures();
 
-        DebugScopedSetImplThread implThread;
         m_resourceProvider = ResourceProvider::create(m_context.get());
     }
 
 
     void appendFullUploadsOfIndexedTextureToUpdateQueue(int count, int textureIndex)
     {
         m_fullUploadCountExpected += count;
         m_totalUploadCountExpected += count;
 
         const gfx::Rect rect(0, 0, 300, 150);
@@ skipping 26 matching lines @@
     }
 
     void setMaxUploadCountPerUpdate(int count)
     {
         m_maxUploadCountPerUpdate = count;
     }
 
     void updateTextures()
     {
         DebugScopedSetImplThreadAndMainThreadBlocked
-            implThreadAndMainThreadBlocked;
+            implThreadAndMainThreadBlocked(&m_proxy);
         scoped_ptr<ResourceUpdateController> updateController =
             ResourceUpdateController::create(
                 NULL,
-                Proxy::implThread(),
+                m_proxy.implThread(),
                 m_queue.Pass(),
-                m_resourceProvider.get());
+                m_resourceProvider.get(),
+                m_proxy.hasImplThread());
         updateController->finalize();
     }
 
     void makeQueryResultAvailable()
     {
         m_queryResultsAvailable++;
     }
 
 protected:
     // Classes required to interact and test the ResourceUpdateController
+    FakeProxy m_proxy;
     scoped_ptr<GraphicsContext> m_context;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<ResourceUpdateQueue> m_queue;
     scoped_ptr<PrioritizedResource> m_textures[4];
     scoped_ptr<PrioritizedResourceManager> m_resourceManager;
     SkBitmap m_bitmap;
     int m_queryResultsAvailable;
 
     // Properties / expectations of this test
     int m_fullUploadCountExpected;
@@ skipping 147 matching lines @@
 
     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:
     FakeResourceUpdateController(cc::ResourceUpdateControllerClient* client, cc::Thread* thread, scoped_ptr<ResourceUpdateQueue> queue, ResourceProvider* resourceProvider)
-        : cc::ResourceUpdateController(client, thread, queue.Pass(), resourceProvider)
+        : cc::ResourceUpdateController(client, thread, queue.Pass(), resourceProvider, false)
         , m_updateMoreTexturesSize(0) { }
 
     base::TimeTicks m_now;
     base::TimeDelta m_updateMoreTexturesTime;
     size_t m_updateMoreTexturesSize;
 };
 
 static void runPendingTask(FakeThread* thread, FakeResourceUpdateController* controller)
 {
     EXPECT_TRUE(thread->hasPendingTask());
     controller->setNow(controller->now() + base::TimeDelta::FromMilliseconds(thread->pendingDelayMs()));
     thread->runPendingTask();
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures)
 {
     FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(3);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
-        implThreadAndMainThreadBlocked;
+        implThreadAndMainThreadBlocked(&m_proxy);
     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));
@@ skipping 26 matching lines @@
 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates)
 {
     FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
-        implThreadAndMainThreadBlocked;
+        implThreadAndMainThreadBlocked(&m_proxy);
     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));
@@ skipping 18 matching lines @@
 TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime)
 {
     FakeResourceUpdateControllerClient client;
     FakeThread thread;
 
     setMaxUploadCountPerUpdate(1);
     appendFullUploadsToUpdateQueue(2);
     appendPartialUploadsToUpdateQueue(0);
 
     DebugScopedSetImplThreadAndMainThreadBlocked
-        implThreadAndMainThreadBlocked;
+        implThreadAndMainThreadBlocked(&m_proxy);
     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);
 }
 
 }  // anonymous namespace