Replace misc. network stub flags with more flexible ones

chromeos/dbus/fake_shill_manager_client.cc

 // Copyright 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_shill_manager_client.h"
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/values.h"
-#include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/dbus/shill_service_client.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/values_util.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
@@ skipping 16 matching lines @@
 // have Type |match_type| to either an active list or an inactive list
 // based on the entry's State.
 void AppendServicesForType(
     const base::ListValue* service_list_in,
     const char* match_type,
     std::vector<std::string>* active_service_list_out,
     std::vector<std::string>* inactive_service_list_out) {
   ShillServiceClient::TestInterface* service_client =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   for (base::ListValue::const_iterator iter = service_list_in->begin();
-       iter != service_list_in->end(); ++iter) {
+       iter != service_list_in->end();
+       ++iter) {
     std::string service_path;
     if (!(*iter)->GetAsString(&service_path))
       continue;
     const base::DictionaryValue* properties =
         service_client->GetServiceProperties(service_path);
     if (!properties) {
       LOG(ERROR) << "Properties not found for service: " << service_path;
       continue;
     }
     std::string type;
     properties->GetString(shill::kTypeProperty, &type);
     if (type != match_type)
       continue;
     std::string state;
     properties->GetString(shill::kStateProperty, &state);
-    if (state == shill::kStateOnline ||
-        state == shill::kStateAssociation ||
-        state == shill::kStateConfiguration ||
-        state == shill::kStatePortal ||
+    if (state == shill::kStateOnline || state == shill::kStateAssociation ||
+        state == shill::kStateConfiguration || state == shill::kStatePortal ||
         state == shill::kStateReady) {
       active_service_list_out->push_back(service_path);
     } else {
       inactive_service_list_out->push_back(service_path);
     }
   }
 }
 
 }  // namespace
 
