replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/easy_unlock_client.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 "chromeos/dbus/easy_unlock_client.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 28 matching lines @@
 // EasyUnlockClient::Create).
 class EasyUnlockClientImpl : public EasyUnlockClient {
  public:
   EasyUnlockClientImpl() : proxy_(NULL), weak_ptr_factory_(this) {}
 
   virtual ~EasyUnlockClientImpl() {}
 
   // EasyUnlockClient override.
   virtual void PerformECDHKeyAgreement(const std::string& private_key,
                                        const std::string& public_key,
-                                       const DataCallback& callback) OVERRIDE {
+                                       const DataCallback& callback) override {
     dbus::MethodCall method_call(
         easy_unlock::kEasyUnlockServiceInterface,
         easy_unlock::kPerformECDHKeyAgreementMethod);
     dbus::MessageWriter writer(&method_call);
     // NOTE: DBus expects that data sent as string is UTF-8 encoded. This is
     //     not guaranteed here, so the method uses byte arrays.
     AppendStringAsByteArray(private_key, &writer);
     AppendStringAsByteArray(public_key, &writer);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&EasyUnlockClientImpl::OnData,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // EasyUnlockClient override.
-  virtual void GenerateEcP256KeyPair(const KeyPairCallback& callback) OVERRIDE {
+  virtual void GenerateEcP256KeyPair(const KeyPairCallback& callback) override {
     dbus::MethodCall method_call(
         easy_unlock::kEasyUnlockServiceInterface,
         easy_unlock::kGenerateEcP256KeyPairMethod);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&EasyUnlockClientImpl::OnKeyPair,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // EasyUnlockClient override.
   virtual void CreateSecureMessage(const std::string& payload,
                                    const CreateSecureMessageOptions& options,
-                                   const DataCallback& callback) OVERRIDE {
+                                   const DataCallback& callback) override {
     dbus::MethodCall method_call(
         easy_unlock::kEasyUnlockServiceInterface,
         easy_unlock::kCreateSecureMessageMethod);
     dbus::MessageWriter writer(&method_call);
     // NOTE: DBus expects that data sent as string is UTF-8 encoded. This is
     //     not guaranteed here, so the method uses byte arrays.
     AppendStringAsByteArray(payload, &writer);
     AppendStringAsByteArray(options.key, &writer);
     AppendStringAsByteArray(options.associated_data, &writer);
     AppendStringAsByteArray(options.public_metadata, &writer);
     AppendStringAsByteArray(options.verification_key_id, &writer);
     AppendStringAsByteArray(options.decryption_key_id, &writer);
     writer.AppendString(options.encryption_type);
     writer.AppendString(options.signature_type);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&EasyUnlockClientImpl::OnData,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
   // EasyUnlockClient override.
   virtual void UnwrapSecureMessage(const std::string& message,
                                    const UnwrapSecureMessageOptions& options,
-                                   const DataCallback& callback) OVERRIDE {
+                                   const DataCallback& callback) override {
     dbus::MethodCall method_call(
         easy_unlock::kEasyUnlockServiceInterface,
         easy_unlock::kUnwrapSecureMessageMethod);
     dbus::MessageWriter writer(&method_call);
     // NOTE: DBus expects that data sent as string is UTF-8 encoded. This is
     //     not guaranteed here, so the method uses byte arrays.
     AppendStringAsByteArray(message, &writer);
     AppendStringAsByteArray(options.key, &writer);
     AppendStringAsByteArray(options.associated_data, &writer);
     writer.AppendString(options.encryption_type);
     writer.AppendString(options.signature_type);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&EasyUnlockClientImpl::OnData,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback));
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     proxy_ =
         bus->GetObjectProxy(
             easy_unlock::kEasyUnlockServiceName,
             dbus::ObjectPath(easy_unlock::kEasyUnlockServicePath));
   }
 
  private:
   void OnData(const DataCallback& callback, dbus::Response* response) {
     if (!response) {
       callback.Run("");
@@ skipping 46 matching lines @@
 
 EasyUnlockClient::~EasyUnlockClient() {
 }
 
 // static
 EasyUnlockClient* EasyUnlockClient::Create() {
   return new EasyUnlockClientImpl();
 }
 
 }  // namespace chromeos