Clean up shill fake implementations

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/strings/string_number_conversions.h"
@@ skipping 82 matching lines @@
                            shill::kStateProperty,
                            base::StringValue(shill::kStatePortal));
 }
 
 const char* kTechnologyUnavailable = "unavailable";
 const char* kNetworkActivated = "activated";
 const char* kNetworkDisabled = "disabled";
 
 }  // namespace
 
+// static
+const char FakeShillManagerClient::kFakeEthernetNetworkPath[] = "/service/eth1";
+
 FakeShillManagerClient::FakeShillManagerClient()
     : interactive_delay_(0),
       weak_ptr_factory_(this) {
   ParseCommandLineSwitch();
 }
 
 FakeShillManagerClient::~FakeShillManagerClient() {}
 
 // ShillManagerClient overrides.
 
@@ skipping 24 matching lines @@
       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) {
+  DVLOG(2) << "SetProperty: " << name;
   stub_properties_.SetWithoutPathExpansion(name, value.DeepCopy());
   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;
@@ skipping 91 matching lines @@
   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 /* guid */,
                                            guid /* name */,
                                            type,
                                            shill::kStateIdle, ipconfig_path,
-                                           true /* visible */,
-                                           true /* watch */);
+                                           true /* visible */);
     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()) {
@@ skipping 167 matching lines @@
   stub_properties_.Clear();
 }
 
 void FakeShillManagerClient::SetManagerProperty(const std::string& key,
                                                 const base::Value& value) {
   SetProperty(key, value,
               base::Bind(&base::DoNothing), base::Bind(&LogErrorCallback));
 }
 
 void FakeShillManagerClient::AddManagerService(const std::string& service_path,
-                                               bool add_to_visible_list,
-                                               bool add_to_watch_list) {
+                                               bool add_to_visible_list) {
+  DVLOG(2) << "AddManagerService: " << service_path
+           << " Visible: " << add_to_visible_list;
   // Always add to ServiceCompleteListProperty.
   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);
   }
-  if (add_to_watch_list)
-    AddServiceToWatchList(service_path);
 }
 
 void FakeShillManagerClient::RemoveManagerService(
     const std::string& service_path,
     bool remove_from_complete_list) {
+  DVLOG(2) << "RemoveManagerService: " << service_path;
   base::StringValue service_path_value(service_path);
   if (remove_from_complete_list) {
     GetListProperty(shill::kServiceCompleteListProperty)->Remove(
         service_path_value, NULL);
   }
   if (GetListProperty(shill::kServicesProperty)->Remove(
       service_path_value, NULL)) {
     CallNotifyObserversPropertyChanged(shill::kServicesProperty);
   }
-  if (GetListProperty(shill::kServiceWatchListProperty)->Remove(
-      service_path_value, NULL)) {
-    CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
-  }
 }
 
 void FakeShillManagerClient::ClearManagerServices() {
+  DVLOG(1) << "ClearManagerServices";
   GetListProperty(shill::kServiceCompleteListProperty)->Clear();
   GetListProperty(shill::kServicesProperty)->Clear();
-  GetListProperty(shill::kServiceWatchListProperty)->Clear();
   CallNotifyObserversPropertyChanged(shill::kServicesProperty);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
 }
 
 void FakeShillManagerClient::ServiceStateChanged(
     const std::string& service_path,
     const std::string& state) {
   if (service_path == default_service_ && !IsConnectedState(state)) {
     // Default service is no longer connected; clear.
     default_service_.clear();
     base::StringValue default_service_value(default_service_);
     SetManagerProperty(shill::kDefaultServiceProperty, default_service_value);
   }
 }
 
 void FakeShillManagerClient::SortManagerServices() {
+  DVLOG(1) << "SortManagerServices";
   SortServiceList(shill::kServicesProperty);
   SortServiceList(shill::kServiceCompleteListProperty);
 }
 
 void FakeShillManagerClient::SortServiceList(const std::string& property) {
   static const char* ordered_types[] = {
     shill::kTypeEthernet,
     shill::kTypeWifi,
     shill::kTypeCellular,
     shill::kTypeWimax,
     shill::kTypeVPN
   };
 
   base::ListValue* service_list = GetListProperty(property);
+  scoped_ptr<base::ListValue> prev_service_list(service_list->DeepCopy());
   std::vector<std::string> active_services;
   std::vector<std::string> inactive_services;
   if (service_list && !service_list->empty()) {
     for (size_t i = 0; i < arraysize(ordered_types); ++i) {
       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]);
   }
 
   if (property != shill::kServicesProperty)
     return;
 
