replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/cryptohome_client.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/dbus/cryptohome_client.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 21 matching lines @@
 const int kTpmDBusTimeoutMs = 2 * 60 * 1000;
 
 // The CryptohomeClient implementation.
 class CryptohomeClientImpl : public CryptohomeClient {
  public:
   CryptohomeClientImpl() : proxy_(NULL), weak_ptr_factory_(this) {}
 
   // CryptohomeClient override.
   virtual void SetAsyncCallStatusHandlers(
       const AsyncCallStatusHandler& handler,
-      const AsyncCallStatusWithDataHandler& data_handler) OVERRIDE {
+      const AsyncCallStatusWithDataHandler& data_handler) override {
     async_call_status_handler_ = handler;
     async_call_status_data_handler_ = data_handler;
   }
 
   // CryptohomeClient override.
-  virtual void ResetAsyncCallStatusHandlers() OVERRIDE {
+  virtual void ResetAsyncCallStatusHandlers() override {
     async_call_status_handler_.Reset();
     async_call_status_data_handler_.Reset();
   }
 
   // CryptohomeClient override.
   virtual void WaitForServiceToBeAvailable(
-      const WaitForServiceToBeAvailableCallback& callback) OVERRIDE {
+      const WaitForServiceToBeAvailableCallback& callback) override {
     proxy_->WaitForServiceToBeAvailable(callback);
   }
 
   // CryptohomeClient override.
-  virtual void IsMounted(const BoolDBusMethodCallback& callback) OVERRIDE {
+  virtual void IsMounted(const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeIsMounted);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
-  virtual bool Unmount(bool *success) OVERRIDE {
+  virtual bool Unmount(bool *success) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeUnmount);
     return CallBoolMethodAndBlock(&method_call, success);
   }
 
   // CryptohomeClient override.
   virtual void AsyncCheckKey(const std::string& username,
                              const std::string& key,
-                             const AsyncMethodCallback& callback) OVERRIDE {
+                             const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncCheckKey);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(key);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncMigrateKey(const std::string& username,
                                const std::string& from_key,
                                const std::string& to_key,
-                               const AsyncMethodCallback& callback) OVERRIDE {
+                               const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncMigrateKey);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(from_key);
     writer.AppendString(to_key);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncRemove(const std::string& username,
-                           const AsyncMethodCallback& callback) OVERRIDE {
+                           const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncRemove);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
-  virtual void GetSystemSalt(const GetSystemSaltCallback& callback) OVERRIDE {
+  virtual void GetSystemSalt(const GetSystemSaltCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetSystemSalt);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnGetSystemSalt,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override,
   virtual void GetSanitizedUsername(
       const std::string& username,
-      const StringDBusMethodCallback& callback) OVERRIDE {
+      const StringDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetSanitizedUsername);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnStringMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual std::string BlockingGetSanitizedUsername(
-      const std::string& username) OVERRIDE {
+      const std::string& username) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetSanitizedUsername);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
 
     scoped_ptr<dbus::Response> response =
         blocking_method_caller_->CallMethodAndBlock(&method_call);
 
     std::string sanitized_username;
     if (response) {
       dbus::MessageReader reader(response.get());
       reader.PopString(&sanitized_username);
     }
 
     return sanitized_username;
   }
 
   // CryptohomeClient override.
   virtual void AsyncMount(const std::string& username,
                           const std::string& key,
                           int flags,
-                          const AsyncMethodCallback& callback) OVERRIDE {
+                          const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncMount);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(key);
     writer.AppendBool(flags & cryptohome::CREATE_IF_MISSING);
     writer.AppendBool(flags & cryptohome::ENSURE_EPHEMERAL);
     // deprecated_tracked_subdirectories
     writer.AppendArrayOfStrings(std::vector<std::string>());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncAddKey(const std::string& username,
                            const std::string& key,
                            const std::string& new_key,
-                           const AsyncMethodCallback& callback) OVERRIDE {
+                           const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncAddKey);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(username);
     writer.AppendString(key);
     writer.AppendString(new_key);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
-  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) OVERRIDE {
+  virtual void AsyncMountGuest(const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncMountGuest);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncMountPublic(const std::string& public_mount_id,
                                 int flags,
-                                const AsyncMethodCallback& callback) OVERRIDE {
+                                const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeAsyncMountPublic);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(public_mount_id);
     writer.AppendBool(flags & cryptohome::CREATE_IF_MISSING);
     writer.AppendBool(flags & cryptohome::ENSURE_EPHEMERAL);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
-  virtual void TpmIsReady(const BoolDBusMethodCallback& callback) OVERRIDE {
+  virtual void TpmIsReady(const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsReady);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
-  virtual void TpmIsEnabled(const BoolDBusMethodCallback& callback) OVERRIDE {
+  virtual void TpmIsEnabled(const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsEnabled);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   // TODO(hashimoto): Remove this method. crbug.com/141006
-  virtual bool CallTpmIsEnabledAndBlock(bool* enabled) OVERRIDE {
+  virtual bool CallTpmIsEnabledAndBlock(bool* enabled) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsEnabled);
     return CallBoolMethodAndBlock(&method_call, enabled);
   }
 
   // CryptohomeClient override.
   virtual void TpmGetPassword(
-      const StringDBusMethodCallback& callback) OVERRIDE {
+      const StringDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmGetPassword);
     proxy_->CallMethod(
         &method_call, kTpmDBusTimeoutMs ,
         base::Bind(&CryptohomeClientImpl::OnStringMethod,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback));
   }
 
   // CryptohomeClient override.
-  virtual void TpmIsOwned(const BoolDBusMethodCallback& callback) OVERRIDE {
+  virtual void TpmIsOwned(const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsOwned);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   // TODO(hashimoto): Remove this method. crbug.com/141012
-  virtual bool CallTpmIsOwnedAndBlock(bool* owned) OVERRIDE {
+  virtual bool CallTpmIsOwnedAndBlock(bool* owned) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsOwned);
     return CallBoolMethodAndBlock(&method_call, owned);
   }
 
   // CryptohomeClient override.
   virtual void TpmIsBeingOwned(const BoolDBusMethodCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsBeingOwned);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   // TODO(hashimoto): Remove this method. crbug.com/141011
-  virtual bool CallTpmIsBeingOwnedAndBlock(bool* owning) OVERRIDE {
+  virtual bool CallTpmIsBeingOwnedAndBlock(bool* owning) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmIsBeingOwned);
     return CallBoolMethodAndBlock(&method_call, owning);
   }
 
   // CryptohomeClient override.
   virtual void TpmCanAttemptOwnership(
-      const VoidDBusMethodCallback& callback) OVERRIDE {
+      const VoidDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmCanAttemptOwnership);
     CallVoidMethod(&method_call, callback);
   }
 
   // CryptohomeClient overrides.
   virtual void TpmClearStoredPassword(const VoidDBusMethodCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmClearStoredPassword);
     CallVoidMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   // TODO(hashimoto): Remove this method. crbug.com/141010
