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

chrome/browser/prefs/proxy_prefs.cc

 // Copyright (c) 2010 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/prefs/proxy_prefs.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 
 namespace ProxyPrefs {
 
 const char kDirectProxyModeName[] = "direct";
 const char kAutoDetectProxyModeName[] = "auto_detect";
 const char kPacScriptProxyModeName[] = "pac_script";
 const char kFixedServersProxyModeName[] = "fixed_servers";
 const char kSystemProxyModeName[] = "system";
 
 }
 
 namespace {
 
 // These names are exposed to the proxy extension API. They must be in sync
 // with the constants of ProxyPrefs.
 const char* kProxyModeNames[] = { ProxyPrefs::kDirectProxyModeName,
                                   ProxyPrefs::kAutoDetectProxyModeName,
                                   ProxyPrefs::kPacScriptProxyModeName,
                                   ProxyPrefs::kFixedServersProxyModeName,
                                   ProxyPrefs::kSystemProxyModeName };
 
+// Integer to specify the type of proxy settings.
+// See ProxyPrefs for possible values and interactions with the other proxy
+// preferences.
+const char kProxyMode[] = "mode";
+// String specifying the proxy server. For a specification of the expected
+// syntax see net::ProxyConfig::ProxyRules::ParseFromString().
+const char kProxyServer[] = "server";
+// URL to the proxy .pac file.
+const char kProxyPacUrl[] = "pac_url";
+// String containing proxy bypass rules. For a specification of the
+// expected syntax see net::ProxyBypassRules::ParseFromString().
+const char kProxyBypassList[] = "bypass_list";
+
 }  // namespace
 
 namespace ProxyPrefs {
 
 COMPILE_ASSERT(arraysize(kProxyModeNames) == kModeCount,
                kProxyModeNames_must_have_size_of_NUM_MODES);
 
 bool IntToProxyMode(int in_value, ProxyMode* out_value) {
   DCHECK(out_value);
   if (in_value < 0 || in_value >= kModeCount)
     return false;
   *out_value = static_cast<ProxyMode>(in_value);
   return true;
 }
 
 // static
 bool StringToProxyMode(const std::string& in_value, ProxyMode* out_value) {
   DCHECK(out_value);
   for (int i = 0; i < kModeCount; i++) {
     if (in_value == kProxyModeNames[i])
       return IntToProxyMode(i, out_value);
   }
   return false;
 }
 
 }  // namespace
+
+ProxyPrefsDictionary::ProxyPrefsDictionary(const DictionaryValue* dict)
+    : dict_(dict) {
+  CHECK(dict);
+}
+
+bool ProxyPrefsDictionary::GetMode(ProxyPrefs::ProxyMode* out) const {
+  std::string mode_str;
+  return dict_->GetString(kProxyMode, &mode_str)
+      && StringToProxyMode(mode_str, out);
+}
+
+bool ProxyPrefsDictionary::GetPacUrl(std::string* out) const {
+  return dict_->GetString(kProxyPacUrl, out);
+}
+
+bool ProxyPrefsDictionary::GetProxyServer(std::string* out) const {
+  return dict_->GetString(kProxyServer, out);
+}
+
+bool ProxyPrefsDictionary::GetBypassList(std::string* out) const {
+  return dict_->GetString(kProxyBypassList, out);
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreateDirect() {
+  return CreateDictionary(ProxyPrefs::MODE_DIRECT, "", "", "");
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreateAutoDetect() {
+  return CreateDictionary(ProxyPrefs::MODE_AUTO_DETECT, "", "", "");
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreatePacScript(
+    const std::string& pac_url) {
+  return CreateDictionary(ProxyPrefs::MODE_PAC_SCRIPT, pac_url, "", "");
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreateFixedServers(
+    const std::string& proxy_server,
+    const std::string& bypass_list) {
+  return CreateDictionary(
+      ProxyPrefs::MODE_FIXED_SERVERS, "", proxy_server, bypass_list);
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreateSystem() {
+  return CreateDictionary(ProxyPrefs::MODE_SYSTEM, "", "", "");
+}
+
+// static
+DictionaryValue* ProxyPrefsDictionary::CreateDictionary(
+    ProxyPrefs::ProxyMode mode,
+    const std::string& pac_url,
+    const std::string& proxy_server,
+    const std::string& bypass_list) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString(kProxyMode, kProxyModeNames[mode]);
+  if (!pac_url.empty())
+    dict->SetString(kProxyPacUrl, pac_url);
+  if (!proxy_server.empty())
+    dict->SetString(kProxyServer, proxy_server);
+  if (!bypass_list.empty())
+    dict->SetString(kProxyBypassList, bypass_list);
+  return dict;
+}