Refactor the setup of Shill*Stubs' default environment.

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/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
-#include "chromeos/dbus/shill_profile_client_stub.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
-#include "dbus/object_proxy.h"
+#include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
-const char kStubPortalledWifiPath[] = "portalled_wifi";
-const char kStubPortalledWifiName[] = "Portalled Wifi";
-
 void ErrorFunction(const std::string& error_name,
                    const std::string& error_message) {
   LOG(ERROR) << "Shill Error: " << error_name << " : " << error_message;
 }
 
 void PassStubListValue(const ShillServiceClient::ListValueCallback& callback,
                        base::ListValue* value) {
   callback.Run(*value);
 }
 
 void PassStubServiceProperties(
     const ShillServiceClient::DictionaryValueCallback& callback,
     DBusMethodCallStatus call_status,
     const base::DictionaryValue* properties) {
   callback.Run(call_status, *properties);
 }
 
 }  // namespace
 
 ShillServiceClientStub::ShillServiceClientStub() : weak_ptr_factory_(this) {
 }
 
 ShillServiceClientStub::~ShillServiceClientStub() {
   STLDeleteContainerPairSecondPointers(
       observer_list_.begin(), observer_list_.end());
 }
 
-// static
-bool ShillServiceClientStub::IsStubPortalledWifiEnabled(
-    const std::string& path) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubPortalledWifi)) {
-    return false;
-  }
-  return path == kStubPortalledWifiPath;
-}
 
 // ShillServiceClient overrides.
 
 void ShillServiceClientStub::Init(dbus::Bus* bus) {
 }
 
 void ShillServiceClientStub::AddPropertyChangedObserver(
     const dbus::ObjectPath& service_path,
     ShillPropertyChangedObserver* observer) {
   GetObserverList(service_path).AddObserver(observer);
@@ skipping 99 matching lines @@
   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) {
   VLOG(1) << "ShillServiceClientStub::Connect: " << service_path.value();
-  base::DictionaryValue* service_properties;
+  base::DictionaryValue* service_properties = NULL;
   if (!stub_services_.GetDictionary(
           service_path.value(), &service_properties)) {
     LOG(ERROR) << "Service not found: " << service_path.value();
     error_callback.Run("Error.InvalidService", "Invalid Service");
     return;
   }
 
   // Set any other services of the same Type to 'offline' first, before setting
   // State to Association which will trigger sorting Manager.Services and
   // sending an update.
   SetOtherServicesOffline(service_path.value());
 
   // Set Associating.
   base::StringValue associating_value(flimflam::kStateAssociation);
   SetServiceProperty(service_path.value(),
                      flimflam::kStateProperty,
                      associating_value);
 
-  // Set Online after a delay.
+  // Stay Associating until the state is changed again after a delay.
   base::TimeDelta delay;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
     const int kConnectDelaySeconds = 5;
     delay = base::TimeDelta::FromSeconds(kConnectDelaySeconds);
   }
-  base::StringValue online_value(flimflam::kStateOnline);
-  if (service_path.value() == kStubPortalledWifiPath)
-    online_value = base::StringValue(flimflam::kStatePortal);
-  std::string passphrase;
-  service_properties->GetStringWithoutPathExpansion(
-      flimflam::kPassphraseProperty, &passphrase);
-  if (passphrase == "failure")
-    online_value = base::StringValue(flimflam::kStateFailure);
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
-      base::Bind(&ShillServiceClientStub::SetProperty,
+      base::Bind(&ShillServiceClientStub::ContinueConnect,
                  weak_ptr_factory_.GetWeakPtr(),
-                 service_path,
-                 flimflam::kStateProperty,
-                 online_value,
-                 base::Bind(&base::DoNothing),
-                 error_callback),
+                 service_path.value()),
       delay);
+
   callback.Run();
-  // On failure, also set the Error property.
-  if (passphrase == "failure") {
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&ShillServiceClientStub::SetProperty,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   service_path,
-                   flimflam::kErrorProperty,
-                   base::StringValue(flimflam::kErrorBadPassphrase),
-                   base::Bind(&base::DoNothing),
-                   error_callback),
-        delay);
-  }
 }
 
 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;
   }
