Make CrOS proxy configuration write prefs directly.

chrome/browser/net/pref_proxy_config_service.cc

Index: chrome/browser/net/pref_proxy_config_service.cc
diff --git a/chrome/browser/net/pref_proxy_config_service.cc b/chrome/browser/net/pref_proxy_config_service.cc
index e783f39a5086e47836392e835e68bbefd176918b..0313736b95b951e22c507df90edee3147f5236d3 100644
--- a/chrome/browser/net/pref_proxy_config_service.cc
+++ b/chrome/browser/net/pref_proxy_config_service.cc
@@ -5,6 +5,7 @@
 #include "chrome/browser/net/pref_proxy_config_service.h"
 
 #include "base/values.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/pref_set_observer.h"
@@ -14,11 +15,21 @@
 #include "chrome/common/notification_type.h"
 #include "chrome/common/pref_names.h"
 
-PrefProxyConfigTracker::PrefProxyConfigTracker(PrefService* pref_service)
-    : pref_service_(pref_service) {
+PrefProxyConfigTracker::PrefProxyConfigTracker(
+    PrefService* pref_service,
+    PrefService* fallback_pref_service)
+    : pref_service_(pref_service),
+      fallback_pref_service_(fallback_pref_service) {
   valid_ = ReadPrefConfig(&pref_config_);
   proxy_prefs_observer_.reset(
       PrefSetObserver::CreateProxyPrefSetObserver(pref_service_, this));
+
+  // Also install an observer on |fallback_pref_service_|, if appropriate.
+  if (fallback_pref_service_) {
+    fallback_proxy_prefs_observer_.reset(
+        PrefSetObserver::CreateProxyPrefSetObserver(fallback_pref_service_,
+                                                    this));
+  }
 }
 
 PrefProxyConfigTracker::~PrefProxyConfigTracker() {
@@ -37,6 +48,8 @@ void PrefProxyConfigTracker::DetachFromPrefService() {
   // Stop notifications.
   proxy_prefs_observer_.reset();
   pref_service_ = NULL;
+  fallback_proxy_prefs_observer_.reset();
+  fallback_pref_service_ = NULL;
 }
 
 void PrefProxyConfigTracker::AddObserver(
@@ -55,8 +68,9 @@ void PrefProxyConfigTracker::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  const PrefService* pref_source = Source<PrefService>(source).ptr();
   if (type == NotificationType::PREF_CHANGED &&
-      Source<PrefService>(source).ptr() == pref_service_) {
+      (pref_source == pref_service_ || pref_source == fallback_pref_service_)) {
     net::ProxyConfig new_config;
     bool valid = ReadPrefConfig(&new_config);
     BrowserThread::PostTask(
@@ -86,7 +100,28 @@ bool PrefProxyConfigTracker::ReadPrefConfig(net::ProxyConfig* config) {
   // Clear the configuration.
   *config = net::ProxyConfig();
 
-  ProxyConfigDictionary proxy_dict(pref_service_->GetDictionary(prefs::kProxy));
+  const PrefService::Preference* pref =
+      pref_service_->FindPreference(prefs::kProxy);
+  if (!pref) {
+    NOTREACHED();
+    return true;
+  }
+
+  const DictionaryValue* proxy_value =
+      pref_service_->GetDictionary(prefs::kProxy);
+  if (fallback_pref_service_ &&
+      pref->IsUserModifiable() &&
+      !pref->HasUserSetting()) {
+    // Default to the fallback, if existing.
+    const PrefService::Preference* fallback_pref =
+        fallback_pref_service_->FindPreference(prefs::kProxy);
+    if (!fallback_pref)
+      NOTREACHED();
+    else if (fallback_pref->HasUserSetting())
+      proxy_value = fallback_pref_service_->GetMutableDictionary(prefs::kProxy);
+  }
+
+  ProxyConfigDictionary proxy_dict(proxy_value);
 
   ProxyPrefs::ProxyMode mode;
   if (!proxy_dict.GetMode(&mode)) {
@@ -153,7 +188,8 @@ PrefProxyConfigService::PrefProxyConfigService(
 
 PrefProxyConfigService::~PrefProxyConfigService() {
   if (registered_observers_) {
-    base_service_->RemoveObserver(this);
+    if (base_service_.get())
+      base_service_->RemoveObserver(this);
     pref_config_tracker_->RemoveObserver(this);
   }
 }
@@ -177,11 +213,17 @@ bool PrefProxyConfigService::GetLatestProxyConfig(net::ProxyConfig* config) {
     return true;
   }
 
-  return base_service_->GetLatestProxyConfig(config);
+  if (base_service_.get())
+    return base_service_->GetLatestProxyConfig(config);
+
+  // Fall back to direct configuration.
+  *config = net::ProxyConfig::CreateDirect();
+  return true;
 }
 
 void PrefProxyConfigService::OnLazyPoll() {
-  base_service_->OnLazyPoll();
+  if (base_service_.get())
+    base_service_->OnLazyPoll();
 }
 
 void PrefProxyConfigService::OnProxyConfigChanged(
@@ -219,7 +261,8 @@ void PrefProxyConfigService::OnPrefProxyConfigChanged() {
 void PrefProxyConfigService::RegisterObservers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!registered_observers_) {
-    base_service_->AddObserver(this);
+    if (base_service_.get())
+      base_service_->AddObserver(this);
     pref_config_tracker_->AddObserver(this);
     registered_observers_ = true;
   }