redesign and reimplement proxy config service and tracker, revise proxy ui on cros

chrome/browser/net/pref_proxy_config_service.cc

 // Copyright (c) 2011 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/net/pref_proxy_config_service.h"
 
 #include "base/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_set_observer.h"
 #include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_details.h"
 #include "content/common/notification_source.h"
 
 PrefProxyConfigTracker::PrefProxyConfigTracker(PrefService* pref_service)
     : pref_service_(pref_service) {
-  config_state_ = ReadPrefConfig(&pref_config_);
+  ui_config_state_ = ReadPrefConfig(&ui_pref_config_, &ui_config_source_);
+  io_config_state_ = ui_config_state_;
+  io_pref_config_ = ui_pref_config_;
+  io_config_source_ = ui_config_source_;
   proxy_prefs_observer_.reset(
       PrefSetObserver::CreateProxyPrefSetObserver(pref_service_, this));
 }
 
 PrefProxyConfigTracker::~PrefProxyConfigTracker() {
   DCHECK(pref_service_ == NULL);
 }
 
 PrefProxyConfigTracker::ConfigState
-    PrefProxyConfigTracker::GetProxyConfig(net::ProxyConfig* config) {
+    PrefProxyConfigTracker::IOGetProxyConfig(net::ProxyConfig* config,
+                                             ConfigSource* config_source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (config_state_ != CONFIG_UNSET)
-    *config = pref_config_;
-  return config_state_;
+  if (io_config_state_ != CONFIG_UNSET) {
+    *config = io_pref_config_;
+    *config_source = io_config_source_;
+  }
+  return io_config_state_;
+}
+
+PrefProxyConfigTracker::ConfigState
+    PrefProxyConfigTracker::UIGetProxyConfig(net::ProxyConfig* config,
+                                             ConfigSource* config_source) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (ui_config_state_ != CONFIG_UNSET) {
+    *config = ui_pref_config_;
+    *config_source = ui_config_source_;
+  }
+  return ui_config_state_;
 }
 
 void PrefProxyConfigTracker::DetachFromPrefService() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Stop notifications.
   proxy_prefs_observer_.reset();
   pref_service_ = NULL;
 }
 
 void PrefProxyConfigTracker::AddObserver(
     PrefProxyConfigTracker::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   observers_.AddObserver(observer);
 }
 
 void PrefProxyConfigTracker::RemoveObserver(
     PrefProxyConfigTracker::Observer* observer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   observers_.RemoveObserver(observer);
 }
 
 void PrefProxyConfigTracker::Observe(int type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (type == chrome::NOTIFICATION_PREF_CHANGED &&
       Source<PrefService>(source).ptr() == pref_service_) {
     net::ProxyConfig new_config;
-    ConfigState config_state = ReadPrefConfig(&new_config);
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        NewRunnableMethod(this,
-                          &PrefProxyConfigTracker::InstallProxyConfig,
-                          new_config, config_state));
+    ConfigSource config_source;
+    ConfigState config_state = ReadPrefConfig(&new_config, &config_source);
+    if (ui_config_state_ != config_state ||
+        (ui_config_state_ != CONFIG_UNSET &&
+         (ui_config_source_ != config_source ||
+          !ui_pref_config_.Equals(new_config)))) {
+      ui_config_state_ = config_state;
+      if (ui_config_state_ != CONFIG_UNSET) {
+        ui_pref_config_ = new_config;
+        ui_config_source_ = config_source;
+      }
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          NewRunnableMethod(this,
+                            &PrefProxyConfigTracker::InstallProxyConfig,
+                            new_config, config_state, config_source));
+    }
   } else {
     NOTREACHED() << "Unexpected notification of type " << type;
   }
 }
 
 void PrefProxyConfigTracker::InstallProxyConfig(
     const net::ProxyConfig& config,
-    PrefProxyConfigTracker::ConfigState config_state) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (config_state_ != config_state ||
-      (config_state_ != CONFIG_UNSET && !pref_config_.Equals(config))) {
-    config_state_ = config_state;
-    if (config_state_ != CONFIG_UNSET)
-      pref_config_ = config;
-    FOR_EACH_OBSERVER(Observer, observers_, OnPrefProxyConfigChanged());
+    PrefProxyConfigTracker::ConfigState config_state,
+    PrefProxyConfigTracker::ConfigSource config_source) {
+  io_config_state_ = config_state;
+  if (io_config_state_ != CONFIG_UNSET) {
+    io_pref_config_ = config;
+    io_config_source_ = config_source;
   }
+  FOR_EACH_OBSERVER(Observer, observers_, OnPrefProxyConfigChanged());
 }
 
 PrefProxyConfigTracker::ConfigState
