Extract common per-network proxy configuration functions.

- Extracted functions to get and set per-network proxy configuration from ProxyConfigServiceImpl, UIProxyConfigService and NetworkStateInformer, and moved them to a common place (chrome/browser/chromeos/net/proxy_config_handler.h).

- The previous SetProxyConfig call to NetworkLibrary was extracted and instead ShillServiceClient is called directly.

- Now uses NetworkStateHandler and NetworkState instead of NetworkLibrary to get the current proxy config.

- This removed any dependency of proxy UI on NetworkLibrary.

BUG=234982
R=mnissler@chromium.org, nkostylev@chromium.org, stevenjb@chromium.org

Review URL: https://codereview.chromium.org/16398005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@205214 0039d316-1c4b-4281-b951-d872f2087c98

13 files changed, 191 insertions, 99 deletions

diff --git a/chrome/browser/chromeos/net/proxy_config_handler.cc b/chrome/browser/chromeos/net/proxy_config_handler.cc
new file mode 100644
index 0000000..b1d2f1e
--- /dev/null
+++ b/chrome/browser/chromeos/net/proxy_config_handler.cc
@@ -0,0 +1,79 @@
+// Copyright (c) 2013 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/net/proxy_config_handler.h"
+
+#include "base/bind.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/values.h"
+#include "chrome/browser/prefs/proxy_config_dictionary.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/shill_service_client.h"
+#include "chromeos/network/network_handler_callbacks.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
+#include "dbus/object_path.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+
+namespace {
+
+void LogError(const std::string& network,
+              const std::string& error_name,
+              const std::string& error_message) {
+  network_handler::ShillErrorCallbackFunction(
+      network,
+      network_handler::ErrorCallback(),
+      "Could not clear or set ProxyConfig",
+      error_message);
+}
+
+}  // namespace
+
+namespace proxy_config {
+
+scoped_ptr<ProxyConfigDictionary> GetProxyConfigForNetwork(
+    const NetworkState& network) {
+  const base::DictionaryValue& value = network.proxy_config();
+  if (value.empty())
+    return scoped_ptr<ProxyConfigDictionary>();
+  return make_scoped_ptr(new ProxyConfigDictionary(&value));
+}
+
+void SetProxyConfigForNetwork(const ProxyConfigDictionary& proxy_config,
+                              const NetworkState& network) {
+  chromeos::ShillServiceClient* shill_service_client =
+      DBusThreadManager::Get()->GetShillServiceClient();
+
+  ProxyPrefs::ProxyMode mode;
+  if (!proxy_config.GetMode(&mode) || mode == ProxyPrefs::MODE_DIRECT) {
+    // TODO(pneubeck): Consider removing this legacy code.  Return empty string
+    // for direct mode for portal check to work correctly.
+    shill_service_client->ClearProperty(
+        dbus::ObjectPath(network.path()),
+        flimflam::kProxyConfigProperty,
+        base::Bind(&base::DoNothing),
+        base::Bind(&LogError, network.path()));
+  } else {
+    std::string proxy_config_str;
+    base::JSONWriter::Write(&proxy_config.GetDictionary(), &proxy_config_str);
+    shill_service_client->SetProperty(
+        dbus::ObjectPath(network.path()),
+        flimflam::kProxyConfigProperty,
+        base::StringValue(proxy_config_str),
+        base::Bind(&base::DoNothing),
+        base::Bind(&LogError, network.path()));
+  }
+
+  if (NetworkHandler::IsInitialized()) {
+    NetworkHandler::Get()->network_state_handler()->
+        RequestUpdateForNetwork(network.path());
+  }
+}
+
+}  // namespace proxy_config
+
+}  // namespace chromeos
diff --git a/chrome/browser/chromeos/net/proxy_config_handler.h b/chrome/browser/chromeos/net/proxy_config_handler.h
new file mode 100644
index 0000000..5162c5c
--- /dev/null
+++ b/chrome/browser/chromeos/net/proxy_config_handler.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2013 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.
+
+#ifndef CHROME_BROWSER_CHROMEOS_NET_PROXY_CONFIG_HANDLER_H_
+#define CHROME_BROWSER_CHROMEOS_NET_PROXY_CONFIG_HANDLER_H_
+
+#include "base/memory/scoped_ptr.h"
+
+class ProxyConfigDictionary;
+
+namespace chromeos {
+
+class NetworkState;
+
+namespace proxy_config {
+
+scoped_ptr<ProxyConfigDictionary> GetProxyConfigForNetwork(
+    const NetworkState& network);
+
+void SetProxyConfigForNetwork(const ProxyConfigDictionary& proxy_config,
+                              const NetworkState& network);
+
+}  // namespace proxy_config
+
+}  // namespace chromeos
+
+#endif  // CHROME_BROWSER_CHROMEOS_NET_PROXY_CONFIG_HANDLER_H_
diff --git a/chrome/browser/chromeos/proxy_config_service_impl.cc b/chrome/browser/chromeos/proxy_config_service_impl.cc
index de8684c..41a2737 100644
--- a/chrome/browser/chromeos/proxy_config_service_impl.cc
+++ b/chrome/browser/chromeos/proxy_config_service_impl.cc
@@ -11,6 +11,7 @@
 #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"
