Move policy code into components/policy.

components/policy/core/browser/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_
+#ifndef COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
+#define COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "components/policy/policy_export.h"
 
 class PrefValueMap;
 
 namespace policy {
 
 class PolicyErrorMap;
 class PolicyMap;
 
 // Maps a policy type to a preference path, and to the expected value type.
-struct PolicyToPreferenceMapEntry {
+struct POLICY_EXPORT PolicyToPreferenceMapEntry {
   const char* const policy_name;
   const char* const preference_path;
   const base::Value::Type value_type;
 };
 
 // An abstract super class that subclasses should implement to map policies to
 // their corresponding preferences, and to check whether the policies are valid.
-class ConfigurationPolicyHandler {
+class POLICY_EXPORT ConfigurationPolicyHandler {
  public:
   static std::string ValueTypeToString(Value::Type type);
 
   ConfigurationPolicyHandler();
   virtual ~ConfigurationPolicyHandler();
 
   // Returns whether the policy settings handled by this
   // ConfigurationPolicyHandler can be applied.  Fills |errors| with error
   // messages or warnings.  |errors| may contain error messages even when
   // |CheckPolicySettings()| returns true.
   virtual bool CheckPolicySettings(const PolicyMap& policies,
                                    PolicyErrorMap* errors) = 0;
 
   // Processes the policies handled by this ConfigurationPolicyHandler and sets
   // the appropriate preferences in |prefs|.
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) = 0;
 
   // Modifies the values of some of the policies in |policies| so that they
   // are more suitable to display to the user. This can be used to remove
   // sensitive values such as passwords, or to pretty-print values.
   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 {
+class POLICY_EXPORT TypeCheckingPolicyHandler
+    : public ConfigurationPolicyHandler {
  public:
   TypeCheckingPolicyHandler(const char* policy_name,
                             base::Value::Type value_type);
   virtual ~TypeCheckingPolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
                                    PolicyErrorMap* errors) OVERRIDE;
 
   const char* policy_name() const;
@@ skipping 10 matching lines @@
 
   // The type the value of the policy should have.
   base::Value::Type value_type_;
 
   DISALLOW_COPY_AND_ASSIGN(TypeCheckingPolicyHandler);
 };
 
 // Abstract class derived from TypeCheckingPolicyHandler that ensures an int
 // policy's value lies in an allowed range. Either clamps or rejects values
 // outside the range.
-class IntRangePolicyHandlerBase : public TypeCheckingPolicyHandler {
+class POLICY_EXPORT IntRangePolicyHandlerBase
+    : public TypeCheckingPolicyHandler {
  public:
   IntRangePolicyHandlerBase(const char* policy_name,
                             int min,
                             int max,
                             bool clamp);
 
   // ConfigurationPolicyHandler:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
                                    PolicyErrorMap* errors) OVERRIDE;
 
@@ skipping 15 matching lines @@
   int max_;
 
   // Whether to clamp values lying outside the allowed range instead of
   // rejecting them.
   bool clamp_;
 
   DISALLOW_COPY_AND_ASSIGN(IntRangePolicyHandlerBase);
 };
 
 // ConfigurationPolicyHandler for policies that map directly to a preference.
-class SimplePolicyHandler : public TypeCheckingPolicyHandler {
+class POLICY_EXPORT SimplePolicyHandler : public TypeCheckingPolicyHandler {
  public:
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(SimplePolicyHandler);
 };
 
 // A policy handler implementation that maps a string enum list to an int enum
 // list as specified by a mapping table.
-class StringToIntEnumListPolicyHandler : public TypeCheckingPolicyHandler {
+class POLICY_EXPORT StringToIntEnumListPolicyHandler
+    : public TypeCheckingPolicyHandler {
  public:
-  struct MappingEntry {
+  struct POLICY_EXPORT MappingEntry {
     const char* enum_value;
     int int_value;
   };
 
   StringToIntEnumListPolicyHandler(const char* policy_name,
                                    const char* pref_path,
                                    const MappingEntry* mapping_begin,
                                    const MappingEntry* mapping_end);
 
   // ConfigurationPolicyHandler methods:
@@ skipping 14 matching lines @@
 
   // The mapping table.
   const MappingEntry* mapping_begin_;
   const MappingEntry* mapping_end_;
 
   DISALLOW_COPY_AND_ASSIGN(StringToIntEnumListPolicyHandler);
 };
 
 // A policy handler implementation that ensures an int policy's value lies in an
 // allowed range.
-class IntRangePolicyHandler : public IntRangePolicyHandlerBase {
+class POLICY_EXPORT IntRangePolicyHandler : public IntRangePolicyHandlerBase {
  public:
   IntRangePolicyHandler(const char* policy_name,
                         const char* pref_path,
                         int min,
                         int max,
                         bool clamp);
   virtual ~IntRangePolicyHandler();
 
   // ConfigurationPolicyHandler:
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   // Name of the pref to write.
   const char* pref_path_;
 
   DISALLOW_COPY_AND_ASSIGN(IntRangePolicyHandler);
 };
 
 // A policy handler implementation that maps an int percentage value to a
 // double.
-class IntPercentageToDoublePolicyHandler : public IntRangePolicyHandlerBase {
+class POLICY_EXPORT IntPercentageToDoublePolicyHandler
+    : public IntRangePolicyHandlerBase {
  public:
   IntPercentageToDoublePolicyHandler(const char* policy_name,
                                      const char* pref_path,
                                      int min,
                                      int max,
                                      bool clamp);
   virtual ~IntPercentageToDoublePolicyHandler();
 
   // ConfigurationPolicyHandler:
   virtual void ApplyPolicySettings(const PolicyMap& policies,
                                    PrefValueMap* prefs) OVERRIDE;
 
  private:
   // Name of the pref to write.
   const char* pref_path_;
 
   DISALLOW_COPY_AND_ASSIGN(IntPercentageToDoublePolicyHandler);
 };
 
 }  // namespace policy
 
-#endif  // CHROME_BROWSER_POLICY_CONFIGURATION_POLICY_HANDLER_H_
+#endif  // COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_