Introduce 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/prefs/proxy_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/common/pref_names.h"
 
 namespace {
 
 // The scheme for which to use a manually specified proxy, not of the proxy URI
 // itself.
 enum {
   SCHEME_ALL = 0,
@@ skipping 26 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);
+  std::string proxy_mode;
+  proxy_config->GetString("mode", &proxy_mode);
 
   DictionaryValue* pac_dict = NULL;
   proxy_config->GetDictionary("pacScript", &pac_dict);
 
   DictionaryValue* proxy_rules = NULL;
   proxy_config->GetDictionary("rules", &proxy_rules);
 
-  return ApplyAutoDetect(auto_detect) &&
+  // TODO(battre,gfeher): Make sure all the preferences get always
+  // overwritten.
+  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,
-  // 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));
-  return true;
+bool UseCustomProxySettingsFunction::ApplyMode(const std::string& 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).
+  bool result = true;
+  ProxyPrefs::ProxyMode mode_enum;
+  if (!ProxyPrefs::StringToProxyMode(mode, &mode_enum)) {
+    mode_enum = ProxyPrefs::MODE_SYSTEM;
+    LOG(WARNING) << "Invalid mode for proxy settings: " << mode;
+    result = false;
+  }
+  ApplyPreference(prefs::kProxyMode, Value::CreateIntegerValue(mode_enum));
+  return result;
 }
 
 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
   // higher-priority source).
-  SendNotification(prefs::kProxyPacUrl, Value::CreateStringValue(pac_url));
+  ApplyPreference(prefs::kProxyPacUrl, Value::CreateStringValue(pac_url));
   return true;
 }
 
 bool UseCustomProxySettingsFunction::ApplyProxyRules(
     DictionaryValue* proxy_rules) {
-  if (!proxy_rules)
+  if (!proxy_rules) {
+    ApplyPreference(prefs::kProxyServer, Value::CreateStringValue(""));
     return true;
+  }
 
   // Local data into which the parameters will be parsed. has_proxy describes
   // whether a setting was found for the scheme; proxy_dict holds the
   // DictionaryValues which in turn contain proxy server descriptions, and
   // proxy_server holds ProxyServer structs containing those descriptions.
   bool has_proxy[SCHEME_MAX + 1];
   DictionaryValue* proxy_dict[SCHEME_MAX + 1];
   ProxyServer proxy_server[SCHEME_MAX + 1];
 
   // Looking for all possible proxy types is inefficient if we have a
@@ skipping 33 matching lines @@
       proxy_pref.append(proxy_server[i].scheme);
       proxy_pref.append("://");
       proxy_pref.append(proxy_server[i].host);
       if (proxy_server[i].port != ProxyServer::INVALID_PORT) {
         proxy_pref.append(":");
         proxy_pref.append(base::StringPrintf("%d", proxy_server[i].port));
       }
     }
   }
 
-  SendNotification(prefs::kProxyServer, Value::CreateStringValue(proxy_pref));
+  ApplyPreference(prefs::kProxyServer, Value::CreateStringValue(proxy_pref));
   return true;
 }
 
-void UseCustomProxySettingsFunction::SendNotification(const char* pref_path,
-                                                      Value* pref_value) {
+void UseCustomProxySettingsFunction::ApplyPreference(const char* pref_path,
+                                                     Value* pref_value) {
   profile()->GetExtensionService()->extension_prefs()
       ->SetExtensionControlledPref(extension_id(), pref_path, pref_value);
 }