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

cc/trees/thread_proxy.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/thread_proxy.h"
 
 #include <string>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
-#include "cc/base/thread.h"
 #include "cc/input/input_handler.h"
 #include "cc/output/context_provider.h"
 #include "cc/output/output_surface.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/frame_rate_controller.h"
 #include "cc/scheduler/scheduler.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_impl.h"
@@ skipping 24 matching lines @@
 struct ThreadProxy::CommitPendingRequest {
   CompletionEvent completion;
   bool commit_pending;
 };
 
 struct ThreadProxy::SchedulerStateRequest {
   CompletionEvent completion;
   std::string state;
 };
 
-scoped_ptr<Proxy> ThreadProxy::Create(LayerTreeHost* layer_tree_host,
-                                      scoped_ptr<Thread> impl_thread) {
+scoped_ptr<Proxy> ThreadProxy::Create(
+    LayerTreeHost* layer_tree_host,
+    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   return make_scoped_ptr(
-      new ThreadProxy(layer_tree_host, impl_thread.Pass())).PassAs<Proxy>();
+      new ThreadProxy(layer_tree_host, impl_task_runner)).PassAs<Proxy>();
 }
 
-ThreadProxy::ThreadProxy(LayerTreeHost* layer_tree_host,
-                         scoped_ptr<Thread> impl_thread)
-    : Proxy(impl_thread.Pass()),
+ThreadProxy::ThreadProxy(
+    LayerTreeHost* layer_tree_host,
+    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner)
+    : Proxy(impl_task_runner),
       animate_requested_(false),
       commit_requested_(false),
       commit_request_sent_to_impl_thread_(false),
       created_offscreen_context_provider_(false),
       layer_tree_host_(layer_tree_host),
       started_(false),
       textures_acquired_(true),
       in_composite_and_readback_(false),
       manage_tiles_pending_(false),
       weak_factory_on_impl_thread_(this),
@@ skipping 33 matching lines @@
 
   if (!layer_tree_host_->InitializeOutputSurfaceIfNeeded()) {
     TRACE_EVENT0("cc", "CompositeAndReadback_EarlyOut_LR_Uninitialized");
     return false;
   }
 
   // Perform a synchronous commit.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     CompletionEvent begin_frame_sent_to_main_thread_completion;
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::ForceCommitOnImplThread,
                    impl_thread_weak_ptr_,
                    &begin_frame_sent_to_main_thread_completion));
     begin_frame_sent_to_main_thread_completion.Wait();
   }
   in_composite_and_readback_ = true;
   BeginFrameOnMainThread(scoped_ptr<BeginFrameAndCommitState>());
   in_composite_and_readback_ = false;
 
   // Perform a synchronous readback.
   ReadbackRequest request;
   request.rect = rect;
   request.pixels = pixels;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::RequestReadbackOnImplThread,
                    impl_thread_weak_ptr_,
                    &request));
     request.completion.Wait();
   }
   return request.success;
 }
 
 void ThreadProxy::ForceCommitOnImplThread(CompletionEvent* completion) {
   TRACE_EVENT0("cc", "ThreadProxy::ForceCommitOnImplThread");
@@ skipping 23 matching lines @@
   scheduler_on_impl_thread_->SetNeedsForcedRedraw();
 }
 
 void ThreadProxy::FinishAllRendering() {
   DCHECK(Proxy::IsMainThread());
   DCHECK(!defer_commits_);
 
   // Make sure all GL drawing is finished on the impl thread.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::FinishAllRenderingOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion));
   completion.Wait();
 }
 
 bool ThreadProxy::IsStarted() const {
   DCHECK(Proxy::IsMainThread());
   return started_;
 }
 
 void ThreadProxy::SetLayerTreeHostClientReady() {
   TRACE_EVENT0("cc", "ThreadProxy::SetLayerTreeHostClientReady");
-  Proxy::ImplThread()->PostTask(base::Bind(
-      &ThreadProxy::SetLayerTreeHostClientReadyOnImplThread,
-      impl_thread_weak_ptr_));
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetLayerTreeHostClientReadyOnImplThread,
+                 impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::SetLayerTreeHostClientReadyOnImplThread() {
   TRACE_EVENT0("cc", "ThreadProxy::SetLayerTreeHostClientReadyOnImplThread");
   scheduler_on_impl_thread_->SetCanStart();
 }
 
 void ThreadProxy::SetVisible(bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisible");
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThread()->PostTask(base::Bind(&ThreadProxy::SetVisibleOnImplThread,
-                                           impl_thread_weak_ptr_,
-                                           &completion,
-                                           visible));
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetVisibleOnImplThread,
+                 impl_thread_weak_ptr_,
+                 &completion,
+                 visible));
   completion.Wait();
 }
 
 void ThreadProxy::SetVisibleOnImplThread(CompletionEvent* completion,
                                          bool visible) {
   TRACE_EVENT0("cc", "ThreadProxy::SetVisibleOnImplThread");
   layer_tree_host_impl_->SetVisible(visible);
   scheduler_on_impl_thread_->SetVisible(visible);
   completion->Signal();
 }
