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

cc/trees/layer_tree_host_unittest.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/trees/layer_tree_host.h"
 
 #include <algorithm>
 
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 698 matching lines @@
 
     EXPECT_NE(first_frame_time_, impl->CurrentFrameTimeTicks());
     EndTest();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // Ensure there isn't a commit between the two draws, to ensure that a
     // commit isn't required for updating the current frame time. We can
     // only check for this in the multi-threaded case, since in the single-
     // threaded case there will always be a commit between consecutive draws.
-    if (ImplThread())
+    if (HasImplThread())
       EXPECT_EQ(0, frame_);
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int frame_;
   base::TimeTicks first_frame_time_;
 };
 
@@ skipping 887 matching lines @@
                                  identity_matrix,
                                  gfx::PointF(0.f, 0.f),
                                  gfx::PointF(0.f, 0.f),
                                  gfx::Size(10, 20),
                                  true);
 
     PostSetNeedsCommitToMainThread();
   }
 
   void PostEvictTextures() {
-    DCHECK(ImplThread());
-    ImplThread()->PostTask(
+    DCHECK(HasImplThread());
+    ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&LayerTreeHostTestEvictTextures::EvictTexturesOnImplThread,
                    base::Unretained(this)));
   }
 
   void EvictTexturesOnImplThread() {
     DCHECK(impl_for_evict_textures_);
     impl_for_evict_textures_->EnforceManagedMemoryPolicy(
         ManagedMemoryPolicy(0));
   }
 
@@ skipping 232 matching lines @@
         proxy->SetLayerTreeHost(this);
     EXPECT_TRUE(InitializeForTesting(proxy.PassAs<Proxy>()));
   }
 };
 
 TEST(LayerTreeHostTest, LimitPartialUpdates) {
   // When partial updates are not allowed, max updates should be 0.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
-    scoped_ptr<FakeProxy> proxy =
-        make_scoped_ptr(new FakeProxy(scoped_ptr<Thread>()));
+    scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = false;
     proxy->SetMaxPartialTextureUpdates(5);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
     EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(0u, host.settings().max_partial_texture_updates);
   }
 
   // When partial updates are allowed,
   // max updates should be limited by the proxy.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
-    scoped_ptr<FakeProxy> proxy =
-        make_scoped_ptr(new FakeProxy(scoped_ptr<Thread>()));
+    scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
     proxy->SetMaxPartialTextureUpdates(5);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
     EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(5u, host.settings().max_partial_texture_updates);
   }
 
   // When partial updates are allowed,
   // max updates should also be limited by the settings.
   {
     FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
-    scoped_ptr<FakeProxy> proxy =
-        make_scoped_ptr(new FakeProxy(scoped_ptr<Thread>()));
+    scoped_ptr<FakeProxy> proxy(new FakeProxy);
     proxy->GetRendererCapabilities().allow_partial_texture_updates = true;
     proxy->SetMaxPartialTextureUpdates(20);
 
     LayerTreeSettings settings;
     settings.max_partial_texture_updates = 10;
 
     LayerTreeHostWithProxy host(&client, settings, proxy.Pass());
     EXPECT_TRUE(host.InitializeOutputSurfaceIfNeeded());
 
     EXPECT_EQ(10u, host.settings().max_partial_texture_updates);
   }
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithGLRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
 
-  scoped_ptr<LayerTreeHost> host =
-      LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
+  scoped_ptr<LayerTreeHost> host = LayerTreeHost::Create(
+      &client,
+      settings,
+      scoped_refptr<base::SingleThreadTaskRunner>());
   EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithSoftwareRenderer) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DIRECT_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
 
-  scoped_ptr<LayerTreeHost> host =
-      LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
+  scoped_ptr<LayerTreeHost> host = LayerTreeHost::Create(
+      &client,
+      settings,
+      scoped_refptr<base::SingleThreadTaskRunner>());
   EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(4u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest, PartialUpdatesWithDelegatingRendererAndGLContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_3D);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
 