-  CallNotifyObserversPropertyChanged(property);
+  if (!service_list->Equals(prev_service_list.get()))
+    CallNotifyObserversPropertyChanged(shill::kServicesProperty);
 
   // Set the first active service as the Default service.
   std::string new_default_service;
   if (!active_services.empty()) {
     ShillServiceClient::TestInterface* service_client =
         DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
     std::string service_path = active_services[0];
     const base::DictionaryValue* properties =
         service_client->GetServiceProperties(service_path);
     if (!properties) {
@@ skipping 33 matching lines @@
       dbus_manager->GetShillDeviceClient()->GetTestInterface();
   DCHECK(devices);
   ShillIPConfigClient::TestInterface* ip_configs =
       dbus_manager->GetShillIPConfigClient()->GetTestInterface();
   DCHECK(ip_configs);
 
   const std::string shared_profile = ShillProfileClient::GetSharedProfilePath();
   profiles->AddProfile(shared_profile, std::string());
 
   const bool add_to_visible = true;
-  const bool add_to_watchlist = true;
 
   bool enabled;
   std::string state;
 
   // IPConfigs
   base::DictionaryValue ipconfig_v4_dictionary;
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
       shill::kAddressProperty, "0.0.0.0");
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
       shill::kGatewayProperty, "0.0.0.1");
@@ skipping 17 matching lines @@
         "/device/eth1", shill::kTypeEthernet, "stub_eth_device1");
     devices->SetDeviceProperty("/device/eth1",
                                shill::kAddressProperty,
                                base::StringValue("0123456789ab"));
     base::ListValue eth_ip_configs;
     eth_ip_configs.AppendString("ipconfig_v4_path");
     eth_ip_configs.AppendString("ipconfig_v6_path");
     devices->SetDeviceProperty("/device/eth1",
                                shill::kIPConfigsProperty,
                                eth_ip_configs);