@@ -27,15 +28,15 @@ 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::GetProxyConfigForNetwork(network);
+  if (!proxy_dict)
     return false;
-  ProxyConfigDictionary proxy_dict(&pref_proxy_config);
-  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(proxy_dict,
+  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(*proxy_dict,
                                                            proxy_config);
 }
 
@@ -186,7 +187,7 @@ void ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork() {
     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();
diff --git a/chrome/browser/chromeos/ui_proxy_config.cc b/chrome/browser/chromeos/ui_proxy_config.cc
index 88e994f..6f55b1fc 100644
--- a/chrome/browser/chromeos/ui_proxy_config.cc
+++ b/chrome/browser/chromeos/ui_proxy_config.cc
@@ -4,7 +4,6 @@
 
 #include "chrome/browser/chromeos/ui_proxy_config.h"
 
-#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h"
@@ -101,7 +100,7 @@ bool UIProxyConfig::FromNetProxyConfig(const net::ProxyConfig& net_config) {
   return false;
 }
 
-base::DictionaryValue* UIProxyConfig::ToPrefProxyConfig() {
+base::DictionaryValue* UIProxyConfig::ToPrefProxyConfig() const {
   switch (mode) {
     case MODE_DIRECT: {
       return ProxyConfigDictionary::CreateDirect();
@@ -150,25 +149,6 @@ UIProxyConfig::ManualProxy* UIProxyConfig::MapSchemeToProxy(
   return NULL;
 }
 
-bool UIProxyConfig::SerializeForNetwork(std::string* output) {
-  scoped_ptr<base::DictionaryValue> proxy_dict_ptr(ToPrefProxyConfig());
-  if (!proxy_dict_ptr.get())
-    return false;
-
-  // Return empty string for direct mode for portal check to work correctly.
-  base::DictionaryValue *dict = proxy_dict_ptr.get();
-  ProxyConfigDictionary proxy_dict(dict);
-  ProxyPrefs::ProxyMode mode;
-  if (proxy_dict.GetMode(&mode)) {
-    if (mode == ProxyPrefs::MODE_DIRECT) {
-      output->clear();
-      return true;
-    }
-  }
-  base::JSONWriter::Write(dict, output);
-  return true;
-}
-
 // static
 void UIProxyConfig::EncodeAndAppendProxyServer(const std::string& url_scheme,
                                                const net::ProxyServer& server,
diff --git a/chrome/browser/chromeos/ui_proxy_config.h b/chrome/browser/chromeos/ui_proxy_config.h
index 6d7c4d4..4541c8f 100644
--- a/chrome/browser/chromeos/ui_proxy_config.h
+++ b/chrome/browser/chromeos/ui_proxy_config.h
@@ -73,16 +73,12 @@ struct UIProxyConfig {
 
   // Converts |this| to Dictionary of ProxyConfigDictionary format (which
   // is the same format used by prefs).
-  base::DictionaryValue* ToPrefProxyConfig();
+  base::DictionaryValue* ToPrefProxyConfig() const;
 
   // Map |scheme| (one of "http", "https", "ftp" or "socks") to the correct
   // ManualProxy.  Returns NULL if scheme is invalid.
   ManualProxy* MapSchemeToProxy(const std::string& scheme);
 
-  // Serializes config into a ProxyConfigDictionary and then std::string
-  // persisted as string property in shill for a network.
-  bool SerializeForNetwork(std::string* output);
-
   // Encodes the proxy server as "<url-scheme>=<proxy-scheme>://<proxy>"
   static void EncodeAndAppendProxyServer(const std::string& url_scheme,
                                          const net::ProxyServer& server,
diff --git a/chrome/browser/chromeos/ui_proxy_config_service.cc b/chrome/browser/chromeos/ui_proxy_config_service.cc
index a613596..0f6988a 100644
--- a/chrome/browser/chromeos/ui_proxy_config_service.cc
+++ b/chrome/browser/chromeos/ui_proxy_config_service.cc
@@ -7,10 +7,10 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/browser/chromeos/proxy_config_service_impl.h"
-#include "chromeos/network/onc/onc_utils.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #include "grit/generated_resources.h"
 #include "net/proxy/proxy_config.h"
 
@@ -35,27 +35,21 @@ const char* ModeToString(UIProxyConfig::Mode mode) {
   return "";
 }
 
-bool ParseProxyConfig(const std::string& 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::GetProxyConfigForNetwork(network);
+  if (!proxy_dict)
     return false;
-
-  scoped_ptr<base::DictionaryValue> proxy_config_dict(
-      chromeos::onc::ReadDictionaryFromJson(pref_proxy_config));
-  if (!proxy_config_dict) {
-    LOG(WARNING) << "Failed to parse proxy config.";
-    return false;
-  }
-
-  ProxyConfigDictionary proxy_config_dict_wrapper(proxy_config_dict.get());
-  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(
-      proxy_config_dict_wrapper,
-      proxy_config);
+  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(*proxy_dict,
+                                                           proxy_config);
 }
 
 // Returns true if proxy settings of |network| are editable.
-bool IsNetworkProxySettingsEditable(const Network& network) {
-  onc::ONCSource source = network.ui_data().onc_source();
+bool IsNetworkProxySettingsEditable(const NetworkState& network) {
+  onc::ONCSource source = network.onc_source();
   return source != onc::ONC_SOURCE_DEVICE_POLICY &&
       source != onc::ONC_SOURCE_USER_POLICY;
 }
@@ -74,9 +68,9 @@ void UIProxyConfigService::SetPrefs(PrefService* pref_service) {
 
 void UIProxyConfigService::SetCurrentNetwork(
     const std::string& current_network) {
-  Network* network = NULL;
+  const NetworkState* network = NULL;
   if (!current_network.empty()) {
-    network = CrosLibrary::Get()->GetNetworkLibrary()->FindNetworkByPath(
+    network = NetworkHandler::Get()->network_state_handler()->GetNetworkState(
         current_network);
     LOG_IF(ERROR, !network)
         << "Can't find requested network " << current_network;
@@ -105,24 +99,28 @@ void UIProxyConfigService::SetProxyConfig(const UIProxyConfig& config) {
   if (current_ui_network_.empty())
     return;
 
-  // Update config to shill.
-  std::string value;
-  if (!current_ui_config_.SerializeForNetwork(&value))
-    return;
-
-  VLOG(1) << "Set proxy for " << current_ui_network_ << " to " << value;
-  current_ui_config_.state = ProxyPrefs::CONFIG_SYSTEM;
-
-  Network* network = CrosLibrary::Get()->GetNetworkLibrary()->FindNetworkByPath(
-      current_ui_network_);
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->
+      GetNetworkState(current_ui_network_);
   if (!network) {
     LOG(ERROR) << "Can't find requested network " << current_ui_network_;
     return;
   }
-  network->SetProxyConfig(value);
+
+  // Store config for this network.
+  scoped_ptr<base::DictionaryValue> proxy_config_value(
+      config.ToPrefProxyConfig());
+  ProxyConfigDictionary proxy_config_dict(proxy_config_value.get());
+
+  VLOG(1) << "Set proxy for " << current_ui_network_
+          << " to " << *proxy_config_value;
+
+  proxy_config::SetProxyConfigForNetwork(proxy_config_dict, *network);
+  current_ui_config_.state = ProxyPrefs::CONFIG_SYSTEM;
 }
 
-void UIProxyConfigService::DetermineEffectiveConfig(const Network& network) {
+void UIProxyConfigService::DetermineEffectiveConfig(
+    const NetworkState& network) {
   DCHECK(pref_service_);
 
   // Get prefs proxy config if available.
@@ -134,7 +132,7 @@ void UIProxyConfigService::DetermineEffectiveConfig(const Network& network) {
   net::ProxyConfig network_config;
   net::ProxyConfigService::ConfigAvailability network_availability =
       net::ProxyConfigService::CONFIG_UNSET;
-  if (ParseProxyConfig(network.proxy_config(), &network_config)) {
+  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;
@@ -162,7 +160,7 @@ void UIProxyConfigService::DetermineEffectiveConfig(const Network& network) {
     current_ui_config_.user_modifiable =
         !ProxyConfigServiceImpl::IgnoreProxy(pref_service_,
                                              network.profile_path(),
-                                             network.ui_data().onc_source());
+                                             network.onc_source());
   }
 }
 
diff --git a/chrome/browser/chromeos/ui_proxy_config_service.h b/chrome/browser/chromeos/ui_proxy_config_service.h
index ec2f273..05d867e 100644
--- a/chrome/browser/chromeos/ui_proxy_config_service.h
+++ b/chrome/browser/chromeos/ui_proxy_config_service.h
@@ -14,7 +14,7 @@ class PrefService;
 
 namespace chromeos {
 
-class Network;
+class NetworkState;
 
 // This class is only accessed from the UI via Profile::GetProxyConfigTracker to
 // allow the user to read and modify the proxy configuration via
@@ -49,7 +49,7 @@ class UIProxyConfigService {
   // |network| and if user is using shared proxies.  The effective config is
   // stored in |current_ui_config_| but not activated on network stack, and
   // hence, not picked up by observers.
-  void DetermineEffectiveConfig(const Network& network);
+  void DetermineEffectiveConfig(const NetworkState& network);
 
   // Service path of network whose proxy configuration is being displayed or
   // edited via UI.
diff --git a/chrome/browser/prefs/proxy_config_dictionary.cc b/chrome/browser/prefs/proxy_config_dictionary.cc
index b6db822..e2d9d4b 100644
--- a/chrome/browser/prefs/proxy_config_dictionary.cc
+++ b/chrome/browser/prefs/proxy_config_dictionary.cc
@@ -65,6 +65,10 @@ bool ProxyConfigDictionary::HasBypassList() const {
   return dict_->HasKey(kProxyBypassList);
 }
 
+const DictionaryValue& ProxyConfigDictionary::GetDictionary() const {
+  return *dict_;
+}
+
 // static
 DictionaryValue* ProxyConfigDictionary::CreateDirect() {
   return CreateDictionary(ProxyPrefs::MODE_DIRECT,
diff --git a/chrome/browser/prefs/proxy_config_dictionary.h b/chrome/browser/prefs/proxy_config_dictionary.h
index c63cb4f..1593768 100644
--- a/chrome/browser/prefs/proxy_config_dictionary.h
+++ b/chrome/browser/prefs/proxy_config_dictionary.h
@@ -37,6 +37,8 @@ class ProxyConfigDictionary {
   bool GetBypassList(std::string* out) const;
   bool HasBypassList() const;
 
+  const base::DictionaryValue& GetDictionary() const;
+
   static base::DictionaryValue* CreateDirect();
   static base::DictionaryValue* CreateAutoDetect();
   static base::DictionaryValue* CreatePacScript(const std::string& pac_url,
diff --git a/chrome/browser/ui/webui/chromeos/login/network_state_informer.cc b/chrome/browser/ui/webui/chromeos/login/network_state_informer.cc
index 28832bc..dbd01b9 100644
--- a/chrome/browser/ui/webui/chromeos/login/network_state_informer.cc
+++ b/chrome/browser/ui/webui/chromeos/login/network_state_informer.cc
@@ -7,6 +7,7 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/chrome_notification_types.h"
@@ -213,9 +214,12 @@ NetworkStateInformer::State NetworkStateInformer::GetNetworkState(
 bool NetworkStateInformer::IsProxyConfigured(const NetworkState* network) {
   DCHECK(network);
 
-  ProxyConfigDictionary proxy_dict(&network->proxy_config());
+  scoped_ptr<ProxyConfigDictionary> proxy_dict(
+      proxy_config::GetProxyConfigForNetwork(*network));
   ProxyPrefs::ProxyMode mode;
-  return proxy_dict.GetMode(&mode) && mode == ProxyPrefs::MODE_FIXED_SERVERS;
+  return (proxy_dict &&
+          proxy_dict->GetMode(&mode) &&
+          mode == ProxyPrefs::MODE_FIXED_SERVERS);
 }
 
 }  // namespace chromeos
diff --git a/chrome/browser/ui/webui/options/preferences_browsertest.cc b/chrome/browser/ui/webui/options/preferences_browsertest.cc
index 8bd8e17..d98b7af 100644
--- a/chrome/browser/ui/webui/options/preferences_browsertest.cc
+++ b/chrome/browser/ui/webui/options/preferences_browsertest.cc
@@ -33,13 +33,14 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_CHROMEOS)
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/network_library.h"
+#include "base/stringprintf.h"
+#include "chrome/browser/chromeos/net/proxy_config_handler.h"
 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/cros_settings_names.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
-#include "chromeos/network/onc/onc_utils.h"
+#include "chromeos/network/network_state.h"
+#include "chromeos/network/network_state_handler.h"
 #endif
 
 using testing::AllOf;
@@ -715,25 +716,24 @@ class ProxyPreferencesBrowserTest : public PreferencesBrowserTest {
             "127.0.0.1:8080",
             "*.google.com, 1.2.3.4:22"));
 
-    std::string proxy_config;
-    base::JSONWriter::Write(proxy_config_dict.get(), &proxy_config);
+    ProxyConfigDictionary proxy_config(proxy_config_dict.get());
 
-    chromeos::Network* network = GetActiveNetwork();
-    network->SetProxyConfig(proxy_config);
+    const chromeos::NetworkState* network = GetDefaultNetwork();
+    chromeos::proxy_config::SetProxyConfigForNetwork(
+        proxy_config, *network);
 
-    std::string url = chrome::kChromeUIProxySettingsURL;
-    url += "?network=";
-    url += network->service_path();
+    std::string url = base::StringPrintf("%s?network=%s",
+                                         chrome::kChromeUIProxySettingsURL,
+                                         network->path().c_str());
 
     ui_test_utils::NavigateToURL(browser(), GURL(url));
     SetUpPrefs();
   }
 
  protected:
-  chromeos::Network* GetActiveNetwork() {
-    chromeos::NetworkLibrary* network_library =
-        chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-    return const_cast<chromeos::Network*>(network_library->active_network());
+  const chromeos::NetworkState* GetDefaultNetwork() {
+    return chromeos::NetworkHandler::Get()->network_state_handler()->
+        DefaultNetwork();
   }
 
   void SetProxyPref(const std::string& name, const base::Value& value) {
@@ -757,13 +757,10 @@ class ProxyPreferencesBrowserTest : public PreferencesBrowserTest {
   }
 
   void VerifyCurrentProxyServer(const std::string& expected_server) {
-    scoped_ptr<base::DictionaryValue> proxy_config =
-        chromeos::onc::ReadDictionaryFromJson(
-            GetActiveNetwork()->proxy_config());
-
-    ProxyConfigDictionary proxy_dict(proxy_config.get());
+    scoped_ptr<ProxyConfigDictionary> proxy_dict(
+        chromeos::proxy_config::GetProxyConfigForNetwork(*GetDefaultNetwork()));
     std::string actual_proxy_server;
-    EXPECT_TRUE(proxy_dict.GetProxyServer(&actual_proxy_server));
+    EXPECT_TRUE(proxy_dict->GetProxyServer(&actual_proxy_server));
     EXPECT_EQ(expected_server, actual_proxy_server);
   }
 };
diff --git a/chrome/chrome_browser_chromeos.gypi b/chrome/chrome_browser_chromeos.gypi
index 01f1389..5392779 100644
--- a/chrome/chrome_browser_chromeos.gypi
+++ b/chrome/chrome_browser_chromeos.gypi
@@ -572,6 +572,8 @@
         'browser/chromeos/net/network_portal_detector_stub.h',
         'browser/chromeos/net/onc_utils.cc',
         'browser/chromeos/net/onc_utils.h',
+        'browser/chromeos/net/proxy_config_handler.cc',
+        'browser/chromeos/net/proxy_config_handler.h',
         'browser/chromeos/network_login_observer.cc',
         'browser/chromeos/network_login_observer.h',
         'browser/chromeos/notifications/balloon_view_host_chromeos.cc',
diff --git a/chromeos/network/network_handler_callbacks.h b/chromeos/network/network_handler_callbacks.h
index 8caf804..2e73d28 100644
--- a/chromeos/network/network_handler_callbacks.h
+++ b/chromeos/network/network_handler_callbacks.h
@@ -39,10 +39,11 @@ CHROMEOS_EXPORT base::DictionaryValue* CreateErrorData(
 
 // Callback for Shill errors. |path| may be blank if not relevant.
 // Logs an error and calls |error_callback| if not null.
-void ShillErrorCallbackFunction(const std::string& path,
-                                const ErrorCallback& error_callback,
-                                const std::string& error_name,
-                                const std::string& error_message);
+CHROMEOS_EXPORT void ShillErrorCallbackFunction(
+    const std::string& path,
+    const ErrorCallback& error_callback,
+    const std::string& error_name,
+    const std::string& error_message);
 
 }  // namespace network_handler
 }  // namespace chromeos