replace OVERRIDE and FINAL with override and final in components/

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 COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
 #define COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 64 matching lines @@
 // subclassed to handle a single policy (not a combination of policies).
 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;
+                                   PolicyErrorMap* errors) override;
 
   const char* policy_name() const;
 
  protected:
   // Runs policy checks and returns the policy value if successful.
   bool CheckAndGetValue(const PolicyMap& policies,
                         PolicyErrorMap* errors,
                         const base::Value** value);
 
  private:
@@ skipping 12 matching lines @@
 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;
+                                   PolicyErrorMap* errors) override;
 
  protected:
   virtual ~IntRangePolicyHandlerBase();
 
   // Ensures that the value is in the allowed range. Returns false if the value
   // cannot be parsed or lies outside the allowed range and clamping is
   // disabled.
   bool EnsureInRange(const base::Value* input,
                      int* output,
                      PolicyErrorMap* errors);
@@ skipping 15 matching lines @@
 // ConfigurationPolicyHandler for policies that map directly to a preference.
 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;
+                                   PrefValueMap* prefs) override;
 
  private:
   // The DictionaryValue path of the preference the policy maps to.
   const char* pref_path_;
 
   DISALLOW_COPY_AND_ASSIGN(SimplePolicyHandler);
 };
 
 // Base class that encapsulates logic for mapping from a string enum list
 // to a separate matching type value.
@@ skipping 14 matching lines @@
   // Callback that generates the map for this instance.
   typedef base::Callback<void(ScopedVector<MappingEntry>*)> GenerateMapCallback;
 
   StringMappingListPolicyHandler(const char* policy_name,
                                  const char* pref_path,
                                  const GenerateMapCallback& map_generator);
   virtual ~StringMappingListPolicyHandler();
 
   // ConfigurationPolicyHandler methods:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
-                                   PolicyErrorMap* errors) OVERRIDE;
+                                   PolicyErrorMap* errors) override;
   virtual void ApplyPolicySettings(const PolicyMap& policies,
-                                   PrefValueMap* prefs) OVERRIDE;
+                                   PrefValueMap* prefs) override;
 
  private:
   // Attempts to convert the list in |input| to |output| according to the table,
   // returns false on errors.
   bool Convert(const base::Value* input,
                base::ListValue* output,
                PolicyErrorMap* errors);
 
   // Helper method that converts from a policy value string to the associated
   // pref value.
@@ skipping 18 matching lines @@
  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;
+                                   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 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;
+                                   PrefValueMap* prefs) override;
 
  private:
   // Name of the pref to write.
   const char* pref_path_;
 
   DISALLOW_COPY_AND_ASSIGN(IntPercentageToDoublePolicyHandler);
 };
 
 // Like TypeCheckingPolicyHandler, but validates against a schema instead of a
 // single type. |schema| is the schema used for this policy, and |strategy| is
 // the strategy used for schema validation errors.
 class POLICY_EXPORT SchemaValidatingPolicyHandler
     : public ConfigurationPolicyHandler {
  public:
   SchemaValidatingPolicyHandler(const char* policy_name,
                                 Schema schema,
                                 SchemaOnErrorStrategy strategy);
   virtual ~SchemaValidatingPolicyHandler();
 
   // ConfigurationPolicyHandler:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
-                                   PolicyErrorMap* errors) OVERRIDE;
+                                   PolicyErrorMap* errors) override;
 
   const char* policy_name() const;
 
  protected:
   // Runs policy checks and returns the policy value if successful.
   bool CheckAndGetValue(const PolicyMap& policies,
                         PolicyErrorMap* errors,
                         scoped_ptr<base::Value>* output);
 
  private:
@@ skipping 20 matching lines @@
       const char* policy_name,
       const char* pref_path,
       Schema schema,
       SchemaOnErrorStrategy strategy,
       RecommendedPermission recommended_permission,
       MandatoryPermission mandatory_permission);
   virtual ~SimpleSchemaValidatingPolicyHandler();
 
   // ConfigurationPolicyHandler:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
-                                   PolicyErrorMap* errors) OVERRIDE;
+                                   PolicyErrorMap* errors) override;
   virtual void ApplyPolicySettings(const PolicyMap& policies,
-                                   PrefValueMap* prefs) OVERRIDE;
+                                   PrefValueMap* prefs) override;
 
  private:
   const char* pref_path_;
   const bool allow_recommended_;
   const bool allow_mandatory_;
 
   DISALLOW_COPY_AND_ASSIGN(SimpleSchemaValidatingPolicyHandler);
 };
 
 // A policy handler to deprecate multiple legacy policies with a new one.
 // This handler will completely ignore any of legacy policy values if the new
 // one is set.
 class POLICY_EXPORT LegacyPoliciesDeprecatingPolicyHandler
     : public ConfigurationPolicyHandler {
  public:
   LegacyPoliciesDeprecatingPolicyHandler(
       ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers,
       scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler);
   virtual ~LegacyPoliciesDeprecatingPolicyHandler();
 
   // ConfigurationPolicyHandler:
   virtual bool CheckPolicySettings(const PolicyMap& policies,
-                                   PolicyErrorMap* errors) OVERRIDE;
+                                   PolicyErrorMap* errors) override;
   virtual void ApplyPolicySettings(const PolicyMap& policies,
-                                   PrefValueMap* prefs) OVERRIDE;
+                                   PrefValueMap* prefs) override;
 
  private:
   ScopedVector<ConfigurationPolicyHandler> legacy_policy_handlers_;
   scoped_ptr<SchemaValidatingPolicyHandler> new_policy_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(LegacyPoliciesDeprecatingPolicyHandler);
 };
 
 }  // namespace policy
 
 #endif  // COMPONENTS_POLICY_CORE_BROWSER_CONFIGURATION_POLICY_HANDLER_H_