replace OVERRIDE and FINAL with override and final in chrome/browser/chromeos/

chrome/browser/chromeos/platform_keys/platform_keys_nss.cc

 // Copyright 2014 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/chromeos/platform_keys/platform_keys.h"
 
 #include <cryptohi.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 123 matching lines @@
                                      state));
 }
 
 class GenerateRSAKeyState : public NSSOperationState {
  public:
   GenerateRSAKeyState(unsigned int modulus_length_bits,
                       const subtle::GenerateKeyCallback& callback);
   virtual ~GenerateRSAKeyState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from, std::string() /* no public key */, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& public_key_spki_der,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, public_key_spki_der, error_message));
   }
 
   const unsigned int modulus_length_bits_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   subtle::GenerateKeyCallback callback_;
 };
 
 class SignState : public NSSOperationState {
  public:
   SignState(const std::string& public_key,
             HashAlgorithm hash_algorithm,
             const std::string& data,
             const subtle::SignCallback& callback);
   virtual ~SignState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from, std::string() /* no signature */, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& signature,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, signature, error_message));
   }
 
   const std::string public_key_;
   HashAlgorithm hash_algorithm_;
   const std::string data_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   subtle::SignCallback callback_;
 };
 
 class GetCertificatesState : public NSSOperationState {
  public:
   explicit GetCertificatesState(const GetCertificatesCallback& callback);
   virtual ~GetCertificatesState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from,
              scoped_ptr<net::CertificateList>() /* no certificates */,
              error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 scoped_ptr<net::CertificateList> certs,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, base::Passed(&certs), error_message));
   }
 
   scoped_ptr<net::CertificateList> certs_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   GetCertificatesCallback callback_;
 };
 
 class ImportCertificateState : public NSSOperationState {
  public:
   ImportCertificateState(scoped_refptr<net::X509Certificate> certificate,
                          const ImportCertificateCallback& callback);
   virtual ~ImportCertificateState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(from, base::Bind(callback_, error_message));
   }
 
   scoped_refptr<net::X509Certificate> certificate_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   ImportCertificateCallback callback_;
 };
 
 class RemoveCertificateState : public NSSOperationState {
  public:
   RemoveCertificateState(scoped_refptr<net::X509Certificate> certificate,
                          const RemoveCertificateCallback& callback);
   virtual ~RemoveCertificateState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from, error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(from, base::Bind(callback_, error_message));
   }
 
   scoped_refptr<net::X509Certificate> certificate_;
 
  private:
   // Must be called on origin thread, therefore use CallBack().
   RemoveCertificateCallback callback_;
 };
 
 class GetTokensState : public NSSOperationState {
  public:
   explicit GetTokensState(const GetTokensCallback& callback);
   virtual ~GetTokensState() {}
 
   virtual void OnError(const tracked_objects::Location& from,
-                       const std::string& error_message) OVERRIDE {
+                       const std::string& error_message) override {
     CallBack(from,
              scoped_ptr<std::vector<std::string> >() /* no token ids */,
              error_message);
   }
 
   void CallBack(const tracked_objects::Location& from,
                 scoped_ptr<std::vector<std::string> > token_ids,
                 const std::string& error_message) {
     origin_task_runner_->PostTask(
         from, base::Bind(callback_, base::Passed(&token_ids), error_message));
@@ skipping 376 matching lines @@
   NSSOperationState* state_ptr = state.get();
   GetCertDatabase(std::string() /* don't get any specific slot */,
                   base::Bind(&GetTokensWithDB, base::Passed(&state)),
                   browser_context,
                   state_ptr);
 }
 
 }  // namespace platform_keys
 
 }  // namespace chromeos