Removed ConfigurationPolicyType and extended PolicyMap.

chrome/browser/policy/configuration_policy_handler.h

 // Copyright (c) 2012 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_POLICY_CONFIGURATION_POLICY_HANDLER_H_
 #define CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_HANDLER_H_
 #pragma once
 
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/values.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
-#include "policy/configuration_policy_type.h"
 
 class PrefValueMap;
 
 namespace policy {
 
 class PolicyErrorMap;
 class PolicyMap;
 
 // An abstract super class that subclasses should implement to map policies to
 // their corresponding preferences, and to check whether the policies are valid.
@@ skipping 22 matching lines @@
   virtual void PrepareForDisplaying(PolicyMap* policies) const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConfigurationPolicyHandler);
 };
 
 // Abstract class derived from ConfigurationPolicyHandler that should be
 // subclassed to handle a single policy (not a combination of policies).
 class TypeCheckingPolicyHandler : public ConfigurationPolicyHandler {
  public:
-  TypeCheckingPolicyHandler(ConfigurationPolicyType policy_type,
+  TypeCheckingPolicyHandler(const char* policy_name,
                             base::Value::Type value_type);
 
   // ConfigurationPolicyHandler methods:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
                                    PolicyErrorMap* errors) OVERRIDE;
 
  protected:
   virtual ~TypeCheckingPolicyHandler();
 
   // Runs policy checks and returns the policy value if successful.
   bool CheckAndGetValue(const PolicyMap& policies,
                         PolicyErrorMap* errors,
                         const Value** value);
 
-  ConfigurationPolicyType policy_type() const;
+  const char* policy_name() const;
 
  private:
-  // The ConfigurationPolicyType of the policy.
-  ConfigurationPolicyType policy_type_;
+  // The name of the policy.
+  const char* policy_name_;
 
   // The type the value of the policy should have.
   base::Value::Type value_type_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeCheckingPolicyHandler);
 };
 
 // ConfigurationPolicyHandler for policies that map directly to a preference.
 class SimplePolicyHandler : public TypeCheckingPolicyHandler {
  public:
-  SimplePolicyHandler(ConfigurationPolicyType policy_type,
-                      base::Value::Type value_type,
-                      const char* pref_path);
+  SimplePolicyHandler(const char* policy_name,
+                      const char* pref_path,
+                      base::Value::Type value_type);
   virtual ~SimplePolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   // The DictionaryValue path of the preference the policy maps to.
   const char* pref_path_;
 
@@ skipping 114 matching lines @@
                                    PolicyErrorMap* errors) OVERRIDE;
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   // Calls |CheckPolicySettings()| on each of the handlers in |handlers_|
   // and returns true if all of the calls return true and false otherwise.
   bool CheckIndividualPolicies(const PolicyMap& policies,
                                PolicyErrorMap* errors);
 
-  // Returns true if there is a value for |policy_type| in |policies| and false
+  // Returns true if there is a value for |policy_name| in |policies| and false
   // otherwise.
   bool HasDefaultSearchPolicy(const PolicyMap& policies,
-                              ConfigurationPolicyType policy_type);
+                              const char* policy_name);
 
   // Returns true if any default search policies are specified in |policies| and
   // false otherwise.
   bool AnyDefaultSearchPoliciesSpecified(const PolicyMap& policies);
 
   // Returns true if the default search provider is disabled and false
   // otherwise.
   bool DefaultSearchProviderIsDisabled(const PolicyMap& policies);
 
   // Returns true if the default search URL was set and is valid and false
   // otherwise.
   bool DefaultSearchURLIsValid(const PolicyMap& policies);
 
   // Make sure that the |path| if present in |prefs_|.  If not, set it to
   // a blank string.
   void EnsureStringPrefExists(PrefValueMap* prefs, const std::string& path);
 
   // The ConfigurationPolicyHandler handlers for each default search policy.
   std::vector<ConfigurationPolicyHandler*> handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultSearchPolicyHandler);
 };
 
 // ConfigurationPolicyHandler for the proxy policies.
 class ProxyPolicyHandler : public ConfigurationPolicyHandler {
  public:
+  // Constants for the "Proxy Server Mode" defined in the policies.
+  // Note that these diverge from internal presentation defined in
+  // ProxyPrefs::ProxyMode for legacy reasons. The following four
+  // PolicyProxyModeType types were not very precise and had overlapping use
+  // cases.
+  enum ProxyModeType {
+    // Disable Proxy, connect directly.
+    kNoProxyServerMode = 0,

[Mattias Nissler (ping if slow), 2012/01/16 18:23:33]

If you touch the enum, you might as well make the constants UPPER_CASE.

[Joao da Silva, 2012/01/17 13:09:29]

Done.

+    // Auto detect proxy or use specific PAC script if given.
+    kAutoDetectProxyServerMode = 1,
+    // Use manually configured proxy servers (fixed servers).
+    kManuallyConfiguredProxyServerMode = 2,
+    // Use system proxy server.
+    kUseSystemProxyServerMode = 3,
+
+    MODE_COUNT
+  };
+
   ProxyPolicyHandler();
   virtual ~ProxyPolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
                                    PolicyErrorMap* errors) OVERRIDE;
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   const Value* GetProxyPolicyValue(const PolicyMap& policies,
-                                   ConfigurationPolicyType policy);
+                                   const char* policy_name);
 
   // Converts the deprecated ProxyServerMode policy value to a ProxyMode value
   // and places the result in |mode_value|. Returns true if the conversion
   // succeeded and false otherwise.
   bool CheckProxyModeAndServerMode(const PolicyMap& policies,
                                    PolicyErrorMap* errors,
                                    std::string* mode_value);
 
   DISALLOW_COPY_AND_ASSIGN(ProxyPolicyHandler);
 };
@@ skipping 10 matching lines @@
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(JavascriptPolicyHandler);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_HANDLER_H_