@@ skipping 25 matching lines @@
   }
 
   success = false;
   {
     // Make a blocking call to InitializeOutputSurfaceOnImplThread. The results
     // of that call are pushed into the success and capabilities local
     // variables.
     CompletionEvent completion;
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::InitializeOutputSurfaceOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    base::Passed(&output_surface),
                    offscreen_context_provider,
                    &success,
                    &capabilities));
     completion.Wait();
   }
 
   OnOutputSurfaceInitializeAttempted(success, capabilities);
 }
 
 void ThreadProxy::OnOutputSurfaceInitializeAttempted(
     bool success,
     const RendererCapabilities& capabilities) {
   DCHECK(IsMainThread());
   DCHECK(layer_tree_host_);
 
   if (success) {
     renderer_capabilities_main_thread_copy_ = capabilities;
   }
 
   LayerTreeHost::CreateResult result =
       layer_tree_host_->OnCreateAndInitializeOutputSurfaceAttempted(success);
   if (result == LayerTreeHost::CreateFailedButTryAgain) {
     if (!output_surface_creation_callback_.callback().is_null()) {
-      Proxy::MainThread()->PostTask(
-          output_surface_creation_callback_.callback());
+      Proxy::MainThreadTaskRunner()->PostTask(
+          FROM_HERE, output_surface_creation_callback_.callback());
     }
   } else {
     output_surface_creation_callback_.Cancel();
   }
 }
 
 const RendererCapabilities& ThreadProxy::GetRendererCapabilities() const {
   DCHECK(IsMainThread());
   DCHECK(!layer_tree_host_->output_surface_lost());
   return renderer_capabilities_main_thread_copy_;
 }
 
 void ThreadProxy::SetNeedsAnimate() {
   DCHECK(IsMainThread());
   if (animate_requested_)
     return;
 
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsAnimate");
   animate_requested_ = true;
 
   if (commit_request_sent_to_impl_thread_)
     return;
   commit_request_sent_to_impl_thread_ = true;
-  Proxy::ImplThread()->PostTask(base::Bind(
-      &ThreadProxy::SetNeedsCommitOnImplThread, impl_thread_weak_ptr_));
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
+                 impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::SetNeedsCommit() {
   DCHECK(IsMainThread());
   if (commit_requested_)
     return;
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommit");
   commit_requested_ = true;
 
   if (commit_request_sent_to_impl_thread_)
     return;
   commit_request_sent_to_impl_thread_ = true;
-  Proxy::ImplThread()->PostTask(base::Bind(
-      &ThreadProxy::SetNeedsCommitOnImplThread, impl_thread_weak_ptr_));
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetNeedsCommitOnImplThread,
+                 impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidLoseOutputSurfaceOnImplThread");
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::CheckOutputSurfaceStatusOnImplThread,
                  impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::CheckOutputSurfaceStatusOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::CheckOutputSurfaceStatusOnImplThread");
   if (!layer_tree_host_impl_->IsContextLost())
     return;
   cc::ContextProvider* offscreen_contexts =
     layer_tree_host_impl_->resource_provider() ?
         layer_tree_host_impl_->resource_provider()->
             offscreen_context_provider() : NULL;
 
   if (offscreen_contexts)
     offscreen_contexts->VerifyContexts();
   scheduler_on_impl_thread_->DidLoseOutputSurface();
 }
 
 void ThreadProxy::OnSwapBuffersCompleteOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::OnSwapBuffersCompleteOnImplThread");
-  Proxy::MainThread()->PostTask(
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::DidCompleteSwapBuffers, main_thread_weak_ptr_));
 }
 
 void ThreadProxy::SetNeedsBeginFrameOnImplThread(bool enable) {
   DCHECK(IsImplThread());
   TRACE_EVENT1("cc", "ThreadProxy::SetNeedsBeginFrameOnImplThread",
                "enable", enable);
   layer_tree_host_impl_->SetNeedsBeginFrame(enable);
 }
 
