cc: Remove FakeThread, use SingleThreadTaskRunner in scheduling classes.

cc/resources/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 "cc/resources/resource_update_controller.h"
 
+#include "base/test/test_simple_task_runner.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_proxy.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "cc/test/tiled_layer_test_common.h"
 #include "cc/trees/single_thread_proxy.h"  // For DebugScopedSetImplThread
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 
@@ skipping 156 matching lines @@
   }
 
   void SetMaxUploadCountPerUpdate(int count) {
     max_upload_count_per_update_ = count;
   }
 
   void UpdateTextures() {
     DebugScopedSetImplThreadAndMainThreadBlocked
     impl_thread_and_main_thread_blocked(&proxy_);
     scoped_ptr<ResourceUpdateController> update_controller =
-        ResourceUpdateController::Create(
-            NULL, proxy_.ImplThread(), queue_.Pass(), resource_provider_.get());
+        ResourceUpdateController::Create(NULL,
+                                         NULL,
+                                         queue_.Pass(),
+                                         resource_provider_.get());
     update_controller->Finalize();
   }
 
   void MakeQueryResultAvailable() { query_results_available_++; }
 
  protected:
   // Classes required to interact and test the ResourceUpdateController
   FakeProxy proxy_;
   scoped_ptr<OutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
@@ skipping 124 matching lines @@
   UpdateTextures();
 
   EXPECT_EQ(full_upload_flush_multipler + partial_upload_flush_multipler,
             num_total_flushes_);
   EXPECT_EQ(full_count + partial_count, num_total_uploads_);
   EXPECT_EQ(0, num_dangling_uploads_)
       << "Last upload wasn't followed by a flush.";
 }
 
 class FakeResourceUpdateControllerClient
