Intorduce a separate preference for 'proxy server mode'

chrome/browser/extensions/extension_proxy_api.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/extensions/extension_proxy_api.h"
 
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 35 matching lines @@
 COMPILE_ASSERT(SCHEME_MAX == SCHEME_SOCKS, SCHEME_MAX_must_equal_SCHEME_SOCKS);
 COMPILE_ASSERT(arraysize(field_name) == SCHEME_MAX + 1,
                field_name_array_is_wrong_size);
 COMPILE_ASSERT(arraysize(scheme_name) == SCHEME_MAX + 1,
                scheme_name_array_is_wrong_size);
 
 bool UseCustomProxySettingsFunction::RunImpl() {
   DictionaryValue* proxy_config;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(0, &proxy_config));
 
-  bool auto_detect = false;
-  proxy_config->GetBoolean("autoDetect", &auto_detect);
+  int proxy_mode = 0;
+  proxy_config->GetInteger("mode", &proxy_mode);

[battre (please use the other), 2010/12/14 09:45:44]

I think we should expose this as string constants instead of magic numbers to
the JavaScript interface.
If not: maybe initialize to -1 to check whether value has been specified and
return false in ApplyMode if not.
Or: we should default to System Proxies

[danno, 2010/12/14 12:48:17]

How about a string value externally to the extension (that's what we'd like to
do for policy anyway), but the enum you define later internally?
On 2010/12/14 09:45:44, battre wrote:

[gfeher, 2010/12/16 10:42:04]

Done.

 
   DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary("pacScript", &pac_dict);
 
   DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary("rules", &proxy_rules);
 
-  return ApplyAutoDetect(auto_detect) &&
+  return ApplyMode(proxy_mode) &&
       ApplyPacScript(pac_dict) &&
       ApplyProxyRules(proxy_rules);
 }
 
 bool UseCustomProxySettingsFunction::GetProxyServer(
     const DictionaryValue* dict, ProxyServer* proxy_server) {
   dict->GetString("scheme", &proxy_server->scheme);
   EXTENSION_FUNCTION_VALIDATE(dict->GetString("host", &proxy_server->host));
   dict->GetInteger("port", &proxy_server->port);
   return true;
 }
 
-bool UseCustomProxySettingsFunction::ApplyAutoDetect(bool auto_detect) {
-  // We take control of the auto-detect preference even if none was specified,
+bool UseCustomProxySettingsFunction::ApplyMode(int mode) {
+  // We take control of the mode preference even if none was specified,
   // so that all proxy preferences are controlled by the same extension (if not
   // by a higher-priority source).
-  SendNotification(prefs::kProxyAutoDetect,
-                   Value::CreateBooleanValue(auto_detect));
+  SendNotification(prefs::kProxyServerMode,
+                   Value::CreateIntegerValue(mode));
   return true;
 }
 
 bool UseCustomProxySettingsFunction::ApplyPacScript(DictionaryValue* pac_dict) {
   std::string pac_url;
   if (pac_dict)
     pac_dict->GetString("url", &pac_url);
 
   // We take control of the PAC preference even if none was specified, so that
   // all proxy preferences are controlled by the same extension (if not by a
@@ skipping 61 matching lines @@
 
   SendNotification(prefs::kProxyServer, Value::CreateStringValue(proxy_pref));
   return true;
 }
 
 void UseCustomProxySettingsFunction::SendNotification(const char* pref_path,
                                                       Value* pref_value) {
   profile()->GetExtensionsService()->extension_prefs()
       ->SetExtensionControlledPref(extension_id(), pref_path, pref_value);
 }