Introduce a separate preference for 'proxy server mode'

The new preference is kProxyServerMode, which supersedes kProxyAutoDetect and kNoProxyServer. The point of this change is to represent 'use system proxy settings' in a more robust way. The proxy extension API is also adjusted to the preference system.

This is a continuation of gfeher's patch from issue 5701003.

BUG=65732, 66023
TEST=ProxyPrefsTest.*, and also covered by ExtensionApiTest.Porxy*, PrefProxyConfigServiceTest.*

Review URL: http://codereview.chromium.org/6004003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@70042 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 211 insertions, 46 deletions

diff --git a/chrome/browser/prefs/command_line_pref_store.cc b/chrome/browser/prefs/command_line_pref_store.cc
index ae70d97..4a386d6 100644
--- a/chrome/browser/prefs/command_line_pref_store.cc
+++ b/chrome/browser/prefs/command_line_pref_store.cc
@@ -7,6 +7,7 @@
 #include "app/app_switches.h"
 #include "base/logging.h"
 #include "base/values.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 
@@ -25,8 +26,6 @@ const CommandLinePrefStore::StringSwitchToPreferenceMapEntry
 
 const CommandLinePrefStore::BooleanSwitchToPreferenceMapEntry
     CommandLinePrefStore::boolean_switch_map_[] = {
-      { switches::kNoProxyServer, prefs::kNoProxyServer, true },
-      { switches::kProxyAutoDetect, prefs::kProxyAutoDetect, true },
       { switches::kDisableAuthNegotiateCnameLookup,
           prefs::kDisableAuthNegotiateCnameLookup, true },
       { switches::kEnableAuthNegotiatePort, prefs::kEnableAuthNegotiatePort,
@@ -37,6 +36,7 @@ const CommandLinePrefStore::BooleanSwitchToPreferenceMapEntry
 CommandLinePrefStore::CommandLinePrefStore(const CommandLine* command_line)
     : command_line_(command_line) {
   ApplySimpleSwitches();
+  ApplyProxyMode();
   ValidateProxySwitches();
 }
 
@@ -73,3 +73,19 @@ bool CommandLinePrefStore::ValidateProxySwitches() {
   }
   return true;
 }
+
+void CommandLinePrefStore::ApplyProxyMode() {
+  if (command_line_->HasSwitch(switches::kNoProxyServer)) {
+    SetValue(prefs::kProxyMode,
+             Value::CreateIntegerValue(ProxyPrefs::MODE_DIRECT));
+  } else if (command_line_->HasSwitch(switches::kProxyPacUrl)) {
+    SetValue(prefs::kProxyMode,
+             Value::CreateIntegerValue(ProxyPrefs::MODE_PAC_SCRIPT));
+  } else if (command_line_->HasSwitch(switches::kProxyAutoDetect)) {
+    SetValue(prefs::kProxyMode,
+             Value::CreateIntegerValue(ProxyPrefs::MODE_AUTO_DETECT));
+  } else if (command_line_->HasSwitch(switches::kProxyServer)) {
+    SetValue(prefs::kProxyMode,
+             Value::CreateIntegerValue(ProxyPrefs::MODE_FIXED_SERVERS));
+  }
+}
diff --git a/chrome/browser/prefs/command_line_pref_store.h b/chrome/browser/prefs/command_line_pref_store.h
index c3baf7a..75d8b10 100644
--- a/chrome/browser/prefs/command_line_pref_store.h
+++ b/chrome/browser/prefs/command_line_pref_store.h
@@ -45,6 +45,9 @@ class CommandLinePrefStore : public ValueMapPrefStore {
   // corresponding preferences in this pref store.
   void ApplySimpleSwitches();
 
+  // Determines the proxy mode preference from the given proxy switches.
+  void ApplyProxyMode();
+
   // Weak reference.
   const CommandLine* command_line_;
 
diff --git a/chrome/browser/prefs/command_line_pref_store_unittest.cc b/chrome/browser/prefs/command_line_pref_store_unittest.cc
index 031a7c9..1be9c0a 100644
--- a/chrome/browser/prefs/command_line_pref_store_unittest.cc
+++ b/chrome/browser/prefs/command_line_pref_store_unittest.cc
@@ -9,6 +9,7 @@
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/command_line_pref_store.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 
@@ -22,6 +23,12 @@ class TestCommandLinePrefStore : public CommandLinePrefStore {
   bool ProxySwitchesAreValid() {
     return ValidateProxySwitches();
   }
+
+  void VerifyIntPref(const std::string& path, int expected_value) {
+    Value* actual = NULL;
+    ASSERT_EQ(PrefStore::READ_OK, GetValue(path, &actual));
+    EXPECT_TRUE(FundamentalValue(expected_value).Equals(actual));
+  }
 };
 
 const char unknown_bool[] = "unknown_switch";
@@ -47,13 +54,9 @@ TEST(CommandLinePrefStoreTest, SimpleStringPref) {
 TEST(CommandLinePrefStoreTest, SimpleBooleanPref) {
   CommandLine cl(CommandLine::NO_PROGRAM);
   cl.AppendSwitch(switches::kNoProxyServer);
-  CommandLinePrefStore store(&cl);
+  TestCommandLinePrefStore store(&cl);
 
-  Value* actual = NULL;
-  ASSERT_EQ(PrefStore::READ_OK, store.GetValue(prefs::kNoProxyServer, &actual));
-  bool result;
-  EXPECT_TRUE(actual->GetAsBoolean(&result));
-  EXPECT_TRUE(result);
+  store.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_DIRECT);
 }
 
 // Tests a command line with no recognized prefs.
@@ -76,15 +79,11 @@ TEST(CommandLinePrefStoreTest, MultipleSwitches) {
   cl.AppendSwitchASCII(switches::kProxyServer, "proxy");
   cl.AppendSwitchASCII(switches::kProxyBypassList, "list");
   cl.AppendSwitchASCII(unknown_bool, "a value");
-  CommandLinePrefStore store(&cl);
+  TestCommandLinePrefStore store(&cl);
 
   Value* actual = NULL;
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store.GetValue(unknown_bool, &actual));
-  ASSERT_EQ(PrefStore::READ_OK,
-            store.GetValue(prefs::kProxyAutoDetect, &actual));
-  bool bool_result = false;
-  EXPECT_TRUE(actual->GetAsBoolean(&bool_result));
-  EXPECT_TRUE(bool_result);
+  store.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_AUTO_DETECT);
 
   EXPECT_EQ(PrefStore::READ_NO_VALUE, store.GetValue(unknown_string, &actual));
   std::string string_result = "";
@@ -124,3 +123,16 @@ TEST(CommandLinePrefStoreTest, ProxySwitchValidation) {
   TestCommandLinePrefStore store4(&cl2);
   EXPECT_TRUE(store4.ProxySwitchesAreValid());
 }
+
+TEST(CommandLinePrefStoreTest, ManualProxyModeInference) {
+  CommandLine cl1(CommandLine::NO_PROGRAM);
+  cl1.AppendSwitch(unknown_string);
+  cl1.AppendSwitchASCII(switches::kProxyServer, "proxy");
+  TestCommandLinePrefStore store1(&cl1);
+  store1.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_FIXED_SERVERS);
+
+  CommandLine cl2(CommandLine::NO_PROGRAM);
+  cl2.AppendSwitchASCII(switches::kProxyPacUrl, "proxy");
+  TestCommandLinePrefStore store2(&cl2);
+  store2.VerifyIntPref(prefs::kProxyMode, ProxyPrefs::MODE_PAC_SCRIPT);
+}
diff --git a/chrome/browser/prefs/pref_service_unittest.cc b/chrome/browser/prefs/pref_service_unittest.cc
index 8ada07a..1a79708 100644
--- a/chrome/browser/prefs/pref_service_unittest.cc
+++ b/chrome/browser/prefs/pref_service_unittest.cc
@@ -16,6 +16,7 @@
 #include "chrome/browser/prefs/pref_observer_mock.h"
 #include "chrome/browser/prefs/pref_service_mock_builder.h"
 #include "chrome/browser/prefs/pref_value_store.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
 #include "chrome/browser/prefs/testing_pref_store.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ -150,17 +151,14 @@ TEST(PrefServiceTest, Observers) {
 TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) {
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kProxyBypassList, "123");
-  command_line.AppendSwitchASCII(switches::kProxyPacUrl, "456");
   command_line.AppendSwitchASCII(switches::kProxyServer, "789");
   scoped_ptr<policy::MockConfigurationPolicyProvider> provider(
       new policy::MockConfigurationPolicyProvider());
   Value* mode_value = Value::CreateIntegerValue(
       policy::kPolicyManuallyConfiguredProxyMode);