-    : public cc::ResourceUpdateControllerClient {
+    : public ResourceUpdateControllerClient {
  public:
   FakeResourceUpdateControllerClient() { Reset(); }
   void Reset() { ready_to_finalize_called_ = false; }
   bool ReadyToFinalizeCalled() const { return ready_to_finalize_called_; }
 
   virtual void ReadyToFinalizeTextureUpdates() OVERRIDE {
     ready_to_finalize_called_ = true;
   }
 
  protected:
   bool ready_to_finalize_called_;
 };
 
-class FakeResourceUpdateController : public cc::ResourceUpdateController {
+class FakeResourceUpdateController : public ResourceUpdateController {
  public:
   static scoped_ptr<FakeResourceUpdateController> Create(
-      cc::ResourceUpdateControllerClient* client, cc::Thread* thread,
+      ResourceUpdateControllerClient* client,
+      base::TestSimpleTaskRunner* task_runner,
       scoped_ptr<ResourceUpdateQueue> queue,
       ResourceProvider* resource_provider) {
     return make_scoped_ptr(new FakeResourceUpdateController(
-        client, thread, queue.Pass(), resource_provider));
+        client, task_runner, queue.Pass(), resource_provider));
   }
 
   void SetNow(base::TimeTicks time) { now_ = time; }
   virtual base::TimeTicks Now() const OVERRIDE { return now_; }
   void SetUpdateMoreTexturesTime(base::TimeDelta time) {
     update_more_textures_time_ = time;
   }
   virtual base::TimeDelta UpdateMoreTexturesTime() const OVERRIDE {
     return update_more_textures_time_;
   }
   void SetUpdateMoreTexturesSize(size_t size) {
     update_more_textures_size_ = size;
   }
   virtual size_t UpdateMoreTexturesSize() const OVERRIDE {
     return update_more_textures_size_;
   }
 
  protected:
-  FakeResourceUpdateController(cc::ResourceUpdateControllerClient* client,
-                               cc::Thread* thread,
+  FakeResourceUpdateController(ResourceUpdateControllerClient* client,
+                               base::TestSimpleTaskRunner* task_runner,
                                scoped_ptr<ResourceUpdateQueue> queue,
                                ResourceProvider* resource_provider)
-      : cc::ResourceUpdateController(
-            client, thread, queue.Pass(), resource_provider),
+      : ResourceUpdateController(
+          client, task_runner, queue.Pass(), resource_provider),
         update_more_textures_size_(0) {}
 
   base::TimeTicks now_;
   base::TimeDelta update_more_textures_time_;
   size_t update_more_textures_size_;
 };
 
-static void RunPendingTask(FakeThread* thread,
+static void RunPendingTask(base::TestSimpleTaskRunner* task_runner,
                            FakeResourceUpdateController* controller) {
-  EXPECT_TRUE(thread->HasPendingTask());
-  controller->SetNow(controller->Now() + base::TimeDelta::FromMilliseconds(
-                                             thread->PendingDelayMs()));
-  thread->RunPendingTask();
+  EXPECT_TRUE(task_runner->HasPendingTask());
+  controller->SetNow(controller->Now() + task_runner->NextPendingTaskDelay());
+  task_runner->RunPendingTasks();
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdateMoreTextures) {
   FakeResourceUpdateControllerClient client;
-  FakeThread thread;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner =
+      new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(3);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
-      FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(),
+      FakeResourceUpdateController::Create(&client,
+                                           task_runner.get(),
+                                           queue_.Pass(),
                                            resource_provider_.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());
+  EXPECT_FALSE(task_runner->HasPendingTask());
 
   controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Only enough time for 1 update.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(120));
-  EXPECT_FALSE(thread.HasPendingTask());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_EQ(1, num_total_uploads_);
 
   // Complete one upload.
   MakeQueryResultAvailable();
 
   controller->SetUpdateMoreTexturesTime(base::TimeDelta::FromMilliseconds(100));
   controller->SetUpdateMoreTexturesSize(1);
   // Enough time for 2 updates.
   controller->PerformMoreUpdates(controller->Now() +
                                  base::TimeDelta::FromMilliseconds(220));
-  RunPendingTask(&thread, controller.get());
-  EXPECT_FALSE(thread.HasPendingTask());
+  RunPendingTask(task_runner.get(), controller.get());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(3, num_total_uploads_);
 }
 
 TEST_F(ResourceUpdateControllerTest, NoMoreUpdates) {
   FakeResourceUpdateControllerClient client;
-  FakeThread thread;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner =
+      new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(2);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
-      FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(),
+      FakeResourceUpdateController::Create(&client,
+                                           task_runner.get(),
+                                           queue_.Pass(),
                                            resource_provider_.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());
-  EXPECT_FALSE(thread.HasPendingTask());
+  RunPendingTask(task_runner.get(), controller.get());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 
   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());
+  RunPendingTask(task_runner.get(), controller.get());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 }
 
 TEST_F(ResourceUpdateControllerTest, UpdatesCompleteInFiniteTime) {
   FakeResourceUpdateControllerClient client;
-  FakeThread thread;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner =
+      new base::TestSimpleTaskRunner;
 
   SetMaxUploadCountPerUpdate(1);
   AppendFullUploadsToUpdateQueue(2);
   AppendPartialUploadsToUpdateQueue(0);
 
   DebugScopedSetImplThreadAndMainThreadBlocked
   impl_thread_and_main_thread_blocked(&proxy_);
   scoped_ptr<FakeResourceUpdateController> controller(
-      FakeResourceUpdateController::Create(&client, &thread, queue_.Pass(),
+      FakeResourceUpdateController::Create(&client,
+                                           task_runner.get(),
+                                           queue_.Pass(),
                                            resource_provider_.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());
+    if (task_runner->HasPendingTask())
+      RunPendingTask(task_runner.get(), controller.get());
   }
 
-  EXPECT_FALSE(thread.HasPendingTask());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_TRUE(client.ReadyToFinalizeCalled());
   EXPECT_EQ(2, num_total_uploads_);
 }
 
 }  // namespace
 }  // namespace cc