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

cc/layers/texture_layer.cc

 // Copyright 2010 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/layers/texture_layer.h"
 
-#include "cc/base/thread.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/trees/layer_tree_host.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 
 namespace cc {
 
 namespace {
 
 void RunCallback(
     const TextureMailbox::ReleaseCallback& callback,
     unsigned sync_point,
     bool lost_resource) {
   callback.Run(sync_point, lost_resource);
 }
 
 void PostCallbackToThread(
-    Thread* thread,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const TextureMailbox::ReleaseCallback& callback,
     unsigned sync_point,
     bool lost_resource) {
   if (!callback.is_null()) {
-    thread->PostTask(base::Bind(&RunCallback, callback,
-                                sync_point, lost_resource));
+    task_runner->PostTask(FROM_HERE,
+                          base::Bind(&RunCallback, callback,
+                                     sync_point, lost_resource));
   }
 }
 
 }  // namespace
 
 scoped_refptr<TextureLayer> TextureLayer::Create(TextureLayerClient* client) {
   return scoped_refptr<TextureLayer>(new TextureLayer(client, false));
 }
 
 scoped_refptr<TextureLayer> TextureLayer::CreateForMailbox(
@@ skipping 165 matching lines @@
 void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
 
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
   texture_layer->set_flipped(flipped_);
   texture_layer->set_uv_top_left(uv_top_left_);
   texture_layer->set_uv_bottom_right(uv_bottom_right_);
   texture_layer->set_vertex_opacity(vertex_opacity_);
   texture_layer->set_premultiplied_alpha(premultiplied_alpha_);
   if (uses_mailbox_ && own_mailbox_) {
-    Thread* main_thread = layer_tree_host()->proxy()->MainThread();
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
+        layer_tree_host()->proxy()->MainThreadTaskRunner();
     TextureMailbox::ReleaseCallback callback = base::Bind(
-        &PostCallbackToThread, main_thread, texture_mailbox_.callback());
+        &PostCallbackToThread,
+        main_thread_task_runner,
+        texture_mailbox_.callback());
     texture_layer->SetTextureMailbox(
         texture_mailbox_.CopyWithNewCallback(callback));
     own_mailbox_ = false;
   } else {
     texture_layer->set_texture_id(texture_id_);
   }
   content_committed_ = DrawsContent();
 }
 
 bool TextureLayer::BlocksPendingCommit() const {
   // Double-buffered texture layers need to be blocked until they can be made
   // triple-buffered.  Single-buffered layers already prevent draws, so
   // can block too for simplicity.
   return DrawsContent();
 }
 
 bool TextureLayer::CanClipSelf() const {
   return true;
 }
 
 }  // namespace cc