diff --git a/chromeos/asynchronous_signal_handler.cc b/chromeos/asynchronous_signal_handler.cc
index 5bb430d..4d188c7 100644
--- a/chromeos/asynchronous_signal_handler.cc
+++ b/chromeos/asynchronous_signal_handler.cc
@@ -8,9 +8,11 @@
 #include <sys/types.h>
 #include <unistd.h>
 
+#include <base/bind.h>
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/message_loop/message_loop.h>
+#include <base/posix/eintr_wrapper.h>
 
 namespace {
 const int kInvalidDescriptor = -1;
@@ -19,8 +21,7 @@
 namespace chromeos {
 
 AsynchronousSignalHandler::AsynchronousSignalHandler()
-    : fd_watcher_(new base::MessageLoopForIO::FileDescriptorWatcher),
-      descriptor_(kInvalidDescriptor) {
+    : descriptor_(kInvalidDescriptor) {
   CHECK_EQ(sigemptyset(&signal_mask_), 0) << "Failed to initialize signal mask";
   CHECK_EQ(sigemptyset(&saved_signal_mask_), 0)
       << "Failed to initialize signal mask";
@@ -28,9 +29,9 @@
 
 AsynchronousSignalHandler::~AsynchronousSignalHandler() {
   if (descriptor_ != kInvalidDescriptor) {
-    fd_watcher_->StopWatchingFileDescriptor();
+    MessageLoop::current()->CancelTask(fd_watcher_task_);
 
-    if (close(descriptor_) != 0)
+    if (IGNORE_EINTR(close(descriptor_)) != 0)
       PLOG(WARNING) << "Failed to close file descriptor";
 
     descriptor_ = kInvalidDescriptor;
@@ -44,12 +45,14 @@
   descriptor_ =
       signalfd(descriptor_, &signal_mask_, SFD_CLOEXEC | SFD_NONBLOCK);
   CHECK_NE(kInvalidDescriptor, descriptor_);
-  CHECK(base::MessageLoopForIO::current()->WatchFileDescriptor(
+  fd_watcher_task_ = MessageLoop::current()->WatchFileDescriptor(
+      FROM_HERE,
       descriptor_,
+      MessageLoop::WatchMode::kWatchRead,
       true,
-      base::MessageLoopForIO::WATCH_READ,
-      fd_watcher_.get(),
-      this))
+      base::Bind(&AsynchronousSignalHandler::OnFileCanReadWithoutBlocking,
+                 base::Unretained(this)));
+  CHECK(fd_watcher_task_ != MessageLoop::kTaskIdNull)
       << "Watching shutdown pipe failed.";
 }
 
@@ -68,9 +71,10 @@
   }
 }
 
-void AsynchronousSignalHandler::OnFileCanReadWithoutBlocking(int fd) {
+void AsynchronousSignalHandler::OnFileCanReadWithoutBlocking() {
   struct signalfd_siginfo info;
-  while (base::ReadFromFD(fd, reinterpret_cast<char*>(&info), sizeof(info))) {
+  while (base::ReadFromFD(descriptor_,
+                          reinterpret_cast<char*>(&info), sizeof(info))) {
     int signal = info.ssi_signo;
     Callbacks::iterator callback_it = registered_callbacks_.find(signal);
     if (callback_it == registered_callbacks_.end()) {
@@ -87,10 +91,6 @@
   }
 }
 
-void AsynchronousSignalHandler::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-
 void AsynchronousSignalHandler::ResetSignal(int signal) {
   CHECK_EQ(0, sigdelset(&signal_mask_, signal));
   UpdateSignals();
diff --git a/chromeos/asynchronous_signal_handler.h b/chromeos/asynchronous_signal_handler.h
index 8da4a99..407a7ed 100644
--- a/chromeos/asynchronous_signal_handler.h
+++ b/chromeos/asynchronous_signal_handler.h
@@ -16,16 +16,16 @@
 #include <base/memory/scoped_ptr.h>
 #include <base/message_loop/message_loop.h>
 #include <chromeos/chromeos_export.h>
+#include <chromeos/message_loops/message_loop.h>
 
 namespace chromeos {
 // Sets up signal handlers for registered signals, and converts signal receipt
 // into a write on a pipe. Watches that pipe for data and, when some appears,
 // execute the associated callback.
-class CHROMEOS_EXPORT AsynchronousSignalHandler
-    : public base::MessageLoopForIO::Watcher {
+class CHROMEOS_EXPORT AsynchronousSignalHandler final {
  public:
   AsynchronousSignalHandler();
-  ~AsynchronousSignalHandler() override;
+  ~AsynchronousSignalHandler();
 
   // The callback called when a signal is received.
   typedef base::Callback<bool(const struct signalfd_siginfo&)> SignalHandler;
@@ -47,13 +47,13 @@
   // Unregister a previously registered handler for the given |signal|.
   void UnregisterHandler(int signal);
 
-  // Implementation of base::MessageLoopForIO::Watcher
-  void OnFileCanReadWithoutBlocking(int fd) override;
-  void OnFileCanWriteWithoutBlocking(int fd) override;
+  // Called from the main loop when we can read from |descriptor_|, indicated
+  // that a signal was processed.
+  void OnFileCanReadWithoutBlocking();
 
  private:
   // Controller used to manage watching of signalling pipe.
-  scoped_ptr<base::MessageLoopForIO::FileDescriptorWatcher> fd_watcher_;
+  MessageLoop::TaskId fd_watcher_task_{MessageLoop::kTaskIdNull};
 
   // The registered callbacks.
   typedef std::map<int, SignalHandler> Callbacks;
diff --git a/chromeos/asynchronous_signal_handler_unittest.cc b/chromeos/asynchronous_signal_handler_unittest.cc
index 44895aa..949b02a 100644
--- a/chromeos/asynchronous_signal_handler_unittest.cc
+++ b/chromeos/asynchronous_signal_handler_unittest.cc
@@ -14,6 +14,7 @@
 #include <base/macros.h>
 #include <base/message_loop/message_loop.h>
 #include <base/run_loop.h>
+#include <chromeos/message_loops/base_message_loop.h>
 #include <gtest/gtest.h>
 
 namespace chromeos {
@@ -23,23 +24,22 @@
   AsynchronousSignalHandlerTest() {}
   virtual ~AsynchronousSignalHandlerTest() {}
 
-  virtual void SetUp() { handler_.Init(); }
+  virtual void SetUp() {
+    chromeos_loop_.SetAsCurrent();
+    handler_.Init();
+  }
 
   virtual void TearDown() {}
 
   bool RecordInfoAndQuit(bool response, const struct signalfd_siginfo& info) {
     infos_.push_back(info);
-    loop_.PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
+    chromeos_loop_.PostTask(FROM_HERE, chromeos_loop_.QuitClosure());
     return response;
   }
 
-  void Run() {
-    base::RunLoop run_loop;
-    run_loop.Run();
-  }
-
  protected:
-  base::MessageLoopForIO loop_;
+  base::MessageLoopForIO base_loop_;
+  BaseMessageLoop chromeos_loop_{&base_loop_};
   std::vector<struct signalfd_siginfo> infos_;
   AsynchronousSignalHandler handler_;
 
@@ -57,7 +57,7 @@
   EXPECT_EQ(0, kill(getpid(), SIGTERM));
 
   // Spin the message loop.
-  Run();
+  MessageLoop::current()->Run();
 
   ASSERT_EQ(1, infos_.size());
   EXPECT_EQ(SIGTERM, infos_[0].ssi_signo);
@@ -73,7 +73,7 @@
   EXPECT_EQ(0, kill(getpid(), SIGCHLD));
 
   // Spin the message loop.
-  Run();
+  MessageLoop::current()->Run();
 
   ASSERT_EQ(1, infos_.size());
   EXPECT_EQ(SIGCHLD, infos_[0].ssi_signo);
@@ -81,10 +81,11 @@
   EXPECT_EQ(0, kill(getpid(), SIGCHLD));
 
   // Run the loop with a timeout, as no message are expected.
-  loop_.PostDelayedTask(FROM_HERE,
-                        base::MessageLoop::QuitClosure(),
-                        base::TimeDelta::FromMilliseconds(10));
-  Run();
+  chromeos_loop_.PostDelayedTask(FROM_HERE,
+                                 base::Bind(&MessageLoop::BreakLoop,
+                                            base::Unretained(&chromeos_loop_)),
+                                 base::TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
 
   // The signal handle should have been unregistered. No new message are
   // expected.
@@ -103,7 +104,7 @@
     EXPECT_EQ(0, kill(getpid(), SIGCHLD));
 
     // Spin the message loop.
-    Run();
+    MessageLoop::current()->Run();
   }
 
   ASSERT_EQ(NB_SIGNALS, infos_.size());
@@ -125,7 +126,7 @@
 
   EXPECT_EQ(0, infos_.size());
   // Spin the message loop.
-  Run();
+  MessageLoop::current()->Run();
 
   ASSERT_EQ(1, infos_.size());
   EXPECT_EQ(SIGCHLD, infos_[0].ssi_signo);
diff --git a/chromeos/daemons/daemon.h b/chromeos/daemons/daemon.h
index 639037b..f36ca7b 100644
--- a/chromeos/daemons/daemon.h
+++ b/chromeos/daemons/daemon.h
@@ -96,13 +96,13 @@
   // |at_exit_manager_| must be first to make sure it is initialized before
   // other members, especially the |message_loop_|.
   base::AtExitManager at_exit_manager_;
-  // A helper to dispatch signal handlers asynchronously, so that the main
-  // system signal handler returns as soon as possible.
-  AsynchronousSignalHandler async_signal_handler_;
   // The main message loop for the daemon.
   base::MessageLoopForIO message_loop_;
   // The chromeos wrapper for the main message loop.
   BaseMessageLoop chromeos_message_loop_{&message_loop_};
+  // A helper to dispatch signal handlers asynchronously, so that the main
+  // system signal handler returns as soon as possible.
+  AsynchronousSignalHandler async_signal_handler_;
   // Process exit code specified in QuitWithExitCode() method call.
   int exit_code_;