-    PrefProxyConfigTracker::ReadPrefConfig(net::ProxyConfig* config) {
+    PrefProxyConfigTracker::ReadPrefConfig(net::ProxyConfig* config,
+                                           ConfigSource* config_source) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Clear the configuration.
+  // Clear the configuration and source.
   *config = net::ProxyConfig();
+  *config_source = CONFIG_SOURCE_UNSET;
 
   const PrefService::Preference* pref =
       pref_service_->FindPreference(prefs::kProxy);
   DCHECK(pref);
 
   const DictionaryValue* dict = pref_service_->GetDictionary(prefs::kProxy);
   DCHECK(dict);
   ProxyConfigDictionary proxy_dict(dict);
 
   if (PrefConfigToNetConfig(proxy_dict, config)) {
-    return (!pref->IsUserModifiable() || pref->HasUserSetting()) ?
-        CONFIG_PRESENT : CONFIG_FALLBACK;
+    if (!pref->IsUserModifiable() || pref->HasUserSetting()) {
+      if (pref->IsManaged())
+        *config_source = CONFIG_SOURCE_POLICY;
+      else if (pref->IsExtensionControlled())
+        *config_source = CONFIG_SOURCE_EXTENSION;
+      return CONFIG_PRESENT;
+    } else  {
+      *config_source = CONFIG_SOURCE_FALLBACK;
+      return CONFIG_FALLBACK;
+    }
   }
 
   return CONFIG_UNSET;
 }
 
 bool PrefProxyConfigTracker::PrefConfigToNetConfig(
     const ProxyConfigDictionary& proxy_dict,
     net::ProxyConfig* config) {
   ProxyPrefs::ProxyMode mode;
   if (!proxy_dict.GetMode(&mode)) {
@@ skipping 46 matching lines @@
       return true;
     }
     case ProxyPrefs::kModeCount: {
       // Fall through to NOTREACHED().
     }
   }
   NOTREACHED() << "Unknown proxy mode, falling back to system settings.";
   return false;
 }
 