-  provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value);
+  provider->AddPolicy(policy::kPolicyProxyMode, mode_value);
   provider->AddPolicy(policy::kPolicyProxyBypassList,
                       Value::CreateStringValue("abc"));
-  provider->AddPolicy(policy::kPolicyProxyPacUrl,
-                      Value::CreateStringValue("def"));
   provider->AddPolicy(policy::kPolicyProxyServer,
                       Value::CreateStringValue("ghi"));
 
@@ -170,10 +168,10 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) {
   builder.WithCommandLine(&command_line);
   scoped_ptr<PrefService> prefs(builder.Create());
   browser::RegisterUserPrefs(prefs.get());
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS,
+            prefs->GetInteger(prefs::kProxyMode));
   EXPECT_EQ("789", prefs->GetString(prefs::kProxyServer));
-  EXPECT_EQ("456", prefs->GetString(prefs::kProxyPacUrl));
+  EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ("123", prefs->GetString(prefs::kProxyBypassList));
 
   // Try a second time time with the managed PrefStore in place, the
@@ -183,23 +181,22 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineOptions) {
   builder.WithManagedPlatformProvider(provider.get());
   scoped_ptr<PrefService> prefs2(builder.Create());
   browser::RegisterUserPrefs(prefs2.get());
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS,
+            prefs2->GetInteger(prefs::kProxyMode));
   EXPECT_EQ("ghi", prefs2->GetString(prefs::kProxyServer));
