Prevent networkingPrivate.forgetNetwork from removing shared configs

chromeos/network/network_configuration_handler.cc

 // Copyright (c) 2012 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/network/network_configuration_handler.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
@@ skipping 77 matching lines @@
                       const base::Closure& callback,
                       const network_handler::ErrorCallback& error_callback)
       : owner_(handler),
         service_path_(service_path),
         guid_(guid),
         source_(source),
         callback_(callback),
         error_callback_(error_callback),
         weak_ptr_factory_(this) {}
 
+  void RestrictToProfilePath(const std::string& profile_path) {
+    restrict_to_profile_path_ = profile_path;
+  }
+
   void Run() {
     DBusThreadManager::Get()
         ->GetShillServiceClient()
         ->GetLoadableProfileEntries(
             dbus::ObjectPath(service_path_),
             base::Bind(&ProfileEntryDeleter::GetProfileEntriesToDeleteCallback,
                        weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
@@ skipping 17 matching lines @@
       if (profile_path.empty() || entry_path.empty()) {
         NET_LOG(ERROR) << "Failed to parse Profile Entry: " << profile_path
                        << ": " << entry_path;
         continue;
       }
       if (profile_delete_entries_.count(profile_path) != 0) {
         NET_LOG(ERROR) << "Multiple Profile Entries: " << profile_path << ": "
                        << entry_path;
         continue;
       }
+
+      if (!restrict_to_profile_path_.empty() &&
+          profile_path != restrict_to_profile_path_) {
+        NET_LOG(DEBUG) << "Skip deleting Profile Entry: " << profile_path
+                       << ": " << entry_path << " - removal is restricted to "
+                       << restrict_to_profile_path_ << " profile";
+        continue;
+      }
+
       NET_LOG(DEBUG) << "Delete Profile Entry: " << profile_path << ": "
                      << entry_path;
       profile_delete_entries_[profile_path] = entry_path;
       DBusThreadManager::Get()->GetShillProfileClient()->DeleteEntry(
           dbus::ObjectPath(profile_path), entry_path,
           base::Bind(&ProfileEntryDeleter::ProfileEntryDeletedCallback,
                      weak_ptr_factory_.GetWeakPtr(), profile_path, entry_path),
           base::Bind(&ProfileEntryDeleter::ShillErrorCallback,
                      weak_ptr_factory_.GetWeakPtr(), profile_path, entry_path));
     }
+
+    RunCallbackIfDone();
   }
 
   void ProfileEntryDeletedCallback(const std::string& profile_path,
                                    const std::string& entry) {
     NET_LOG(DEBUG) << "Profile Entry Deleted: " << profile_path << ": "
                    << entry;
     profile_delete_entries_.erase(profile_path);
+
+    RunCallbackIfDone();
+  }
+
+  void RunCallbackIfDone() {
     if (!profile_delete_entries_.empty())
       return;
     // Run the callback if this is the last pending deletion.
     if (!callback_.is_null())
       callback_.Run();
     // ProfileEntryDeleterCompleted will delete this.
     owner_->ProfileEntryDeleterCompleted(service_path_, guid_, source_,
                                          true /* success */);
   }
 
   void ShillErrorCallback(const std::string& profile_path,
                           const std::string& entry,
                           const std::string& dbus_error_name,
                           const std::string& dbus_error_message) {
     // Any Shill Error triggers a failure / error.
     network_handler::ShillErrorCallbackFunction(
         "GetLoadableProfileEntries Failed", profile_path, error_callback_,
         dbus_error_name, dbus_error_message);
     // Delete this even if there are pending deletions; any callbacks will
     // safely become no-ops (by invalidating the WeakPtrs).
     owner_->ProfileEntryDeleterCompleted(service_path_, guid_, source_,
                                          false /* failed */);
   }
 
   NetworkConfigurationHandler* owner_;  // Unowned
   std::string service_path_;
+  // Non empty if the service has to be removed only from a single profile. This
+  // value is the profile path of the profile in question.
+  std::string restrict_to_profile_path_;
   std::string guid_;
   NetworkConfigurationObserver::Source source_;
   base::Closure callback_;
   network_handler::ErrorCallback error_callback_;
 
   // Map of pending profile entry deletions, indexed by profile path.
   std::map<std::string, std::string> profile_delete_entries_;
 
   base::WeakPtrFactory<ProfileEntryDeleter> weak_ptr_factory_;
 
@@ skipping 142 matching lines @@
                  base::Passed(&properties_copy), callback),
       base::Bind(&network_handler::ShillErrorCallbackFunction,
                  "Config.CreateConfiguration Failed", "", error_callback));
 }
 
 void NetworkConfigurationHandler::RemoveConfiguration(
     const std::string& service_path,
     NetworkConfigurationObserver::Source source,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
+  RemoveConfigurationFromProfile(service_path, "", source, callback,
+                                 error_callback);
+}
+
+void NetworkConfigurationHandler::RemoveConfigurationFromCurrentProfile(
+    const std::string& service_path,
+    NetworkConfigurationObserver::Source source,
+    const base::Closure& callback,
+    const network_handler::ErrorCallback& error_callback) {
+  const NetworkState* network_state =
+      network_state_handler_->GetNetworkState(service_path);
+
+  if (!network_state || network_state->profile_path().empty()) {
+    InvokeErrorCallback(service_path, error_callback, "NetworkNotConfigured");
+    return;
+  }
+  RemoveConfigurationFromProfile(service_path, network_state->profile_path(),
+                                 source, callback, error_callback);
+}
+
+void NetworkConfigurationHandler::RemoveConfigurationFromProfile(
+    const std::string& service_path,
+    const std::string& profile_path,
+    NetworkConfigurationObserver::Source source,
+    const base::Closure& callback,
+    const network_handler::ErrorCallback& error_callback) {
   // Service.Remove is not reliable. Instead, request the profile entries
   // for the service and remove each entry.
   if (base::ContainsKey(profile_entry_deleters_, service_path)) {
     InvokeErrorCallback(service_path, error_callback,
                         "RemoveConfigurationInProgress");
     return;
   }
 
   std::string guid;
   const NetworkState* network_state =
       network_state_handler_->GetNetworkState(service_path);
   if (network_state)
     guid = network_state->guid();
-  NET_LOG(USER) << "Remove Configuration: " << service_path;
+  NET_LOG(USER) << "Remove Configuration: " << service_path
+                << " from profiles: "
+                << (!profile_path.empty() ? profile_path : "all");
   ProfileEntryDeleter* deleter = new ProfileEntryDeleter(
       this, service_path, guid, source, callback, error_callback);
+  if (!profile_path.empty())
+    deleter->RestrictToProfilePath(profile_path);
   profile_entry_deleters_[service_path] = base::WrapUnique(deleter);
   deleter->Run();
 }
 
 void NetworkConfigurationHandler::SetNetworkProfile(
     const std::string& service_path,
     const std::string& profile_path,
     NetworkConfigurationObserver::Source source,
     const base::Closure& callback,
     const network_handler::ErrorCallback& error_callback) {
@@ skipping 227 matching lines @@
 // static
 NetworkConfigurationHandler* NetworkConfigurationHandler::InitializeForTest(
     NetworkStateHandler* network_state_handler,
     NetworkDeviceHandler* network_device_handler) {
   NetworkConfigurationHandler* handler = new NetworkConfigurationHandler();
   handler->Init(network_state_handler, network_device_handler);
   return handler;
 }
 
 }  // namespace chromeos