@@ skipping 23 matching lines @@
                                     const ErrorCallback& error_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) {
   base::DictionaryValue* service_properties =
-      GetModifiableServiceProperties(service_path.value());
+      GetModifiableServiceProperties(service_path.value(), false);
   if (!service_properties) {
     LOG(ERROR) << "Service not found: " << service_path.value();
     error_callback.Run("Error.InvalidService", "Invalid Service");
   }
   SetServiceProperty(service_path.value(),
                      flimflam::kActivationStateProperty,
                      base::StringValue(flimflam::kActivationStateActivating));
   base::TimeDelta delay;
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           chromeos::switches::kEnableStubInteractive)) {
@@ skipping 20 matching lines @@
 }
 
 void ShillServiceClientStub::GetLoadableProfileEntries(
     const dbus::ObjectPath& service_path,
     const DictionaryValueCallback& callback) {
   // Provide a dictionary with a single { profile_path, service_path } entry
   // if the Profile property is set, or an empty dictionary.
   scoped_ptr<base::DictionaryValue> result_properties(
       new base::DictionaryValue);
   base::DictionaryValue* service_properties =
-      GetModifiableServiceProperties(service_path.value());
+      GetModifiableServiceProperties(service_path.value(), false);
   if (service_properties) {
     std::string profile_path;
     if (service_properties->GetStringWithoutPathExpansion(
             flimflam::kProfileProperty, &profile_path)) {
       result_properties->SetStringWithoutPathExpansion(
           profile_path, service_path.value());
     }
   } else {
     LOG(WARNING) << "Service not in profile: " << service_path.value();
   }
@@ skipping 33 matching lines @@
     const std::string& name,
     const std::string& type,
     const std::string& state,
     const std::string& ipconfig_path,
     bool add_to_visible_list,
     bool add_to_watch_list) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddManagerService(service_path, add_to_visible_list, add_to_watch_list);
 
   base::DictionaryValue* properties =
-      GetModifiableServiceProperties(service_path);
+      GetModifiableServiceProperties(service_path, true);
+  connect_behavior_.erase(service_path);
   properties->SetWithoutPathExpansion(
       flimflam::kSSIDProperty,
       base::Value::CreateStringValue(service_path));
   properties->SetWithoutPathExpansion(
       flimflam::kNameProperty,
       base::Value::CreateStringValue(name));
   properties->SetWithoutPathExpansion(
       flimflam::kTypeProperty,
       base::Value::CreateStringValue(type));
   properties->SetWithoutPathExpansion(
       flimflam::kStateProperty,
       base::Value::CreateStringValue(state));
   if (!ipconfig_path.empty())
     properties->SetWithoutPathExpansion(
         shill::kIPConfigProperty,
         base::Value::CreateStringValue(ipconfig_path));
 }
 
 void ShillServiceClientStub::RemoveService(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       RemoveManagerService(service_path);
 
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
+  connect_behavior_.erase(service_path);
 }
 
 bool ShillServiceClientStub::SetServiceProperty(const std::string& service_path,
                                                 const std::string& property,
                                                 const base::Value& value) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path, &dict))
     return false;
 
   VLOG(1) << "Service.SetProperty: " << property << " = " << value
@@ skipping 38 matching lines @@
   const base::DictionaryValue* properties = NULL;
   stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties);
   return properties;
 }
 
 void ShillServiceClientStub::ClearServices() {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       ClearManagerServices();
 
   stub_services_.Clear();
+  connect_behavior_.clear();
 }
 
