Policy: Add ProxyMode and deprecate ProxyServerMode.

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>
@@ skipping 346 matching lines @@
   return false;
 }
 
 bool ConfigurationPolicyPrefKeeper::ApplyProxyPolicy(
     ConfigurationPolicyType policy,
     Value* value) {
   // We only collect the values until we have sufficient information when
   // FinalizeProxyPolicySettings() is called to determine whether the presented
   // values were correct and apply them in that case.
   if (policy == kPolicyProxyMode ||
+      policy == kPolicyProxyServerMode ||
       policy == kPolicyProxyServer ||
       policy == kPolicyProxyPacUrl ||
       policy == kPolicyProxyBypassList) {
     delete proxy_policies_[policy];
     proxy_policies_[policy] = value;
     return true;
   }
   // We are not interested in this policy.
   return false;
 }
@@ skipping 106 matching lines @@
 void ConfigurationPolicyPrefKeeper::FinalizeProxyPolicySettings() {
   if (CheckProxySettings())
     ApplyProxySettings();
 
   STLDeleteContainerPairSecondPointers(proxy_policies_.begin(),
                                        proxy_policies_.end());
   proxy_policies_.clear();
 }
 
 bool ConfigurationPolicyPrefKeeper::CheckProxySettings() {
-  bool mode = HasProxyPolicy(kPolicyProxyMode);
+  bool mode = HasProxyPolicy(kPolicyProxyMode); //  deprecated
+  bool server_mode = HasProxyPolicy(kPolicyProxyServerMode);

[battre, 2011/01/10 11:42:20]

actually, the ProxyServerMode is deprecated. (sorry for my imprecise comment
before)

Nit: whitespaces around //

[danno, 2011/01/11 08:46:46]

Done.

   bool server = HasProxyPolicy(kPolicyProxyServer);
   bool pac_url = HasProxyPolicy(kPolicyProxyPacUrl);
   bool bypass_list = HasProxyPolicy(kPolicyProxyBypassList);
 
-  if ((server || pac_url || bypass_list) && !mode) {
+  if ((server || pac_url || bypass_list) && !(mode || server_mode)) {
     LOG(WARNING) << "A centrally-administered policy defines proxy setting"
                  << " details without setting a proxy mode.";
     return false;
   }
 
-  if (!mode)
-    return true;
+  // If there's a server mode, convert it into a mode.
+  std::string mode_value;
+  if (mode) {
+    if (!proxy_policies_[kPolicyProxyMode]->GetAsString(&mode_value)) {
+      LOG(WARNING) << "Invalid ProxyMode value.";
+      return false;
+    }
+  } else if (server_mode) {
+    int server_mode_value;
+    if (!proxy_policies_[kPolicyProxyServerMode]->GetAsInteger(
+        &server_mode_value)) {
+      LOG(WARNING) << "Invalid ProxyServerMode value.";
+      return false;
+    }
 
-  int mode_value;
-  if (!proxy_policies_[kPolicyProxyMode]->GetAsInteger(&mode_value)) {
-    LOG(WARNING) << "Invalid proxy mode value.";
-    return false;
+    switch (server_mode_value) {
+      case kPolicyNoProxyServerMode:
+        mode_value = ProxyPrefs::kDirectProxyModeName;
+        break;
+      case kPolicyAutoDetectProxyServerMode:
+        mode_value = ProxyPrefs::kAutoDetectProxyModeName;
+        break;
+      case kPolicyManuallyConfiguredProxyServerMode:
+        if (server && pac_url) {
+          LOG(WARNING) << "A centrally-administered policy dictates that"
+                       << " both fixed proxy servers and a .pac url. should"
+                       << " be used for proxy configuration.";
+          return false;
+        }
+        if (!server && !pac_url) {
+          LOG(WARNING) << "A centrally-administered policy dictates that the"
+                       << " proxy settings should use either fixed"
+                       << " proxy servers or a .pac url, but specifies neither.";

[battre, 2011/01/10 11:42:20]

Nit: 80 characters

[danno, 2011/01/11 08:46:46]

Done.

+          return false;
+        }
+        if (pac_url)
+          mode_value = ProxyPrefs::kPacScriptProxyModeName;
+        else
+          mode_value = ProxyPrefs::kFixedServersProxyModeName;
+        break;
+      case kPolicyUseSystemProxyServerMode:
+        mode_value = ProxyPrefs::kSystemProxyModeName;
+        break;
+      default:
+        LOG(WARNING) << "Invalid proxy mode " << server_mode_value;
+        return false;
+    }
   }
 
-  switch (mode_value) {
-    case kPolicyNoProxyServerMode:
+  if (!mode_value.empty()) {
+    if (mode_value == ProxyPrefs::kDirectProxyModeName) {
       if (server || pac_url || bypass_list) {
         LOG(WARNING) << "A centrally-administered policy disables the use of"
                      << " a proxy but also specifies an explicit proxy"
                      << " configuration.";
         return false;
       }
-      break;
-    case kPolicyAutoDetectProxyMode:
+    } else if (mode_value == ProxyPrefs::kAutoDetectProxyModeName) {
       if (server || bypass_list || pac_url) {
         LOG(WARNING) << "A centrally-administered policy dictates that a proxy"
                      << " shall be auto configured but specifies fixed proxy"
                      << " servers, a by-pass list or a .pac script URL.";
         return false;
       }
-      break;
-    case kPolicyManuallyConfiguredProxyMode:
-      if (server && pac_url) {
-        LOG(WARNING) << "A centrally-administered policy dictates that the"
-                     << " system proxy settings should use both a fixed"
-                     << " proxy server and a .pac url.";
+    } else if (mode_value == ProxyPrefs::kPacScriptProxyModeName) {
+      if (server || bypass_list) {
+        LOG(WARNING) << "A centrally-administered policy dictates that a .pac"
+                     << " script URL should be used for proxy configuration but"
+                     << " also specifies policies required only for fixed"
+                     << " proxy servers.";
         return false;
       }
-      if (!server && !pac_url) {
-        LOG(WARNING) << "A centrally-administered policy dictates that the"
-                     << " system proxy settings should use either a fixed"
-                     << " proxy server or a .pac url, but specifies neither.";
+    } else if (mode_value == ProxyPrefs::kFixedServersProxyModeName) {
+      if (pac_url) {
+        LOG(WARNING) << "A centrally-administered policy dictates that"
+                     << " fixed proxy servers should be used but also"
+                     << " specifies a .pac script URL.";
         return false;
       }
-      break;
-    case kPolicyUseSystemProxyMode:
+    } else if (mode_value == ProxyPrefs::kSystemProxyModeName) {
       if (server || pac_url || bypass_list) {
         LOG(WARNING) << "A centrally-administered policy dictates that the"
                      << " system proxy settings should be used but also "
                      << " specifies an explicit proxy configuration.";
         return false;
       }
-      break;
-    default:
+    } else {
       LOG(WARNING) << "Invalid proxy mode " << mode_value;
       return false;
+    }
   }
   return true;
 }
 
 void ConfigurationPolicyPrefKeeper::ApplyProxySettings() {
-  if (!HasProxyPolicy(kPolicyProxyMode))
+  ProxyPrefs::ProxyMode mode;
+  if (HasProxyPolicy(kPolicyProxyMode)) {
+    std::string string_mode;
+    CHECK(proxy_policies_[kPolicyProxyMode]->GetAsString(&string_mode));
+    ProxyPrefs::StringToProxyMode(string_mode, &mode);

[gfeher, 2011/01/10 14:20:33]

A warning in case the supplied string literal is unknown and a default is
applied? if (!ProxyPrefs::StringToProx...)

[danno, 2011/01/11 08:46:46]

Done.

+  } else if (HasProxyPolicy(kPolicyProxyServerMode)) {
+    int int_mode = 0;
+    CHECK(proxy_policies_[kPolicyProxyServerMode]->GetAsInteger(&int_mode));
+    switch (int_mode) {
+      case kPolicyNoProxyServerMode:
+        mode = ProxyPrefs::MODE_DIRECT;
+        break;
+      case kPolicyAutoDetectProxyServerMode:
+        mode = ProxyPrefs::MODE_AUTO_DETECT;
+        break;
+      case kPolicyManuallyConfiguredProxyServerMode:
+        mode = ProxyPrefs::MODE_FIXED_SERVERS;
+        if (HasProxyPolicy(kPolicyProxyPacUrl))
+          mode = ProxyPrefs::MODE_PAC_SCRIPT;
+        break;
+      case kPolicyUseSystemProxyServerMode:
+        mode = ProxyPrefs::MODE_SYSTEM;
+        break;
+      default:
+        mode = ProxyPrefs::MODE_DIRECT;
+        NOTREACHED();
+    }
+  } else {
     return;
-
-  int int_mode;
-  CHECK(proxy_policies_[kPolicyProxyMode]->GetAsInteger(&int_mode));
-  ProxyPrefs::ProxyMode mode;
-  switch (int_mode) {
-    case kPolicyNoProxyServerMode:
-      mode = ProxyPrefs::MODE_DIRECT;
-      break;
-    case kPolicyAutoDetectProxyMode:
-      mode = ProxyPrefs::MODE_AUTO_DETECT;
-      break;
-    case kPolicyManuallyConfiguredProxyMode:
-      mode = ProxyPrefs::MODE_FIXED_SERVERS;
-      if (HasProxyPolicy(kPolicyProxyPacUrl))
-        mode = ProxyPrefs::MODE_PAC_SCRIPT;
-      break;
-    case kPolicyUseSystemProxyMode:
-      mode = ProxyPrefs::MODE_SYSTEM;
-      break;
-    default:
-      mode = ProxyPrefs::MODE_DIRECT;
-      NOTREACHED();
   }
   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)) {
@@ skipping 106 matching lines @@
     { kPolicyDefaultSearchProviderKeyword, Value::TYPE_STRING,
       key::kDefaultSearchProviderKeyword },
     { kPolicyDefaultSearchProviderSearchURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderSearchURL },
     { kPolicyDefaultSearchProviderSuggestURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderSuggestURL },
     { kPolicyDefaultSearchProviderIconURL, Value::TYPE_STRING,
       key::kDefaultSearchProviderIconURL },
     { kPolicyDefaultSearchProviderEncodings, Value::TYPE_STRING,
       key::kDefaultSearchProviderEncodings },
-    { kPolicyProxyMode, Value::TYPE_INTEGER, key::kProxyMode },
+    { kPolicyProxyMode, Value::TYPE_STRING, key::kProxyMode },
+    { kPolicyProxyServerMode, Value::TYPE_INTEGER, key::kProxyServerMode },
     { kPolicyProxyServer, Value::TYPE_STRING, key::kProxyServer },
     { kPolicyProxyPacUrl, Value::TYPE_STRING, key::kProxyPacUrl },
     { kPolicyProxyBypassList, Value::TYPE_STRING, key::kProxyBypassList },
     { kPolicyAlternateErrorPagesEnabled, Value::TYPE_BOOLEAN,
       key::kAlternateErrorPagesEnabled },
     { kPolicySearchSuggestEnabled, Value::TYPE_BOOLEAN,
       key::kSearchSuggestEnabled },
     { kPolicyDnsPrefetchingEnabled, Value::TYPE_BOOLEAN,
       key::kDnsPrefetchingEnabled },
     { kPolicyDisableSpdy, Value::TYPE_BOOLEAN, key::kDisableSpdy },
@@ skipping 88 matching lines @@
   // Update the initialization flag.
   if (!initialization_complete_ &&
       provider_->IsInitializationComplete()) {
     initialization_complete_ = true;
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted());
   }
 }
 
 }  // namespace policy