-FakeShillManagerClient::FakeShillManagerClient()
-    : weak_ptr_factory_(this) {
-}
+FakeShillManagerClient::FakeShillManagerClient() : weak_ptr_factory_(this) {}
 
 FakeShillManagerClient::~FakeShillManagerClient() {}
 
 // ShillManagerClient overrides.
 
 void FakeShillManagerClient::Init(dbus::Bus* bus) {}
 
 void FakeShillManagerClient::AddPropertyChangedObserver(
     ShillPropertyChangedObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void FakeShillManagerClient::RemovePropertyChangedObserver(
     ShillPropertyChangedObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void FakeShillManagerClient::GetProperties(
     const DictionaryValueCallback& callback) {
   base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(
-          &FakeShillManagerClient::PassStubProperties,
-          weak_ptr_factory_.GetWeakPtr(),
-          callback));
+      FROM_HERE,
+      base::Bind(&FakeShillManagerClient::PassStubProperties,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void FakeShillManagerClient::GetNetworksForGeolocation(
     const DictionaryValueCallback& callback) {
   base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(
-          &FakeShillManagerClient::PassStubGeoNetworks,
-          weak_ptr_factory_.GetWeakPtr(),
-          callback));
+      FROM_HERE,
+      base::Bind(&FakeShillManagerClient::PassStubGeoNetworks,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback));
 }
 
 void FakeShillManagerClient::SetProperty(const std::string& name,
                                          const base::Value& value,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
-  CallNotifyObserversPropertyChanged(name, 0);
+  CallNotifyObserversPropertyChanged(name);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::RequestScan(const std::string& type,
                                          const base::Closure& callback,
                                          const ErrorCallback& error_callback) {
   // For Stub purposes, default to a Wifi scan.
   std::string device_type = shill::kTypeWifi;
   if (!type.empty())
     device_type = type;
   ShillDeviceClient::TestInterface* device_client =
       DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface();
   std::string device_path = device_client->GetDevicePathForType(device_type);
   if (!device_path.empty()) {
-    device_client->SetDeviceProperty(device_path,
-                                     shill::kScanningProperty,
-                                     base::FundamentalValue(true));
+    device_client->SetDeviceProperty(
+        device_path, shill::kScanningProperty, base::FundamentalValue(true));
   }
-  const int kScanDurationSeconds = 3;
-  int scan_duration_seconds = kScanDurationSeconds;
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-      chromeos::switches::kEnableStubInteractive)) {
-    scan_duration_seconds = 0;
-  }
+  int scan_duration_seconds =
+      DBusThreadManager::Get()->GetShillInteractiveDelay();
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::ScanCompleted,
-                 weak_ptr_factory_.GetWeakPtr(), device_path, callback),
+                 weak_ptr_factory_.GetWeakPtr(),
+                 device_path,
+                 callback),
       base::TimeDelta::FromSeconds(scan_duration_seconds));
 }
 
 void FakeShillManagerClient::EnableTechnology(
     const std::string& type,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::ListValue* enabled_list = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
-      shill::kEnabledTechnologiesProperty, &enabled_list)) {
+          shill::kEnabledTechnologiesProperty, &enabled_list)) {
     base::MessageLoop::current()->PostTask(FROM_HERE, callback);
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback, "StubError", "Property not found"));
     return;
   }
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    const int kEnableTechnologyDelaySeconds = 3;
+  int interactive_delay = DBusThreadManager::Get()->GetShillInteractiveDelay();
+  if (interactive_delay) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeShillManagerClient::SetTechnologyEnabled,
-                   weak_ptr_factory_.GetWeakPtr(), type, callback, true),
-        base::TimeDelta::FromSeconds(kEnableTechnologyDelaySeconds));
+                   weak_ptr_factory_.GetWeakPtr(),
+                   type,
+                   callback,
+                   true),
+        base::TimeDelta::FromSeconds(interactive_delay));
   } else {
     SetTechnologyEnabled(type, callback, true);
   }
 }
 
 void FakeShillManagerClient::DisableTechnology(
     const std::string& type,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   base::ListValue* enabled_list = NULL;
   if (!stub_properties_.GetListWithoutPathExpansion(
-      shill::kEnabledTechnologiesProperty, &enabled_list)) {
+          shill::kEnabledTechnologiesProperty, &enabled_list)) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(error_callback, "StubError", "Property not found"));
     return;
   }
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    const int kDisableTechnologyDelaySeconds = 3;
+  int interactive_delay = DBusThreadManager::Get()->GetShillInteractiveDelay();
+  if (interactive_delay) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&FakeShillManagerClient::SetTechnologyEnabled,
-                   weak_ptr_factory_.GetWeakPtr(), type, callback, false),
-        base::TimeDelta::FromSeconds(kDisableTechnologyDelaySeconds));
+                   weak_ptr_factory_.GetWeakPtr(),
+                   type,
+                   callback,
+                   false),
+        base::TimeDelta::FromSeconds(interactive_delay));
   } else {
     SetTechnologyEnabled(type, callback, false);
   }
 }
 
 void FakeShillManagerClient::ConfigureService(
     const base::DictionaryValue& properties,
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback) {
   ShillServiceClient::TestInterface* service_client =
@@ skipping 18 matching lines @@
 
   std::string ipconfig_path;
   properties.GetString(shill::kIPConfigProperty, &ipconfig_path);
 
   // Merge the new properties with existing properties, if any.
   const base::DictionaryValue* existing_properties =
       service_client->GetServiceProperties(service_path);
   if (!existing_properties) {
     // Add a new service to the service client stub because none exists, yet.
     // This calls AddManagerService.
-    service_client->AddServiceWithIPConfig(service_path, guid, type,
-                                           shill::kStateIdle, ipconfig_path,
+    service_client->AddServiceWithIPConfig(service_path,
+                                           guid,
+                                           type,
+                                           shill::kStateIdle,
+                                           ipconfig_path,
                                            true /* visible */,
                                            true /* watch */);
     existing_properties = service_client->GetServiceProperties(service_path);
   }
 
   scoped_ptr<base::DictionaryValue> merged_properties(
       existing_properties->DeepCopy());
   merged_properties->MergeDictionary(&properties);
 
   // Now set all the properties.
   for (base::DictionaryValue::Iterator iter(*merged_properties);
-       !iter.IsAtEnd(); iter.Advance()) {
+       !iter.IsAtEnd();
+       iter.Advance()) {
     service_client->SetServiceProperty(service_path, iter.key(), iter.value());
   }
 
   // If the Profile property is set, add it to ProfileClient.
   std::string profile_path;
   merged_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                    &profile_path);
   if (!profile_path.empty()) {
-    DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
-        AddService(profile_path, service_path);
+    DBusThreadManager::Get()
+        ->GetShillProfileClient()
+        ->GetTestInterface()
+        ->AddService(profile_path, service_path);
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, dbus::ObjectPath(service_path)));
 }
 
 void FakeShillManagerClient::ConfigureServiceForProfile(
     const dbus::ObjectPath& profile_path,
     const base::DictionaryValue& properties,
     const ObjectPathCallback& callback,
     const ErrorCallback& error_callback) {
   std::string profile_property;
   properties.GetStringWithoutPathExpansion(shill::kProfileProperty,
                                            &profile_property);
   CHECK(profile_property == profile_path.value());
   ConfigureService(properties, callback, error_callback);
 }
 