@@ skipping 24 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsCommitOnImplThread");
   scheduler_on_impl_thread_->SetNeedsCommit();
 }
 
 void ThreadProxy::PostAnimationEventsToMainThreadOnImplThread(
     scoped_ptr<AnimationEventsVector> events,
     base::Time wall_clock_time) {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc",
                "ThreadProxy::PostAnimationEventsToMainThreadOnImplThread");
-  Proxy::MainThread()->PostTask(base::Bind(&ThreadProxy::SetAnimationEvents,
-                                           main_thread_weak_ptr_,
-                                           base::Passed(&events),
-                                           wall_clock_time));
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetAnimationEvents,
+                 main_thread_weak_ptr_,
+                 base::Passed(&events),
+                 wall_clock_time));
 }
 
 bool ThreadProxy::ReduceContentsTextureMemoryOnImplThread(size_t limit_bytes,
                                                           int priority_cutoff) {
   DCHECK(IsImplThread());
 
   if (!layer_tree_host_->contents_texture_manager())
     return false;
   if (!layer_tree_host_impl_->resource_provider())
     return false;
@@ skipping 44 matching lines @@
       layer_tree_host_->contents_texture_manager()->
           MemoryVisibleAndNearbyBytes(),
       layer_tree_host_->contents_texture_manager()->MemoryUseBytes());
 }
 
 bool ThreadProxy::IsInsideDraw() { return inside_draw_; }
 
 void ThreadProxy::SetNeedsRedraw(gfx::Rect damage_rect) {
   DCHECK(IsMainThread());
   TRACE_EVENT0("cc", "ThreadProxy::SetNeedsRedraw");
-  Proxy::ImplThread()->PostTask(base::Bind(
-      &ThreadProxy::SetNeedsRedrawRectOnImplThread,
-      impl_thread_weak_ptr_, damage_rect));
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadProxy::SetNeedsRedrawRectOnImplThread,
+                 impl_thread_weak_ptr_,
+                 damage_rect));
 }
 
 void ThreadProxy::SetDeferCommits(bool defer_commits) {
   DCHECK(IsMainThread());
   DCHECK_NE(defer_commits_, defer_commits);
   defer_commits_ = defer_commits;
 
   if (defer_commits_)
     TRACE_EVENT_ASYNC_BEGIN0("cc", "ThreadProxy::SetDeferCommits", this);
   else
     TRACE_EVENT_ASYNC_END0("cc", "ThreadProxy::SetDeferCommits", this);
 
   if (!defer_commits_ && pending_deferred_commit_)
-    Proxy::MainThread()->PostTask(
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                    main_thread_weak_ptr_,
                    base::Passed(&pending_deferred_commit_)));
 }
 
 bool ThreadProxy::CommitRequested() const {
   DCHECK(IsMainThread());
   return commit_requested_;
 }
 
