base: Remove most uses of MessageLoopProxy

base/synchronization/waitable_event_watcher_posix.cc

 // Copyright (c) 2012 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 "base/synchronization/waitable_event_watcher.h"
 
 #include "base/bind.h"
 #include "base/location.h"
-#include "base/message_loop/message_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 
 namespace base {
 
 // -----------------------------------------------------------------------------
 // WaitableEventWatcher (async waits).
 //
 // The basic design is that we add an AsyncWaiter to the wait-list of the event.
 // That AsyncWaiter has a pointer to MessageLoop, and a Task to be posted to it.
@@ skipping 41 matching lines @@
   AsyncWaiter(MessageLoop* message_loop,
               const base::Closure& callback,
               Flag* flag)
       : message_loop_(message_loop),
         callback_(callback),
         flag_(flag) { }
 
   bool Fire(WaitableEvent* event) override {
     // Post the callback if we haven't been cancelled.
     if (!flag_->value()) {
-      message_loop_->PostTask(FROM_HERE, callback_);
+      message_loop_->task_runner()->PostTask(FROM_HERE, callback_);
     }
 
     // We are removed from the wait-list by the WaitableEvent itself. It only
     // remains to delete ourselves.
     delete this;
 
     // We can always return true because an AsyncWaiter is never in two
     // different wait-lists at the same time.
     return true;
   }
@@ skipping 69 matching lines @@
   AutoLock locked(kernel->lock_);
 
   event_ = event;
 
   if (kernel->signaled_) {
     if (!kernel->manual_reset_)
       kernel->signaled_ = false;
 
     // No hairpinning - we can't call the delegate directly here. We have to
     // enqueue a task on the MessageLoop as normal.
-    current_ml->PostTask(FROM_HERE, internal_callback_);
+    current_ml->task_runner()->PostTask(FROM_HERE, internal_callback_);
     return true;
   }
 
   message_loop_ = current_ml;
   current_ml->AddDestructionObserver(this);
 
   kernel_ = kernel;
   waiter_ = new AsyncWaiter(current_ml, internal_callback_, cancel_flag_.get());
   event->Enqueue(waiter_);
 
@@ skipping 88 matching lines @@
 // -----------------------------------------------------------------------------
 // This is called when the MessageLoop which the callback will be run it is
 // deleted. We need to cancel the callback as if we had been deleted, but we
 // will still be deleted at some point in the future.
 // -----------------------------------------------------------------------------
 void WaitableEventWatcher::WillDestroyCurrentMessageLoop() {
   StopWatching();
 }
 
 }  // namespace base