Make proxy settings one atomic dictionary in the PrefStores such that modifications are atomic.

chrome/browser/policy/configuration_policy_pref_store.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/policy/configuration_policy_pref_store.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider_keeper.h"
 #include "chrome/browser/policy/device_management_policy_provider.h"
 #include "chrome/browser/policy/profile_policy_context.h"
 #include "chrome/browser/prefs/pref_value_map.h"
-#include "chrome/browser/prefs/proxy_prefs.h"
+#include "chrome/browser/prefs/proxy_config_dictionary.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 // Accepts policy settings from a ConfigurationPolicyProvider, converts them
@@ skipping 213 matching lines @@
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSearchURL,
     prefs::kDefaultSearchProviderSearchURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderSuggestURL,
     prefs::kDefaultSearchProviderSuggestURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderIconURL,
     prefs::kDefaultSearchProviderIconURL },
   { Value::TYPE_STRING, kPolicyDefaultSearchProviderEncodings,
     prefs::kDefaultSearchProviderEncodings },
 };
 
-const ConfigurationPolicyPrefKeeper::PolicyToPreferenceMapEntry
-    ConfigurationPolicyPrefKeeper::kProxyPolicyMap[] = {
-  { Value::TYPE_STRING, kPolicyProxyServer, prefs::kProxyServer },
-  { Value::TYPE_STRING, kPolicyProxyPacUrl, prefs::kProxyPacUrl },
-  { Value::TYPE_STRING, kPolicyProxyBypassList, prefs::kProxyBypassList }
-};
-
 ConfigurationPolicyPrefKeeper::ConfigurationPolicyPrefKeeper(
     ConfigurationPolicyProvider* provider)
   : lower_priority_proxy_settings_overridden_(false),
     proxy_disabled_(false),
     proxy_configuration_specified_(false),
     use_system_proxy_(false) {
   if (!provider->Provide(this))
     LOG(WARNING) << "Failed to get policy from provider.";
   FinalizeProxyPolicySettings();
   FinalizeDefaultSearchPolicySettings();
@@ skipping 365 matching lines @@
       case kPolicyUseSystemProxyServerMode:
         mode = ProxyPrefs::MODE_SYSTEM;
         break;
       default:
         mode = ProxyPrefs::MODE_DIRECT;
         NOTREACHED();
     }
   } else {
     return;
   }
-  prefs_.SetValue(prefs::kProxyMode, Value::CreateIntegerValue(mode));
-
-  if (HasProxyPolicy(kPolicyProxyServer)) {
-    prefs_.SetValue(prefs::kProxyServer, proxy_policies_[kPolicyProxyServer]);
-    proxy_policies_[kPolicyProxyServer] = NULL;
-  } else {
-    prefs_.SetValue(prefs::kProxyServer, Value::CreateNullValue());
-  }
-  if (HasProxyPolicy(kPolicyProxyPacUrl)) {
-    prefs_.SetValue(prefs::kProxyPacUrl, proxy_policies_[kPolicyProxyPacUrl]);
-    proxy_policies_[kPolicyProxyPacUrl] = NULL;
-  } else {
-    prefs_.SetValue(prefs::kProxyPacUrl, Value::CreateNullValue());
-  }
-  if (HasProxyPolicy(kPolicyProxyBypassList)) {
-    prefs_.SetValue(prefs::kProxyBypassList,
-                proxy_policies_[kPolicyProxyBypassList]);
-    proxy_policies_[kPolicyProxyBypassList] = NULL;
-  } else {
-    prefs_.SetValue(prefs::kProxyBypassList, Value::CreateNullValue());
+  switch (mode) {
+    case ProxyPrefs::MODE_DIRECT:
+      prefs_.SetValue(prefs::kProxy, ProxyConfigDictionary::CreateDirect());
+      break;
+    case ProxyPrefs::MODE_AUTO_DETECT:
+      prefs_.SetValue(prefs::kProxy, ProxyConfigDictionary::CreateAutoDetect());
+      break;
+    case ProxyPrefs::MODE_PAC_SCRIPT: {
+      std::string pac_url;
+      proxy_policies_[kPolicyProxyPacUrl]->GetAsString(&pac_url);
+      prefs_.SetValue(prefs::kProxy,
+                      ProxyConfigDictionary::CreatePacScript(pac_url));
+      break;
+    }
+    case ProxyPrefs::MODE_FIXED_SERVERS: {
+      std::string proxy_server;
+      proxy_policies_[kPolicyProxyServer]->GetAsString(&proxy_server);
+      std::string bypass_list;
+      if (HasProxyPolicy(kPolicyProxyBypassList))
+        proxy_policies_[kPolicyProxyBypassList]->GetAsString(&bypass_list);
+      prefs_.SetValue(prefs::kProxy,
+                      ProxyConfigDictionary::CreateFixedServers(proxy_server,
+                                                                bypass_list));
+      break;
+    }
+    case ProxyPrefs::MODE_SYSTEM:
+      prefs_.SetValue(prefs::kProxy,
+                      ProxyConfigDictionary::CreateSystem());
+      break;
+    case ProxyPrefs::kModeCount:
+      NOTREACHED();
   }
 }
 
 bool ConfigurationPolicyPrefKeeper::HasProxyPolicy(
     ConfigurationPolicyType policy) const {
   std::map<ConfigurationPolicyType, Value*>::const_iterator iter;
   iter = proxy_policies_.find(policy);
   return iter != proxy_policies_.end() &&
          iter->second && !iter->second->IsType(Value::TYPE_NULL);
 }
@@ skipping 216 matching lines @@
   // Update the initialization flag.
   if (!initialization_complete_ &&
       provider_->IsInitializationComplete()) {
     initialization_complete_ = true;
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted());
   }
 }
 
 }  // namespace policy