-
-void FakeShillManagerClient::GetService(
-    const base::DictionaryValue& properties,
-    const ObjectPathCallback& callback,
-    const ErrorCallback& error_callback) {
+void FakeShillManagerClient::GetService(const base::DictionaryValue& properties,
+                                        const ObjectPathCallback& callback,
+                                        const ErrorCallback& error_callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, dbus::ObjectPath()));
 }
 
 void FakeShillManagerClient::VerifyDestination(
     const VerificationProperties& properties,
     const BooleanCallback& callback,
     const ErrorCallback& error_callback) {
   base::MessageLoop::current()->PostTask(FROM_HERE, base::Bind(callback, true));
 }
 
 void FakeShillManagerClient::VerifyAndEncryptCredentials(
     const VerificationProperties& properties,
     const std::string& service_path,
     const StringCallback& callback,
     const ErrorCallback& error_callback) {
   base::MessageLoop::current()->PostTask(
       FROM_HERE, base::Bind(callback, "encrypted_credentials"));
 }
 
 void FakeShillManagerClient::VerifyAndEncryptData(
     const VerificationProperties& properties,
     const std::string& data,
     const StringCallback& callback,
     const ErrorCallback& error_callback) {
-  base::MessageLoop::current()->PostTask(FROM_HERE,
-                                   base::Bind(callback, "encrypted_data"));
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(callback, "encrypted_data"));
 }
 
 void FakeShillManagerClient::ConnectToBestServices(
     const base::Closure& callback,
-    const ErrorCallback& error_callback) {
-}
+    const ErrorCallback& error_callback) {}
 
 ShillManagerClient::TestInterface* FakeShillManagerClient::GetTestInterface() {
   return this;
 }
 
 // ShillManagerClient::TestInterface overrides.
 
 void FakeShillManagerClient::AddDevice(const std::string& device_path) {
-  if (GetListProperty(shill::kDevicesProperty)->AppendIfNotPresent(
-      base::Value::CreateStringValue(device_path))) {
-    CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+  if (GetListProperty(shill::kDevicesProperty)
+          ->AppendIfNotPresent(base::Value::CreateStringValue(device_path))) {
+    CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveDevice(const std::string& device_path) {
   base::StringValue device_path_value(device_path);
-  if (GetListProperty(shill::kDevicesProperty)->Remove(
-      device_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+  if (GetListProperty(shill::kDevicesProperty)
+          ->Remove(device_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
   }
 }
 
 void FakeShillManagerClient::ClearDevices() {
   GetListProperty(shill::kDevicesProperty)->Clear();
-  CallNotifyObserversPropertyChanged(shill::kDevicesProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kDevicesProperty);
 }
 
 void FakeShillManagerClient::AddTechnology(const std::string& type,
                                            bool enabled) {
-  if (GetListProperty(shill::kAvailableTechnologiesProperty)->
-      AppendIfNotPresent(base::Value::CreateStringValue(type))) {
-    CallNotifyObserversPropertyChanged(
-        shill::kAvailableTechnologiesProperty, 0);
+  if (GetListProperty(shill::kAvailableTechnologiesProperty)
+          ->AppendIfNotPresent(base::Value::CreateStringValue(type))) {
+    CallNotifyObserversPropertyChanged(shill::kAvailableTechnologiesProperty);
   }
   if (enabled &&
-      GetListProperty(shill::kEnabledTechnologiesProperty)->
-      AppendIfNotPresent(base::Value::CreateStringValue(type))) {
-    CallNotifyObserversPropertyChanged(
-        shill::kEnabledTechnologiesProperty, 0);
+      GetListProperty(shill::kEnabledTechnologiesProperty)
+          ->AppendIfNotPresent(base::Value::CreateStringValue(type))) {
+    CallNotifyObserversPropertyChanged(shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::RemoveTechnology(const std::string& type) {
   base::StringValue type_value(type);
-  if (GetListProperty(shill::kAvailableTechnologiesProperty)->Remove(
-      type_value, NULL)) {
-    CallNotifyObserversPropertyChanged(
-        shill::kAvailableTechnologiesProperty, 0);
+  if (GetListProperty(shill::kAvailableTechnologiesProperty)
+          ->Remove(type_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kAvailableTechnologiesProperty);
   }
-  if (GetListProperty(shill::kEnabledTechnologiesProperty)->Remove(
-      type_value, NULL)) {
-    CallNotifyObserversPropertyChanged(
-        shill::kEnabledTechnologiesProperty, 0);
+  if (GetListProperty(shill::kEnabledTechnologiesProperty)
+          ->Remove(type_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kEnabledTechnologiesProperty);
   }
 }
 
 void FakeShillManagerClient::SetTechnologyInitializing(const std::string& type,
                                                        bool initializing) {
   if (initializing) {
-    if (GetListProperty(shill::kUninitializedTechnologiesProperty)->
-        AppendIfNotPresent(base::Value::CreateStringValue(type))) {
+    if (GetListProperty(shill::kUninitializedTechnologiesProperty)
+            ->AppendIfNotPresent(base::Value::CreateStringValue(type))) {
       CallNotifyObserversPropertyChanged(
-          shill::kUninitializedTechnologiesProperty, 0);
+          shill::kUninitializedTechnologiesProperty);
     }
   } else {
-    if (GetListProperty(shill::kUninitializedTechnologiesProperty)->Remove(
-            base::StringValue(type), NULL)) {
+    if (GetListProperty(shill::kUninitializedTechnologiesProperty)
+            ->Remove(base::StringValue(type), NULL)) {
       CallNotifyObserversPropertyChanged(
-          shill::kUninitializedTechnologiesProperty, 0);
+          shill::kUninitializedTechnologiesProperty);
     }
   }
 }
 
-void FakeShillManagerClient::ClearProperties() {
-  stub_properties_.Clear();
-}
+void FakeShillManagerClient::ClearProperties() { stub_properties_.Clear(); }
 
 void FakeShillManagerClient::AddManagerService(const std::string& service_path,
                                                bool add_to_visible_list,
                                                bool add_to_watch_list) {
   // Always add to ServiceCompleteListProperty.
-  GetListProperty(shill::kServiceCompleteListProperty)->AppendIfNotPresent(
-      base::Value::CreateStringValue(service_path));
+  GetListProperty(shill::kServiceCompleteListProperty)
+      ->AppendIfNotPresent(base::Value::CreateStringValue(service_path));
   // If visible, add to Services and notify if new.
   if (add_to_visible_list &&
-      GetListProperty(shill::kServicesProperty)->AppendIfNotPresent(
-      base::Value::CreateStringValue(service_path))) {
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
+      GetListProperty(shill::kServicesProperty)
+          ->AppendIfNotPresent(base::Value::CreateStringValue(service_path))) {
+    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
   if (add_to_watch_list)
     AddServiceToWatchList(service_path);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
     const std::string& service_path) {
   base::StringValue service_path_value(service_path);
-  if (GetListProperty(shill::kServicesProperty)->Remove(
-      service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
+  if (GetListProperty(shill::kServicesProperty)
+          ->Remove(service_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
-  GetListProperty(shill::kServiceCompleteListProperty)->Remove(
-      service_path_value, NULL);
-  if (GetListProperty(shill::kServiceWatchListProperty)->Remove(
-      service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(
-        shill::kServiceWatchListProperty, 0);
+  GetListProperty(shill::kServiceCompleteListProperty)
+      ->Remove(service_path_value, NULL);
+  if (GetListProperty(shill::kServiceWatchListProperty)
+          ->Remove(service_path_value, NULL)) {
+    CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
   }
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
   GetListProperty(shill::kServicesProperty)->Clear();
   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   GetListProperty(shill::kServiceWatchListProperty)->Clear();
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 void FakeShillManagerClient::SortManagerServices() {
-  static const char* ordered_types[] = {
-    shill::kTypeEthernet,
-    shill::kTypeWifi,
-    shill::kTypeCellular,
-    shill::kTypeWimax,
-    shill::kTypeVPN
-  };
+  static const char* ordered_types[] = {shill::kTypeEthernet, shill::kTypeWifi,
+                                        shill::kTypeCellular, shill::kTypeWimax,
+                                        shill::kTypeVPN};
   base::ListValue* service_list = GetListProperty(shill::kServicesProperty);
   if (!service_list || service_list->empty())
     return;
   std::vector<std::string> active_services;
   std::vector<std::string> inactive_services;
   for (size_t i = 0; i < arraysize(ordered_types); ++i) {
-    AppendServicesForType(service_list, ordered_types[i],
-                          &active_services, &inactive_services);
+    AppendServicesForType(
+        service_list, ordered_types[i], &active_services, &inactive_services);
   }
   service_list->Clear();
   for (size_t i = 0; i < active_services.size(); ++i)
     service_list->AppendString(active_services[i]);
   for (size_t i = 0; i < inactive_services.size(); ++i)
     service_list->AppendString(inactive_services[i]);
 
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
 }
 
 void FakeShillManagerClient::AddGeoNetwork(
     const std::string& technology,
     const base::DictionaryValue& network) {
   base::ListValue* list_value = NULL;
-  if (!stub_geo_networks_.GetListWithoutPathExpansion(
-      technology, &list_value)) {
+  if (!stub_geo_networks_.GetListWithoutPathExpansion(technology,
+                                                      &list_value)) {
     list_value = new base::ListValue;
     stub_geo_networks_.SetWithoutPathExpansion(technology, list_value);
   }
   list_value->Append(network.DeepCopy());
 }
 
 void FakeShillManagerClient::AddProfile(const std::string& profile_path) {
   const char* key = shill::kProfilesProperty;
-  if (GetListProperty(key)->AppendIfNotPresent(
-          new base::StringValue(profile_path))) {
-    CallNotifyObserversPropertyChanged(key, 0);
+  if (GetListProperty(key)
+          ->AppendIfNotPresent(new base::StringValue(profile_path))) {
+    CallNotifyObserversPropertyChanged(key);
   }
 }
 
 void FakeShillManagerClient::AddServiceToWatchList(
     const std::string& service_path) {
   // Remove and insert the service, moving it to the front of the watch list.
-  GetListProperty(shill::kServiceWatchListProperty)->Remove(
-      base::StringValue(service_path), NULL);
-  GetListProperty(shill::kServiceWatchListProperty)->Insert(
-      0, base::Value::CreateStringValue(service_path));
-  CallNotifyObserversPropertyChanged(
-      shill::kServiceWatchListProperty, 0);
+  GetListProperty(shill::kServiceWatchListProperty)
+      ->Remove(base::StringValue(service_path), NULL);
+  GetListProperty(shill::kServiceWatchListProperty)
+      ->Insert(0, base::Value::CreateStringValue(service_path));
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 void FakeShillManagerClient::PassStubProperties(
     const DictionaryValueCallback& callback) const {
   scoped_ptr<base::DictionaryValue> stub_properties(
       stub_properties_.DeepCopy());
   // Remove disabled services from the list.
   stub_properties->SetWithoutPathExpansion(
       shill::kServicesProperty,
       GetEnabledServiceList(shill::kServicesProperty));
   stub_properties->SetWithoutPathExpansion(
       shill::kServiceWatchListProperty,
       GetEnabledServiceList(shill::kServiceWatchListProperty));
   callback.Run(DBUS_METHOD_CALL_SUCCESS, *stub_properties);
 }
 
 void FakeShillManagerClient::PassStubGeoNetworks(
     const DictionaryValueCallback& callback) const {
   callback.Run(DBUS_METHOD_CALL_SUCCESS, stub_geo_networks_);
 }
 
 void FakeShillManagerClient::CallNotifyObserversPropertyChanged(
-    const std::string& property,
-    int delay_ms) {
+    const std::string& property) {
   // Avoid unnecessary delayed task if we have no observers (e.g. during
   // initial setup).
   if (!observer_list_.might_have_observers())
     return;
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubInteractive)) {
-    delay_ms = 0;
-  }
-  base::MessageLoop::current()->PostDelayedTask(
+  base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(),
-                 property),
-                 base::TimeDelta::FromMilliseconds(delay_ms));
+                 property));
 }
 
 void FakeShillManagerClient::NotifyObserversPropertyChanged(
     const std::string& property) {
   if (property == shill::kServicesProperty ||
       property == shill::kServiceWatchListProperty) {
     scoped_ptr<base::ListValue> services(GetEnabledServiceList(property));
     FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                       observer_list_,
                       OnPropertyChanged(property, *(services.get())));
     return;
   }
   if (property == shill::kDevicesProperty) {
     base::ListValue* devices = NULL;
-    if (stub_properties_.GetListWithoutPathExpansion(
-            shill::kDevicesProperty, &devices)) {
+    if (stub_properties_.GetListWithoutPathExpansion(shill::kDevicesProperty,
+                                                     &devices)) {
       FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                         observer_list_,
                         OnPropertyChanged(property, *devices));
     }
     return;
   }
   base::Value* value = NULL;
   if (!stub_properties_.GetWithoutPathExpansion(property, &value)) {
     LOG(ERROR) << "Notify for unknown property: " << property;
     return;
   }
   FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                     observer_list_,
                     OnPropertyChanged(property, *value));
 }
 
 base::ListValue* FakeShillManagerClient::GetListProperty(
     const std::string& property) {
   base::ListValue* list_property = NULL;
-  if (!stub_properties_.GetListWithoutPathExpansion(
-      property, &list_property)) {
+  if (!stub_properties_.GetListWithoutPathExpansion(property, &list_property)) {
     list_property = new base::ListValue;
     stub_properties_.SetWithoutPathExpansion(property, list_property);
   }
   return list_property;
 }
 
 bool FakeShillManagerClient::TechnologyEnabled(const std::string& type) const {
   if (type == shill::kTypeVPN)
     return true;  // VPN is always "enabled" since there is no associated device
   bool enabled = false;
   const base::ListValue* technologies;
   if (stub_properties_.GetListWithoutPathExpansion(
           shill::kEnabledTechnologiesProperty, &technologies)) {
     base::StringValue type_value(type);
     if (technologies->Find(type_value) != technologies->end())
       enabled = true;
   }
   return enabled;
 }
 
-void FakeShillManagerClient::SetTechnologyEnabled(
-    const std::string& type,
-    const base::Closure& callback,
-    bool enabled) {
+void FakeShillManagerClient::SetTechnologyEnabled(const std::string& type,
+                                                  const base::Closure& callback,
+                                                  bool enabled) {
   base::ListValue* enabled_list = NULL;
   stub_properties_.GetListWithoutPathExpansion(
       shill::kEnabledTechnologiesProperty, &enabled_list);
   DCHECK(enabled_list);
   if (enabled)
     enabled_list->AppendIfNotPresent(new base::StringValue(type));
   else
     enabled_list->Remove(base::StringValue(type), NULL);
-  CallNotifyObserversPropertyChanged(
-      shill::kEnabledTechnologiesProperty, 0 /* already delayed */);
+  CallNotifyObserversPropertyChanged(shill::kEnabledTechnologiesProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
   // May affect available services
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 base::ListValue* FakeShillManagerClient::GetEnabledServiceList(
     const std::string& property) const {
   base::ListValue* new_service_list = new base::ListValue;
   const base::ListValue* service_list;
   if (stub_properties_.GetListWithoutPathExpansion(property, &service_list)) {
     ShillServiceClient::TestInterface* service_client =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     for (base::ListValue::const_iterator iter = service_list->begin();
-         iter != service_list->end(); ++iter) {
+         iter != service_list->end();
+         ++iter) {
       std::string service_path;
       if (!(*iter)->GetAsString(&service_path))
         continue;
       const base::DictionaryValue* properties =
           service_client->GetServiceProperties(service_path);
       if (!properties) {
         LOG(ERROR) << "Properties not found for service: " << service_path;
         continue;
       }
       std::string name;
       properties->GetString(shill::kNameProperty, &name);
       std::string type;
       properties->GetString(shill::kTypeProperty, &type);
       if (TechnologyEnabled(type))
         new_service_list->Append((*iter)->DeepCopy());
     }
   }
   return new_service_list;
 }
 
 void FakeShillManagerClient::ScanCompleted(const std::string& device_path,
                                            const base::Closure& callback) {
   if (!device_path.empty()) {
-    DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
-        SetDeviceProperty(device_path,
-                          shill::kScanningProperty,
-                          base::FundamentalValue(false));
+    DBusThreadManager::Get()
+        ->GetShillDeviceClient()
+        ->GetTestInterface()
+        ->SetDeviceProperty(device_path,
+                            shill::kScanningProperty,
+                            base::FundamentalValue(false));
   }
-  CallNotifyObserversPropertyChanged(shill::kServicesProperty, 0);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty, 0);
+  CallNotifyObserversPropertyChanged(shill::kServicesProperty);
+  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 }  // namespace chromeos