Improve network stub behavior

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"
 #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_property_changed_observer.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_proxy.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
@@ skipping 217 matching lines @@
 
 ShillServiceClient::TestInterface* ShillServiceClientStub::GetTestInterface() {
   return this;
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void ShillServiceClientStub::AddService(const std::string& service_path,
                                         const std::string& name,
                                         const std::string& type,
-                                        const std::string& state) {
-  base::DictionaryValue* properties = GetServiceProperties(service_path);
+                                        const std::string& state,
+                                        bool add_to_watch_list) {
+  DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
+      AddService(service_path, add_to_watch_list);
+
+  base::DictionaryValue* properties =
+      GetModifiableServiceProperties(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));
 }
 
 void ShillServiceClientStub::RemoveService(const std::string& service_path) {
+  DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
+      RemoveService(service_path);
+
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
 }
 
 void ShillServiceClientStub::SetServiceProperty(const std::string& service_path,
                                                 const std::string& property,
                                                 const base::Value& value) {
   SetProperty(dbus::ObjectPath(service_path), property, value,
               base::Bind(&base::DoNothing),
               base::Bind(&ErrorFunction));
 }
 
+const base::DictionaryValue* ShillServiceClientStub::GetServiceProperties(
+    const std::string& service_path) const {
+  const base::DictionaryValue* properties = NULL;
+  stub_services_.GetDictionaryWithoutPathExpansion(service_path, &properties);
+  return properties;
+}
+
 void ShillServiceClientStub::ClearServices() {
   stub_services_.Clear();
 }
 
 void ShillServiceClientStub::SetDefaultProperties() {
-  // Add stub services. Note: names match Manager stub impl.
-  AddService("stub_ethernet", "eth0",
-             flimflam::kTypeEthernet,
-             flimflam::kStateOnline);
+  const bool add_to_watchlist = true;
+
+  if (!CommandLine::ForCurrentProcess()->HasSwitch(
+          chromeos::switches::kDisableStubEthernet)) {
+    AddService("stub_ethernet", "eth0",
+               flimflam::kTypeEthernet,
+               flimflam::kStateOnline,
+               add_to_watchlist);
+  }
 
   AddService("stub_wifi1", "wifi1",
              flimflam::kTypeWifi,
-             flimflam::kStateOnline);
+             flimflam::kStateOnline,
+             add_to_watchlist);
 
   AddService("stub_wifi2", "wifi2_PSK",
              flimflam::kTypeWifi,
-             flimflam::kStateIdle);
+             flimflam::kStateIdle,
+             add_to_watchlist);
   base::StringValue psk_value(flimflam::kSecurityPsk);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSecurityProperty,
                      psk_value);
   base::FundamentalValue strength_value(80);
   SetServiceProperty("stub_wifi2",
                      flimflam::kSignalStrengthProperty,
                      strength_value);
 
   AddService("stub_cellular1", "cellular1",
              flimflam::kTypeCellular,
-             flimflam::kStateIdle);
+             flimflam::kStateIdle,
+             add_to_watchlist);
   base::StringValue technology_value(flimflam::kNetworkTechnologyGsm);
   SetServiceProperty("stub_cellular1",
                      flimflam::kNetworkTechnologyProperty,
                      technology_value);
+  base::StringValue activation_value(flimflam::kActivationStateActivated);
+  SetServiceProperty("stub_cellular1",
+                     flimflam::kActivationStateProperty,
+                     activation_value);
 }
 
 void ShillServiceClientStub::PassStubServiceProperties(
     const dbus::ObjectPath& service_path,
     const DictionaryValueCallback& callback) {
   base::DictionaryValue* dict = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path.value(), &dict)) {
     base::DictionaryValue empty_dictionary;
     callback.Run(DBUS_METHOD_CALL_FAILURE, empty_dictionary);
@@ skipping 15 matching lines @@
   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::GetServiceProperties(
+base::DictionaryValue* ShillServiceClientStub::GetModifiableServiceProperties(
     const std::string& service_path) {
   base::DictionaryValue* properties = NULL;
   if (!stub_services_.GetDictionaryWithoutPathExpansion(
       service_path, &properties)) {
     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);
   if (iter != observer_list_.end())
     return *(iter->second);
   PropertyObserverList* observer_list = new PropertyObserverList();
   observer_list_[device_path] = observer_list;
   return *observer_list;
 }
 
 }  // namespace chromeos