@@ skipping 16 matching lines @@
 }
 
 void ThreadProxy::DidInitializeVisibleTileOnImplThread() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidInitializeVisibleTileOnImplThread");
   scheduler_on_impl_thread_->SetNeedsRedraw();
 }
 
 void ThreadProxy::MainThreadHasStoppedFlinging() {
   DCHECK(IsMainThread());
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::MainThreadHasStoppedFlingingOnImplThread,
                  impl_thread_weak_ptr_));
 }
 
 void ThreadProxy::MainThreadHasStoppedFlingingOnImplThread() {
   DCHECK(IsImplThread());
   layer_tree_host_impl_->MainThreadHasStoppedFlinging();
 }
 
 void ThreadProxy::Start(scoped_ptr<OutputSurface> first_output_surface) {
   DCHECK(IsMainThread());
-  DCHECK(Proxy::ImplThread());
+  DCHECK(Proxy::HasImplThread());
   DCHECK(first_output_surface);
   // Create LayerTreeHostImpl.
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::InitializeImplOnImplThread,
                  base::Unretained(this),
                  &completion));
   completion.Wait();
 
   main_thread_weak_ptr_ = weak_factory_.GetWeakPtr();
   first_output_surface_ = first_output_surface.Pass();
 
   started_ = true;
 }
 
 void ThreadProxy::Stop() {
   TRACE_EVENT0("cc", "ThreadProxy::Stop");
   DCHECK(IsMainThread());
   DCHECK(started_);
 
   // Synchronously finishes pending GL operations and deletes the impl.
   // The two steps are done as separate post tasks, so that tasks posted
   // by the GL implementation due to the Finish can be executed by the
   // renderer before shutting it down.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     CompletionEvent completion;
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::FinishGLOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion));
     completion.Wait();
   }
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     CompletionEvent completion;
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::LayerTreeHostClosedOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion));
     completion.Wait();
   }
 
   weak_factory_.InvalidateWeakPtrs();
 
   DCHECK(!layer_tree_host_impl_.get());  // verify that the impl deleted.
   layer_tree_host_ = NULL;
   started_ = false;
 }
 
 void ThreadProxy::ForceSerializeOnSwapBuffers() {
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::ForceSerializeOnSwapBuffersOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion));
   completion.Wait();
 }
 
 void ThreadProxy::ForceSerializeOnSwapBuffersOnImplThread(
     CompletionEvent* completion) {
   if (layer_tree_host_impl_->renderer())
     layer_tree_host_impl_->renderer()->DoNoOp();
@@ skipping 11 matching lines @@
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionSendBeginFrameToMainThread");
   scoped_ptr<BeginFrameAndCommitState> begin_frame_state(
       new BeginFrameAndCommitState);
   begin_frame_state->monotonic_frame_begin_time =
       layer_tree_host_impl_->CurrentPhysicalTimeTicks();
   begin_frame_state->scroll_info =
       layer_tree_host_impl_->ProcessScrollDeltas();
   DCHECK_GT(layer_tree_host_impl_->memory_allocation_limit_bytes(), 0u);
   begin_frame_state->memory_allocation_limit_bytes =
       layer_tree_host_impl_->memory_allocation_limit_bytes();
-  Proxy::MainThread()->PostTask(
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::BeginFrameOnMainThread,
                  main_thread_weak_ptr_,
                  base::Passed(&begin_frame_state)));
 
   if (begin_frame_sent_to_main_thread_completion_event_on_impl_thread_) {
     begin_frame_sent_to_main_thread_completion_event_on_impl_thread_->Signal();
     begin_frame_sent_to_main_thread_completion_event_on_impl_thread_ = NULL;
   }
 }
 
