cc: Use correct message loop proxy in BlockingTaskRunner

cc/trees/single_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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "cc/debug/benchmark_instrumentation.h"
 #include "cc/output/context_provider.h"
@@ skipping 174 matching lines @@
   layer_tree_host_->WillCommit();
 
   // Commit immediately.
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
 
     // This CapturePostTasks should be destroyed before CommitComplete() is
     // called since that goes out to the embedder, and we want the embedder
     // to receive its callbacks before that.
-    BlockingTaskRunner::CapturePostTasks blocked;
+    BlockingTaskRunner::CapturePostTasks blocked(
+        blocking_main_thread_task_runner());
 
     layer_tree_host_impl_->BeginCommit();
 
     if (PrioritizedResourceManager* contents_texture_manager =
         layer_tree_host_->contents_texture_manager()) {
       contents_texture_manager->PushTexturePrioritiesToBackings();
     }
     layer_tree_host_->BeginCommitOnImplThread(layer_tree_host_impl_.get());
 
     scoped_ptr<ResourceUpdateController> update_controller =
@@ skipping 95 matching lines @@
   return std::numeric_limits<size_t>::max();
 }
 
 void SingleThreadProxy::Stop() {
   TRACE_EVENT0("cc", "SingleThreadProxy::stop");
   DCHECK(Proxy::IsMainThread());
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
     DebugScopedSetImplThread impl(this);
 
-    BlockingTaskRunner::CapturePostTasks blocked;
+    BlockingTaskRunner::CapturePostTasks blocked(
+        blocking_main_thread_task_runner());
     layer_tree_host_->DeleteContentsTexturesOnImplThread(
         layer_tree_host_impl_->resource_provider());
     scheduler_on_impl_thread_.reset();
     layer_tree_host_impl_.reset();
   }
   layer_tree_host_ = NULL;
 }
 
 void SingleThreadProxy::OnCanDrawStateChanged(bool can_draw) {
   TRACE_EVENT1(
@@ skipping 205 matching lines @@
     // This CapturePostTasks should be destroyed before
     // DidCommitAndDrawFrame() is called since that goes out to the
     // embedder,
     // and we want the embedder to receive its callbacks before that.
     // NOTE: This maintains consistent ordering with the ThreadProxy since
     // the DidCommitAndDrawFrame() must be post-tasked from the impl thread
     // there as the main thread is not blocked, so any posted tasks inside
     // the swap buffers will execute first.
     DebugScopedSetMainThreadBlocked main_thread_blocked(this);
 
-    BlockingTaskRunner::CapturePostTasks blocked;
+    BlockingTaskRunner::CapturePostTasks blocked(
+        blocking_main_thread_task_runner());
     layer_tree_host_impl_->SwapBuffers(*frame);
   }
   DidCommitAndDrawFrame();
 
   return DRAW_SUCCESS;
 }
 
 void SingleThreadProxy::DidCommitAndDrawFrame() {
   if (next_frame_is_newly_committed_frame_) {
     DebugScopedSetMainThread main(this);
@@ skipping 138 matching lines @@
 
 base::TimeDelta SingleThreadProxy::CommitToActivateDurationEstimate() {
   return timing_history_.CommitToActivateDurationEstimate();
 }
 
 void SingleThreadProxy::DidBeginImplFrameDeadline() {
   layer_tree_host_impl_->ResetCurrentBeginFrameArgsForNextFrame();
 }
 
 }  // namespace cc