replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/dbus/cros_disks_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/cros_disks_client.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 84 matching lines @@
 // The CrosDisksClient implementation.
 class CrosDisksClientImpl : public CrosDisksClient {
  public:
   CrosDisksClientImpl() : proxy_(NULL), weak_ptr_factory_(this) {}
 
   // CrosDisksClient override.
   virtual void Mount(const std::string& source_path,
                      const std::string& source_format,
                      const std::string& mount_label,
                      const base::Closure& callback,
-                     const base::Closure& error_callback) OVERRIDE {
+                     const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kMount);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(source_path);
     writer.AppendString(source_format);
     std::vector<std::string> mount_options(kDefaultMountOptions,
                                            kDefaultMountOptions +
                                            arraysize(kDefaultMountOptions));
     if (!mount_label.empty()) {
       std::string mount_label_option = base::StringPrintf("%s=%s",
                                                           kMountLabelOption,
                                                           mount_label.c_str());
       mount_options.push_back(mount_label_option);
     }
     writer.AppendArrayOfStrings(mount_options);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CrosDisksClientImpl::OnMount,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback,
                                   error_callback));
   }
 
   // CrosDisksClient override.
   virtual void Unmount(const std::string& device_path,
                        UnmountOptions options,
                        const base::Closure& callback,
-                       const base::Closure& error_callback) OVERRIDE {
+                       const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kUnmount);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(device_path);
 
     std::vector<std::string> unmount_options(
         kDefaultUnmountOptions,
         kDefaultUnmountOptions + arraysize(kDefaultUnmountOptions));
     if (options == UNMOUNT_OPTIONS_LAZY)
       unmount_options.push_back(kLazyUnmountOption);
 
     writer.AppendArrayOfStrings(unmount_options);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CrosDisksClientImpl::OnUnmount,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback,
                                   error_callback));
   }
 
   // CrosDisksClient override.
   virtual void EnumerateAutoMountableDevices(
       const EnumerateAutoMountableDevicesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kEnumerateAutoMountableDevices);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrosDisksClientImpl::OnEnumerateAutoMountableDevices,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // CrosDisksClient override.
   virtual void EnumerateMountEntries(
       const EnumerateMountEntriesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kEnumerateMountEntries);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrosDisksClientImpl::OnEnumerateMountEntries,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // CrosDisksClient override.
   virtual void Format(const std::string& device_path,
                       const std::string& filesystem,
                       const base::Closure& callback,
-                      const base::Closure& error_callback) OVERRIDE {
+                      const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kFormat);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(device_path);
     writer.AppendString(filesystem);
     // No format option is currently specified, but we can later use this
     // argument to specify options for the format operation.
     std::vector<std::string> format_options;
     writer.AppendArrayOfStrings(format_options);
     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CrosDisksClientImpl::OnFormat,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   callback,
                                   error_callback));
   }
 
   // CrosDisksClient override.
   virtual void GetDeviceProperties(
       const std::string& device_path,
       const GetDevicePropertiesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kGetDeviceProperties);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(device_path);
     proxy_->CallMethod(&method_call,
                        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
                        base::Bind(&CrosDisksClientImpl::OnGetDeviceProperties,
                                   weak_ptr_factory_.GetWeakPtr(),
                                   device_path,
                                   callback,
                                   error_callback));
   }
 
   // CrosDisksClient override.
   virtual void SetMountEventHandler(
-      const MountEventHandler& mount_event_handler) OVERRIDE {
+      const MountEventHandler& mount_event_handler) override {
     static const SignalEventTuple kSignalEventTuples[] = {
       { cros_disks::kDeviceAdded, CROS_DISKS_DEVICE_ADDED },
       { cros_disks::kDeviceScanned, CROS_DISKS_DEVICE_SCANNED },
       { cros_disks::kDeviceRemoved, CROS_DISKS_DEVICE_REMOVED },
       { cros_disks::kDiskAdded, CROS_DISKS_DISK_ADDED },
       { cros_disks::kDiskChanged, CROS_DISKS_DISK_CHANGED },
       { cros_disks::kDiskRemoved, CROS_DISKS_DISK_REMOVED },
     };
     const size_t kNumSignalEventTuples = arraysize(kSignalEventTuples);
 
     for (size_t i = 0; i < kNumSignalEventTuples; ++i) {
       proxy_->ConnectToSignal(
           cros_disks::kCrosDisksInterface,
           kSignalEventTuples[i].signal_name,
           base::Bind(&CrosDisksClientImpl::OnMountEvent,
                      weak_ptr_factory_.GetWeakPtr(),
                      kSignalEventTuples[i].event_type,
                      mount_event_handler),
           base::Bind(&CrosDisksClientImpl::OnSignalConnected,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
   // CrosDisksClient override.
   virtual void SetMountCompletedHandler(
-      const MountCompletedHandler& mount_completed_handler) OVERRIDE {
+      const MountCompletedHandler& mount_completed_handler) override {
     proxy_->ConnectToSignal(
         cros_disks::kCrosDisksInterface,
         cros_disks::kMountCompleted,
         base::Bind(&CrosDisksClientImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    mount_completed_handler),
         base::Bind(&CrosDisksClientImpl::OnSignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // CrosDisksClient override.
   virtual void SetFormatCompletedHandler(
-      const FormatCompletedHandler& format_completed_handler) OVERRIDE {
+      const FormatCompletedHandler& format_completed_handler) override {
     proxy_->ConnectToSignal(
         cros_disks::kCrosDisksInterface,
         cros_disks::kFormatCompleted,
         base::Bind(&CrosDisksClientImpl::OnFormatCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    format_completed_handler),
         base::Bind(&CrosDisksClientImpl::OnSignalConnected,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  protected:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {
+  virtual void Init(dbus::Bus* bus) override {
     proxy_ = bus->GetObjectProxy(
         cros_disks::kCrosDisksServiceName,
         dbus::ObjectPath(cros_disks::kCrosDisksServicePath));
   }
 
  private:
   // A struct to contain a pair of signal name and mount event type.
   // Used by SetMountEventHandler.
   struct SignalEventTuple {
     const char *signal_name;
@@ skipping 173 matching lines @@
 
 // A stub implementaion of CrosDisksClient.
 class CrosDisksClientStubImpl : public CrosDisksClient {
  public:
   CrosDisksClientStubImpl()
       : weak_ptr_factory_(this) {}
 
   virtual ~CrosDisksClientStubImpl() {}
 
   // CrosDisksClient overrides:
-  virtual void Init(dbus::Bus* bus) OVERRIDE {}
+  virtual void Init(dbus::Bus* bus) override {}
   virtual void Mount(const std::string& source_path,
                      const std::string& source_format,
                      const std::string& mount_label,
                      const base::Closure& callback,
-                     const base::Closure& error_callback) OVERRIDE {
+                     const base::Closure& error_callback) override {
     // This stub implementation only accepts archive mount requests.
     const MountType type = MOUNT_TYPE_ARCHIVE;
 
     const base::FilePath mounted_path = GetArchiveMountPoint().Append(
         base::FilePath::FromUTF8Unsafe(mount_label));
 
     // Already mounted path.
     if (mounted_to_source_path_map_.count(mounted_path.value()) != 0) {
       FinishMount(MOUNT_ERROR_PATH_ALREADY_MOUNTED, source_path, type,
                   std::string(), callback);
       return;
     }
 
     // Perform fake mount.
     base::PostTaskAndReplyWithResult(
         base::WorkerPool::GetTaskRunner(true /* task_is_slow */).get(),
         FROM_HERE,
         base::Bind(&PerformFakeMount, source_path, mounted_path),
         base::Bind(&CrosDisksClientStubImpl::ContinueMount,
                    weak_ptr_factory_.GetWeakPtr(),
                    source_path,
                    type,
                    callback,
                    mounted_path));
   }
 
   virtual void Unmount(const std::string& device_path,
                        UnmountOptions options,
                        const base::Closure& callback,
-                       const base::Closure& error_callback) OVERRIDE {
+                       const base::Closure& error_callback) override {
     // Not mounted.
     if (mounted_to_source_path_map_.count(device_path) == 0) {
       base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
       return;
     }
 
     mounted_to_source_path_map_.erase(device_path);
 
     // Remove the directory created in Mount().
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&base::DeleteFile),
                    base::FilePath::FromUTF8Unsafe(device_path),
                    true /* recursive */),
         callback,
         true /* task_is_slow */);
   }
 
   virtual void EnumerateAutoMountableDevices(
       const EnumerateAutoMountableDevicesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     std::vector<std::string> device_paths;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, device_paths));
   }
 
   virtual void EnumerateMountEntries(
       const EnumerateMountEntriesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     std::vector<MountEntry> entries;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, entries));
   }
 
   virtual void Format(const std::string& device_path,
                       const std::string& filesystem,
                       const base::Closure& callback,
-                      const base::Closure& error_callback) OVERRIDE {
+                      const base::Closure& error_callback) override {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
   }
 
   virtual void GetDeviceProperties(
       const std::string& device_path,
       const GetDevicePropertiesCallback& callback,
-      const base::Closure& error_callback) OVERRIDE {
+      const base::Closure& error_callback) override {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
   }
 
   virtual void SetMountEventHandler(
-      const MountEventHandler& mount_event_handler) OVERRIDE {
+      const MountEventHandler& mount_event_handler) override {
     mount_event_handler_ = mount_event_handler;
   }
 
   virtual void SetMountCompletedHandler(
-      const MountCompletedHandler& mount_completed_handler) OVERRIDE {
+      const MountCompletedHandler& mount_completed_handler) override {
     mount_completed_handler_ = mount_completed_handler;
   }
 
   virtual void SetFormatCompletedHandler(
-      const FormatCompletedHandler& format_completed_handler) OVERRIDE {
+      const FormatCompletedHandler& format_completed_handler) override {
     format_completed_handler_ = format_completed_handler;
   }
 
  private:
   // Performs file actions for Mount().
   static MountError PerformFakeMount(const std::string& source_path,
                                      const base::FilePath& mounted_path) {
     // Check the source path exists.
     if (!base::PathExists(base::FilePath::FromUTF8Unsafe(source_path))) {
       DLOG(ERROR) << "Source does not exist at " << source_path;
@@ skipping 261 matching lines @@
 }
 
 // static
 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/removable") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 }
 
 }  // namespace chromeos