@@ skipping 25 matching lines @@
   animate_requested_ = false;
 
   if (begin_frame_state)
     layer_tree_host_->ApplyScrollAndScale(*begin_frame_state->scroll_info);
 
   if (!in_composite_and_readback_ && !layer_tree_host_->visible()) {
     commit_requested_ = false;
     commit_request_sent_to_impl_thread_ = false;
 
     TRACE_EVENT0("cc", "EarlyOut_NotVisible");
-    Proxy::ImplThread()->PostTask(base::Bind(
-        &ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
-        impl_thread_weak_ptr_));
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::BeginFrameAbortedByMainThreadOnImplThread,
+                   impl_thread_weak_ptr_));
     return;
   }
 
   layer_tree_host_->WillBeginFrame();
 
   if (begin_frame_state) {
     layer_tree_host_->UpdateClientAnimations(
         begin_frame_state->monotonic_frame_begin_time);
     layer_tree_host_->AnimateLayers(
         begin_frame_state->monotonic_frame_begin_time);
@@ skipping 53 matching lines @@
   {
     TRACE_EVENT0("cc", "ThreadProxy::BeginFrameOnMainThread::commit");
 
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
     RenderingStatsInstrumentation* stats_instrumentation =
         layer_tree_host_->rendering_stats_instrumentation();
     base::TimeTicks start_time = stats_instrumentation->StartRecording();
 
     CompletionEvent completion;
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::StartCommitOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    queue.release(),
                    offscreen_context_provider));
     completion.Wait();
 
     base::TimeDelta duration = stats_instrumentation->EndRecording(start_time);
     stats_instrumentation->AddCommit(duration);
   }
@@ skipping 40 matching lines @@
 
     layer_tree_host_->contents_texture_manager()->
         PushTexturePrioritiesToBackings();
   }
 
   commit_completion_event_on_impl_thread_ = completion;
   if (layer_tree_host_impl_->resource_provider()) {
     current_resource_update_controller_on_impl_thread_ =
         ResourceUpdateController::Create(
             this,
-            Proxy::ImplThread()->TaskRunner(),
+            Proxy::ImplThreadTaskRunner(),
             queue.Pass(),
             layer_tree_host_impl_->resource_provider());
     current_resource_update_controller_on_impl_thread_->PerformMoreUpdates(
         scheduler_on_impl_thread_->AnticipatedDrawTime());
   } else {
     // Normally the ResourceUpdateController notifies when commit should
     // finish, but in tile-free software rendering there is no resource
     // update step so jump straight to the notification.
     scheduler_on_impl_thread_->FinishCommit();
   }
