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

cc/layers/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/layer.h"
 
 #include <algorithm>
 
+#include "base/location.h"
 #include "base/metrics/histogram.h"
+#include "base/single_thread_task_runner.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_events.h"
 #include "cc/animation/layer_animation_controller.h"
-#include "cc/base/thread.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "third_party/WebKit/public/platform/WebAnimationDelegate.h"
 #include "third_party/WebKit/public/platform/WebLayerScrollClient.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/rect_conversions.h"
 
 namespace cc {
@@ skipping 626 matching lines @@
   position_constraint_ = constraint;
   SetNeedsCommit();
 }
 
 static void RunCopyCallbackOnMainThread(scoped_ptr<CopyOutputRequest> request,
                                         scoped_ptr<SkBitmap> bitmap) {
   if (request->HasBitmapRequest())
     request->SendBitmapResult(bitmap.Pass());
 }
 
-static void PostCopyCallbackToMainThread(Thread* main_thread,
-                                         scoped_ptr<CopyOutputRequest> request,
-                                         scoped_ptr<SkBitmap> bitmap) {
-  main_thread->PostTask(base::Bind(&RunCopyCallbackOnMainThread,
-                                   base::Passed(&request),
-                                   base::Passed(&bitmap)));
+static void PostCopyCallbackToMainThread(
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
+    scoped_ptr<CopyOutputRequest> request,
+    scoped_ptr<SkBitmap> bitmap) {
+  main_thread_task_runner->PostTask(FROM_HERE,
+                                    base::Bind(&RunCopyCallbackOnMainThread,
+                                               base::Passed(&request),
+                                               base::Passed(&bitmap)));
 }
 
 void Layer::PushPropertiesTo(LayerImpl* layer) {
   layer->SetAnchorPoint(anchor_point_);
   layer->SetAnchorPointZ(anchor_point_z_);
   layer->SetBackgroundColor(background_color_);
   layer->SetBounds(paint_properties_.bounds);
   layer->SetContentBounds(content_bounds());
   layer->SetContentsScale(contents_scale_x(), contents_scale_y());
   layer->SetDebugName(debug_name_);
@@ skipping 29 matching lines @@
 
   layer->SetScrollable(scrollable_);
   layer->SetScrollOffset(scroll_offset_);
   layer->SetMaxScrollOffset(max_scroll_offset_);
 
   // Wrap the copy_requests_ in a PostTask to the main thread.
   ScopedPtrVector<CopyOutputRequest> main_thread_copy_requests;
   for (ScopedPtrVector<CopyOutputRequest>::iterator it = copy_requests_.begin();
        it != copy_requests_.end();
        ++it) {
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner =
+        layer_tree_host()->proxy()->MainThreadTaskRunner();
     scoped_ptr<CopyOutputRequest> original_request = copy_requests_.take(it);
     scoped_ptr<CopyOutputRequest> main_thread_request =
         CopyOutputRequest::CreateBitmapRequest(base::Bind(
             &PostCopyCallbackToMainThread,
-            layer_tree_host()->proxy()->MainThread(),
+            main_thread_task_runner,
             base::Passed(&original_request)));
     main_thread_copy_requests.push_back(main_thread_request.Pass());
   }
   copy_requests_.clear();
   layer->PassCopyRequests(&main_thread_copy_requests);
 
   // If the main thread commits multiple times before the impl thread actually
   // draws, then damage tracking will become incorrect if we simply clobber the
   // update_rect here. The LayerImpl's update_rect needs to accumulate (i.e.
   // union) any update changes that have occurred on the main thread.
@@ skipping 150 matching lines @@
 
 RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
   return layer_tree_host_->rendering_stats_instrumentation();
 }
 
 bool Layer::SupportsLCDText() const {
   return false;
 }
 
 }  // namespace cc