Extract common per-network proxy configuration functions.

chrome/browser/chromeos/proxy_config_service_impl.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 "chrome/browser/chromeos/proxy_config_service_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/cloud/cloud_policy_constants.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/onc/onc_utils.h"
 #include "components/user_prefs/pref_registry_syncable.h"
 
 namespace chromeos {
 
 namespace {
 
-// Convert and store the proxy config of |pref_proxy_config| of
-// ProxyConfigDictionary format to |proxy_config|.  Returns true if
-// |pref_proxy_config| was not empty and if it was successfully converted.
-bool ParseProxyConfig(const base::DictionaryValue& pref_proxy_config,
-                      net::ProxyConfig* proxy_config) {
-  if (pref_proxy_config.empty())
+// Writes the proxy config of |network| to |proxy_config|.  Returns false if no
+// proxy was configured for this network.
+bool GetProxyConfig(const NetworkState& network,
+                    net::ProxyConfig* proxy_config) {
+  scoped_ptr<ProxyConfigDictionary> proxy_dict =
+      proxy_config::GetProxyConfigOfNetwork(network);
+  if (!proxy_dict)
     return false;
-  ProxyConfigDictionary proxy_dict(&pref_proxy_config);
-  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(proxy_dict,
+  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(*proxy_dict,
                                                            proxy_config);
 }
 
 }  // namespace
 
 ProxyConfigServiceImpl::ProxyConfigServiceImpl(PrefService* pref_service)
     : PrefProxyConfigTrackerImpl(pref_service),
       active_config_state_(ProxyPrefs::CONFIG_UNSET),
       pointer_factory_(this) {
 
@@ skipping 130 matching lines @@
   net::ProxyConfigService::ConfigAvailability network_availability =
       net::ProxyConfigService::CONFIG_UNSET;
   bool ignore_proxy = true;
   if (network) {
     ignore_proxy =
         IgnoreProxy(prefs(), network->profile_path(), network->onc_source());
     // If network is shared but use-shared-proxies is off, use direct mode.
     if (ignore_proxy) {
       VLOG(1) << "Shared network && !use-shared-proxies, use direct";
       network_availability = net::ProxyConfigService::CONFIG_VALID;
-    } else if (ParseProxyConfig(network->proxy_config(), &network_config)) {
+    } else if (chromeos::GetProxyConfig(*network, &network_config)) {
       // Network is private or shared with user using shared proxies.
       VLOG(1) << this << ": using network proxy: "
               << network->proxy_config();
       network_availability = net::ProxyConfigService::CONFIG_VALID;
     }
   }
 
   // Determine effective proxy config, either from prefs or network.
   ProxyPrefs::ConfigState effective_config_state;
   net::ProxyConfig effective_config;
@@ skipping 29 matching lines @@
       scoped_ptr<base::DictionaryValue> config_dict(
           effective_config.ToValue());
       VLOG(1) << this << ": Proxy changed: "
               << ProxyPrefs::ConfigStateToDebugString(active_config_state_)
               << ", " << *config_dict;
     }
   }
 }
 
 }  // namespace chromeos