-    services->AddService("eth1", "eth1",
+    services->AddService(kFakeEthernetNetworkPath, "eth1",
                          shill::kTypeEthernet,
                          state,
-                         add_to_visible, add_to_watchlist);
-    profiles->AddService(shared_profile, "eth1");
+                         add_to_visible);
+    profiles->AddService(shared_profile, kFakeEthernetNetworkPath);
   }
 
   // Wifi
   state = GetInitialStateForType(shill::kTypeWifi, &enabled);
   if (state != kTechnologyUnavailable) {
     bool portaled = false;
     if (state == shill::kStatePortal) {
       portaled = true;
       state = shill::kStateIdle;
     }
     AddTechnology(shill::kTypeWifi, enabled);
     devices->AddDevice("/device/wifi1", shill::kTypeWifi, "stub_wifi_device1");
     devices->SetDeviceProperty("/device/wifi1",
                                shill::kAddressProperty,
                                base::StringValue("23456789abc"));
     base::ListValue wifi_ip_configs;
     wifi_ip_configs.AppendString("ipconfig_v4_path");
     wifi_ip_configs.AppendString("ipconfig_v6_path");
     devices->SetDeviceProperty("/device/wifi1",
                                shill::kIPConfigsProperty,
                                wifi_ip_configs);
 
-    services->AddService("wifi1",
+    services->AddService("/service/wifi1",
                          "wifi1",
                          shill::kTypeWifi,
                          state,
-                         add_to_visible, add_to_watchlist);
-    services->SetServiceProperty("wifi1",
+                         add_to_visible);
+    services->SetServiceProperty("/service/wifi1",
                                  shill::kSecurityProperty,
                                  base::StringValue(shill::kSecurityWep));
-    profiles->AddService(shared_profile, "wifi1");
+    profiles->AddService(shared_profile, "/service/wifi1");
 
-    services->AddService("wifi2",
+    services->AddService("/service/wifi2",
                          "wifi2_PSK",
                          shill::kTypeWifi,
                          shill::kStateIdle,
-                         add_to_visible, add_to_watchlist);
-    services->SetServiceProperty("wifi2",
+                         add_to_visible);
+    services->SetServiceProperty("/service/wifi2",
                                  shill::kSecurityProperty,
                                  base::StringValue(shill::kSecurityPsk));
 
     base::FundamentalValue strength_value(80);
     services->SetServiceProperty(
-        "wifi2", shill::kSignalStrengthProperty, strength_value);
-    profiles->AddService(shared_profile, "wifi2");
+        "/service/wifi2", shill::kSignalStrengthProperty, strength_value);
+    profiles->AddService(shared_profile, "/service/wifi2");
 
     if (portaled) {
-      const std::string kPortaledWifiPath = "portaled_wifi";
+      const std::string kPortaledWifiPath = "/service/portaled_wifi";
       services->AddService(kPortaledWifiPath,
                            "Portaled Wifi",
                            shill::kTypeWifi,
                            shill::kStatePortal,
-                           add_to_visible, add_to_watchlist);
+                           add_to_visible);
       services->SetServiceProperty(kPortaledWifiPath,
                                    shill::kSecurityProperty,
                                    base::StringValue(shill::kSecurityNone));
       services->SetConnectBehavior(kPortaledWifiPath,
                                    base::Bind(&UpdatePortaledWifiState,
                                               "portaled_wifi"));
       services->SetServiceProperty(kPortaledWifiPath,
                                    shill::kConnectableProperty,
                                    base::FundamentalValue(true));
       profiles->AddService(shared_profile, kPortaledWifiPath);
     }
   }
 
   // Wimax
   state = GetInitialStateForType(shill::kTypeWimax, &enabled);
   if (state != kTechnologyUnavailable) {
     AddTechnology(shill::kTypeWimax, enabled);
     devices->AddDevice(
         "/device/wimax1", shill::kTypeWimax, "stub_wimax_device1");
 
-    services->AddService("wimax1",
+    services->AddService("/service/wimax1",
                          "wimax1",
                          shill::kTypeWimax,
                          state,
-                         add_to_visible, add_to_watchlist);
-    services->SetServiceProperty(
-        "wimax1", shill::kConnectableProperty, base::FundamentalValue(true));
+                         add_to_visible);
+    services->SetServiceProperty("/service/wimax1",
+                                 shill::kConnectableProperty,
+                                 base::FundamentalValue(true));
   }
 
   // Cellular
   state = GetInitialStateForType(shill::kTypeCellular, &enabled);
   if (state != kTechnologyUnavailable) {
     bool activated = false;
     if (state == kNetworkActivated) {
       activated = true;
       state = shill::kStateIdle;
     }
     AddTechnology(shill::kTypeCellular, enabled);
     devices->AddDevice(
         "/device/cellular1", shill::kTypeCellular, "stub_cellular_device1");
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kCarrierProperty,
                                base::StringValue(shill::kCarrierSprint));
 
-    services->AddService("cellular1",
+    services->AddService("/service/cellular1",
                          "cellular1",
                          shill::kTypeCellular,
                          state,
-                         add_to_visible, add_to_watchlist);
+                         add_to_visible);
     base::StringValue technology_value(shill::kNetworkTechnologyGsm);
