Prevent networkingPrivate.forgetNetwork from removing shared configs

extensions/browser/api/networking_private/networking_private_chromeos.cc

 // Copyright 2014 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 "extensions/browser/api/networking_private/networking_private_chromeos.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 426 matching lines @@
   }
 
   GetManagedConfigurationHandler()->CreateConfiguration(
       user_id_hash, *properties,
       base::Bind(&NetworkHandlerCreateCallback, success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::ForgetNetwork(
     const std::string& guid,
+    bool allow_forget_shared_config,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
-  GetManagedConfigurationHandler()->RemoveConfiguration(
-      service_path, success_callback,
-      base::Bind(&NetworkHandlerFailureCallback, failure_callback));
+  const chromeos::NetworkState* network =
+      GetStateHandler()->GetNetworkStateFromServicePath(
+          service_path, true /* configured only */);
+  if (!network) {
+    failure_callback.Run(networking_private::kErrorNetworkUnavailable);
+    return;
+  }
+
+  std::string user_id_hash;
+  // Don't allow non-primary user to remove private configs - the private
+  // configs belong to the primary user (non-primary users' network configs
+  // never get loaded by shill).
+  if (!GetPrimaryUserIdHash(browser_context_, &user_id_hash, &error) &&
+      network->IsPrivate()) {
+    failure_callback.Run(error);
+    return;
+  }
+
+  if (!allow_forget_shared_config && !network->IsPrivate()) {
+    failure_callback.Run(networking_private::kErrorAccessToSharedConfig);
+    return;
+  }
+
+  onc::ONCSource onc_source = onc::ONC_SOURCE_UNKNOWN;
+  if (GetManagedConfigurationHandler()->FindPolicyByGUID(user_id_hash, guid,
+                                                         &onc_source)) {
+    // Fail if requested configuration removal includes a policy controlled
+    // network configuration.
+    if (allow_forget_shared_config ||
+        onc_source == onc::ONC_SOURCE_USER_POLICY) {

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

This logic is confusing to follow. I guess it is saying that if we are
restricting removal to the current profile and it is a device policy then the
removal is OK? In that case, shouldn't we set |allow_forget_shared_config| =
false if onc_source == onc::ONC_SOURCE_DEVICE_POLICY instead? i.e.

if (onc_source == onc::ONC_SOURCE_DEVICE_POLICY)
  allow_forget_shared_config = false;
else
  fail and return

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

yeah, good point. Done.

+      failure_callback.Run(networking_private::kErrorPolicyControlled);
+      return;
+    }
+  }
+
+  if (allow_forget_shared_config) {
+    GetManagedConfigurationHandler()->RemoveConfiguration(
+        service_path, success_callback,
+        base::Bind(&NetworkHandlerFailureCallback, failure_callback));
+  } else {
+    GetManagedConfigurationHandler()->RemoveConfigurationFromCurrentProfile(
+        service_path, success_callback,
+        base::Bind(&NetworkHandlerFailureCallback, failure_callback));
+  }
 }
 
 void NetworkingPrivateChromeOS::GetNetworks(
     const std::string& network_type,
     bool configured_only,
     bool visible_only,
     int limit,
     const NetworkListCallback& success_callback,
     const FailureCallback& failure_callback) {
   NetworkTypePattern pattern =
@@ skipping 384 matching lines @@
   // Eventually the caller (e.g. Settings) should handle any failures and
   // show its own configuration UI. crbug.com/380937.
   if (ui_delegate()->HandleConnectFailed(guid, error_name)) {
     success_callback.Run();
     return;
   }
   failure_callback.Run(error_name);
 }
 
 }  // namespace extensions