Improve functionality of FakeShillProfileClient

chromeos/dbus/fake_shill_service_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_service_client.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.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/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_device_client.h"
 #include "chromeos/dbus/shill_manager_client.h"
+#include "chromeos/dbus/shill_profile_client.h"
 #include "chromeos/dbus/shill_property_changed_observer.h"
 #include "chromeos/network/shill_property_util.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 276 matching lines @@
 }
 
 // ShillServiceClient::TestInterface overrides.
 
 void FakeShillServiceClient::AddService(const std::string& service_path,
                                         const std::string& name,
                                         const std::string& type,
                                         const std::string& state,
                                         bool add_to_visible_list,
                                         bool add_to_watch_list) {
-  AddServiceWithIPConfig(service_path, name, type, state, "",
+  AddServiceWithIPConfig(service_path, "" /* guid */, name,
+                         type, state, "" /* ipconfig_path */,
                          add_to_visible_list, add_to_watch_list);
 }
 
 void FakeShillServiceClient::AddServiceWithIPConfig(
     const std::string& service_path,
+    const std::string& guid,
     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);
   std::string device_path =
       DBusThreadManager::Get()->GetShillDeviceClient()->GetTestInterface()->
       GetDevicePathForType(type);
 
   base::DictionaryValue* properties =
       GetModifiableServiceProperties(service_path, true);
   connect_behavior_.erase(service_path);
+
+  std::string profile_path;
+  base::DictionaryValue profile_properties;
+  if (DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
+      GetService(service_path, &profile_path, &profile_properties)) {
+    properties->SetWithoutPathExpansion(
+        shill::kProfileProperty,
+        new base::StringValue(profile_path));
+  }
+
+  // If |guid| is provided, set Service.GUID to that. Otherwise if a GUID is
+  // stored in a profile entry, use that. Otherwise leave it blank. Shill does
+  // not enforce a valid guid, we do that at the NetworkStateHandler layer.
+  std::string guid_to_set = guid;
+  if (guid_to_set.empty()) {
+    profile_properties.GetStringWithoutPathExpansion(
+        shill::kGuidProperty, &guid_to_set);
+  }
+  if (!guid_to_set.empty()) {
+    properties->SetWithoutPathExpansion(shill::kGuidProperty,
+                                        new base::StringValue(guid_to_set));
+  }
   shill_property_util::SetSSID(name, properties);
   properties->SetWithoutPathExpansion(
       shill::kNameProperty,
-      base::Value::CreateStringValue(name));
+      new base::StringValue(name));
   properties->SetWithoutPathExpansion(
       shill::kDeviceProperty,
-      base::Value::CreateStringValue(device_path));
+      new base::StringValue(device_path));
   properties->SetWithoutPathExpansion(
       shill::kTypeProperty,
-      base::Value::CreateStringValue(type));
+      new base::StringValue(type));
   properties->SetWithoutPathExpansion(
       shill::kStateProperty,
-      base::Value::CreateStringValue(state));
+      new base::StringValue(state));
   if (!ipconfig_path.empty()) {
     properties->SetWithoutPathExpansion(
         shill::kIPConfigProperty,
-        base::Value::CreateStringValue(ipconfig_path));
+        new base::StringValue(ipconfig_path));
+  }
+  if (type == shill::kTypeWifi) {
+    properties->SetWithoutPathExpansion(
+        shill::kSecurityProperty,
+        new base::StringValue(shill::kSecurityNone));
   }
 
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       SortManagerServices();
+
+  if (!profile_path.empty()) {
+    DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
+        UpdateService(profile_path, service_path);
+  }
 }
 
 void FakeShillServiceClient::RemoveService(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       RemoveManagerService(service_path);
 
   stub_services_.RemoveWithoutPathExpansion(service_path, NULL);
   connect_behavior_.erase(service_path);
 }
 
@@ skipping 19 matching lines @@
     provider->SetWithoutPathExpansion(property, value.DeepCopy());
     new_properties.SetWithoutPathExpansion(shill::kProviderProperty, provider);
     changed_property = shill::kProviderProperty;
   } else {
     new_properties.SetWithoutPathExpansion(property, value.DeepCopy());
     changed_property = property;
   }
 
   dict->MergeDictionary(&new_properties);
 
+  // Add or update the profile entry.
+  if (property == shill::kProfileProperty) {
+    std::string profile_path;
+    if (value.GetAsString(&profile_path)) {
+      DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
+          AddService(profile_path, service_path);
+    } else {
+      LOG(ERROR) << "Profile value is not a String!";
+    }
+  } else {
+    std::string profile_path;
+    if (dict->GetStringWithoutPathExpansion(
+            shill::kProfileProperty, &profile_path) && !profile_path.empty()) {
+      DBusThreadManager::Get()->GetShillProfileClient()->GetTestInterface()->
+          UpdateService(profile_path, service_path);
+    }
+  }
+
   // Notify the Manager if the state changed (affects DefaultService).
   if (property == shill::kStateProperty) {
     std::string state;
     value.GetAsString(&state);
     DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
         ServiceStateChanged(service_path, state);
   }
 
   // If the State changes, the sort order of Services may change and the
   // DefaultService property may change.
@@ skipping 93 matching lines @@
     base::DictionaryValue* properties;
     if (!stub_services_.GetDictionaryWithoutPathExpansion(path, &properties))
       NOTREACHED();
 
     std::string type;
     properties->GetString(shill::kTypeProperty, &type);
     if (type != service_type)
       continue;
     properties->SetWithoutPathExpansion(
         shill::kStateProperty,
-        base::Value::CreateStringValue(shill::kStateIdle));
+        new base::StringValue(shill::kStateIdle));
   }
 }
 
 void FakeShillServiceClient::SetCellularActivated(
     const dbus::ObjectPath& service_path,
     const ErrorCallback& error_callback) {
   SetProperty(service_path,
               shill::kActivationStateProperty,
               base::StringValue(shill::kActivationStateActivated),
               base::Bind(&base::DoNothing),
@@ skipping 40 matching lines @@
             base::StringValue(shill::kErrorBadPassphrase)));
   } else {
     // Set Online.
     SetServiceProperty(service_path,
                        shill::kStateProperty,
                        base::StringValue(shill::kStateOnline));
   }
 }
 
 }  // namespace chromeos