chromeos: Use base::MessageLoop.

chromeos/dbus/fake_bluetooth_device_client.cc

 // Copyright (c) 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 "chromeos/dbus/fake_bluetooth_device_client.h"
 
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ skipping 400 matching lines @@
   if (agent_service_provider == NULL) {
     error_callback.Run(kNoResponseError, "Missing agent");
     return;
   }
 
   if (object_path == dbus::ObjectPath(kAppleMousePath) ||
       object_path == dbus::ObjectPath(kMicrosoftMousePath) ||
       object_path == dbus::ObjectPath(kUnconnectableDevicePath)) {
     // No need to call anything on the pairing delegate, just wait 3 times
     // the interval before acting as if the other end accepted it.
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
 
   } else if (object_path == dbus::ObjectPath(kAppleKeyboardPath)) {
     // Display a Pincode, and wait 7 times the interval before acting as
     // if the other end accepted it.
     agent_service_provider->DisplayPinCode(object_path, "123456");
 
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(7 * simulation_interval_ms_));
 
   } else if (object_path == dbus::ObjectPath(kVanishingDevicePath)) {
     // The vanishing device simulates being too far away, and thus times out.
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::TimeoutSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(4 * simulation_interval_ms_));
 
   } else if (object_path == dbus::ObjectPath(kMotorolaKeyboardPath)) {
     // Display a passkey, and each interval act as if another key was entered
     // for it.
     agent_service_provider->DisplayPasskey(object_path, 123456, 0);
 
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
                    base::Unretained(this),
                    1, object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (object_path == dbus::ObjectPath(kSonyHeadphonesPath)) {
     // Request a Pincode.
     agent_service_provider->RequestPinCode(
         object_path,
@@ skipping 18 matching lines @@
     agent_service_provider->RequestPasskey(
         object_path,
         base::Bind(&FakeBluetoothDeviceClient::PasskeyCallback,
                    base::Unretained(this),
                    object_path,
                    callback,
                    error_callback));
 
   } else if (object_path == dbus::ObjectPath(kUnpairableDevicePath)) {
     // Fails the pairing with an org.bluez.Error.Failed error.
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::FailSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else {
     error_callback.Run(kNoResponseError, "No pairing fake");
   }
 }
 
 void FakeBluetoothDeviceClient::CancelPairing(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "CancelPairing: " << object_path.value();
   pairing_cancelled_ = true;
   callback.Run();
 }
 
 
 void FakeBluetoothDeviceClient::BeginDiscoverySimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "starting discovery simulation";
 
   discovery_simulation_step_ = 1;
 
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
                  base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 }
 
 void FakeBluetoothDeviceClient::EndDiscoverySimulation(
     const dbus::ObjectPath& adapter_path) {
   VLOG(1) << "stopping discovery simulation";
   discovery_simulation_step_ = 0;
@@ skipping 269 matching lines @@
   } else if (discovery_simulation_step_ == 13) {
     RemoveDevice(dbus::ObjectPath(FakeBluetoothAdapterClient::kAdapterPath),
                  dbus::ObjectPath(kVanishingDevicePath));
 
   } else if (discovery_simulation_step_ == 14) {
     return;
 
   }
 
   ++discovery_simulation_step_;
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothDeviceClient::DiscoverySimulationTimer,
                  base::Unretained(this)),
       base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 }
 
 
 void FakeBluetoothDeviceClient::CompleteSimulatedPairing(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
@@ skipping 64 matching lines @@
 
 void FakeBluetoothDeviceClient::PinCodeCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     ExperimentalBluetoothAgentServiceProvider::Delegate::Status status,
     const std::string& pincode) {
   VLOG(1) << "PinCodeCallback: " << object_path.value();
 
   if (status == ExperimentalBluetoothAgentServiceProvider::Delegate::SUCCESS) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::CANCELLED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::REJECTED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 void FakeBluetoothDeviceClient::PasskeyCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     ExperimentalBluetoothAgentServiceProvider::Delegate::Status status,
     uint32 passkey) {
   VLOG(1) << "PasskeyCallback: " << object_path.value();
 
   if (status == ExperimentalBluetoothAgentServiceProvider::Delegate::SUCCESS) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::CANCELLED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::REJECTED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 void FakeBluetoothDeviceClient::ConfirmationCallback(
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback,
     ExperimentalBluetoothAgentServiceProvider::Delegate::Status status) {
   VLOG(1) << "ConfirmationCallback: " << object_path.value();
 
   if (status == ExperimentalBluetoothAgentServiceProvider::Delegate::SUCCESS) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(3 * simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::CANCELLED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CancelSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else if (status ==
              ExperimentalBluetoothAgentServiceProvider::Delegate::REJECTED) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::RejectSimulatedPairing,
                    base::Unretained(this),
                    object_path, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 void FakeBluetoothDeviceClient::SimulateKeypress(
     uint16 entered,
     const dbus::ObjectPath& object_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   VLOG(1) << "SimulateKeypress " << entered << ": " << object_path.value();
 
   FakeBluetoothAgentManagerClient* fake_bluetooth_agent_manager_client =
       static_cast<FakeBluetoothAgentManagerClient*>(
           DBusThreadManager::Get()->
               GetExperimentalBluetoothAgentManagerClient());
   FakeBluetoothAgentServiceProvider* agent_service_provider =
       fake_bluetooth_agent_manager_client->GetAgentServiceProvider();
   agent_service_provider->DisplayPasskey(object_path, 123456, entered);
 
   if (entered < 7) {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::SimulateKeypress,
                    base::Unretained(this),
                    entered + 1, object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   } else {
-    MessageLoop::current()->PostDelayedTask(
+    base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeBluetoothDeviceClient::CompleteSimulatedPairing,
                    base::Unretained(this),
                    object_path, callback, error_callback),
         base::TimeDelta::FromMilliseconds(simulation_interval_ms_));
 
   }
 }
 
 void FakeBluetoothDeviceClient::ConnectionCallback(
@@ skipping 31 matching lines @@
   } else if (status ==
              ExperimentalBluetoothProfileServiceProvider::Delegate::CANCELLED) {
     error_callback.Run(bluetooth_adapter::kErrorFailed, "Canceled");
   } else if (status ==
              ExperimentalBluetoothProfileServiceProvider::Delegate::REJECTED) {
     error_callback.Run(bluetooth_adapter::kErrorFailed, "Rejected");
   }
 }
 
 }  // namespace chromeos