-  EXPECT_EQ("def", prefs2->GetString(prefs::kProxyPacUrl));
+  EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ("abc", prefs2->GetString(prefs::kProxyBypassList));
 }
 
 TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) {
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kProxyBypassList, "123");
-  command_line.AppendSwitchASCII(switches::kProxyPacUrl, "456");
   command_line.AppendSwitchASCII(switches::kProxyServer, "789");
   scoped_ptr<policy::MockConfigurationPolicyProvider> provider(
       new policy::MockConfigurationPolicyProvider());
   Value* mode_value = Value::CreateIntegerValue(
-      policy::kPolicyUseSystemProxyMode);
-  provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value);
+      policy::kPolicyAutoDetectProxyMode);
+  provider->AddPolicy(policy::kPolicyProxyMode, mode_value);
 
   // First verify that command-line options are set correctly when
   // there is no policy in effect.
@@ -207,10 +204,9 @@ TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) {
   builder.WithCommandLine(&command_line);
   scoped_ptr<PrefService> prefs(builder.Create());
   browser::RegisterUserPrefs(prefs.get());
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS,
+            prefs->GetInteger(prefs::kProxyMode));
   EXPECT_EQ("789", prefs->GetString(prefs::kProxyServer));
-  EXPECT_EQ("456", prefs->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ("123", prefs->GetString(prefs::kProxyBypassList));
 
   // Try a second time time with the managed PrefStore in place, the
@@ -221,8 +217,8 @@ TEST(PrefServiceTest, ProxyPolicyOverridesUnrelatedCommandLineOptions) {
   builder.WithManagedPlatformProvider(provider.get());
   scoped_ptr<PrefService> prefs2(builder.Create());
   browser::RegisterUserPrefs(prefs2.get());
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT,
+      prefs2->GetInteger(prefs::kProxyMode));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList));
@@ -235,7 +231,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) {
       new policy::MockConfigurationPolicyProvider());
   Value* mode_value = Value::CreateIntegerValue(
       policy::kPolicyAutoDetectProxyMode);
-  provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value);
+  provider->AddPolicy(policy::kPolicyProxyMode, mode_value);
 
   // First verify that command-line options are set correctly when
   // there is no policy in effect.
@@ -243,8 +239,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) {
   builder.WithCommandLine(&command_line);
   scoped_ptr<PrefService> prefs(builder.Create());
   browser::RegisterUserPrefs(prefs.get());
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_TRUE(prefs->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_DIRECT, prefs->GetInteger(prefs::kProxyMode));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyServer));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyBypassList));
@@ -256,8 +251,8 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineNoProxy) {
   builder.WithManagedPlatformProvider(provider.get());
   scoped_ptr<PrefService> prefs2(builder.Create());
   browser::RegisterUserPrefs(prefs2.get());
-  EXPECT_TRUE(prefs2->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT,
+      prefs2->GetInteger(prefs::kProxyMode));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList));
@@ -270,7 +265,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) {
       new policy::MockConfigurationPolicyProvider());
   Value* mode_value = Value::CreateIntegerValue(
       policy::kPolicyNoProxyServerMode);