-  virtual bool CallTpmClearStoredPasswordAndBlock() OVERRIDE {
+  virtual bool CallTpmClearStoredPasswordAndBlock() override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeTpmClearStoredPassword);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_->CallMethodAndBlock(&method_call));
     return response.get() != NULL;
   }
 
   // CryptohomeClient override.
   virtual void Pkcs11IsTpmTokenReady(const BoolDBusMethodCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomePkcs11IsTpmTokenReady);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void Pkcs11GetTpmTokenInfo(
-      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
+      const Pkcs11GetTpmTokenInfoCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomePkcs11GetTpmTokenInfo);
     proxy_->CallMethod(
         &method_call, kTpmDBusTimeoutMs ,
         base::Bind(
             &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfo,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
   virtual void Pkcs11GetTpmTokenInfoForUser(
       const std::string& user_email,
-      const Pkcs11GetTpmTokenInfoCallback& callback) OVERRIDE {
+      const Pkcs11GetTpmTokenInfoCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomePkcs11GetTpmTokenInfoForUser);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(user_email);
     proxy_->CallMethod(
         &method_call, kTpmDBusTimeoutMs ,
         base::Bind(
             &CryptohomeClientImpl::OnPkcs11GetTpmTokenInfoForUser,
             weak_ptr_factory_.GetWeakPtr(),
             callback));
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesGet(const std::string& name,
                                     std::vector<uint8>* value,
-                                    bool* successful) OVERRIDE {
+                                    bool* successful) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesGet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     scoped_ptr<dbus::Response> response(
         blocking_method_caller_->CallMethodAndBlock(&method_call));
     if (!response.get())
       return false;
     dbus::MessageReader reader(response.get());
     const uint8* bytes = NULL;
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length) ||
         !reader.PopBool(successful))
       return false;
     value->assign(bytes, bytes + length);
     return true;
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesSet(const std::string& name,
                                     const std::vector<uint8>& value,
-                                    bool* successful) OVERRIDE {
+                                    bool* successful) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeInstallAttributesSet);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(name);
     writer.AppendArrayOfBytes(value.data(), value.size());
     return CallBoolMethodAndBlock(&method_call, successful);
   }
 
   // CryptohomeClient override.
