Componentize proxy code from chrome/browser/net

chrome/browser/ui/webui/options/chromeos/core_chromeos_options_handler.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/ui/webui/options/chromeos/core_chromeos_options_handler.h"
 
 #include <string>
 
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/prefs/pref_change_registrar.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_chromeos_factory.h"
 #include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/proxy_cros_settings_parser.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chromeos/ui_account_tweaks.h"
 #include "chrome/browser/ui/webui/options/chromeos/accounts_options_handler.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/proxy_config/proxy_config_pref_names.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace chromeos {
 namespace options {
 
 namespace {
@@ skipping 93 matching lines @@
   proxy_config_service_.UpdateFromPrefs();
 
   CoreOptionsHandler::InitializeHandler();
 
   PrefService* profile_prefs = NULL;
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!ProfileHelper::IsSigninProfile(profile)) {
     profile_prefs = profile->GetPrefs();
     ObservePref(prefs::kOpenNetworkConfiguration);
   }
-  ObservePref(prefs::kProxy);
+  ObservePref(proxy_config::prefs::kProxy);
   ObservePref(prefs::kDeviceOpenNetworkConfiguration);
   proxy_config_service_.SetPrefs(profile_prefs,
                                  g_browser_process->local_state());
 }
 
 void CoreChromeOSOptionsHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   // The only expected notification for now is this one.
@@ skipping 20 matching lines @@
     proxy_cros_settings_parser::GetProxyPrefValue(
         proxy_config_service_, pref_name, &value);
     if (!value)
       return base::Value::CreateNullValue().release();
 
     return value;
   }
 
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!CrosSettings::IsCrosSettings(pref_name)) {
-    std::string controlling_pref =
-        pref_name == prefs::kUseSharedProxies ? prefs::kProxy : std::string();
+    std::string controlling_pref = pref_name == prefs::kUseSharedProxies
+                                       ? proxy_config::prefs::kProxy
+                                       : std::string();
     base::Value* value = CreateValueForPref(pref_name, controlling_pref);
     if (!IsSettingShared(pref_name) || !IsSecondaryUser(profile))
       return value;
     base::DictionaryValue* dict;
     if (!value->GetAsDictionary(&dict) || dict->HasKey("controlledBy"))
       return value;
     Profile* primary_profile = ProfileHelper::Get()->GetProfileByUser(
         user_manager::UserManager::Get()->GetPrimaryUser());
     if (!primary_profile)
       return value;
@@ skipping 181 matching lines @@
   NotifyProxyPrefsChanged();
 }
 
 void CoreChromeOSOptionsHandler::OnPreferenceChanged(
     PrefService* service,
     const std::string& pref_name) {
   // Redetermine the current proxy settings and notify the UI if any of these
   // preferences change.
   if (pref_name == prefs::kOpenNetworkConfiguration ||
       pref_name == prefs::kDeviceOpenNetworkConfiguration ||
-      pref_name == prefs::kProxy) {
+      pref_name == proxy_config::prefs::kProxy) {
     NotifyProxyPrefsChanged();
     return;
   }
   if (pref_name == prefs::kUseSharedProxies) {
     // kProxy controls kUseSharedProxies and decides if it's managed by
     // policy/extension.
-    NotifyPrefChanged(prefs::kUseSharedProxies, prefs::kProxy);
+    NotifyPrefChanged(prefs::kUseSharedProxies, proxy_config::prefs::kProxy);
     return;
   }
   ::options::CoreOptionsHandler::OnPreferenceChanged(service, pref_name);
 }
 
 void CoreChromeOSOptionsHandler::NotifySettingsChanged(
     const std::string& setting_name) {
   DCHECK(CrosSettings::Get()->IsCrosSettings(setting_name));
   scoped_ptr<base::Value> value(FetchPref(setting_name));
   if (!value.get())
     NOTREACHED();
   DispatchPrefChangeNotification(setting_name, value.Pass());
 }
 
 void CoreChromeOSOptionsHandler::NotifyProxyPrefsChanged() {
   proxy_config_service_.UpdateFromPrefs();
   for (size_t i = 0; i < kProxySettingsCount; ++i) {
     base::Value* value = NULL;
     proxy_cros_settings_parser::GetProxyPrefValue(
         proxy_config_service_, kProxySettings[i], &value);
     DCHECK(value);
     scoped_ptr<base::Value> ptr(value);
     DispatchPrefChangeNotification(kProxySettings[i], ptr.Pass());
   }
 }
 
 }  // namespace options
 }  // namespace chromeos