-  provider->AddPolicy(policy::kPolicyProxyServerMode, mode_value);
+  provider->AddPolicy(policy::kPolicyProxyMode, mode_value);
 
   // First verify that the auto-detect is set if there is no managed
   // PrefStore.
@@ -278,8 +273,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) {
   builder.WithCommandLine(&command_line);
   scoped_ptr<PrefService> prefs(builder.Create());
   browser::RegisterUserPrefs(prefs.get());
-  EXPECT_TRUE(prefs->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_FALSE(prefs->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, prefs->GetInteger(prefs::kProxyMode));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyServer));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ(std::string(), prefs->GetString(prefs::kProxyBypassList));
@@ -291,8 +285,7 @@ TEST(PrefServiceTest, ProxyPolicyOverridesCommandLineAutoDetect) {
   builder.WithManagedPlatformProvider(provider.get());
   scoped_ptr<PrefService> prefs2(builder.Create());
   browser::RegisterUserPrefs(prefs2.get());
-  EXPECT_FALSE(prefs2->GetBoolean(prefs::kProxyAutoDetect));
-  EXPECT_TRUE(prefs2->GetBoolean(prefs::kNoProxyServer));
+  EXPECT_EQ(ProxyPrefs::MODE_DIRECT, prefs2->GetInteger(prefs::kProxyMode));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyServer));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyPacUrl));
   EXPECT_EQ(std::string(), prefs2->GetString(prefs::kProxyBypassList));
diff --git a/chrome/browser/prefs/pref_set_observer.cc b/chrome/browser/prefs/pref_set_observer.cc
index a073eb2..133b219 100644
--- a/chrome/browser/prefs/pref_set_observer.cc
+++ b/chrome/browser/prefs/pref_set_observer.cc
@@ -47,8 +47,7 @@ PrefSetObserver* PrefSetObserver::CreateProxyPrefSetObserver(
     PrefService* pref_service,
     NotificationObserver* observer) {
   PrefSetObserver* pref_set = new PrefSetObserver(pref_service, observer);
-  pref_set->AddPref(prefs::kNoProxyServer);
-  pref_set->AddPref(prefs::kProxyAutoDetect);
+  pref_set->AddPref(prefs::kProxyMode);
   pref_set->AddPref(prefs::kProxyServer);
   pref_set->AddPref(prefs::kProxyPacUrl);
   pref_set->AddPref(prefs::kProxyBypassList);
diff --git a/chrome/browser/prefs/pref_value_store_unittest.cc b/chrome/browser/prefs/pref_value_store_unittest.cc
index 5649061..b78e0fc 100644
--- a/chrome/browser/prefs/pref_value_store_unittest.cc
+++ b/chrome/browser/prefs/pref_value_store_unittest.cc
@@ -133,8 +133,8 @@ class PrefValueStoreTest : public testing::Test {
                                               Value::TYPE_LIST);
     pref_value_store_->RegisterPreferenceType(prefs::kDefaultPref,
                                               Value::TYPE_INTEGER);
-    pref_value_store_->RegisterPreferenceType(prefs::kProxyAutoDetect,
-                                              Value::TYPE_BOOLEAN);
+    pref_value_store_->RegisterPreferenceType(prefs::kProxyMode,
+                                              Value::TYPE_INTEGER);
   }
 
   // Creates a new dictionary and stores some sample user preferences