-    services->SetServiceProperty(
-        "cellular1", shill::kNetworkTechnologyProperty, technology_value);
+    services->SetServiceProperty("/service/cellular1",
+                                 shill::kNetworkTechnologyProperty,
+                                 technology_value);
 
     if (activated) {
       services->SetServiceProperty(
-          "cellular1",
+          "/service/cellular1",
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateActivated));
-      services->SetServiceProperty("cellular1",
+      services->SetServiceProperty("/service/cellular1",
                                    shill::kConnectableProperty,
                                    base::FundamentalValue(true));
     } else {
       services->SetServiceProperty(
-          "cellular1",
+          "/service/cellular1",
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateNotActivated));
     }
 
-    services->SetServiceProperty("cellular1",
+    services->SetServiceProperty("/service/cellular1",
                                  shill::kRoamingStateProperty,
                                  base::StringValue(shill::kRoamingStateHome));
   }
 
   // VPN
   state = GetInitialStateForType(shill::kTypeVPN, &enabled);
   if (state != kTechnologyUnavailable) {
     // 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(shill::kTypeProperty,
                                   shill::kProviderOpenVpn);
     provider_properties.SetString(shill::kHostProperty, "vpn_host");
 
-    services->AddService("vpn1",
+    services->AddService("/service/vpn1",
                          "vpn1",
                          shill::kTypeVPN,
                          state,
-                         add_to_visible, add_to_watchlist);
+                         add_to_visible);
     services->SetServiceProperty(
-        "vpn1", shill::kProviderProperty, provider_properties);
-    profiles->AddService(shared_profile, "vpn1");
+        "/service/vpn1", shill::kProviderProperty, provider_properties);
+    profiles->AddService(shared_profile, "/service/vpn1");
 
-    services->AddService("vpn2",
+    services->AddService("/service/vpn2",
                          "vpn2",
                          shill::kTypeVPN,
                          shill::kStateIdle,
-                         add_to_visible, add_to_watchlist);
+                         add_to_visible);
     services->SetServiceProperty(
-        "vpn2", shill::kProviderProperty, provider_properties);
+        "/service/vpn2", shill::kProviderProperty, provider_properties);
   }
 
   SortManagerServices();
 }
 
 // Private methods
 
-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);
-}
-
 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) {
   // Avoid unnecessary delayed task if we have no observers (e.g. during
   // initial setup).
   if (!observer_list_.might_have_observers())
     return;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&FakeShillManagerClient::NotifyObserversPropertyChanged,
                  weak_ptr_factory_.GetWeakPtr(),
                  property));
 }
 
 void FakeShillManagerClient::NotifyObserversPropertyChanged(
     const std::string& property) {
-  if (property == shill::kServicesProperty ||
-      property == shill::kServiceWatchListProperty) {
+  DVLOG(1) << "NotifyObserversPropertyChanged: " << property;
+  if (property == shill::kServicesProperty) {
     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)) {
@@ skipping 46 matching lines @@
       GetListProperty(shill::kEnabledTechnologiesProperty);
   if (enabled)
     enabled_list->AppendIfNotPresent(new base::StringValue(type));
   else
     enabled_list->Remove(base::StringValue(type), NULL);
   CallNotifyObserversPropertyChanged(
       shill::kEnabledTechnologiesProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
   // May affect available services
   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();
@@ skipping 17 matching lines @@
 }
 
 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));
   }
+  DVLOG(2) << "ScanCompleted";
   CallNotifyObserversPropertyChanged(shill::kServicesProperty);
-  CallNotifyObserversPropertyChanged(shill::kServiceWatchListProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::ParseCommandLineSwitch() {
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (command_line->HasSwitch(switches::kShillStub)) {
     std::string option_str =
         command_line->GetSwitchValueASCII(switches::kShillStub);
     base::StringPairs string_pairs;
     base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
@@ skipping 99 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos