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;
 }
 
+base::DictionaryValue* EnsureDictionaryValue(const std::string& key,

[michaelpg, 2016/11/02 23:55:25]

comment, please: ensure dictionary is what? set_active what?

[stevenjb, 2016/11/03 17:48:56]

Added comment and split up function.

+                                             base::DictionaryValue* container,
+                                             bool set_active) {
+  base::DictionaryValue* dict;
+  if (!container->GetDictionary(key, &dict)) {
+    container->SetWithoutPathExpansion(
+        key, base::MakeUnique<base::DictionaryValue>());
+    container->GetDictionary(key, &dict);
+  }
+  if (set_active) {
+    dict->SetBooleanWithoutPathExpansion(::onc::kAugmentationUserEditable,
+                                         false);
+    dict->SetStringWithoutPathExpansion(::onc::kAugmentationEffectiveSetting,
+                                        ::onc::kAugmentationActiveExtension);
+  }
+  return dict;
+}
+
+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,
+                    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,
+                                         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);
+  if (config.state != ProxyPrefs::CONFIG_EXTENSION)
+    return;
+  // Ensure that the ProxySettings dictionary exists.

[michaelpg, 2016/11/02 23:55:25]

nit: line break above

[stevenjb, 2016/11/03 17:48:56]

Done.

+  base::DictionaryValue* proxy_settings = EnsureDictionaryValue(
+      ::onc::network_config::kProxySettings, dictionary, false);
+
+  // Ensure that the ProxySettings.Type dictionary exists.
+  base::DictionaryValue* proxy_type_dict =
+      EnsureDictionaryValue(::onc::network_config::kType, proxy_settings, true);
+  proxy_type_dict->SetStringWithoutPathExpansion(
+      ::onc::kAugmentationActiveSetting, GetProxySettingsType(config.mode));
+  if (config.mode == UIProxyConfig::MODE_SINGLE_PROXY) {

[michaelpg, 2016/11/02 23:55:25]

nit: may be more readable as a switch. I don't normally care but this code is
very dense-looking.

[michaelpg, 2016/11/02 23:55:25]

nit: line break above

[stevenjb, 2016/11/03 17:48:56]

There are a couple of modes we don't care about so I will stick to an if, but
added a line break and comment.

+    base::DictionaryValue* manual =
+        EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings, false);
+    SetManualProxy(manual, ::onc::proxy::kHttp, config.single_proxy);
+    manual->RemoveWithoutPathExpansion(::onc::proxy::kHttps, nullptr);
+    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, false);
+    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, true);
+    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