Improve functionality of FakeShillProfileClient

chromeos/dbus/fake_shill_profile_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_profile_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/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_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"
 
 namespace chromeos {
 
 struct FakeShillProfileClient::ProfileProperties {
-  base::DictionaryValue entries;
-  base::DictionaryValue properties;
+  base::DictionaryValue entries;  // Dictionary of Service Dictionaries
+  base::DictionaryValue properties;  // Dictionary of Profile properties
 };
 
 namespace {
 
 void PassDictionary(
     const ShillProfileClient::DictionaryValueCallbackWithoutStatus& callback,
     const base::DictionaryValue* dictionary) {
   callback.Run(*dictionary);
 }
 
@@ skipping 99 matching lines @@
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddProfile(profile_path);
 }
 
 void FakeShillProfileClient::AddEntry(const std::string& profile_path,
                                       const std::string& entry_path,
                                       const base::DictionaryValue& properties) {
   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
                                           ErrorCallback());
   DCHECK(profile);
-  profile->entries.SetWithoutPathExpansion(entry_path,
-                                           properties.DeepCopy());
+  profile->entries.SetWithoutPathExpansion(entry_path, properties.DeepCopy());
   DBusThreadManager::Get()->GetShillManagerClient()->GetTestInterface()->
       AddManagerService(entry_path, false /* visible */, false /* watch */);
 }
 
 bool FakeShillProfileClient::AddService(const std::string& profile_path,
                                         const std::string& service_path) {
   ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
                                           ErrorCallback());
   if (!profile) {
-    LOG(ERROR) << "No matching profile: " << profile_path;
+    LOG(ERROR) << "AddService: No matching profile: " << profile_path;
     return false;
   }
+  if (profile->entries.HasKey(service_path)) {
+    LOG(ERROR) << "AddService: Profile: " << profile_path
+               << " already contains Service: " << service_path;
+    return false;
+  }
+  return AddOrUpdateServiceImpl(profile_path, service_path, profile);
+}
 
+bool FakeShillProfileClient::UpdateService(const std::string& profile_path,
+                                           const std::string& service_path) {
+  ProfileProperties* profile = GetProfile(dbus::ObjectPath(profile_path),
+                                          ErrorCallback());
+  if (!profile) {
+    LOG(ERROR) << "UpdateService: No matching profile: " << profile_path;
+    return false;
+  }
+  if (!profile->entries.HasKey(service_path)) {
+    LOG(ERROR) << "UpdateService: Profile: " << profile_path
+               << " does not contain Service: " << service_path;
+    return false;
+  }
+  return AddOrUpdateServiceImpl(profile_path, service_path, profile);
+}
+
+bool FakeShillProfileClient::AddOrUpdateServiceImpl(
+    const std::string& profile_path,
+    const std::string& service_path,
+    ProfileProperties* profile) {
   ShillServiceClient::TestInterface* service_test =
       DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface();
   const base::DictionaryValue* service_properties =
       service_test->GetServiceProperties(service_path);
   if (!service_properties) {
     LOG(ERROR) << "No matching service: " << service_path;
     return false;
   }
   std::string service_profile_path;
   service_properties->GetStringWithoutPathExpansion(shill::kProfileProperty,
                                                     &service_profile_path);
-  if (!service_profile_path.empty() && service_profile_path != profile_path) {
+  if (service_profile_path.empty()) {
+    base::StringValue profile_path_value(profile_path);
+    service_test->SetServiceProperty(service_path,
+                                     shill::kProfileProperty,
+                                     profile_path_value);
+  } else if (service_profile_path != profile_path) {
     LOG(ERROR) << "Service has non matching profile path: "
                << service_profile_path;
     return false;
   }
 
-  base::StringValue profile_path_value(profile_path);
-  service_test->SetServiceProperty(service_path,
-                                   shill::kProfileProperty,
-                                   profile_path_value);
   profile->entries.SetWithoutPathExpansion(service_path,
                                            service_properties->DeepCopy());
   return true;
 }
 
 void FakeShillProfileClient::GetProfilePaths(
     std::vector<std::string>* profiles) {
   for (ProfileMap::iterator iter = profiles_.begin();
        iter != profiles_.end(); ++iter) {
     profiles->push_back(iter->first);
   }
 }
 
+bool FakeShillProfileClient::GetService(const std::string& service_path,
+                                        std::string* profile_path,
+                                        base::DictionaryValue* properties) {
+  properties->Clear();
+  for (ProfileMap::const_iterator iter = profiles_.begin();
+       iter != profiles_.end(); ++iter) {
+    const ProfileProperties* profile = iter->second;
+    const base::DictionaryValue* entry;
+    if (!profile->entries.GetDictionaryWithoutPathExpansion(
+            service_path, &entry)) {
+      continue;
+    }
+    *profile_path = iter->first;
+    properties->MergeDictionary(entry);
+    return true;
+  }
+  return false;
+}
+
+void FakeShillProfileClient::ClearProfiles() {
+  STLDeleteValues(&profiles_);
+}
+
 FakeShillProfileClient::ProfileProperties* FakeShillProfileClient::GetProfile(
     const dbus::ObjectPath& profile_path,
     const ErrorCallback& error_callback) {
   ProfileMap::const_iterator found = profiles_.find(profile_path.value());
   if (found == profiles_.end()) {
     if (!error_callback.is_null())
       error_callback.Run("Error.InvalidProfile", "Invalid profile");
     return NULL;
   }
 
   return found->second;
 }
 
 }  // namespace chromeos