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 <memory>
+
 #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| has a DictionaryValue for |key| and returns it.
+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 active and effective ONC dictionary values of |dict| based on
+// |state|. Also sets the UserEditable property to false.
+void SetProxyEffectiveValue(base::DictionaryValue* dict,
+                            ProxyPrefs::ConfigState state,
+                            std::unique_ptr<base::Value> value) {
+  // NOTE: ProxyPrefs::ConfigState only exposes 'CONFIG_POLICY' so just use
+  // 'UserPolicy' here for the effective type. The existing UI does not
+  // differentiate between policy types. TODO(stevenjb): Eliminate UIProxyConfig
+  // and instead generate a proper ONC dictionary with the correct policy source
+  // preserved. crbug.com/662529.
+  dict->SetStringWithoutPathExpansion(::onc::kAugmentationEffectiveSetting,
+                                      state == ProxyPrefs::CONFIG_EXTENSION
+                                          ? ::onc::kAugmentationActiveExtension
+                                          : ::onc::kAugmentationUserPolicy);
+  if (state != ProxyPrefs::CONFIG_EXTENSION) {
+    std::unique_ptr<base::Value> value_copy(value->CreateDeepCopy());
+    dict->SetWithoutPathExpansion(::onc::kAugmentationUserPolicy,
+                                  std::move(value_copy));
+  }
+  dict->SetWithoutPathExpansion(::onc::kAugmentationActiveSetting,
+                                std::move(value));
+  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,
+                    ProxyPrefs::ConfigState state,
+                    const std::string& key,
+                    const UIProxyConfig::ManualProxy& proxy) {
+  base::DictionaryValue* dict = EnsureDictionaryValue(key, manual);
+  base::DictionaryValue* host_dict =
+      EnsureDictionaryValue(::onc::proxy::kHost, dict);
+  SetProxyEffectiveValue(host_dict, state,
+                         base::MakeUnique<base::StringValue>(
+                             proxy.server.host_port_pair().host()));
+  uint16_t port = proxy.server.host_port_pair().port();
+  base::DictionaryValue* port_dict =
+      EnsureDictionaryValue(::onc::proxy::kPort, dict);
+  SetProxyEffectiveValue(port_dict, state,
+                         base::MakeUnique<base::FundamentalValue>(port));
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
     std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
       browser_context_(browser_context),
       weak_ptr_factory_(this) {}
 
-NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {
-}
+NetworkingPrivateChromeOS::~NetworkingPrivateChromeOS() {}
 
 void NetworkingPrivateChromeOS::GetProperties(
     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()->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 290 matching lines @@
 
   std::unique_ptr<DeviceStateList> device_state_list(new DeviceStateList);
   for (const chromeos::DeviceState* device : devices) {
     std::string onc_type =
         chromeos::network_util::TranslateShillTypeToONC(device->type());
     AppendDeviceState(onc_type, device, device_state_list.get());
     technologies_found.insert(onc_type);
   }
 
   // For any technologies that we do not have a DeviceState entry for, append
-  // an entry if the technolog is available.
-  const char* technology_types[] = {::onc::network_type::kEthernet,
-                                    ::onc::network_type::kWiFi,
-                                    ::onc::network_type::kWimax,
-                                    ::onc::network_type::kCellular};
+  // an entry if the technology is available.
+  const char* technology_types[] = {
+      ::onc::network_type::kEthernet, ::onc::network_type::kWiFi,
+      ::onc::network_type::kWimax, ::onc::network_type::kCellular};
   for (const char* technology : technology_types) {
     if (base::ContainsValue(technologies_found, technology))
       continue;
     AppendDeviceState(technology, nullptr /* device */,
                       device_state_list.get());
   }
   return device_state_list;
 }
 
 bool NetworkingPrivateChromeOS::EnableNetworkType(const std::string& type) {
@@ skipping 17 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)
+    SetManagedActiveProxyValues(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::SetManagedActiveProxyValues(
+    const std::string& guid,
+    base::DictionaryValue* dictionary) {
+  // NOTE: We use UIProxyConfigService and UIProxyConfig for historical
+  // reasons. The model and service were written for a much older UI but
+  // contain a fair amount of subtle logic which is why we use them.
+  // TODO(stevenjb): Re-factor this code and eliminate UIProxyConfig once
+  // the old options UI is abandoned. crbug.com/662529.
+  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);
+  ProxyPrefs::ConfigState state = config.state;
+
+  VLOG(1) << "CONFIG STATE FOR: " << guid << ": " << state
+          << " MODE: " << config.mode;
+
+  if (state != ProxyPrefs::CONFIG_POLICY &&
+      state != ProxyPrefs::CONFIG_EXTENSION &&
+      state != ProxyPrefs::CONFIG_OTHER_PRECEDE) {
+    return;
+  }
+
+  // Ensure that the ProxySettings dictionary exists.
+  base::DictionaryValue* proxy_settings =
+      EnsureDictionaryValue(::onc::network_config::kProxySettings, dictionary);
+  VLOG(2) << " PROXY: " << *proxy_settings;
+
+  // Ensure that the ProxySettings.Type dictionary exists and set the Type
+  // value to the value from |ui_proxy_config_service|.
+  base::DictionaryValue* proxy_type_dict =
+      EnsureDictionaryValue(::onc::network_config::kType, proxy_settings);
+  SetProxyEffectiveValue(proxy_type_dict, state,
+                         base::WrapUnique<base::Value>(new base::StringValue(
+                             GetProxySettingsType(config.mode))));
+
+  // Update any appropriate sub dictionary based on the new type.
+  switch (config.mode) {
+    case UIProxyConfig::MODE_SINGLE_PROXY: {
+      // Use the same proxy value (config.single_proxy) for all proxies.
+      base::DictionaryValue* manual =
+          EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
+      SetManualProxy(manual, state, ::onc::proxy::kHttp, config.single_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kHttps, config.single_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kFtp, config.single_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kSocks, config.single_proxy);
+      break;
+    }
+    case UIProxyConfig::MODE_PROXY_PER_SCHEME: {
+      base::DictionaryValue* manual =
+          EnsureDictionaryValue(::onc::proxy::kManual, proxy_settings);
+      SetManualProxy(manual, state, ::onc::proxy::kHttp, config.http_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kHttps, config.https_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kFtp, config.ftp_proxy);
+      SetManualProxy(manual, state, ::onc::proxy::kSocks, config.socks_proxy);
+      break;
+    }
+    case UIProxyConfig::MODE_PAC_SCRIPT: {
+      base::DictionaryValue* pac =
+          EnsureDictionaryValue(::onc::proxy::kPAC, proxy_settings);
+      SetProxyEffectiveValue(
+          pac, state, base::WrapUnique<base::Value>(new base::StringValue(
+                          config.automatic_proxy.pac_url.spec())));
+      break;
+    }
+    case UIProxyConfig::MODE_DIRECT:
+    case UIProxyConfig::MODE_AUTO_DETECT:
+      break;
+  }
+
+  VLOG(2) << " NEW PROXY: " << *proxy_settings;
+}
+
 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