Policy: Add ProxyMode and deprecate ProxyServerMode.

chrome/browser/policy/configuration_policy_pref_store.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/policy/configuration_policy_pref_store.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 353 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);

[battre, 2011/01/03 13:19:16]

Add comment "deprecated"?

[danno, 2011/01/07 12:24:25]

Done.

+  bool server_mode = HasProxyPolicy(kPolicyProxyServerMode);
   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 info a mode.

[gfeher, 2011/01/03 10:30:10]

Not: into

[danno, 2011/01/07 12:24:25]

Done.

+  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 a fixed proxy server 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 a fixed"
+                       << " proxy server or a .pac url, but specifies neither.";
+          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:
-      if (server || bypass_list) {
+    } 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 or a by-pass list.";
+                     << " servers, a by-pass list or a .pac script URL.";
         return false;
       }
-      break;
-    case kPolicyManuallyConfiguredProxyMode:
-      if (!server) {
-        LOG(WARNING) << "A centrally-administered policy dictates that the"
-                     << " system proxy settings should use fixed proxy servers"
-                     << " without specifying which ones.";
+    } 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;
       }
+    } else if (mode_value == ProxyPrefs::kFixedServersProxyModeName) {
       if (pac_url) {
-        LOG(WARNING) << "A centrally-administered policy dictates that the"
-                     << " system proxy settings should use fixed proxy servers"
-                     << " but also specifies a PAC script.";
+        LOG(WARNING) << "A centrally-administered policy dictates that a"
+                     << " fixed proxy server should be used but also"

[battre, 2011/01/03 13:19:16]

servers (plural)?

[danno, 2011/01/07 12:24:25]

Done.

+                     << " 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))
-    return;
-
-  int int_mode;
-  CHECK(proxy_policies_[kPolicyProxyMode]->GetAsInteger(&int_mode));
   ProxyPrefs::ProxyMode mode;
-  switch (int_mode) {
-    case kPolicyNoProxyServerMode:
+  if (HasProxyPolicy(kPolicyProxyMode)) {
+    std::string string_mode;

[gfeher, 2011/01/03 10:30:10]

Why not use ProxyPrefs::StringToProxyMode here?

[danno, 2011/01/07 12:24:25]

Done.

+    CHECK(proxy_policies_[kPolicyProxyMode]->GetAsString(&string_mode));
+    if (string_mode == std::string(ProxyPrefs::kDirectProxyModeName)) {
       mode = ProxyPrefs::MODE_DIRECT;
-      break;
-    case kPolicyAutoDetectProxyMode:
+    } else if (string_mode ==
+               std::string(ProxyPrefs::kAutoDetectProxyModeName)) {
       mode = ProxyPrefs::MODE_AUTO_DETECT;
-      if (HasProxyPolicy(kPolicyProxyPacUrl))
-        mode = ProxyPrefs::MODE_PAC_SCRIPT;
-      break;
-    case kPolicyManuallyConfiguredProxyMode:
+    } else if (string_mode ==
+               std::string(ProxyPrefs::kFixedServersProxyModeName)) {
       mode = ProxyPrefs::MODE_FIXED_SERVERS;
-      break;
-    case kPolicyUseSystemProxyMode:
+    } else if (string_mode ==
+               std::string(ProxyPrefs::kPacScriptProxyModeName)) {
+      mode = ProxyPrefs::MODE_PAC_SCRIPT;
+    } else if (string_mode ==
+               std::string(ProxyPrefs::kSystemProxyModeName)) {
       mode = ProxyPrefs::MODE_SYSTEM;
-      break;
-    default:
+    } else {
       mode = ProxyPrefs::MODE_DIRECT;
       NOTREACHED();
+    }
+  } 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;
   }
   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 189 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 85 matching lines @@
   // Update the initialization flag.
   if (!initialization_complete_ &&
       provider_->IsInitializationComplete()) {
     initialization_complete_ = true;
     FOR_EACH_OBSERVER(PrefStore::Observer, observers_,
                       OnInitializationCompleted());
   }
 }
 
 }  // namespace policy