-  virtual bool InstallAttributesFinalize(bool* successful) OVERRIDE {
+  virtual bool InstallAttributesFinalize(bool* successful) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeInstallAttributesFinalize);
     return CallBoolMethodAndBlock(&method_call, successful);
   }
 
   // CryptohomeClient override.
   virtual void InstallAttributesIsReady(const BoolDBusMethodCallback& callback)
-      OVERRIDE {
+      override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeInstallAttributesIsReady);
     return CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
-  virtual bool InstallAttributesIsInvalid(bool* is_invalid) OVERRIDE {
+  virtual bool InstallAttributesIsInvalid(bool* is_invalid) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeInstallAttributesIsInvalid);
     return CallBoolMethodAndBlock(&method_call, is_invalid);
   }
 
   // CryptohomeClient override.
   virtual bool InstallAttributesIsFirstInstall(
-      bool* is_first_install) OVERRIDE {
+      bool* is_first_install) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeInstallAttributesIsFirstInstall);
     return CallBoolMethodAndBlock(&method_call, is_first_install);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationIsPrepared(
-        const BoolDBusMethodCallback& callback) OVERRIDE {
+        const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmIsAttestationPrepared);
     return CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationIsEnrolled(
-        const BoolDBusMethodCallback& callback) OVERRIDE {
+        const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmIsAttestationEnrolled);
     return CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationCreateEnrollRequest(
       attestation::PrivacyCAType pca_type,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationCreateEnrollRequest);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(pca_type);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationEnroll(
       attestation::PrivacyCAType pca_type,
       const std::string& pca_response,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationEnroll);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(pca_type);
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8*>(pca_response.data()),
         pca_response.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationCreateCertRequest(
       attestation::PrivacyCAType pca_type,
       attestation::AttestationCertificateProfile certificate_profile,
       const std::string& user_id,
       const std::string& request_origin,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationCreateCertRequest);
     dbus::MessageWriter writer(&method_call);
     writer.AppendInt32(pca_type);
     writer.AppendInt32(certificate_profile);
     writer.AppendString(user_id);
     writer.AppendString(request_origin);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void AsyncTpmAttestationFinishCertRequest(
       const std::string& pca_response,
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeAsyncTpmAttestationFinishCertRequest);
     dbus::MessageWriter writer(&method_call);
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8*>(pca_response.data()),
         pca_response.size());
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationDoesKeyExist(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const BoolDBusMethodCallback& callback) OVERRIDE {
+      const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationDoesKeyExist);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetCertificate(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
+      const DataMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetCertificate);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetPublicKey(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
+      const DataMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetPublicKey);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationRegisterKey(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationRegisterKey);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignEnterpriseChallenge(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& domain,
       const std::string& device_id,
       attestation::AttestationChallengeOptions options,
       const std::string& challenge,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignEnterpriseChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     writer.AppendString(domain);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(device_id.data()),
                               device_id.size());
     bool include_signed_public_key =
         (options & attestation::CHALLENGE_INCLUDE_SIGNED_PUBLIC_KEY);
     writer.AppendBool(include_signed_public_key);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
                               challenge.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSignSimpleChallenge(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& challenge,
-      const AsyncMethodCallback& callback) OVERRIDE {
+      const AsyncMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSignSimpleChallenge);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(challenge.data()),
                               challenge.size());
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnAsyncMethodCall,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationGetKeyPayload(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
-      const DataMethodCallback& callback) OVERRIDE {
+      const DataMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationGetKeyPayload);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnDataMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationSetKeyPayload(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_name,
       const std::string& payload,
-      const BoolDBusMethodCallback& callback) OVERRIDE {
+      const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationSetKeyPayload);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_name);
     writer.AppendArrayOfBytes(reinterpret_cast<const uint8*>(payload.data()),
                               payload.size());
     CallBoolMethod(&method_call, callback);
   }
 
   // CryptohomeClient override.
   virtual void TpmAttestationDeleteKeys(
       attestation::AttestationKeyType key_type,
       const std::string& user_id,
       const std::string& key_prefix,
-      const BoolDBusMethodCallback& callback) OVERRIDE {
+      const BoolDBusMethodCallback& callback) override {
     dbus::MethodCall method_call(
         cryptohome::kCryptohomeInterface,
         cryptohome::kCryptohomeTpmAttestationDeleteKeys);
     dbus::MessageWriter writer(&method_call);
     bool is_user_specific = (key_type == attestation::KEY_USER);
     writer.AppendBool(is_user_specific);
     writer.AppendString(user_id);
     writer.AppendString(key_prefix);
     CallBoolMethod(&method_call, callback);
   }
 
   virtual void GetKeyDataEx(
       const cryptohome::AccountIdentifier& id,
       const cryptohome::AuthorizationRequest& auth,
       const cryptohome::GetKeyDataRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  cryptohome::kCryptohomeGetKeyDataEx);
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void CheckKeyEx(
       const cryptohome::AccountIdentifier& id,
       const cryptohome::AuthorizationRequest& auth,
       const cryptohome::CheckKeyRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeCheckKeyEx;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                         base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                    weak_ptr_factory_.GetWeakPtr(),
                                    callback));
   }
 
   virtual void MountEx(
       const cryptohome::AccountIdentifier& id,
       const cryptohome::AuthorizationRequest& auth,
       const cryptohome::MountRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeMountEx;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void AddKeyEx(
       const cryptohome::AccountIdentifier& id,
       const cryptohome::AuthorizationRequest& auth,
       const cryptohome::AddKeyRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeAddKeyEx;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call, kTpmDBusTimeoutMs,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void UpdateKeyEx(
       const cryptohome::AccountIdentifier& id,
       const cryptohome::AuthorizationRequest& auth,
       const cryptohome::UpdateKeyRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeUpdateKeyEx;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface,
                                  method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void RemoveKeyEx(const cryptohome::AccountIdentifier& id,
                            const cryptohome::AuthorizationRequest& auth,
                            const cryptohome::RemoveKeyRequest& request,
-                           const ProtobufMethodCallback& callback) OVERRIDE {
+                           const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeRemoveKeyEx;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface, method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(id);
     writer.AppendProtoAsArrayOfBytes(auth);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void GetBootAttribute(
       const cryptohome::GetBootAttributeRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeGetBootAttribute;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface, method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void SetBootAttribute(
       const cryptohome::SetBootAttributeRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeSetBootAttribute;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface, method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   virtual void FlushAndSignBootAttributes(
       const cryptohome::FlushAndSignBootAttributesRequest& request,
-      const ProtobufMethodCallback& callback) OVERRIDE {
+      const ProtobufMethodCallback& callback) override {
     const char* method_name = cryptohome::kCryptohomeFlushAndSignBootAttributes;
     dbus::MethodCall method_call(cryptohome::kCryptohomeInterface, method_name);
 
     dbus::MessageWriter writer(&method_call);
     writer.AppendProtoAsArrayOfBytes(request);
 
     proxy_->CallMethod(&method_call,
                        kTpmDBusTimeoutMs ,
                        base::Bind(&CryptohomeClientImpl::OnBaseReplyMethod,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     proxy_ = bus->GetObjectProxy(
         cryptohome::kCryptohomeServiceName,
         dbus::ObjectPath(cryptohome::kCryptohomeServicePath));
 
     blocking_method_caller_.reset(new BlockingMethodCaller(bus, proxy_));
 
     proxy_->ConnectToSignal(cryptohome::kCryptohomeInterface,
                             cryptohome::kSignalAsyncCallStatus,
                             base::Bind(&CryptohomeClientImpl::OnAsyncCallStatus,
                                        weak_ptr_factory_.GetWeakPtr()),
@@ skipping 259 matching lines @@
   return new CryptohomeClientImpl();
 }
 
 // static
 std::string CryptohomeClient::GetStubSanitizedUsername(
     const std::string& username) {
   return username + kUserIdStubHashSuffix;
 }
 
 }  // namespace chromeos