Revert of [mojo] Replace MessageLoopProxy usage with ThreadTaskRunnerHandle

mojo/common/handle_watcher.cc

 // Copyright 2013 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 "mojo/common/handle_watcher.h"
 
 #include <map>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
-#include "base/single_thread_task_runner.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time/time.h"
 #include "mojo/common/message_pump_mojo.h"
 #include "mojo/common/message_pump_mojo_handler.h"
 #include "mojo/common/time_helper.h"
 
 namespace mojo {
 namespace common {
 
 typedef int WatcherID;
 
 namespace {
 
 const char kWatcherThreadName[] = "handle-watcher-thread";
 
 base::TimeTicks MojoDeadlineToTimeTicks(MojoDeadline deadline) {
   return deadline == MOJO_DEADLINE_INDEFINITE ? base::TimeTicks() :
       internal::NowTicks() + base::TimeDelta::FromMicroseconds(deadline);
 }
 
 // Tracks the data for a single call to Start().
 struct WatchData {
   WatchData()
       : id(0),
         handle_signals(MOJO_HANDLE_SIGNAL_NONE),
-        task_runner(NULL) {}
+        message_loop(NULL) {}
 
   WatcherID id;
   Handle handle;
   MojoHandleSignals handle_signals;
   base::TimeTicks deadline;
   base::Callback<void(MojoResult)> callback;
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner;
+  scoped_refptr<base::MessageLoopProxy> message_loop;
 };
 
 // WatcherBackend --------------------------------------------------------------
 
 // WatcherBackend is responsible for managing the requests and interacting with
 // MessagePumpMojo. All access (outside of creation/destruction) is done on the
 // thread WatcherThreadManager creates.
 class WatcherBackend : public MessagePumpMojoHandler {
  public:
   WatcherBackend();
@@ skipping 53 matching lines @@
 
 void WatcherBackend::RemoveAndNotify(const Handle& handle,
                                      MojoResult result) {
   if (handle_to_data_.count(handle) == 0)
     return;
 
   const WatchData data(handle_to_data_[handle]);
   handle_to_data_.erase(handle);
   MessagePumpMojo::current()->RemoveHandler(handle);
 
-  data.task_runner->PostTask(FROM_HERE, base::Bind(data.callback, result));
+  data.message_loop->PostTask(FROM_HERE, base::Bind(data.callback, result));
 }
 
 bool WatcherBackend::GetMojoHandleByWatcherID(WatcherID watcher_id,
                                               Handle* handle) const {
   for (HandleToWatchDataMap::const_iterator i = handle_to_data_.begin();
        i != handle_to_data_.end(); ++i) {
     if (i->second.id == watcher_id) {
       *handle = i->second.handle;
       return true;
     }
@@ skipping 93 matching lines @@
     MojoHandleSignals handle_signals,
     base::TimeTicks deadline,
     const base::Callback<void(MojoResult)>& callback) {
   RequestData request_data;
   request_data.type = REQUEST_START;
   request_data.start_data.id = watcher_id_generator_.GetNext();
   request_data.start_data.handle = handle;
   request_data.start_data.callback = callback;
   request_data.start_data.handle_signals = handle_signals;
   request_data.start_data.deadline = deadline;
-  request_data.start_data.task_runner = base::ThreadTaskRunnerHandle::Get();
-  DCHECK_NE(static_cast<base::SingleThreadTaskRunner*>(NULL),
-            request_data.start_data.task_runner.get());
+  request_data.start_data.message_loop = base::MessageLoopProxy::current();
+  DCHECK_NE(static_cast<base::MessageLoopProxy*>(NULL),
+            request_data.start_data.message_loop.get());
   AddRequest(request_data);
   return request_data.start_data.id;
 }
 
 void WatcherThreadManager::StopWatching(WatcherID watcher_id) {
   // Handle the case of StartWatching() followed by StopWatching() before
   // |thread_| woke up.
   {
     base::AutoLock auto_lock(lock_);
     for (Requests::iterator i = requests_.begin(); i != requests_.end(); ++i) {
@@ skipping 215 matching lines @@
         this, handle, handle_signals, deadline, callback));
   }
 }
 
 void HandleWatcher::Stop() {
   state_.reset();
 }
 
 }  // namespace common
 }  // namespace mojo