proxy_config_service_impl.cc revision cedac228d2dd51db4b79ea1e72c7f249408ee061 
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "chrome/browser/chromeos/proxy_config_service_impl.h"
6
7#include "base/bind.h"
8#include "base/bind_helpers.h"
9#include "base/callback.h"
10#include "base/location.h"
11#include "base/logging.h"
12#include "base/prefs/pref_service.h"
13#include "base/values.h"
14#include "chrome/browser/browser_process.h"
15#include "chrome/browser/chromeos/login/users/user_manager.h"
16#include "chrome/browser/chromeos/net/proxy_config_handler.h"
17#include "chrome/browser/chromeos/policy/browser_policy_connector_chromeos.h"
18#include "chrome/browser/prefs/proxy_config_dictionary.h"
19#include "chrome/browser/prefs/proxy_prefs.h"
20#include "chrome/common/pref_names.h"
21#include "chromeos/network/favorite_state.h"
22#include "chromeos/network/network_profile.h"
23#include "chromeos/network/network_profile_handler.h"
24#include "chromeos/network/network_state.h"
25#include "chromeos/network/network_state_handler.h"
26#include "chromeos/network/onc/onc_utils.h"
27#include "components/policy/core/common/cloud/cloud_policy_constants.h"
28
29namespace chromeos {
30
31namespace {
32
33// Writes the proxy config of |network| to |proxy_config|.  Set |onc_source| to
34// the source of this configuration. Returns false if no
35// proxy was configured for this network.
36bool GetProxyConfig(const PrefService* profile_prefs,
37                    const PrefService* local_state_prefs,
38                    const FavoriteState& network,
39                    net::ProxyConfig* proxy_config,
40                    ::onc::ONCSource* onc_source) {
41  scoped_ptr<ProxyConfigDictionary> proxy_dict =
42      proxy_config::GetProxyConfigForFavoriteNetwork(
43          profile_prefs, local_state_prefs, network, onc_source);
44  if (!proxy_dict)
45    return false;
46  return PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(*proxy_dict,
47                                                           proxy_config);
48}
49
50}  // namespace
51
52ProxyConfigServiceImpl::ProxyConfigServiceImpl(PrefService* profile_prefs,
53                                               PrefService* local_state_prefs)
54    : PrefProxyConfigTrackerImpl(profile_prefs ? profile_prefs
55                                               : local_state_prefs),
56      active_config_state_(ProxyPrefs::CONFIG_UNSET),
57      profile_prefs_(profile_prefs),
58      local_state_prefs_(local_state_prefs),
59      pointer_factory_(this) {
60  const base::Closure proxy_change_callback = base::Bind(
61      &ProxyConfigServiceImpl::OnProxyPrefChanged, base::Unretained(this));
62
63  if (profile_prefs) {
64    profile_pref_registrar_.Init(profile_prefs);
65    profile_pref_registrar_.Add(prefs::kOpenNetworkConfiguration,
66                                proxy_change_callback);
67    profile_pref_registrar_.Add(prefs::kUseSharedProxies,
68                                proxy_change_callback);
69  }
70  local_state_pref_registrar_.Init(local_state_prefs);
71  local_state_pref_registrar_.Add(prefs::kDeviceOpenNetworkConfiguration,
72                                  proxy_change_callback);
73
74  // Register for changes to the default network.
75  NetworkStateHandler* state_handler =
76      NetworkHandler::Get()->network_state_handler();
77  state_handler->AddObserver(this, FROM_HERE);
78  DefaultNetworkChanged(state_handler->DefaultNetwork());
79}
80
81ProxyConfigServiceImpl::~ProxyConfigServiceImpl() {
82  if (NetworkHandler::IsInitialized()) {
83    NetworkHandler::Get()->network_state_handler()->RemoveObserver(
84        this, FROM_HERE);
85  }
86}
87
88void ProxyConfigServiceImpl::OnProxyConfigChanged(
89    ProxyPrefs::ConfigState config_state,
90    const net::ProxyConfig& config) {
91  VLOG(1) << "Got prefs change: "
92          << ProxyPrefs::ConfigStateToDebugString(config_state)
93          << ", mode=" << config.proxy_rules().type;
94  DetermineEffectiveConfigFromDefaultNetwork();
95}
96
97void ProxyConfigServiceImpl::OnProxyPrefChanged() {
98  DetermineEffectiveConfigFromDefaultNetwork();
99}
100
101void ProxyConfigServiceImpl::DefaultNetworkChanged(
102    const NetworkState* new_network) {
103  std::string new_network_path;
104  if (new_network)
105    new_network_path = new_network->path();
106
107  VLOG(1) << "DefaultNetworkChanged to '" << new_network_path << "'.";
108  VLOG_IF(1, new_network) << "New network: name=" << new_network->name()
109                          << ", profile=" << new_network->profile_path();
110
111  // Even if the default network is the same, its proxy config (e.g. if private
112  // version of network replaces the shared version after login), or
113  // use-shared-proxies setting (e.g. after login) may have changed, so
114  // re-determine effective proxy config, and activate if different.
115  DetermineEffectiveConfigFromDefaultNetwork();
116}
117
118// static
119bool ProxyConfigServiceImpl::IgnoreProxy(const PrefService* profile_prefs,
120                                         const std::string network_profile_path,
121                                         ::onc::ONCSource onc_source) {
122  if (!profile_prefs) {
123    // If the profile preference are not available, this must be the object
124    // associated to local state used for system requests or login-profile. Make
125    // sure that proxies are enabled.
126    VLOG(1) << "Use proxy for system requests and sign-in screen.";
127    return false;
128  }
129
130  if (network_profile_path.empty())
131    return true;
132
133  const NetworkProfile* profile = NetworkHandler::Get()
134      ->network_profile_handler()->GetProfileForPath(network_profile_path);
135  if (!profile) {
136    VLOG(1) << "Unknown profile_path '" << network_profile_path
137            << "'. Ignoring proxy.";
138    return true;
139  }
140  if (profile->type() == NetworkProfile::TYPE_USER) {
141    VLOG(1) << "Respect proxy of not-shared networks.";
142    return false;
143  }
144  if (onc_source == ::onc::ONC_SOURCE_DEVICE_POLICY) {
145    policy::BrowserPolicyConnectorChromeOS* connector =
146        g_browser_process->platform_part()->browser_policy_connector_chromeos();
147    const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
148    if (connector->GetUserAffiliation(logged_in_user->email()) ==
149        policy::USER_AFFILIATION_MANAGED) {
150      VLOG(1) << "Respecting proxy for network, as logged-in user belongs to "
151              << "the domain the device is enrolled to.";
152      return false;
153    }
154  }
155
156  // This network is shared and not managed by the user's domain.
157  bool use_shared_proxies = profile_prefs->GetBoolean(prefs::kUseSharedProxies);
158  VLOG(1) << "Use proxy of shared network: " << use_shared_proxies;
159  return !use_shared_proxies;
160}
161
162void ProxyConfigServiceImpl::DetermineEffectiveConfigFromDefaultNetwork() {
163  NetworkStateHandler* handler = NetworkHandler::Get()->network_state_handler();
164  const FavoriteState* network = handler->DefaultFavoriteNetwork();
165
166  // Get prefs proxy config if available.
167  net::ProxyConfig pref_config;
168  ProxyPrefs::ConfigState pref_state = GetProxyConfig(&pref_config);
169
170  // Get network proxy config if available.
171  net::ProxyConfig network_config;
172  net::ProxyConfigService::ConfigAvailability network_availability =
173      net::ProxyConfigService::CONFIG_UNSET;
174  bool ignore_proxy = true;
175  if (network) {
176    ::onc::ONCSource onc_source = ::onc::ONC_SOURCE_NONE;
177    const bool network_proxy_configured = chromeos::GetProxyConfig(
178        prefs(), local_state_prefs_, *network, &network_config, &onc_source);
179    ignore_proxy =
180        IgnoreProxy(profile_prefs_, network->profile_path(), onc_source);
181
182    // If network is shared but use-shared-proxies is off, use direct mode.
183    if (ignore_proxy) {
184      network_config = net::ProxyConfig();
185      network_availability = net::ProxyConfigService::CONFIG_VALID;
186    } else if (network_proxy_configured) {
187      // Network is private or shared with user using shared proxies.
188      VLOG(1) << this << ": using proxy of network " << network->path();
189      network_availability = net::ProxyConfigService::CONFIG_VALID;
190    }
191  }
192
193  // Determine effective proxy config, either from prefs or network.
194  ProxyPrefs::ConfigState effective_config_state;
195  net::ProxyConfig effective_config;
196  GetEffectiveProxyConfig(pref_state, pref_config,
197                          network_availability, network_config, ignore_proxy,
198                          &effective_config_state, &effective_config);
199
200  // Activate effective proxy and store into |active_config_|.
201  // If last update didn't complete, we definitely update now.
202  bool update_now = update_pending();
203  if (!update_now) {  // Otherwise, only update now if there're changes.
204    update_now = active_config_state_ != effective_config_state ||
205                 (active_config_state_ != ProxyPrefs::CONFIG_UNSET &&
206                  !active_config_.Equals(effective_config));
207  }
208  if (update_now) {  // Activate and store new effective config.
209    active_config_state_ = effective_config_state;
210    if (active_config_state_ != ProxyPrefs::CONFIG_UNSET)
211      active_config_ = effective_config;
212    // If effective config is from system (i.e. network), it's considered a
213    // special kind of prefs that ranks below policy/extension but above
214    // others, so bump it up to CONFIG_OTHER_PRECEDE to force its precedence
215    // when PrefProxyConfigTrackerImpl pushes it to ChromeProxyConfigService.
216    if (effective_config_state == ProxyPrefs::CONFIG_SYSTEM)
217      effective_config_state = ProxyPrefs::CONFIG_OTHER_PRECEDE;
218    // If config is manual, add rule to bypass local host.
219    if (effective_config.proxy_rules().type !=
220        net::ProxyConfig::ProxyRules::TYPE_NO_RULES) {
221      effective_config.proxy_rules().bypass_rules.AddRuleToBypassLocal();
222    }
223    PrefProxyConfigTrackerImpl::OnProxyConfigChanged(effective_config_state,
224                                                     effective_config);
225    if (VLOG_IS_ON(1) && !update_pending()) {  // Update was successful.
226      scoped_ptr<base::DictionaryValue> config_dict(effective_config.ToValue());
227      VLOG(1) << this << ": Proxy changed: "
228              << ProxyPrefs::ConfigStateToDebugString(active_config_state_)
229              << ", " << *config_dict;
230    }
231  }
232}
233
234}  // namespace chromeos
235