cc: Remove cc::Thread and cc::ThreadImpl.

cc/test/layer_tree_test.cc

 // Copyright 2011 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/test/layer_tree_test.h"
 
 #include "base/command_line.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_registrar.h"
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/timing_function.h"
 #include "cc/base/switches.h"
-#include "cc/base/thread_impl.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_context_provider.h"
 #include "cc/test/fake_layer_tree_host_client.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/occlusion_tracker_test_common.h"
 #include "cc/test/tiled_layer_test_common.h"
@@ skipping 148 matching lines @@
   TestHooks* test_hooks_;
 };
 
 // Adapts LayerTreeHost for test. Injects LayerTreeHostImplForTesting.
 class LayerTreeHostForTesting : public cc::LayerTreeHost {
  public:
   static scoped_ptr<LayerTreeHostForTesting> Create(
       TestHooks* test_hooks,
       cc::LayerTreeHostClient* host_client,
       const cc::LayerTreeSettings& settings,
-      scoped_ptr<cc::Thread> impl_thread) {
+      scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
     scoped_ptr<LayerTreeHostForTesting> layer_tree_host(
         new LayerTreeHostForTesting(test_hooks, host_client, settings));
-    bool success = layer_tree_host->Initialize(impl_thread.Pass());
+    bool success = layer_tree_host->Initialize(impl_task_runner);
     EXPECT_TRUE(success);
     return layer_tree_host.Pass();
   }
 
   virtual scoped_ptr<cc::LayerTreeHostImpl> CreateLayerTreeHostImpl(
       cc::LayerTreeHostImplClient* host_impl_client) OVERRIDE {
     return LayerTreeHostImplForTesting::Create(
         test_hooks_,
         settings(),
         host_impl_client,
@@ skipping 122 matching lines @@
 LayerTreeTest::~LayerTreeTest() {}
 
 void LayerTreeTest::EndTest() {
   // For the case where we EndTest during BeginTest(), set a flag to indicate
   // that the test should end the second BeginTest regains control.
   if (beginning_) {
     end_when_begin_returns_ = true;
   } else if (proxy()) {
     // Racy timeouts and explicit EndTest calls might have cleaned up
     // the tree host. Should check proxy first.
-    proxy()->MainThread()->PostTask(
+    proxy()->MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
   }
 }
 
 void LayerTreeTest::EndTestAfterDelay(int delay_milliseconds) {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::EndTest, main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostAddAnimationToMainThread(
     Layer* layer_to_receive_animation) {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchAddAnimation,
                  main_thread_weak_ptr_,
                  base::Unretained(layer_to_receive_animation)));
 }
 
 void LayerTreeTest::PostAddInstantAnimationToMainThread(
     Layer* layer_to_receive_animation) {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchAddInstantAnimation,
                  main_thread_weak_ptr_,
                  base::Unretained(layer_to_receive_animation)));
 }
 
 void LayerTreeTest::PostSetNeedsCommitToMainThread() {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetNeedsCommit,
                  main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostAcquireLayerTextures() {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchAcquireLayerTextures,
                  main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostSetNeedsRedrawToMainThread() {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetNeedsRedraw,
                  main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::PostSetNeedsRedrawRectToMainThread(gfx::Rect damage_rect) {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetNeedsRedrawRect,
                  main_thread_weak_ptr_, damage_rect));
 }
 
 void LayerTreeTest::PostSetVisibleToMainThread(bool visible) {
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchSetVisible,
                  main_thread_weak_ptr_,
                  visible));
 }
 
 void LayerTreeTest::DoBeginTest() {
   client_ = LayerTreeHostClientForTesting::Create(this);
 
-  scoped_ptr<cc::Thread> impl_ccthread;
-  if (impl_thread_) {
-    impl_ccthread = cc::ThreadImpl::CreateForDifferentThread(
-        impl_thread_->message_loop_proxy());
-  }
-  layer_tree_host_ = LayerTreeHostForTesting::Create(this,
-                                                     client_.get(),
-                                                     settings_,
-                                                     impl_ccthread.Pass());
+  DCHECK(!impl_thread_ || impl_thread_->message_loop_proxy());
+  layer_tree_host_ = LayerTreeHostForTesting::Create(
+      this,
+      client_.get(),
+      settings_,
+      impl_thread_ ? impl_thread_->message_loop_proxy() : NULL);
   ASSERT_TRUE(layer_tree_host_);
 
   started_ = true;
   beginning_ = true;
   SetupTree();
   layer_tree_host_->SetLayerTreeHostClientReady();
   BeginTest();
   beginning_ = false;
   if (end_when_begin_returns_)
     RealEndTest();
@@ skipping 25 matching lines @@
 
 void LayerTreeTest::Timeout() {
   timed_out_ = true;
   EndTest();
 }
 
 void LayerTreeTest::ScheduleComposite() {
   if (!started_ || scheduled_)
     return;
   scheduled_ = true;
-  proxy()->MainThread()->PostTask(
+  proxy()->MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DispatchComposite, main_thread_weak_ptr_));
 }
 
 void LayerTreeTest::RealEndTest() {
   ended_ = true;
 
   if (layer_tree_host_ && proxy()->CommitPendingForTesting()) {
-    proxy()->MainThread()->PostTask(
+    proxy()->MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&LayerTreeTest::RealEndTest, main_thread_weak_ptr_));
     return;
   }
 
   base::MessageLoop::current()->Quit();
 }
 
 void LayerTreeTest::DispatchAddInstantAnimation(
     Layer* layer_to_receive_animation) {
   DCHECK(!proxy() || proxy()->IsMainThread());
@@ skipping 80 matching lines @@
 }
 
 void LayerTreeTest::RunTest(bool threaded,
                             bool delegating_renderer,
                             bool impl_side_painting) {
   if (threaded) {
     impl_thread_.reset(new base::Thread("Compositor"));
     ASSERT_TRUE(impl_thread_->Start());
   }
 
-  main_ccthread_ = cc::ThreadImpl::CreateForCurrentThread();
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_ =
+      base::MessageLoopProxy::current();
 
   delegating_renderer_ = delegating_renderer;
 
   // Spend less time waiting for BeginFrame because the output is
   // mocked out.
   settings_.refresh_rate = 200.0;
   if (impl_side_painting) {
     DCHECK(threaded) <<
         "Don't run single thread + impl side painting, it doesn't exist.";
     settings_.impl_side_painting = true;
   }
   InitializeSettings(&settings_);
 
-  main_ccthread_->PostTask(
+  main_task_runner_->PostTask(
+      FROM_HERE,
       base::Bind(&LayerTreeTest::DoBeginTest, base::Unretained(this)));
 
   if (timeout_seconds_) {
     timeout_.Reset(base::Bind(&LayerTreeTest::Timeout, base::Unretained(this)));
-    main_ccthread_->PostDelayedTask(
+    main_task_runner_->PostDelayedTask(
+        FROM_HERE,
         timeout_.callback(),
         base::TimeDelta::FromSeconds(timeout_seconds_));
   }
 
   base::MessageLoop::current()->Run();
   if (layer_tree_host_ && layer_tree_host_->root_layer())
     layer_tree_host_->root_layer()->SetLayerTreeHost(NULL);
   layer_tree_host_.reset();
 
   timeout_.Cancel();
@@ skipping 30 matching lines @@
 
 scoped_refptr<cc::ContextProvider> LayerTreeTest::
     OffscreenContextProviderForCompositorThread() {
   if (!compositor_thread_contexts_.get() ||
       compositor_thread_contexts_->DestroyedOnMainThread())
     compositor_thread_contexts_ = FakeContextProvider::Create();
   return compositor_thread_contexts_;
 }
 
 }  // namespace cc