dbus: Use base::MessageLoop.

dbus/bus.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 "dbus/bus.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 32 matching lines @@
   // Returns true if the underlying file descriptor is ready to be watched.
   bool IsReadyToBeWatched() {
     return dbus_watch_get_enabled(raw_watch_);
   }
 
   // Starts watching the underlying file descriptor.
   void StartWatching() {
     const int file_descriptor = dbus_watch_get_unix_fd(raw_watch_);
     const int flags = dbus_watch_get_flags(raw_watch_);
 
-    MessageLoopForIO::Mode mode = MessageLoopForIO::WATCH_READ;
+    base::MessageLoopForIO::Mode mode = base::MessageLoopForIO::WATCH_READ;
     if ((flags & DBUS_WATCH_READABLE) && (flags & DBUS_WATCH_WRITABLE))
-      mode = MessageLoopForIO::WATCH_READ_WRITE;
+      mode = base::MessageLoopForIO::WATCH_READ_WRITE;
     else if (flags & DBUS_WATCH_READABLE)
-      mode = MessageLoopForIO::WATCH_READ;
+      mode = base::MessageLoopForIO::WATCH_READ;
     else if (flags & DBUS_WATCH_WRITABLE)
-      mode = MessageLoopForIO::WATCH_WRITE;
+      mode = base::MessageLoopForIO::WATCH_WRITE;
     else
       NOTREACHED();
 
     const bool persistent = true;  // Watch persistently.
-    const bool success = MessageLoopForIO::current()->WatchFileDescriptor(
-        file_descriptor,
-        persistent,
-        mode,
-        &file_descriptor_watcher_,
-        this);
+    const bool success = base::MessageLoopForIO::current()->WatchFileDescriptor(
+        file_descriptor, persistent, mode, &file_descriptor_watcher_, this);
     CHECK(success) << "Unable to allocate memory";
   }
 
   // Stops watching the underlying file descriptor.
   void StopWatching() {
     file_descriptor_watcher_.StopWatchingFileDescriptor();
   }
 
  private:
   // Implement MessagePumpLibevent::Watcher.
@@ skipping 109 matching lines @@
       async_operations_set_up_(false),
       shutdown_completed_(false),
       num_pending_watches_(0),
       num_pending_timeouts_(0),
       address_(options.address),
       on_disconnected_closure_(options.disconnected_callback) {
   // This is safe to call multiple times.
   dbus_threads_init_default();
   // The origin message loop is unnecessary if the client uses synchronous
   // functions only.
-  if (MessageLoop::current())
-    origin_task_runner_ =  MessageLoop::current()->message_loop_proxy();
+  if (base::MessageLoop::current())
+    origin_task_runner_ = base::MessageLoop::current()->message_loop_proxy();
 }
 
 Bus::~Bus() {
   DCHECK(!connection_);
   DCHECK(owned_service_names_.empty());
   DCHECK(match_rules_added_.empty());
   DCHECK(filter_functions_added_.empty());
   DCHECK(registered_object_paths_.empty());
   DCHECK_EQ(0, num_pending_watches_);
   // TODO(satorux): This check fails occasionally in browser_tests for tests
@@ skipping 763 matching lines @@
                              kDisconnectedSignal)) {
     Bus* self = static_cast<Bus*>(data);
     self->AssertOnDBusThread();
     self->OnConnectionDisconnected(connection);
     return DBUS_HANDLER_RESULT_HANDLED;
   }
   return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 }
 
 }  // namespace dbus