cc: Remove FakeThread, use SingleThreadTaskRunner in scheduling classes.

cc/output/output_surface_unittest.cc

 // Copyright 2013 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 "base/test/test_simple_task_runner.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "cc/test/scheduler_test_common.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
@@ skipping 186 matching lines @@
   TestOutputSurface output_surface(
       context3d.PassAs<WebKit::WebGraphicsContext3D>());
   EXPECT_FALSE(output_surface.HasClientForTesting());
 
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   EXPECT_TRUE(output_surface.HasClientForTesting());
   EXPECT_FALSE(client.deferred_initialize_called());
 
   // Initialize BeginFrame emulation
-  FakeThread impl_thread;
+  scoped_refptr<base::TestSimpleTaskRunner> task_runner =
+      new base::TestSimpleTaskRunner;
   bool throttle_frame_production = true;
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(16666);
 
   output_surface.InitializeBeginFrameEmulation(
-      &impl_thread,
+      task_runner.get(),
       throttle_frame_production,
       display_refresh_interval);
 
   output_surface.SetMaxFramesPending(2);
 
   // We should start off with 0 BeginFrames
   EXPECT_EQ(client.begin_frame_count(), 0);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // We should not have a pending task until a BeginFrame has been requested.
-  EXPECT_FALSE(impl_thread.HasPendingTask());
+  EXPECT_FALSE(task_runner->HasPendingTask());
   output_surface.SetNeedsBeginFrame(true);
-  EXPECT_TRUE(impl_thread.HasPendingTask());
+  EXPECT_TRUE(task_runner->HasPendingTask());
 
   // BeginFrame should be called on the first tick.
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 1);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // BeginFrame should not be called when there is a pending BeginFrame.
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 1);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 0);
 
   // DidSwapBuffers should clear the pending BeginFrame.
   output_surface.DidSwapBuffersForTesting();
   EXPECT_EQ(client.begin_frame_count(), 1);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 2);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // BeginFrame should be throttled by pending swap buffers.
   output_surface.DidSwapBuffersForTesting();
   EXPECT_EQ(client.begin_frame_count(), 2);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 2);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
 
   // SwapAck should decrement pending swap buffers and unblock BeginFrame again.
   output_surface.OnSwapBuffersCompleteForTesting();
   EXPECT_EQ(client.begin_frame_count(), 2);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 3);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Calling SetNeedsBeginFrame again indicates a swap did not occur but
   // the client still wants another BeginFrame.
   output_surface.SetNeedsBeginFrame(true);
-  impl_thread.RunPendingTask();
+  task_runner->RunPendingTasks();
   EXPECT_EQ(client.begin_frame_count(), 4);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Disabling SetNeedsBeginFrame should prevent further BeginFrames.
   output_surface.SetNeedsBeginFrame(false);
-  impl_thread.RunPendingTask();
-  EXPECT_FALSE(impl_thread.HasPendingTask());
+  task_runner->RunPendingTasks();
+  EXPECT_FALSE(task_runner->HasPendingTask());
   EXPECT_EQ(client.begin_frame_count(), 4);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should be
   // allowed.
   output_surface.BeginFrameForTesting(base::TimeTicks::Now());
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
   // still be throttled by pending begin frames however.
   output_surface.BeginFrameForTesting(base::TimeTicks::Now());
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 1);
 
   // Optimistically injected BeginFrames without a SetNeedsBeginFrame should
   // also be throttled by pending swap buffers.
   output_surface.DidSwapBuffersForTesting();
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
   output_surface.BeginFrameForTesting(base::TimeTicks::Now());
   EXPECT_EQ(client.begin_frame_count(), 5);
   EXPECT_EQ(output_surface.pending_swap_buffers(), 2);
 }
 
 }  // namespace
 }  // namespace cc