Standardize usage of virtual/override/final in components/

components/policy/core/browser/policy_error_map.cc

 // Copyright 2013 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 "components/policy/core/browser/policy_error_map.h"
 
 #include <utility>
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 23 matching lines @@
 namespace {
 
 class SimplePendingError : public PolicyErrorMap::PendingError {
  public:
   SimplePendingError(const std::string& policy_name,
                      int message_id,
                      const std::string& replacement)
       : PendingError(policy_name),
         message_id_(message_id),
         replacement_(replacement) {}
-  virtual ~SimplePendingError() {}
+  ~SimplePendingError() override {}
 
-  virtual base::string16 GetMessage() const override {
+  base::string16 GetMessage() const override {
     if (message_id_ >= 0) {
       if (replacement_.empty())
         return l10n_util::GetStringUTF16(message_id_);
       return l10n_util::GetStringFUTF16(message_id_,
                                         base::ASCIIToUTF16(replacement_));
     }
     return base::ASCIIToUTF16(replacement_);
   }
 
  private:
   int message_id_;
   std::string replacement_;
 
   DISALLOW_COPY_AND_ASSIGN(SimplePendingError);
 };
 
 class DictSubkeyPendingError : public SimplePendingError {
  public:
   DictSubkeyPendingError(const std::string& policy_name,
                          const std::string& subkey,
                          int message_id,
                          const std::string& replacement)
       : SimplePendingError(policy_name, message_id, replacement),
         subkey_(subkey) {}
-  virtual ~DictSubkeyPendingError() {}
+  ~DictSubkeyPendingError() override {}
 
-  virtual base::string16 GetMessage() const override {
+  base::string16 GetMessage() const override {
     return l10n_util::GetStringFUTF16(IDS_POLICY_SUBKEY_ERROR,
                                       base::ASCIIToUTF16(subkey_),
                                       SimplePendingError::GetMessage());
   }
 
  private:
   std::string subkey_;
 
   DISALLOW_COPY_AND_ASSIGN(DictSubkeyPendingError);
 };
 
 class ListItemPendingError : public SimplePendingError {
  public:
   ListItemPendingError(const std::string& policy_name,
                        int index,
                        int message_id,
                        const std::string& replacement)
       : SimplePendingError(policy_name, message_id, replacement),
         index_(index) {}
-  virtual ~ListItemPendingError() {}
+  ~ListItemPendingError() override {}
 
-  virtual base::string16 GetMessage() const override {
+  base::string16 GetMessage() const override {
     return l10n_util::GetStringFUTF16(IDS_POLICY_LIST_ENTRY_ERROR,
                                       base::IntToString16(index_),
                                       SimplePendingError::GetMessage());
   }
 
  private:
   int index_;
 
   DISALLOW_COPY_AND_ASSIGN(ListItemPendingError);
 };
 
 class SchemaValidatingPendingError : public SimplePendingError {
  public:
   SchemaValidatingPendingError(const std::string& policy_name,
                                const std::string& error_path,
                                const std::string& replacement)
       : SimplePendingError(policy_name, -1, replacement),
         error_path_(error_path) {};
-  virtual ~SchemaValidatingPendingError() {}
+  ~SchemaValidatingPendingError() override {}
 
-  virtual base::string16 GetMessage() const override {
+  base::string16 GetMessage() const override {
     return l10n_util::GetStringFUTF16(IDS_POLICY_SCHEMA_VALIDATION_ERROR,
                                       base::ASCIIToUTF16(error_path_),
                                       SimplePendingError::GetMessage());
   }
 
  private:
   std::string error_path_;
 
   DISALLOW_COPY_AND_ASSIGN(SchemaValidatingPendingError);
 };
@@ skipping 102 matching lines @@
 
 void PolicyErrorMap::CheckReadyAndConvert() {
   DCHECK(IsReady());
   for (size_t i = 0; i < pending_.size(); ++i) {
     Convert(pending_[i]);
   }
   pending_.clear();
 }
 
 }  // namespace policy