Fix chromeos::ProxyConfigService starting with the wrong ProxyConfig.

components/proxy_config/pref_proxy_config_tracker_impl.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 "components/proxy_config/pref_proxy_config_tracker_impl.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
-#include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
 #include "components/proxy_config/proxy_config_dictionary.h"
 #include "components/proxy_config/proxy_config_pref_names.h"
 #include "net/proxy/proxy_server.h"
 #include "url/gurl.h"
 
 //============================= ProxyConfigServiceImpl =======================
 
 ProxyConfigServiceImpl::ProxyConfigServiceImpl(
@@ skipping 98 matching lines @@
 }
 
 //========================= PrefProxyConfigTrackerImpl =========================
 
 PrefProxyConfigTrackerImpl::PrefProxyConfigTrackerImpl(
     PrefService* pref_service,
     scoped_refptr<base::SingleThreadTaskRunner> io_task_runner)
     : pref_service_(pref_service),
       proxy_config_service_impl_(NULL),
       io_task_runner_(io_task_runner) {
-  config_state_ = ReadPrefConfig(pref_service_, &pref_config_);
+  pref_config_state_ = ReadPrefConfig(pref_service_, &pref_config_);
+  active_config_state_ = pref_config_state_;
+  active_config_ = pref_config_;
+
   proxy_prefs_.Init(pref_service);
   proxy_prefs_.Add(proxy_config::prefs::kProxy,
                    base::Bind(&PrefProxyConfigTrackerImpl::OnProxyPrefChanged,
                               base::Unretained(this)));
 }
 
 PrefProxyConfigTrackerImpl::~PrefProxyConfigTrackerImpl() {
   DCHECK(pref_service_ == NULL);
 }
 
 std::unique_ptr<net::ProxyConfigService>
 PrefProxyConfigTrackerImpl::CreateTrackingProxyConfigService(
     std::unique_ptr<net::ProxyConfigService> base_service) {
   DCHECK(!proxy_config_service_impl_);
   proxy_config_service_impl_ = new ProxyConfigServiceImpl(
-      std::move(base_service), config_state_, pref_config_);
+      std::move(base_service), active_config_state_, active_config_);
   VLOG(1) << this << ": set chrome proxy config service to "
           << proxy_config_service_impl_;
 
   return std::unique_ptr<net::ProxyConfigService>(proxy_config_service_impl_);
 }
 
 void PrefProxyConfigTrackerImpl::DetachFromPrefService() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Stop notifications.
   proxy_prefs_.RemoveAll();
@@ skipping 43 matching lines @@
 // static
 void PrefProxyConfigTrackerImpl::RegisterPrefs(PrefRegistrySimple* registry) {
   std::unique_ptr<base::DictionaryValue> default_settings =
       ProxyConfigDictionary::CreateSystem();
   registry->RegisterDictionaryPref(proxy_config::prefs::kProxy,
                                    std::move(default_settings));
 }
 
 // static
 void PrefProxyConfigTrackerImpl::RegisterProfilePrefs(
-    user_prefs::PrefRegistrySyncable* pref_service) {
+    PrefRegistrySimple* registry) {
   std::unique_ptr<base::DictionaryValue> default_settings =
       ProxyConfigDictionary::CreateSystem();
-  pref_service->RegisterDictionaryPref(proxy_config::prefs::kProxy,
-                                       std::move(default_settings));
-  pref_service->RegisterBooleanPref(proxy_config::prefs::kUseSharedProxies,
-                                    false);
+  registry->RegisterDictionaryPref(proxy_config::prefs::kProxy,
+                                   std::move(default_settings));
+  registry->RegisterBooleanPref(proxy_config::prefs::kUseSharedProxies, false);
 }
 
 // static
 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::ReadPrefConfig(
     const PrefService* pref_service,
     net::ProxyConfig* config) {
   // Clear the configuration and source.
   *config = net::ProxyConfig();
   ProxyPrefs::ConfigState config_state = ProxyPrefs::CONFIG_UNSET;
 
@@ skipping 18 matching lines @@
       config_state = ProxyPrefs::CONFIG_FALLBACK;
     }
   }
 
   return config_state;
 }
 
 ProxyPrefs::ConfigState PrefProxyConfigTrackerImpl::GetProxyConfig(
     net::ProxyConfig* config) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (config_state_ != ProxyPrefs::CONFIG_UNSET)
+  if (pref_config_state_ != ProxyPrefs::CONFIG_UNSET)
     *config = pref_config_;
-  return config_state_;
+  return pref_config_state_;
 }
 
 void PrefProxyConfigTrackerImpl::OnProxyConfigChanged(
     ProxyPrefs::ConfigState config_state,
     const net::ProxyConfig& config) {
+  // If the configuration hasn't changed, do nothing.
+  if (active_config_state_ == config_state &&
+      (active_config_state_ == ProxyPrefs::CONFIG_UNSET ||
+       active_config_.Equals(config))) {
+    return;
+  }
+
+  active_config_state_ = config_state;
+  if (active_config_state_ != ProxyPrefs::CONFIG_UNSET)
+    active_config_ = config;
+
   if (!proxy_config_service_impl_)
     return;
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&ProxyConfigServiceImpl::UpdateProxyConfig,
                             base::Unretained(proxy_config_service_impl_),
                             config_state, config));
 }
 
 bool PrefProxyConfigTrackerImpl::PrefConfigToNetConfig(
     const ProxyConfigDictionary& proxy_dict,
@@ skipping 54 matching lines @@
   }
   NOTREACHED() << "Unknown proxy mode, falling back to system settings.";
   return false;
 }
 
 void PrefProxyConfigTrackerImpl::OnProxyPrefChanged() {
   DCHECK(thread_checker_.CalledOnValidThread());
   net::ProxyConfig new_config;
   ProxyPrefs::ConfigState config_state =
       ReadPrefConfig(pref_service_, &new_config);
-  if (config_state_ != config_state ||
-      (config_state_ != ProxyPrefs::CONFIG_UNSET &&
+  if (pref_config_state_ != config_state ||
+      (pref_config_state_ != ProxyPrefs::CONFIG_UNSET &&
        !pref_config_.Equals(new_config))) {
-    config_state_ = config_state;
-    if (config_state_ != ProxyPrefs::CONFIG_UNSET)
+    pref_config_state_ = config_state;
+    if (pref_config_state_ != ProxyPrefs::CONFIG_UNSET)
       pref_config_ = new_config;
     OnProxyConfigChanged(config_state, new_config);
   }
 }