@@ skipping 55 matching lines @@
 }
 
 void ThreadProxy::ScheduledActionActivatePendingTreeIfNeeded() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionActivatePendingTreeIfNeeded");
   layer_tree_host_impl_->ActivatePendingTreeIfNeeded();
 }
 
 void ThreadProxy::ScheduledActionBeginOutputSurfaceCreation() {
   DCHECK(IsImplThread());
-  Proxy::MainThread()->PostTask(
+  Proxy::MainThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::CreateAndInitializeOutputSurface,
                  main_thread_weak_ptr_));
 }
 
 ScheduledActionDrawAndSwapResult
 ThreadProxy::ScheduledActionDrawAndSwapInternal(bool forced_draw) {
   TRACE_EVENT0("cc", "ThreadProxy::ScheduledActionDrawAndSwap");
 
   ScheduledActionDrawAndSwapResult result;
   result.did_draw = false;
@@ skipping 82 matching lines @@
   } else if (draw_frame) {
     result.did_swap = layer_tree_host_impl_->SwapBuffers(frame);
 
     if (frame.contains_incomplete_tile)
       DidSwapUseIncompleteTileOnImplThread();
   }
 
   // Tell the main thread that the the newly-commited frame was drawn.
   if (next_frame_is_newly_committed_frame_on_impl_thread_) {
     next_frame_is_newly_committed_frame_on_impl_thread_ = false;
-    Proxy::MainThread()->PostTask(
+    Proxy::MainThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::DidCommitAndDrawFrame, main_thread_weak_ptr_));
   }
 
   if (draw_frame) {
     CheckOutputSurfaceStatusOnImplThread();
 
     base::TimeDelta draw_duration = base::TimeTicks::HighResNow() - start_time;
     draw_duration_history_.InsertSample(draw_duration);
     base::TimeDelta draw_duration_overestimate;
     base::TimeDelta draw_duration_underestimate;
@@ skipping 34 matching lines @@
   // previously committed frame that is still undrawn. This is necessary to
   // ensure that the main thread does not monopolize access to the textures.
   DCHECK(IsMainThread());
 
   if (textures_acquired_)
     return;
 
   TRACE_EVENT0("cc", "ThreadProxy::AcquireLayerTextures");
   DebugScopedSetMainThreadBlocked main_thread_blocked(this);
   CompletionEvent completion;
-  Proxy::ImplThread()->PostTask(
+  Proxy::ImplThreadTaskRunner()->PostTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread,
                  impl_thread_weak_ptr_,
                  &completion));
   // Block until it is safe to write to layer textures from the main thread.
   completion.Wait();
 
   textures_acquired_ = true;
 }
 
 void ThreadProxy::AcquireLayerTexturesForMainThreadOnImplThread(
@@ skipping 66 matching lines @@
 
 void ThreadProxy::CreateAndInitializeOutputSurface() {
   TRACE_EVENT0("cc", "ThreadProxy::CreateAndInitializeOutputSurface");
   DCHECK(IsMainThread());
 
   // Check that output surface has not been recreated by CompositeAndReadback
   // after this task is posted but before it is run.
   bool has_initialized_output_surface_on_impl_thread = true;
   {
     CompletionEvent completion;
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::HasInitializedOutputSurfaceOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    &has_initialized_output_surface_on_impl_thread));
     completion.Wait();
   }
   if (has_initialized_output_surface_on_impl_thread)
     return;
 
   layer_tree_host_->DidLoseOutputSurface();
