replace OVERRIDE and FINAL with override and final in device/

device/media_transfer_protocol/media_transfer_protocol_daemon_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 "device/media_transfer_protocol/media_transfer_protocol_daemon_client.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 19 matching lines @@
   explicit MediaTransferProtocolDaemonClientImpl(dbus::Bus* bus)
       : proxy_(bus->GetObjectProxy(
           mtpd::kMtpdServiceName,
           dbus::ObjectPath(mtpd::kMtpdServicePath))),
         listen_for_changes_called_(false),
         weak_ptr_factory_(this) {
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void EnumerateStorages(const EnumerateStoragesCallback& callback,
-                                 const ErrorCallback& error_callback) OVERRIDE {
+                                 const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kEnumerateStorages);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnEnumerateStorages,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void GetStorageInfo(const std::string& storage_name,
                               const GetStorageInfoCallback& callback,
-                              const ErrorCallback& error_callback) OVERRIDE {
+                              const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kGetStorageInfo);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(storage_name);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnGetStorageInfo,
                    weak_ptr_factory_.GetWeakPtr(),
                    storage_name,
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void OpenStorage(const std::string& storage_name,
                            const std::string& mode,
                            const OpenStorageCallback& callback,
-                           const ErrorCallback& error_callback) OVERRIDE {
+                           const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kOpenStorage);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(storage_name);
     DCHECK_EQ(mtpd::kReadOnlyMode, mode);
     writer.AppendString(mtpd::kReadOnlyMode);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnOpenStorage,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void CloseStorage(const std::string& handle,
                             const CloseStorageCallback& callback,
-                            const ErrorCallback& error_callback) OVERRIDE {
+                            const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kCloseStorage);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void ReadDirectoryEntryIds(
       const std::string& handle,
       uint32 file_id,
       const ReadDirectoryEntryIdsCallback& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
+      const ErrorCallback& error_callback) override {
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kReadDirectoryEntryIds);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadDirectoryIds,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   virtual void GetFileInfo(const std::string& handle,
                            const std::vector<uint32>& file_ids,
                            size_t offset,
                            size_t entries_to_read,
                            const GetFileInfoCallback& callback,
-                           const ErrorCallback& error_callback) OVERRIDE {
+                           const ErrorCallback& error_callback) override {
     if (offset >= file_ids.size()) {
       error_callback.Run();
       return;
     }
 
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kGetFileInfo);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     {
       dbus::MessageWriter array_writer(NULL);
@@ skipping 14 matching lines @@
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void ReadFileChunk(const std::string& handle,
                              uint32 file_id,
                              uint32 offset,
                              uint32 bytes_to_read,
                              const ReadFileCallback& callback,
-                             const ErrorCallback& error_callback) OVERRIDE {
+                             const ErrorCallback& error_callback) override {
     DCHECK_LE(bytes_to_read, kMaxChunkSize);
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kReadFileChunk);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     writer.AppendUint32(offset);
     writer.AppendUint32(bytes_to_read);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
   virtual void ListenForChanges(
-      const MTPStorageEventHandler& handler) OVERRIDE {
+      const MTPStorageEventHandler& handler) override {
     DCHECK(!listen_for_changes_called_);
     listen_for_changes_called_ = true;
 
     static const SignalEventTuple kSignalEventTuples[] = {
       { mtpd::kMTPStorageAttached, true },
       { mtpd::kMTPStorageDetached, false },
     };
     const size_t kNumSignalEventTuples = arraysize(kSignalEventTuples);
 
     for (size_t i = 0; i < kNumSignalEventTuples; ++i) {
@@ skipping 206 matching lines @@
 
 MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {}
 
 // static
 MediaTransferProtocolDaemonClient* MediaTransferProtocolDaemonClient::Create(
     dbus::Bus* bus) {
   return new MediaTransferProtocolDaemonClientImpl(bus);
 }
 
 }  // namespace device