+net::ProxyConfigService::ConfigAvailability
+    ProxyConfigDecider::GetEffectiveProxyConfig(
+        PrefProxyConfigTracker::ConfigState pref_state,
+        const net::ProxyConfig& pref_config,
+        PrefProxyConfigTracker::ConfigSource pref_source,
+        net::ProxyConfigService::ConfigAvailability system_availability,
+        const net::ProxyConfig& system_config,
+        bool ignore_fallback_config,
+        net::ProxyConfig* config,
+        PrefProxyConfigTracker::ConfigSource* config_source) {
+  *config_source = pref_source;
+
+  if (pref_state == PrefProxyConfigTracker::CONFIG_PRESENT) {
+    *config = pref_config;
+    return net::ProxyConfigService::CONFIG_VALID;
+  }
+
+  // There's no system proxy config, fall back to prefs or default.
+  if (system_availability == net::ProxyConfigService::CONFIG_UNSET) {
+    if (pref_state == PrefProxyConfigTracker::CONFIG_FALLBACK &&
+        !ignore_fallback_config) {
+      *config = pref_config;
+    } else {
+      *config = net::ProxyConfig::CreateDirect();
+    }
+    return net::ProxyConfigService::CONFIG_VALID;
+  }
+
+  *config = system_config;
+  *config_source = PrefProxyConfigTracker::CONFIG_SOURCE_SYSTEM;
+  return system_availability;
+}
+
 PrefProxyConfigService::PrefProxyConfigService(
     PrefProxyConfigTracker* tracker,
     net::ProxyConfigService* base_service)
     : base_service_(base_service),
       pref_config_tracker_(tracker),
       registered_observers_(false) {
 }
 
 PrefProxyConfigService::~PrefProxyConfigService() {
   if (registered_observers_) {
     base_service_->RemoveObserver(this);
     pref_config_tracker_->RemoveObserver(this);
   }
 }
 
 void PrefProxyConfigService::AddObserver(
     net::ProxyConfigService::Observer* observer) {
   RegisterObservers();
   observers_.AddObserver(observer);
 }
 
 void PrefProxyConfigService::RemoveObserver(
     net::ProxyConfigService::Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 net::ProxyConfigService::ConfigAvailability
     PrefProxyConfigService::GetLatestProxyConfig(net::ProxyConfig* config) {
   RegisterObservers();
+
+  // Get prefs proxy config.
   net::ProxyConfig pref_config;
-  PrefProxyConfigTracker::ConfigState state =
-      pref_config_tracker_->GetProxyConfig(&pref_config);
-  if (state == PrefProxyConfigTracker::CONFIG_PRESENT) {
-    *config = pref_config;
-    return CONFIG_VALID;
-  }
+  PrefProxyConfigTracker::ConfigSource pref_source;
+  PrefProxyConfigTracker::ConfigState pref_state =
+      pref_config_tracker_->IOGetProxyConfig(&pref_config, &pref_source);
 
   // Ask the base service.
-  ConfigAvailability available = base_service_->GetLatestProxyConfig(config);
+  net::ProxyConfig system_config;
+  ConfigAvailability system_availability =
+      base_service_->GetLatestProxyConfig(&system_config);
 
-  // Base service doesn't have a configuration, fall back to prefs or default.
-  if (available == CONFIG_UNSET) {
-    if (state == PrefProxyConfigTracker::CONFIG_FALLBACK)
-      *config = pref_config;
-    else
-      *config = net::ProxyConfig::CreateDirect();
-    return CONFIG_VALID;
-  }
-
-  return available;
+  PrefProxyConfigTracker::ConfigSource config_source;
+  return GetEffectiveProxyConfig(pref_state, pref_config, pref_source,
+                                 system_availability, system_config, false,
+                                 config, &config_source);
 }
 
 void PrefProxyConfigService::OnLazyPoll() {
   base_service_->OnLazyPoll();
 }
 
 void PrefProxyConfigService::OnProxyConfigChanged(
     const net::ProxyConfig& config,
     ConfigAvailability availability) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Check whether there is a proxy configuration defined by preferences. In
   // this case that proxy configuration takes precedence and the change event
   // from the delegate proxy service can be disregarded.
   net::ProxyConfig actual_config;
-  if (pref_config_tracker_->GetProxyConfig(&actual_config) !=
+  PrefProxyConfigTracker::ConfigSource config_source;
+  if (pref_config_tracker_->IOGetProxyConfig(&actual_config, &config_source) !=
           PrefProxyConfigTracker::CONFIG_PRESENT) {
     availability = GetLatestProxyConfig(&actual_config);
     FOR_EACH_OBSERVER(net::ProxyConfigService::Observer, observers_,
                       OnProxyConfigChanged(actual_config, availability));
   }
 }
 
 void PrefProxyConfigService::OnPrefProxyConfigChanged() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
@@ skipping 22 matching lines @@
   }
 }
 
 // static
 void PrefProxyConfigService::RegisterPrefs(PrefService* pref_service) {
   DictionaryValue* default_settings = ProxyConfigDictionary::CreateSystem();
   pref_service->RegisterDictionaryPref(prefs::kProxy,
                                        default_settings,
                                        PrefService::UNSYNCABLE_PREF);
 }