@@ skipping 105 matching lines @@
 
 ThreadProxy::BeginFrameAndCommitState::~BeginFrameAndCommitState() {}
 
 scoped_ptr<base::Value> ThreadProxy::AsValue() const {
   scoped_ptr<base::DictionaryValue> state(new base::DictionaryValue());
 
   CompletionEvent completion;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(
         const_cast<ThreadProxy*>(this));
-    Proxy::ImplThread()->PostTask(base::Bind(&ThreadProxy::AsValueOnImplThread,
-                                             impl_thread_weak_ptr_,
-                                             &completion,
-                                             state.get()));
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ThreadProxy::AsValueOnImplThread,
+                   impl_thread_weak_ptr_,
+                   &completion,
+                   state.get()));
     completion.Wait();
   }
   return state.PassAs<base::Value>();
 }
 
 void ThreadProxy::AsValueOnImplThread(CompletionEvent* completion,
                                       base::DictionaryValue* state) const {
   state->Set("layer_tree_host_impl",
              layer_tree_host_impl_->AsValue().release());
   completion->Signal();
 }
 
 bool ThreadProxy::CommitPendingForTesting() {
   DCHECK(IsMainThread());
   CommitPendingRequest commit_pending_request;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::CommitPendingOnImplThreadForTesting,
                    impl_thread_weak_ptr_,
                    &commit_pending_request));
     commit_pending_request.completion.Wait();
   }
   return commit_pending_request.commit_pending;
 }
 
 void ThreadProxy::CommitPendingOnImplThreadForTesting(
     CommitPendingRequest* request) {
   DCHECK(IsImplThread());
   if (layer_tree_host_impl_->output_surface())
     request->commit_pending = scheduler_on_impl_thread_->CommitPending();
   else
     request->commit_pending = false;
   request->completion.Signal();
 }
 
 std::string ThreadProxy::SchedulerStateAsStringForTesting() {
   if (IsImplThread())
     return scheduler_on_impl_thread_->StateAsStringForTesting();
 
   SchedulerStateRequest scheduler_state_request;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::SchedulerStateAsStringOnImplThreadForTesting,
                    impl_thread_weak_ptr_,
                    &scheduler_state_request));
     scheduler_state_request.completion.Wait();
   }
   return scheduler_state_request.state;
 }
 
 void ThreadProxy::SchedulerStateAsStringOnImplThreadForTesting(
     SchedulerStateRequest* request) {
   DCHECK(IsImplThread());
   request->state = scheduler_on_impl_thread_->StateAsStringForTesting();
   request->completion.Signal();
 }
 
 skia::RefPtr<SkPicture> ThreadProxy::CapturePicture() {
   DCHECK(IsMainThread());
   CompletionEvent completion;
   skia::RefPtr<SkPicture> picture;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
-    Proxy::ImplThread()->PostTask(
+    Proxy::ImplThreadTaskRunner()->PostTask(
+        FROM_HERE,
         base::Bind(&ThreadProxy::CapturePictureOnImplThread,
                    impl_thread_weak_ptr_,
                    &completion,
                    &picture));
     completion.Wait();
   }
   return picture;
 }
 
 void ThreadProxy::CapturePictureOnImplThread(CompletionEvent* completion,
@@ skipping 43 matching lines @@
 
   base::TimeDelta delay = smoothness_takes_priority_expiration_time_ - now;
 
   // Need to make sure a delayed task is posted when we have smoothness
   // takes priority expiration time in the future.
   if (delay <= base::TimeDelta())
     return;
   if (renew_tree_priority_on_impl_thread_pending_)
     return;
 
-  Proxy::ImplThread()->PostDelayedTask(
+  Proxy::ImplThreadTaskRunner()->PostDelayedTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::RenewTreePriorityOnImplThread,
                  weak_factory_on_impl_thread_.GetWeakPtr()),
       delay);
 
   renew_tree_priority_on_impl_thread_pending_ = true;
 }
 
 void ThreadProxy::RenewTreePriorityOnImplThread() {
   DCHECK(renew_tree_priority_on_impl_thread_pending_);
   renew_tree_priority_on_impl_thread_pending_ = false;
 
   RenewTreePriority();
 }
 
 void ThreadProxy::RequestScrollbarAnimationOnImplThread(base::TimeDelta delay) {
-  Proxy::ImplThread()->PostDelayedTask(
+  Proxy::ImplThreadTaskRunner()->PostDelayedTask(
+      FROM_HERE,
       base::Bind(&ThreadProxy::StartScrollbarAnimationOnImplThread,
                  impl_thread_weak_ptr_),
       delay);
 }
 
 void ThreadProxy::StartScrollbarAnimationOnImplThread() {
   layer_tree_host_impl_->StartScrollbarAnimation();
 }
 
 void ThreadProxy::DidActivatePendingTree() {
   DCHECK(IsImplThread());
   TRACE_EVENT0("cc", "ThreadProxy::DidActivatePendingTreeOnImplThread");
 
   if (completion_event_for_commit_held_on_tree_activation_ &&
       !layer_tree_host_impl_->pending_tree()) {
     TRACE_EVENT_INSTANT0("cc", "ReleaseCommitbyActivation",
                          TRACE_EVENT_SCOPE_THREAD);
     DCHECK(layer_tree_host_impl_->settings().impl_side_painting);
     completion_event_for_commit_held_on_tree_activation_->Signal();
     completion_event_for_commit_held_on_tree_activation_ = NULL;
   }
 }
 
 }  // namespace cc