Update {virtual,override,final} to follow C++11 style in chromeos.

chromeos/cryptohome/async_method_caller.cc

 // 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.
 
 #include "chromeos/cryptohome/async_method_caller.h"
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 12 matching lines @@
 class AsyncMethodCallerImpl : public AsyncMethodCaller {
  public:
   AsyncMethodCallerImpl() : weak_ptr_factory_(this) {
     DBusThreadManager::Get()->GetCryptohomeClient()->SetAsyncCallStatusHandlers(
         base::Bind(&AsyncMethodCallerImpl::HandleAsyncResponse,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&AsyncMethodCallerImpl::HandleAsyncDataResponse,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual ~AsyncMethodCallerImpl() {
+  ~AsyncMethodCallerImpl() override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         ResetAsyncCallStatusHandlers();
   }
 
-  virtual void AsyncCheckKey(const std::string& user_email,
-                             const std::string& passhash,
-                             Callback callback) override {
+  void AsyncCheckKey(const std::string& user_email,
+                     const std::string& passhash,
+                     Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncCheckKey(user_email, passhash, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async check of user's key."));
   }
 
-  virtual void AsyncMigrateKey(const std::string& user_email,
-                               const std::string& old_hash,
-                               const std::string& new_hash,
-                               Callback callback) override {
+  void AsyncMigrateKey(const std::string& user_email,
+                       const std::string& old_hash,
+                       const std::string& new_hash,
+                       Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncMigrateKey(user_email, old_hash, new_hash, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate aync migration of user's key"));
   }
 
-  virtual void AsyncMount(const std::string& user_email,
-                          const std::string& passhash,
-                          int flags,
-                          Callback callback) override {
+  void AsyncMount(const std::string& user_email,
+                  const std::string& passhash,
+                  int flags,
+                  Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncMount(user_email, passhash, flags, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async mount of cryptohome."));
   }
 
-  virtual void AsyncAddKey(const std::string& user_email,
-                           const std::string& passhash,
-                           const std::string& new_passhash,
-                           Callback callback) override {
+  void AsyncAddKey(const std::string& user_email,
+                   const std::string& passhash,
+                   const std::string& new_passhash,
+                   Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncAddKey(user_email, passhash, new_passhash, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async key addition."));
   }
 
-  virtual void AsyncMountGuest(Callback callback) override {
+  void AsyncMountGuest(Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncMountGuest(base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async mount of cryptohome."));
   }
 
-  virtual void AsyncMountPublic(const std::string& public_mount_id,
-                                int flags,
-                                Callback callback) override {
+  void AsyncMountPublic(const std::string& public_mount_id,
+                        int flags,
+                        Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncMountPublic(public_mount_id, flags, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async mount public of cryptohome."));
   }
 
-  virtual void AsyncRemove(const std::string& user_email,
-                           Callback callback) override {
+  void AsyncRemove(const std::string& user_email, Callback callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncRemove(user_email, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async removal of cryptohome."));
   }
 
-  virtual void AsyncTpmAttestationCreateEnrollRequest(
+  void AsyncTpmAttestationCreateEnrollRequest(
       chromeos::attestation::PrivacyCAType pca_type,
       const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncTpmAttestationCreateEnrollRequest(pca_type, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async attestation enroll request."));
   }
 
-  virtual void AsyncTpmAttestationEnroll(
-      chromeos::attestation::PrivacyCAType pca_type,
-      const std::string& pca_response,
-      const Callback& callback) override {
+  void AsyncTpmAttestationEnroll(chromeos::attestation::PrivacyCAType pca_type,
+                                 const std::string& pca_response,
+                                 const Callback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncTpmAttestationEnroll(pca_type, pca_response, base::Bind(
             &AsyncMethodCallerImpl::RegisterAsyncCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback,
             "Couldn't initiate async attestation enroll."));
   }
 
-  virtual void AsyncTpmAttestationCreateCertRequest(
+  void AsyncTpmAttestationCreateCertRequest(
       chromeos::attestation::PrivacyCAType pca_type,
       chromeos::attestation::AttestationCertificateProfile certificate_profile,
       const std::string& user_id,
       const std::string& request_origin,
       const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncTpmAttestationCreateCertRequest(
             pca_type,
             certificate_profile,
             user_id,
             request_origin,
             base::Bind(&AsyncMethodCallerImpl::RegisterAsyncDataCallback,
                        weak_ptr_factory_.GetWeakPtr(),
                        callback,
                        "Couldn't initiate async attestation cert request."));
   }
 
-  virtual void AsyncTpmAttestationFinishCertRequest(
+  void AsyncTpmAttestationFinishCertRequest(
       const std::string& pca_response,
       chromeos::attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         AsyncTpmAttestationFinishCertRequest(
             pca_response,
             key_type,
             user_id,
             key_name,
             base::Bind(
                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
                 weak_ptr_factory_.GetWeakPtr(),
                 callback,
                 "Couldn't initiate async attestation finish cert request."));
   }
 
-  virtual void TpmAttestationRegisterKey(
+  void TpmAttestationRegisterKey(
       chromeos::attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const Callback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         TpmAttestationRegisterKey(
             key_type,
             user_id,
             key_name,
             base::Bind(
                 &AsyncMethodCallerImpl::RegisterAsyncCallback,
                 weak_ptr_factory_.GetWeakPtr(),
                 callback,
                 "Couldn't initiate async attestation register key."));
   }
 
-  virtual void TpmAttestationSignEnterpriseChallenge(
+  void TpmAttestationSignEnterpriseChallenge(
       chromeos::attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& domain,
       const std::string& device_id,
       chromeos::attestation::AttestationChallengeOptions options,
       const std::string& challenge,
       const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         TpmAttestationSignEnterpriseChallenge(
             key_type,
             user_id,
             key_name,
             domain,
             device_id,
             options,
             challenge,
             base::Bind(
                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
                 weak_ptr_factory_.GetWeakPtr(),
                 callback,
                 "Couldn't initiate async attestation enterprise challenge."));
   }
 
-  virtual void TpmAttestationSignSimpleChallenge(
+  void TpmAttestationSignSimpleChallenge(
       chromeos::attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& challenge,
       const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         TpmAttestationSignSimpleChallenge(
             key_type,
             user_id,
             key_name,
             challenge,
             base::Bind(
                 &AsyncMethodCallerImpl::RegisterAsyncDataCallback,
                 weak_ptr_factory_.GetWeakPtr(),
                 callback,
                 "Couldn't initiate async attestation simple challenge."));
   }
 
-  virtual void AsyncGetSanitizedUsername(
-      const std::string& user,
-      const DataCallback& callback) override {
+  void AsyncGetSanitizedUsername(const std::string& user,
+                                 const DataCallback& callback) override {
     DBusThreadManager::Get()->GetCryptohomeClient()->
         GetSanitizedUsername(user,
         base::Bind(
             &AsyncMethodCallerImpl::GetSanitizedUsernameCallback,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   virtual void GetSanitizedUsernameCallback(
       const DataCallback& callback,
@@ skipping 129 matching lines @@
   g_async_method_caller = NULL;
   VLOG(1) << "AsyncMethodCaller Shutdown completed";
 }
 
 // static
 AsyncMethodCaller* AsyncMethodCaller::GetInstance() {
   return g_async_method_caller;
 }
 
 }  // namespace cryptohome