-void ShillServiceClientStub::AddDefaultServices() {
-  const bool add_to_visible = true;
-  const bool add_to_watchlist = true;
-
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kDisableStubEthernet)) {
-    AddService("eth1", "eth1",
-               flimflam::kTypeEthernet,
-               flimflam::kStateOnline,
-               add_to_visible, add_to_watchlist);
-  }
-
-  // Wifi
-
-  AddService("wifi1", "wifi1",
-             flimflam::kTypeWifi,
-             flimflam::kStateOnline,
-             add_to_visible, add_to_watchlist);
-  SetServiceProperty("wifi1",
-                     flimflam::kSecurityProperty,
-                     base::StringValue(flimflam::kSecurityWep));
-
-  AddService("wifi2", "wifi2_PSK",
-             flimflam::kTypeWifi,
-             flimflam::kStateIdle,
-             add_to_visible, add_to_watchlist);
-  SetServiceProperty("wifi2",
-                     flimflam::kSecurityProperty,
-                     base::StringValue(flimflam::kSecurityPsk));
-  base::FundamentalValue strength_value(80);
-  SetServiceProperty("wifi2",
-                     flimflam::kSignalStrengthProperty,
-                     strength_value);
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          chromeos::switches::kEnableStubPortalledWifi)) {
-    AddService(kStubPortalledWifiPath, kStubPortalledWifiName,
-               flimflam::kTypeWifi,
-               flimflam::kStatePortal,
-               add_to_visible, add_to_watchlist);
-    SetServiceProperty(kStubPortalledWifiPath,
-                       flimflam::kSecurityProperty,
-                       base::StringValue(flimflam::kSecurityNone));
-  }
-
-  // Wimax
-
-  AddService("wimax1", "wimax1",
-             flimflam::kTypeWimax,
-             flimflam::kStateIdle,
-             add_to_visible, add_to_watchlist);
-  SetServiceProperty("wimax1",
-                     flimflam::kConnectableProperty,
-                     base::FundamentalValue(true));
-
-  // Cellular
-
-  AddService("cellular1", "cellular1",
-             flimflam::kTypeCellular,
-             flimflam::kStateIdle,
-             add_to_visible, add_to_watchlist);
-  base::StringValue technology_value(flimflam::kNetworkTechnologyGsm);
-  SetServiceProperty("cellular1",
-                     flimflam::kNetworkTechnologyProperty,
-                     technology_value);
-  SetServiceProperty("cellular1",
-                     flimflam::kActivationStateProperty,
-                     base::StringValue(flimflam::kActivationStateNotActivated));
-  SetServiceProperty("cellular1",
-                     flimflam::kRoamingStateProperty,
-                     base::StringValue(flimflam::kRoamingStateHome));
-
-  // VPN
-
-  // Set the "Provider" dictionary properties. Note: when setting these in
-  // Shill, "Provider.Type", etc keys are used, but when reading the values
-  // "Provider" . "Type", etc keys are used. Here we are setting the values
-  // that will be read (by the UI, tests, etc).
-  base::DictionaryValue provider_properties;
-  provider_properties.SetString(flimflam::kTypeProperty,
-                                flimflam::kProviderOpenVpn);
-  provider_properties.SetString(flimflam::kHostProperty, "vpn_host");
-
-  AddService("vpn1", "vpn1",
-             flimflam::kTypeVPN,
-             flimflam::kStateOnline,
-             add_to_visible, add_to_watchlist);
-  SetServiceProperty("vpn1",
-                     flimflam::kProviderProperty,
-                     provider_properties);
-
-  AddService("vpn2", "vpn2",
-             flimflam::kTypeVPN,
-             flimflam::kStateOffline,
-             add_to_visible, add_to_watchlist);
-  SetServiceProperty("vpn2",
-                     flimflam::kProviderProperty,
-                     provider_properties);
-
-  DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
-      AddService(ShillProfileClientStub::kSharedProfilePath, "wifi2");
-
-  DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
-      SortManagerServices();
+void ShillServiceClientStub::SetConnectBehavior(const std::string& service_path,
+                                const base::Closure& behavior) {
+  connect_behavior_[service_path] = behavior;
 }
 
 void ShillServiceClientStub::NotifyObserversPropertyChanged(
     const dbus::ObjectPath& service_path,
     const std::string& property) {
   base::DictionaryValue* dict = NULL;
   std::string path = service_path.value();
   if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &dict)) {
     LOG(ERROR) << "Notify for unknown service: " << path;
     return;
   }
   base::Value* value = NULL;
   if (!dict->GetWithoutPathExpansion(property, &value)) {
     LOG(ERROR) << "Notify for unknown property: "
                << path << " : " << property;
     return;
   }
   FOR_EACH_OBSERVER(ShillPropertyChangedObserver,
                     GetObserverList(service_path),
                     OnPropertyChanged(property, *value));
 }
 
 base::DictionaryValue* ShillServiceClientStub::GetModifiableServiceProperties(
-    const std::string& service_path) {
+    const std::string& service_path, bool create_if_missing) {
   base::DictionaryValue* properties = NULL;
-  if (!stub_services_.GetDictionaryWithoutPathExpansion(
-      service_path, &properties)) {
+  if (!stub_services_.GetDictionaryWithoutPathExpansion(service_path,
+                                                        &properties) &&
+      create_if_missing) {
     properties = new base::DictionaryValue;
     stub_services_.Set(service_path, properties);
   }
   return properties;
 }
 
 ShillServiceClientStub::PropertyObserverList&
 ShillServiceClientStub::GetObserverList(const dbus::ObjectPath& device_path) {
   std::map<dbus::ObjectPath, PropertyObserverList*>::iterator iter =
       observer_list_.find(device_path);
@@ skipping 42 matching lines @@
               base::StringValue(flimflam::kActivationStateActivated),
               base::Bind(&base::DoNothing),
               error_callback);
   SetProperty(service_path,
               flimflam::kConnectableProperty,
               base::FundamentalValue(true),
               base::Bind(&base::DoNothing),
               error_callback);
 }
 
+void ShillServiceClientStub::ContinueConnect(
+    const std::string& service_path) {
+  VLOG(1) << "ShillServiceClientStub::ContinueConnect: " << service_path;
+  base::DictionaryValue* service_properties = NULL;
+  if (!stub_services_.GetDictionary(service_path, &service_properties)) {
+    LOG(ERROR) << "Service not found: " << service_path;
+    return;
+  }
+
+  if (ContainsKey(connect_behavior_, service_path)) {
+    const base::Closure& custom_connect_behavior =
+        connect_behavior_[service_path];
+    custom_connect_behavior.Run();
+    return;
+  }
+
+  // No custom connect behavior set, continue with the default connect behavior.
+  std::string passphrase;
+  service_properties->GetStringWithoutPathExpansion(
+      flimflam::kPassphraseProperty, &passphrase);
+  if (passphrase == "failure") {
+    // Simulate a password failure.
+    SetServiceProperty(service_path,
+                       flimflam::kStateProperty,
+                       base::StringValue(flimflam::kStateFailure));
+    base::MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(
+            base::IgnoreResult(&ShillServiceClientStub::SetServiceProperty),
+            weak_ptr_factory_.GetWeakPtr(),
+            service_path,
+            flimflam::kErrorProperty,
+            base::StringValue(flimflam::kErrorBadPassphrase)));
+  } else {
+    // Set Online.
+    SetServiceProperty(service_path,
+                       flimflam::kStateProperty,
+                       base::StringValue(flimflam::kStateOnline));
+  }
+}
+
 }  // namespace chromeos