chromeos: Use base::MessageLoop.

chromeos/dbus/shill_service_client_stub.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/shill_service_client_stub.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 68 matching lines @@
     result_properties.reset(nested_dict->DeepCopy());
     // Remove credentials that Shill wouldn't send.
     result_properties->RemoveWithoutPathExpansion(flimflam::kPassphraseProperty,
                                                   NULL);
     call_status = DBUS_METHOD_CALL_SUCCESS;
   } else {
     result_properties.reset(new base::DictionaryValue);
     call_status = DBUS_METHOD_CALL_FAILURE;
   }
 
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PassStubServiceProperties,
                  callback,
                  call_status,
                  base::Owned(result_properties.release())));
 }
 
 void ShillServiceClientStub::SetProperty(const dbus::ObjectPath& service_path,
                                          const std::string& name,
                                          const base::Value& value,
@@ skipping 13 matching lines @@
     std::string state;
     if (value.GetAsString(&state) && (state == flimflam::kStateOnline ||
                                       state == flimflam::kStatePortal))  {
       ShillManagerClient* manager_client =
           DBusThreadManager::Get()->GetShillManagerClient();
       manager_client->GetTestInterface()->MoveServiceToIndex(
           service_path.value(), 0, true);
     }
   }
   dict->SetWithoutPathExpansion(name, value.DeepCopy());
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), service_path, name));
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillServiceClientStub::ClearProperty(
     const dbus::ObjectPath& service_path,
     const std::string& name,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   dict->Remove(name, NULL);
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(), service_path, name));
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillServiceClientStub::ClearProperties(
     const dbus::ObjectPath& service_path,
     const std::vector<std::string>& names,
     const ListValueCallback& callback,
     const ErrorCallback& error_callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   scoped_ptr<base::ListValue> results(new base::ListValue);
   for (std::vector<std::string>::const_iterator iter = names.begin();
       iter != names.end(); ++iter) {
     dict->Remove(*iter, NULL);
     results->AppendBoolean(true);
   }
   for (std::vector<std::string>::const_iterator iter = names.begin();
       iter != names.end(); ++iter) {
-    MessageLoop::current()->PostTask(
+    base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(
             &ShillServiceClientStub::NotifyObserversPropertyChanged,
             weak_ptr_factory_.GetWeakPtr(), service_path, *iter));
   }
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&PassStubListValue,
                  callback, base::Owned(results.release())));
 }
 
 void ShillServiceClientStub::Connect(const dbus::ObjectPath& service_path,
                                      const base::Closure& callback,
                                      const ErrorCallback& error_callback) {
   base::Value* service;
   if (!stub_services_.Get(service_path.value(), &service)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   base::TimeDelta delay;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
     // Set Associating
     base::StringValue associating_value(flimflam::kStateAssociation);
     SetServiceProperty(service_path.value(),
                        flimflam::kStateProperty,
                        associating_value);
     const int kConnectDelaySeconds = 5;
     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
   }
   // Set Online after a delay
   base::StringValue online_value(flimflam::kStateOnline);
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  flimflam::kStateProperty,
                  online_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
       delay);
   callback.Run();
 }
 
 void ShillServiceClientStub::Disconnect(const dbus::ObjectPath& service_path,
                                         const base::Closure& callback,
                                         const ErrorCallback& error_callback) {
   base::Value* service;
   if (!stub_services_.Get(service_path.value(), &service)) {
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
   base::TimeDelta delay;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
     const int kConnectDelaySeconds = 2;
     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
   }
   // Set Idle after a delay
   base::StringValue idle_value(flimflam::kStateIdle);
-  MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ShillServiceClientStub::SetProperty,
                  weak_ptr_factory_.GetWeakPtr(),
                  service_path,
                  flimflam::kStateProperty,
                  idle_value,
                  base::Bind(&base::DoNothing),
                  error_callback),
       delay);
   callback.Run();
 }
 
 void ShillServiceClientStub::Remove(const dbus::ObjectPath& service_path,
                                     const base::Closure& callback,
                                     const ErrorCallback& error_callback) {
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillServiceClientStub::ActivateCellularModem(
     const dbus::ObjectPath& service_path,
     const std::string& carrier,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void ShillServiceClientStub::CompleteCellularActivation(
     const dbus::ObjectPath& service_path,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (callback.is_null())
     return;
-  MessageLoop::current()->PostTask(FROM_HERE, callback);
+  base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 bool ShillServiceClientStub::CallActivateCellularModemAndBlock(
     const dbus::ObjectPath& service_path,
     const std::string& carrier) {
   return true;
 }
 
 ShillServiceClient::TestInterface* ShillServiceClientStub::GetTestInterface() {
   return this;
@@ skipping 162 matching lines @@
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos