Move onc and proxy pref names to components.

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/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/net/proxy_config_handler.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/onc/onc_pref_names.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/prefs/pref_service.h"
 #include "components/proxy_config/pref_proxy_config_tracker_impl.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "components/proxy_config/proxy_prefs.h"
 #include "components/user_manager/user_manager.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace chromeos {
@@ skipping 27 matching lines @@
               content::BrowserThread::IO)),
       active_config_state_(ProxyPrefs::CONFIG_UNSET),
       profile_prefs_(profile_prefs),
       local_state_prefs_(local_state_prefs),
       pointer_factory_(this) {
   const base::Closure proxy_change_callback = base::Bind(
       &ProxyConfigServiceImpl::OnProxyPrefChanged, base::Unretained(this));
 
   if (profile_prefs) {
     profile_pref_registrar_.Init(profile_prefs);
-    profile_pref_registrar_.Add(prefs::kOpenNetworkConfiguration,
+    profile_pref_registrar_.Add(::onc::prefs::kOpenNetworkConfiguration,
                                 proxy_change_callback);
-    profile_pref_registrar_.Add(prefs::kUseSharedProxies,
+    profile_pref_registrar_.Add(::proxy_config::prefs::kUseSharedProxies,
                                 proxy_change_callback);
   }
   local_state_pref_registrar_.Init(local_state_prefs);
-  local_state_pref_registrar_.Add(prefs::kDeviceOpenNetworkConfiguration,
+  local_state_pref_registrar_.Add(::onc::prefs::kDeviceOpenNetworkConfiguration,
                                   proxy_change_callback);
 
   // Register for changes to the default network.
   NetworkStateHandler* state_handler =
       NetworkHandler::Get()->network_state_handler();
   state_handler->AddObserver(this, FROM_HERE);
   DefaultNetworkChanged(state_handler->DefaultNetwork());
 }
 
 ProxyConfigServiceImpl::~ProxyConfigServiceImpl() {
@@ skipping 77 matching lines @@
     const user_manager::User* logged_in_user =
         user_manager::UserManager::Get()->GetLoggedInUser();
     if (logged_in_user->IsAffiliated()) {
       VLOG(1) << "Respecting proxy for network, as logged-in user belongs to "
               << "the domain the device is enrolled to.";
       return false;
     }
   }
 
   // This network is shared and not managed by the user's domain.
-  bool use_shared_proxies = profile_prefs->GetBoolean(prefs::kUseSharedProxies);
+  bool use_shared_proxies =
+      profile_prefs->GetBoolean(::proxy_config::prefs::kUseSharedProxies);
   VLOG(1) << "Use proxy of shared network: " << use_shared_proxies;
   return !use_shared_proxies;
 }
 
 // static
 std::unique_ptr<ProxyConfigDictionary>
 ProxyConfigServiceImpl::GetActiveProxyConfigDictionary(
-    const PrefService* profile_prefs) {
+    const PrefService* profile_prefs,
+    const PrefService* local_state_prefs) {
   // Apply Pref Proxy configuration if available.
   net::ProxyConfig pref_proxy_config;
   ProxyPrefs::ConfigState pref_state =
       PrefProxyConfigTrackerImpl::ReadPrefConfig(profile_prefs,
                                                  &pref_proxy_config);
   if (PrefProxyConfigTrackerImpl::PrefPrecedes(pref_state)) {
     const PrefService::Preference* const pref =
         profile_prefs->FindPreference(::proxy_config::prefs::kProxy);
     const base::DictionaryValue* proxy_config_value;
     bool value_exists = pref->GetValue()->GetAsDictionary(&proxy_config_value);
     DCHECK(value_exists);
 
     return base::MakeUnique<ProxyConfigDictionary>(proxy_config_value);
   }
 
   const chromeos::NetworkState* network = chromeos::NetworkHandler::Get()
                                               ->network_state_handler()
                                               ->DefaultNetwork();
   // No connected network.
   if (!network)
     return nullptr;
 
   // Apply network proxy configuration.
   ::onc::ONCSource onc_source;
   std::unique_ptr<ProxyConfigDictionary> proxy_config =
       chromeos::proxy_config::GetProxyConfigForNetwork(
-          profile_prefs, g_browser_process->local_state(), *network,
-          &onc_source);
+          profile_prefs, local_state_prefs, *network, &onc_source);
   if (!chromeos::ProxyConfigServiceImpl::IgnoreProxy(
           profile_prefs, network->profile_path(), onc_source))
     return proxy_config;
 
   return base::MakeUnique<ProxyConfigDictionary>(
       ProxyConfigDictionary::CreateDirect());
 }
 
 void ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork() {
   if (!NetworkHandler::IsInitialized())
@@ skipping 65 matching lines @@
       std::unique_ptr<base::DictionaryValue> config_dict(
           effective_config.ToValue());
       VLOG(1) << this << ": Proxy changed: "
               << ProxyPrefs::ConfigStateToDebugString(active_config_state_)
               << ", " << *config_dict;
     }
   }
 }
 
 }  // namespace chromeos