diff --git a/chrome/browser/prefs/proxy_prefs.cc b/chrome/browser/prefs/proxy_prefs.cc
new file mode 100644
index 0000000..7eb504c
--- /dev/null
+++ b/chrome/browser/prefs/proxy_prefs.cc
@@ -0,0 +1,45 @@
+// 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 {
+
+// These names are exposed to the proxy extension API. They must be in sync
+// with the constants of ProxyPrefs.
+const char* kProxyModeNames[] = { "direct",
+                                  "auto_detect",
+                                  "pac_script",
+                                  "fixed_servers",
+                                  "system" };
+
+}  // 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
diff --git a/chrome/browser/prefs/proxy_prefs.h b/chrome/browser/prefs/proxy_prefs.h
new file mode 100644
index 0000000..bbeb44d
--- /dev/null
+++ b/chrome/browser/prefs/proxy_prefs.h
@@ -0,0 +1,45 @@
+// 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.
+
+#ifndef CHROME_BROWSER_PREFS_PROXY_PREFS_H_
+#define CHROME_BROWSER_PREFS_PROXY_PREFS_H_
+#pragma once
+
+#include <string>
+
+namespace ProxyPrefs {
+
+// Possible types of specifying proxy settings. Do not change the order of
+// the constants, because numeric values are exposed to users.
+// If you add an enum constant, you should also add a string to
+// kProxyModeNames in the .cc file.
+enum ProxyMode {
+  // Direct connection to the network, other proxy preferences are ignored.
+  MODE_DIRECT = 0,
+
+  // Try to retrieve a PAC script from http://wpad/wpad.dat or fall back to
+  // direct connection.
+  MODE_AUTO_DETECT = 1,
+
+  // Try to retrieve a PAC script from kProxyPacURL or fall back to direct
+  // connection.
+  MODE_PAC_SCRIPT = 2,
+
+  // Use the settings specified in kProxyServer and kProxyBypassList.
+  MODE_FIXED_SERVERS = 3,
+
+  // The system's proxy settings are used, other proxy preferences are
+  // ignored.
+  MODE_SYSTEM = 4,
+
+  kModeCount
+};
+
+bool IntToProxyMode(int in_value, ProxyMode* out_value);
+bool StringToProxyMode(const std::string& in_value,
+                       ProxyMode* out_value);
+
+}  // namespace ProxyPrefs
+
+#endif  // CHROME_BROWSER_PREFS_PROXY_PREFS_H_
diff --git a/chrome/browser/prefs/proxy_prefs_unittest.cc b/chrome/browser/prefs/proxy_prefs_unittest.cc
new file mode 100644
index 0000000..72aa0f1
--- /dev/null
+++ b/chrome/browser/prefs/proxy_prefs_unittest.cc
@@ -0,0 +1,52 @@
+// 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 <string>
+
+#include "base/logging.h"
+#include "base/values.h"
+#include "base/version.h"
+#include "chrome/browser/prefs/proxy_prefs.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(ProxyPrefsTest, StringToProxyMode) {
+  ProxyPrefs::ProxyMode mode;
+  EXPECT_TRUE(ProxyPrefs::StringToProxyMode("direct", &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode);
+  EXPECT_TRUE(ProxyPrefs::StringToProxyMode("auto_detect", &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, mode);
+  EXPECT_TRUE(ProxyPrefs::StringToProxyMode("pac_script", &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, mode);
+  EXPECT_TRUE(ProxyPrefs::StringToProxyMode("system", &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_SYSTEM, mode);
+  EXPECT_TRUE(ProxyPrefs::StringToProxyMode("fixed_servers", &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, mode);
+
+  EXPECT_FALSE(ProxyPrefs::StringToProxyMode("monkey", &mode));
+}
+
+TEST(ProxyPrefsTest, IntToProxyMode) {
+  ASSERT_EQ(ProxyPrefs::MODE_DIRECT, 0);
+  ASSERT_EQ(ProxyPrefs::MODE_AUTO_DETECT, 1);
+  ASSERT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, 2);
+  ASSERT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, 3);
+  ASSERT_EQ(ProxyPrefs::MODE_SYSTEM, 4);
+  // Update the following as necessary, don't change the previous ones.
+  ASSERT_EQ(ProxyPrefs::kModeCount, 5);
+
+  ProxyPrefs::ProxyMode mode;
+  EXPECT_TRUE(ProxyPrefs::IntToProxyMode(0, &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_DIRECT, mode);
+  EXPECT_TRUE(ProxyPrefs::IntToProxyMode(1, &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_AUTO_DETECT, mode);
+  EXPECT_TRUE(ProxyPrefs::IntToProxyMode(2, &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_PAC_SCRIPT, mode);
+  EXPECT_TRUE(ProxyPrefs::IntToProxyMode(3, &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_FIXED_SERVERS, mode);
+  EXPECT_TRUE(ProxyPrefs::IntToProxyMode(4, &mode));
+  EXPECT_EQ(ProxyPrefs::MODE_SYSTEM, mode);
+
+  EXPECT_FALSE(ProxyPrefs::IntToProxyMode(-1, &mode));
+  EXPECT_FALSE(ProxyPrefs::IntToProxyMode(ProxyPrefs::kModeCount, &mode));
+}