1 // Copyright (c) 2011 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/net/pref_proxy_config_tracker_impl.h" 6 7 #include "base/bind.h" 8 #include "base/prefs/pref_registry_simple.h" 9 #include "base/prefs/pref_service.h" 10 #include "base/values.h" 11 #include "chrome/browser/chrome_notification_types.h" 12 #include "chrome/browser/prefs/proxy_config_dictionary.h" 13 #include "chrome/common/pref_names.h" 14 #include "components/pref_registry/pref_registry_syncable.h" 15 #include "content/public/browser/browser_thread.h" 16 #include "content/public/browser/notification_details.h" 17 #include "content/public/browser/notification_source.h" 18 19 using content::BrowserThread; 20 21 //============================= ChromeProxyConfigService ======================= 22 23 ChromeProxyConfigService::ChromeProxyConfigService( 24 net::ProxyConfigService* base_service) 25 : base_service_(base_service), 26 pref_config_state_(ProxyPrefs::CONFIG_UNSET), 27 pref_config_read_pending_(true), 28 registered_observer_(false) { 29 } 30 31 ChromeProxyConfigService::~ChromeProxyConfigService() { 32 if (registered_observer_ && base_service_.get()) 33 base_service_->RemoveObserver(this); 34 } 35 36 void ChromeProxyConfigService::AddObserver( 37 net::ProxyConfigService::Observer* observer) { 38 RegisterObserver(); 39 observers_.AddObserver(observer); 40 } 41 42 void ChromeProxyConfigService::RemoveObserver( 43 net::ProxyConfigService::Observer* observer) { 44 observers_.RemoveObserver(observer); 45 } 46 47 net::ProxyConfigService::ConfigAvailability 48 ChromeProxyConfigService::GetLatestProxyConfig(net::ProxyConfig* config) { 49 RegisterObserver(); 50 51 if (pref_config_read_pending_) 52 return net::ProxyConfigService::CONFIG_PENDING; 53 54 // Ask the base service if available. 55 net::ProxyConfig system_config; 56 ConfigAvailability system_availability = 57 net::ProxyConfigService::CONFIG_UNSET; 58 if (base_service_.get()) 59 system_availability = base_service_->GetLatestProxyConfig(&system_config); 60 61 ProxyPrefs::ConfigState config_state; 62 return PrefProxyConfigTrackerImpl::GetEffectiveProxyConfig( 63 pref_config_state_, pref_config_, 64 system_availability, system_config, false, 65 &config_state, config); 66 } 67 68 void ChromeProxyConfigService::OnLazyPoll() { 69 if (base_service_.get()) 70 base_service_->OnLazyPoll(); 71 } 72 73 void ChromeProxyConfigService::UpdateProxyConfig( 74 ProxyPrefs::ConfigState config_state, 75 const net::ProxyConfig& config) { 76 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 77 78 pref_config_read_pending_ = false; 79 pref_config_state_ = config_state; 80 pref_config_ = config; 81 82 if (!observers_.might_have_observers()) 83 return; 84 85 // Evaluate the proxy configuration. If GetLatestProxyConfig returns 86 // CONFIG_PENDING, we are using the system proxy service, but it doesn't have 87 // a valid configuration yet. Once it is ready, OnProxyConfigChanged() will be 88 // called and broadcast the proxy configuration. 89 // Note: If a switch between a preference proxy configuration and the system 90 // proxy configuration occurs an unnecessary notification might get send if 91 // the two configurations agree. This case should be rare however, so we don't 92 // handle that case specially. 93 net::ProxyConfig new_config; 94 ConfigAvailability availability = GetLatestProxyConfig(&new_config); 95 if (availability != CONFIG_PENDING) { 96 FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_, 97 OnProxyConfigChanged(new_config, availability)); 98 } 99 } 100 101 void ChromeProxyConfigService::OnProxyConfigChanged( 102 const net::ProxyConfig& config, 103 ConfigAvailability availability) { 104 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 105 106 // Check whether there is a proxy configuration defined by preferences. In 107 // this case that proxy configuration takes precedence and the change event 108 // from the delegate proxy service can be disregarded. 109 if (!PrefProxyConfigTrackerImpl::PrefPrecedes(pref_config_state_)) { 110 net::ProxyConfig actual_config; 111 availability = GetLatestProxyConfig(&actual_config); 112 FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_, 113 OnProxyConfigChanged(actual_config, availability)); 114 } 115 } 116 117 void ChromeProxyConfigService::RegisterObserver() { 118 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 119 if (!registered_observer_ && base_service_.get()) { 120 base_service_->AddObserver(this); 121 registered_observer_ = true; 122 } 123 } 124 125 //========================= PrefProxyConfigTrackerImpl ========================= 126 127 PrefProxyConfigTrackerImpl::PrefProxyConfigTrackerImpl( 128 PrefService* pref_service) 129 : pref_service_(pref_service), 130 chrome_proxy_config_service_(NULL), 131 update_pending_(true) { 132 config_state_ = ReadPrefConfig(pref_service_, &pref_config_); 133 proxy_prefs_.Init(pref_service); 134 proxy_prefs_.Add(prefs::kProxy, 135 base::Bind(&PrefProxyConfigTrackerImpl::OnProxyPrefChanged, 136 base::Unretained(this))); 137 } 138 139 PrefProxyConfigTrackerImpl::~PrefProxyConfigTrackerImpl() { 140 DCHECK(pref_service_ == NULL); 141 } 142 143 scoped_ptr<net::ProxyConfigService> 144 PrefProxyConfigTrackerImpl::CreateTrackingProxyConfigService( 145 scoped_ptr<net::ProxyConfigService> base_service) { 146 chrome_proxy_config_service_ = 147 new ChromeProxyConfigService(base_service.release()); 148 VLOG(1) << this << ": set chrome proxy config service to " 149 << chrome_proxy_config_service_; 150 if (chrome_proxy_config_service_ && update_pending_) 151 OnProxyConfigChanged(config_state_, pref_config_); 152 153 return scoped_ptr<net::ProxyConfigService>(chrome_proxy_config_service_); 154 } 155 156 void PrefProxyConfigTrackerImpl::DetachFromPrefService() { 157 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 158 // Stop notifications. 159 proxy_prefs_.RemoveAll(); 160 pref_service_ = NULL; 161 chrome_proxy_config_service_ = NULL; 162 } 163 164 // static 165 bool PrefProxyConfigTrackerImpl::PrefPrecedes( 166 ProxyPrefs::ConfigState config_state) { 167 return config_state == ProxyPrefs::CONFIG_POLICY || 168 config_state == ProxyPrefs::CONFIG_EXTENSION || 169 config_state == ProxyPrefs::CONFIG_OTHER_PRECEDE; 170 } 171 172 // static 173 net::ProxyConfigService::ConfigAvailability 174 PrefProxyConfigTrackerImpl::GetEffectiveProxyConfig( 175 ProxyPrefs::ConfigState pref_state, 176 const net::ProxyConfig& pref_config, 177 net::ProxyConfigService::ConfigAvailability system_availability, 178 const net::ProxyConfig& system_config, 179 bool ignore_fallback_config, 180 ProxyPrefs::ConfigState* effective_config_state, 181 net::ProxyConfig* effective_config) { 182 *effective_config_state = pref_state; 183 184 if (PrefPrecedes(pref_state)) { 185 *effective_config = pref_config; 186 return net::ProxyConfigService::CONFIG_VALID; 187 } 188 189 // If there's no system proxy config, fall back to prefs or default. 190 if (system_availability == net::ProxyConfigService::CONFIG_UNSET) { 191 if (pref_state == ProxyPrefs::CONFIG_FALLBACK && !ignore_fallback_config) 192 *effective_config = pref_config; 193 else 194 *effective_config = net::ProxyConfig::CreateDirect(); 195 return net::ProxyConfigService::CONFIG_VALID; 196 } 197 198 *effective_config_state = ProxyPrefs::CONFIG_SYSTEM; 199 *effective_config = system_config; 200 return system_availability; 201 } 202 203 // static 204 void PrefProxyConfigTrackerImpl::RegisterPrefs(PrefRegistrySimple* registry) { 205 base::DictionaryValue* default_settings = 206 ProxyConfigDictionary::CreateSystem(); 207 registry->RegisterDictionaryPref(prefs::kProxy, default_settings); 208 } 209 210 // static 211 void PrefProxyConfigTrackerImpl::RegisterProfilePrefs( 212 user_prefs::PrefRegistrySyncable* pref_service) { 213 base::DictionaryValue* default_settings = 214 ProxyConfigDictionary::CreateSystem(); 215 pref_service->RegisterDictionaryPref( 216 prefs::kProxy, 217 default_settings, 218 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 219 } 220 221 // static 222 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::ReadPrefConfig( 223 const PrefService* pref_service, 224 net::ProxyConfig* config) { 225 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 226 227 // Clear the configuration and source. 228 *config = net::ProxyConfig(); 229 ProxyPrefs::ConfigState config_state = ProxyPrefs::CONFIG_UNSET; 230 231 const PrefService::Preference* pref = 232 pref_service->FindPreference(prefs::kProxy); 233 DCHECK(pref); 234 235 const base::DictionaryValue* dict = 236 pref_service->GetDictionary(prefs::kProxy); 237 DCHECK(dict); 238 ProxyConfigDictionary proxy_dict(dict); 239 240 if (PrefConfigToNetConfig(proxy_dict, config)) { 241 if (!pref->IsUserModifiable() || pref->HasUserSetting()) { 242 if (pref->IsManaged()) 243 config_state = ProxyPrefs::CONFIG_POLICY; 244 else if (pref->IsExtensionControlled()) 245 config_state = ProxyPrefs::CONFIG_EXTENSION; 246 else 247 config_state = ProxyPrefs::CONFIG_OTHER_PRECEDE; 248 } else { 249 config_state = ProxyPrefs::CONFIG_FALLBACK; 250 } 251 } 252 253 return config_state; 254 } 255 256 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::GetProxyConfig( 257 net::ProxyConfig* config) { 258 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 259 if (config_state_ != ProxyPrefs::CONFIG_UNSET) 260 *config = pref_config_; 261 return config_state_; 262 } 263 264 void PrefProxyConfigTrackerImpl::OnProxyConfigChanged( 265 ProxyPrefs::ConfigState config_state, 266 const net::ProxyConfig& config) { 267 if (!chrome_proxy_config_service_) { 268 VLOG(1) << "No chrome proxy config service to push to UpdateProxyConfig"; 269 update_pending_ = true; 270 return; 271 } 272 update_pending_ = !BrowserThread::PostTask( 273 BrowserThread::IO, FROM_HERE, 274 base::Bind(&ChromeProxyConfigService::UpdateProxyConfig, 275 base::Unretained(chrome_proxy_config_service_), 276 config_state, config)); 277 VLOG(1) << this << (update_pending_ ? ": Error" : ": Done") 278 << " pushing proxy to UpdateProxyConfig"; 279 } 280 281 bool PrefProxyConfigTrackerImpl::PrefConfigToNetConfig( 282 const ProxyConfigDictionary& proxy_dict, 283 net::ProxyConfig* config) { 284 ProxyPrefs::ProxyMode mode; 285 if (!proxy_dict.GetMode(&mode)) { 286 // Fall back to system settings if the mode preference is invalid. 287 return false; 288 } 289 290 switch (mode) { 291 case ProxyPrefs::MODE_SYSTEM: 292 // Use system settings. 293 return false; 294 case ProxyPrefs::MODE_DIRECT: 295 // Ignore all the other proxy config preferences if the use of a proxy 296 // has been explicitly disabled. 297 return true; 298 case ProxyPrefs::MODE_AUTO_DETECT: 299 config->set_auto_detect(true); 300 return true; 301 case ProxyPrefs::MODE_PAC_SCRIPT: { 302 std::string proxy_pac; 303 if (!proxy_dict.GetPacUrl(&proxy_pac)) { 304 LOG(ERROR) << "Proxy settings request PAC script but do not specify " 305 << "its URL. Falling back to direct connection."; 306 return true; 307 } 308 GURL proxy_pac_url(proxy_pac); 309 if (!proxy_pac_url.is_valid()) { 310 LOG(ERROR) << "Invalid proxy PAC url: " << proxy_pac; 311 return true; 312 } 313 config->set_pac_url(proxy_pac_url); 314 bool pac_mandatory = false; 315 proxy_dict.GetPacMandatory(&pac_mandatory); 316 config->set_pac_mandatory(pac_mandatory); 317 return true; 318 } 319 case ProxyPrefs::MODE_FIXED_SERVERS: { 320 std::string proxy_server; 321 if (!proxy_dict.GetProxyServer(&proxy_server)) { 322 LOG(ERROR) << "Proxy settings request fixed proxy servers but do not " 323 << "specify their URLs. Falling back to direct connection."; 324 return true; 325 } 326 config->proxy_rules().ParseFromString(proxy_server); 327 328 std::string proxy_bypass; 329 if (proxy_dict.GetBypassList(&proxy_bypass)) { 330 config->proxy_rules().bypass_rules.ParseFromString(proxy_bypass); 331 } 332 return true; 333 } 334 case ProxyPrefs::kModeCount: { 335 // Fall through to NOTREACHED(). 336 } 337 } 338 NOTREACHED() << "Unknown proxy mode, falling back to system settings."; 339 return false; 340 } 341 342 void PrefProxyConfigTrackerImpl::OnProxyPrefChanged() { 343 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 344 net::ProxyConfig new_config; 345 ProxyPrefs::ConfigState config_state = ReadPrefConfig(pref_service_, 346 &new_config); 347 if (config_state_ != config_state || 348 (config_state_ != ProxyPrefs::CONFIG_UNSET && 349 !pref_config_.Equals(new_config))) { 350 config_state_ = config_state; 351 if (config_state_ != ProxyPrefs::CONFIG_UNSET) 352 pref_config_ = new_config; 353 update_pending_ = true; 354 } 355 if (update_pending_) 356 OnProxyConfigChanged(config_state, new_config); 357 } 358
