Prevent networkingPrivate.forgetNetwork from removing shared configs

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/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.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 {
+  std::string path;               // Profile path
   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 84 matching lines @@
 
 ShillProfileClient::TestInterface* FakeShillProfileClient::GetTestInterface() {
   return this;
 }
 
 void FakeShillProfileClient::AddProfile(const std::string& profile_path,
                                         const std::string& userhash) {
   if (GetProfile(dbus::ObjectPath(profile_path), ErrorCallback()))
     return;
 
-  std::unique_ptr<ProfileProperties> profile =
-      base::MakeUnique<ProfileProperties>();
+  // If adding a shared profile, make sure there are no user profiles currently
+  // on the stack - note that it's enough to check the top of the stack only.
+  if (profile_path == GetSharedProfilePath()) {
+    if (!(profiles_.empty() ||
+          profiles_.back()->path == GetSharedProfilePath())) {
+      NOTREACHED() << "Adding shared profile when a user profile exists.";
+      return;
+    }
+  }

[stevenjb, 2017/03/30 17:33:13]

nit: We shouldn't need to support multiple shared profiles either, so this could
just be:
CHECK(profile_path != GetSharedProfilePath() || profiles_.empty()) <<
  "The shared profile must be added first.";

[tbarzic, 2017/03/30 18:00:05]

Done.

+
+  auto profile = base::MakeUnique<ProfileProperties>();
   profile->properties.SetStringWithoutPathExpansion(shill::kUserHashProperty,
                                                     userhash);
-  profiles_[profile_path] = std::move(profile);
+  profile->path = profile_path;
+  profiles_.emplace_back(std::move(profile));
+
   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);
@@ skipping 59 matching lines @@
     return false;
   }
 
   profile->entries.SetWithoutPathExpansion(service_path,
                                            service_properties->DeepCopy());
   return true;
 }
 
 void FakeShillProfileClient::GetProfilePaths(
     std::vector<std::string>* profiles) {
-  for (auto iter = profiles_.begin(); iter != profiles_.end(); ++iter)
-    profiles->push_back(iter->first);
+  for (const auto& profile : profiles_)
+    profiles->push_back(profile->path);
+}
+
+void FakeShillProfileClient::GetProfilePathsContainingService(
+    const std::string& service_path,
+    std::vector<std::string>* profiles) {
+  for (const auto& profile : profiles_) {
+    if (GetServiceDataFromProfile(profile.get(), service_path, nullptr))
+      profiles->push_back(profile->path);
+  }
 }
 
 bool FakeShillProfileClient::GetService(const std::string& service_path,
                                         std::string* profile_path,
                                         base::DictionaryValue* properties) {
   properties->Clear();
-  for (auto iter = profiles_.begin(); iter != profiles_.end(); ++iter) {
-    const ProfileProperties* profile = iter->second.get();
-    const base::DictionaryValue* entry;
-    if (!profile->entries.GetDictionaryWithoutPathExpansion(
-            service_path, &entry)) {
-      continue;
+
+  bool found_profile = false;
+  for (const auto& profile : profiles_) {
+    if (GetServiceDataFromProfile(profile.get(), service_path, properties)) {
+      found_profile = true;
+      *profile_path = profile->path;
     }
-    *profile_path = iter->first;
-    properties->MergeDictionary(entry);
-    return true;
   }
-  return false;
+  return found_profile;
 }
 
 void FakeShillProfileClient::ClearProfiles() {
   profiles_.clear();
 }
 
 FakeShillProfileClient::ProfileProperties* FakeShillProfileClient::GetProfile(
     const dbus::ObjectPath& profile_path,
     const ErrorCallback& error_callback) {
-  auto found = profiles_.find(profile_path.value());
-  if (found == profiles_.end()) {
-    if (!error_callback.is_null())
-      error_callback.Run("Error.InvalidProfile", "Invalid profile");
-    return nullptr;
+  for (auto& profile : profiles_) {
+    if (profile->path == profile_path.value())
+      return profile.get();
+  }
+  if (!error_callback.is_null())
+    error_callback.Run("Error.InvalidProfile", "Invalid profile");
+  return nullptr;
+}
+
+bool FakeShillProfileClient::GetServiceDataFromProfile(
+    const FakeShillProfileClient::ProfileProperties* profile,
+    const std::string& service_path,
+    base::DictionaryValue* properties) {
+  const base::DictionaryValue* entry;
+  if (!profile->entries.GetDictionaryWithoutPathExpansion(service_path,
+                                                          &entry)) {
+    return false;
   }
 
-  return found->second.get();
+  if (properties)
+    properties->MergeDictionary(entry);
+
+  return true;
 }
 
 }  // namespace chromeos