chromeos: networkingPrivate: Set active proxy values

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/shill_manager_client.h"
 #include "chromeos/login/login_state.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_activation_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "chromeos/network/portal_detector/network_portal_detector.h"
+#include "chromeos/network/proxy/ui_proxy_config.h"
+#include "chromeos/network/proxy/ui_proxy_config_service.h"
 #include "components/onc/onc_constants.h"
+#include "components/proxy_config/proxy_prefs.h"
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using chromeos::NetworkHandler;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
+using chromeos::UIProxyConfig;
 using extensions::NetworkingPrivateDelegate;
 
 namespace private_api = extensions::api::networking_private;
 
 namespace {
 
 chromeos::NetworkStateHandler* GetStateHandler() {
   return NetworkHandler::Get()->network_state_handler();
 }
 
@@ skipping 154 matching lines @@
     device_state =
         GetStateHandler()->GetDeviceState(network_state->device_path());
   }
   if (!device_state) {
     device_state =
         GetStateHandler()->GetDeviceStateByType(NetworkTypePattern::Cellular());
   }
   return device_state;
 }
 
+// Ensures that |container| contains a DictionaryValue for |key| and
+// returns the dictionary.
+base::DictionaryValue* EnsureDictionaryValue(const std::string& key,
+                                             base::DictionaryValue* container) {
+  base::DictionaryValue* dict;
+  if (!container->GetDictionary(key, &dict)) {
+    container->SetWithoutPathExpansion(
+        key, base::MakeUnique<base::DictionaryValue>());
+    container->GetDictionary(key, &dict);
+  }
+  return dict;
+}
+
+// Sets the effective ONC dictionary value of |dict| to 'ActiveExtension' and
+// sets the UserEditable property to false.
+void SetEffectiveToActiveExtension(base::DictionaryValue* dict) {
+  dict->SetStringWithoutPathExpansion(::onc::kAugmentationEffectiveSetting,
+                                      ::onc::kAugmentationActiveExtension);
+  dict->SetBooleanWithoutPathExpansion(::onc::kAugmentationUserEditable, false);
+}
+
+std::string GetProxySettingsType(const UIProxyConfig::Mode& mode) {
+  switch (mode) {
+    case UIProxyConfig::MODE_DIRECT:
+      return ::onc::proxy::kDirect;
+    case UIProxyConfig::MODE_AUTO_DETECT:
+      return ::onc::proxy::kWPAD;
+    case UIProxyConfig::MODE_PAC_SCRIPT:
+      return ::onc::proxy::kPAC;
+    case UIProxyConfig::MODE_SINGLE_PROXY:
+    case UIProxyConfig::MODE_PROXY_PER_SCHEME:
+      return ::onc::proxy::kManual;
+  }
+  NOTREACHED();
+  return ::onc::proxy::kDirect;
+}
+
+void SetManualProxy(base::DictionaryValue* manual,
+                    const std::string& key,

[michaelpg, 2016/11/04 00:58:28]

unused?

[stevenjb, 2016/11/09 22:20:18]

Done.

+                    const UIProxyConfig::ManualProxy& proxy) {
+  manual->SetStringWithoutPathExpansion(::onc::proxy::kHost,
+                                        proxy.server.host_port_pair().host());
+  uint16_t port = proxy.server.host_port_pair().port();
+  manual->SetIntegerWithoutPathExpansion(::onc::proxy::kHost,

[michaelpg, 2016/11/04 00:58:28]

kHost is being set twice...

[stevenjb, 2016/11/09 22:20:18]

Done.

+                                         static_cast<int>(port));
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
     std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
@@ skipping 15 matching lines @@
 
   std::string user_id_hash;
   if (!GetPrimaryUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->GetProperties(
       user_id_hash, service_path,
       base::Bind(&NetworkingPrivateChromeOS::GetPropertiesCallback,
-                 weak_ptr_factory_.GetWeakPtr(), success_callback),
+                 weak_ptr_factory_.GetWeakPtr(), guid, false /* managed */,
+                 success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetManagedProperties(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   std::string user_id_hash;
   if (!GetPrimaryUserIdHash(browser_context_, &user_id_hash, &error)) {
     failure_callback.Run(error);
     return;
   }
 
   GetManagedConfigurationHandler()->GetManagedProperties(
       user_id_hash, service_path,
       base::Bind(&NetworkingPrivateChromeOS::GetPropertiesCallback,
-                 weak_ptr_factory_.GetWeakPtr(), success_callback),
+                 weak_ptr_factory_.GetWeakPtr(), guid, true /* managed */,
+                 success_callback),
       base::Bind(&NetworkHandlerFailureCallback, failure_callback));
 }
 
 void NetworkingPrivateChromeOS::GetState(
     const std::string& guid,
     const DictionaryCallback& success_callback,
     const FailureCallback& failure_callback) {
   std::string service_path, error;
   if (!GetServicePathFromGuid(guid, &service_path, &error)) {
     failure_callback.Run(error);
@@ skipping 332 matching lines @@
 }
 
 bool NetworkingPrivateChromeOS::RequestScan() {
   GetStateHandler()->RequestScan();
   return true;
 }
 
 // Private methods
 
 void NetworkingPrivateChromeOS::GetPropertiesCallback(
+    const std::string& guid,
+    bool managed,
     const DictionaryCallback& callback,
     const std::string& service_path,
     const base::DictionaryValue& dictionary) {
   std::unique_ptr<base::DictionaryValue> dictionary_copy(dictionary.DeepCopy());
   AppendThirdPartyProviderName(dictionary_copy.get());
+  if (managed)
+    SetActiveProxyValues(guid, dictionary_copy.get());
   callback.Run(std::move(dictionary_copy));
 }
 
-// Populate ThirdPartyVPN.kProviderName for third-party VPNs.
 void NetworkingPrivateChromeOS::AppendThirdPartyProviderName(
     base::DictionaryValue* dictionary) {
   base::DictionaryValue* third_party_vpn =
       GetThirdPartyVPNDictionary(dictionary);
   if (!third_party_vpn)
     return;
 
   const std::string extension_id = GetStringFromDictionary(
       *third_party_vpn, ::onc::third_party_vpn::kExtensionID);
   const ExtensionSet& extensions =
       ExtensionRegistry::Get(browser_context_)->enabled_extensions();
   for (const auto& extension : extensions) {
     if (extension->permissions_data()->HasAPIPermission(
             APIPermission::kVpnProvider) &&
         extension->id() == extension_id) {
       third_party_vpn->SetStringWithoutPathExpansion(
           ::onc::third_party_vpn::kProviderName, extension->name());
       break;
     }
   }
 }
 
+void NetworkingPrivateChromeOS::SetActiveProxyValues(
+    const std::string& guid,
+    base::DictionaryValue* dictionary) {
+  chromeos::UIProxyConfigService* ui_proxy_config_service =
+      NetworkHandler::Get()->ui_proxy_config_service();
+  ui_proxy_config_service->UpdateFromPrefs(guid);
+  UIProxyConfig config;
+  ui_proxy_config_service->GetProxyConfig(guid, &config);
+
+  // We only override the active values if the proxy is set by an extension.
+  if (config.state != ProxyPrefs::CONFIG_EXTENSION)
+    return;
+
+  // Ensure that the ProxySettings dictionary exists.

[michaelpg, 2016/11/04 00:58:28]

The rest of the function assumes kProxySettings is a ManagedProxySettings dict
(not a ProxySettings dict). Is that because CONFIG_EXTENSION means that
|dictionary| is a ManagedProperties? There's an odd dependency on UIProxyConfig
I wouldn't have expected; can you add a comment to the effect that we know we're
dealing with managed properties?

[stevenjb, 2016/11/09 22:20:18]

This is only called for managed dictionaries (managed is true in
GetPropertiesCallback). I renamed this and updated the comment in the header.

I also commented about the fubar nature of using UIProxyConfig.

+  base::DictionaryValue* proxy_settings =
+      EnsureDictionaryValue(::onc::network_config::kProxySettings, dictionary);
+
+  // Ensure that the ProxySettings.Type dictionary exists and set the active
+  // type value to the value from |ui_proxy_config_service|.
+  base::DictionaryValue* proxy_type_dict =
+      EnsureDictionaryValue(::onc::network_config::kType, proxy_settings);
+  SetEffectiveToActiveExtension(proxy_type_dict);
+  proxy_type_dict->SetStringWithoutPathExpansion(
+      ::onc::kAugmentationActiveSetting, GetProxySettingsType(config.mode));
+
+  // Update any appropriate sub dictionary based on the new type.
+  if (config.mode == UIProxyConfig::MODE_SINGLE_PROXY) {
+    base::DictionaryValue* manual =
+        EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
+    SetManualProxy(manual, ::onc::proxy::kHttp, config.single_proxy);
+    manual->RemoveWithoutPathExpansion(::onc::proxy::kHttps, nullptr);

[emaxx, 2016/11/03 21:15:44]

I'm lacking the context here, but maybe some explanation would be helpful
regarding the reason why these values are removed in this case and why this is
not necessary in other cases.

[michaelpg, 2016/11/04 00:58:28]

+1; SetManualProxy doesn't seem like it's doing whatever it's supposed to be
doing. Also not sure why a single proxy has to be http or if http is the
default; don't see that documented anywhere.

[stevenjb, 2016/11/09 22:20:18]

Short version: We only care about kHttp when we indicate "use the same proxy for
all protocols". However, I have since determined that it makes more sense just
to set all properties to the same value (which is what Shill does). I also added
a comment.

+    manual->RemoveWithoutPathExpansion(::onc::proxy::kFtp, nullptr);
+    manual->RemoveWithoutPathExpansion(::onc::proxy::kSocks, nullptr);
+  } else if (config.mode == UIProxyConfig::MODE_PROXY_PER_SCHEME) {
+    base::DictionaryValue* manual =
+        EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
+    SetManualProxy(manual, ::onc::proxy::kHttp, config.http_proxy);
+    SetManualProxy(manual, ::onc::proxy::kHttps, config.https_proxy);
+    SetManualProxy(manual, ::onc::proxy::kFtp, config.ftp_proxy);
+    SetManualProxy(manual, ::onc::proxy::kSocks, config.socks_proxy);
+  } else if (config.mode == UIProxyConfig::MODE_PAC_SCRIPT) {
+    base::DictionaryValue* pac =
+        EnsureDictionaryValue(::onc::proxy::kPAC, proxy_settings);
+    SetEffectiveToActiveExtension(pac);
+    pac->SetStringWithoutPathExpansion(::onc::kAugmentationActiveSetting,
+                                       config.automatic_proxy.pac_url.spec());
+  }
+}
+
 void NetworkingPrivateChromeOS::ConnectFailureCallback(
     const std::string& guid,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback,
     const std::string& error_name,
     std::unique_ptr<base::DictionaryValue> error_data) {
   // TODO(stevenjb): Temporary workaround to show the configuration UI.
   // 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