-  scoped_ptr<LayerTreeHost> host =
-      LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
+  scoped_ptr<LayerTreeHost> host = LayerTreeHost::Create(
+      &client,
+      settings,
+      scoped_refptr<base::SingleThreadTaskRunner>());
   EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
 }
 
 TEST(LayerTreeHostTest,
      PartialUpdatesWithDelegatingRendererAndSoftwareContent) {
   FakeLayerTreeHostClient client(FakeLayerTreeHostClient::DELEGATED_SOFTWARE);
 
   LayerTreeSettings settings;
   settings.max_partial_texture_updates = 4;
 
-  scoped_ptr<LayerTreeHost> host =
-      LayerTreeHost::Create(&client, settings, scoped_ptr<Thread>());
+  scoped_ptr<LayerTreeHost> host = LayerTreeHost::Create(
+      &client,
+      settings,
+      scoped_refptr<base::SingleThreadTaskRunner>());
   EXPECT_TRUE(host->InitializeOutputSurfaceIfNeeded());
   EXPECT_EQ(0u, host->settings().max_partial_texture_updates);
 }
 
 class LayerTreeHostTestCapturePicture : public LayerTreeHostTest {
  public:
   LayerTreeHostTestCapturePicture()
       : bounds_(gfx::Size(100, 100)),
         layer_(PictureLayer::Create(&content_client_)) {}
 
@@ skipping 271 matching lines @@
     FakeOutputSurface* fake_output_surface =
         reinterpret_cast<FakeOutputSurface*>(host_impl->output_surface());
 
     // The BeginFrame notification is turned off now but will get
     // enabled once we return, so post a task to trigger it.
     ASSERT_FALSE(fake_output_surface->needs_begin_frame());
     PostBeginFrameOnImplThread(fake_output_surface);
   }
 
   void PostBeginFrameOnImplThread(FakeOutputSurface* fake_output_surface) {
-    DCHECK(ImplThread());
-    ImplThread()->PostTask(
+    DCHECK(HasImplThread());
+    ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&LayerTreeHostTestBeginFrameNotification::BeginFrame,
                    base::Unretained(this),
                    base::Unretained(fake_output_surface)));
   }
 
   void BeginFrame(FakeOutputSurface* fake_output_surface) {
     ASSERT_TRUE(fake_output_surface->needs_begin_frame());
     fake_output_surface->BeginFrame(frame_time_);
   }
 
@@ skipping 19 matching lines @@
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->begin_frame_scheduling_enabled = true;
     settings->using_synchronous_renderer_compositor = true;
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     // The BeginFrame notification is turned off now but will get enabled
     // once we return. End test while it's enabled.
-    ImplThread()->PostTask(base::Bind(
-        &LayerTreeHostTestBeginFrameNotification::EndTest,
-        base::Unretained(this)));
+    ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&LayerTreeHostTestBeginFrameNotification::EndTest,
+                   base::Unretained(this)));
   }
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 MULTI_THREAD_TEST_F(
     LayerTreeHostTestBeginFrameNotificationShutdownWhileEnabled);
 
 class LayerTreeHostTestUninvertibleTransformDoesNotBlockActivation
     : public LayerTreeHostTest {
@@ skipping 547 matching lines @@
         scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice))
         .PassAs<OutputSurface>();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
     ASSERT_TRUE(host_impl->RootLayer());
     FakePictureLayerImpl* layer_impl =
         static_cast<FakePictureLayerImpl*>(host_impl->RootLayer());
     if (!initialized_gl_) {
       EXPECT_EQ(1u, layer_impl->append_quads_count());
-      ImplThread()->PostTask(base::Bind(
+      ImplThreadTaskRunner()->PostTask(FROM_HERE, base::Bind(
           &LayerTreeHostTestDeferredInitialize::DeferredInitializeAndRedraw,
           base::Unretained(this),
           base::Unretained(host_impl)));
     } else {
       EXPECT_EQ(2u, layer_impl->append_quads_count());
       EndTest();
     }
   }
 
   void DeferredInitializeAndRedraw(LayerTreeHostImpl* host_impl) {
@@ skipping 12 matching lines @@
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> layer_;
   bool initialized_gl_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestDeferredInitialize);
 
 }  // namespace
 }  // namespace cc