replace OVERRIDE and FINAL with override and final in chromeos/

chromeos/disks/disk_mount_manager.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/disks/disk_mount_manager.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 31 matching lines @@
     cros_disks_client_->SetFormatCompletedHandler(
         base::Bind(&DiskMountManagerImpl::OnFormatCompleted,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual ~DiskMountManagerImpl() {
     STLDeleteContainerPairSecondPointers(disks_.begin(), disks_.end());
   }
 
   // DiskMountManager override.
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
   // DiskMountManager override.
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
   // DiskMountManager override.
   virtual void MountPath(const std::string& source_path,
                          const std::string& source_format,
                          const std::string& mount_label,
-                         MountType type) OVERRIDE {
+                         MountType type) override {
     // Hidden and non-existent devices should not be mounted.
     if (type == MOUNT_TYPE_DEVICE) {
       DiskMap::const_iterator it = disks_.find(source_path);
       if (it == disks_.end() || it->second->is_hidden()) {
         OnMountCompleted(MountEntry(MOUNT_ERROR_INTERNAL, source_path, type,
                                     ""));
         return;
       }
     }
     cros_disks_client_->Mount(
         source_path,
         source_format,
         mount_label,
         // When succeeds, OnMountCompleted will be called by
         // "MountCompleted" signal instead.
         base::Bind(&base::DoNothing),
         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    MountEntry(MOUNT_ERROR_INTERNAL, source_path, type, "")));
   }
 
   // DiskMountManager override.
   virtual void UnmountPath(const std::string& mount_path,
                            UnmountOptions options,
-                           const UnmountPathCallback& callback) OVERRIDE {
+                           const UnmountPathCallback& callback) override {
     UnmountChildMounts(mount_path);
     cros_disks_client_->Unmount(mount_path, options,
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            callback,
                                            true,
                                            mount_path),
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            callback,
                                            false,
                                            mount_path));
   }
 
   // DiskMountManager override.
-  virtual void FormatMountedDevice(const std::string& mount_path) OVERRIDE {
+  virtual void FormatMountedDevice(const std::string& mount_path) override {
     MountPointMap::const_iterator mount_point = mount_points_.find(mount_path);
     if (mount_point == mount_points_.end()) {
       LOG(ERROR) << "Mount point with path \"" << mount_path << "\" not found.";
       OnFormatCompleted(FORMAT_ERROR_UNKNOWN, mount_path);
       return;
     }
 
     std::string device_path = mount_point->second.source_path;
     DiskMap::const_iterator disk = disks_.find(device_path);
     if (disk == disks_.end()) {
       LOG(ERROR) << "Device with path \"" << device_path << "\" not found.";
       OnFormatCompleted(FORMAT_ERROR_UNKNOWN, device_path);
       return;
     }
 
     UnmountPath(disk->second->mount_path(),
                 UNMOUNT_OPTIONS_NONE,
                 base::Bind(&DiskMountManagerImpl::OnUnmountPathForFormat,
                            weak_ptr_factory_.GetWeakPtr(),
                            device_path));
   }
 
   // DiskMountManager override.
   virtual void UnmountDeviceRecursively(
       const std::string& device_path,
-      const UnmountDeviceRecursivelyCallbackType& callback) OVERRIDE {
+      const UnmountDeviceRecursivelyCallbackType& callback) override {
     std::vector<std::string> devices_to_unmount;
 
     // Get list of all devices to unmount.
     int device_path_len = device_path.length();
     for (DiskMap::iterator it = disks_.begin(); it != disks_.end(); ++it) {
       if (!it->second->mount_path().empty() &&
           strncmp(device_path.c_str(), it->second->device_path().c_str(),
                   device_path_len) == 0) {
         devices_to_unmount.push_back(it->second->mount_path());
       }
@@ skipping 42 matching lines @@
           base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursively,
                      weak_ptr_factory_.GetWeakPtr(),
                      cb_data,
                      false,
                      devices_to_unmount[i]));
     }
   }
 
   // DiskMountManager override.
   virtual void EnsureMountInfoRefreshed(
-      const EnsureMountInfoRefreshedCallback& callback) OVERRIDE {
+      const EnsureMountInfoRefreshedCallback& callback) override {
     if (already_refreshed_) {
       callback.Run(true);
       return;
     }
 
     refresh_callbacks_.push_back(callback);
     if (refresh_callbacks_.size() == 1) {
       // If there's no in-flight refreshing task, start it.
       cros_disks_client_->EnumerateAutoMountableDevices(
           base::Bind(&DiskMountManagerImpl::RefreshAfterEnumerateDevices,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&DiskMountManagerImpl::RefreshCompleted,
                      weak_ptr_factory_.GetWeakPtr(), false));
     }
   }
 
   // DiskMountManager override.
-  virtual const DiskMap& disks() const OVERRIDE { return disks_; }
+  virtual const DiskMap& disks() const override { return disks_; }
 
   // DiskMountManager override.
   virtual const Disk* FindDiskBySourcePath(const std::string& source_path)
-      const OVERRIDE {
+      const override {
     DiskMap::const_iterator disk_it = disks_.find(source_path);
     return disk_it == disks_.end() ? NULL : disk_it->second;
   }
 
   // DiskMountManager override.
-  virtual const MountPointMap& mount_points() const OVERRIDE {
+  virtual const MountPointMap& mount_points() const override {
     return mount_points_;
   }
 
   // DiskMountManager override.
-  virtual bool AddDiskForTest(Disk* disk) OVERRIDE {
+  virtual bool AddDiskForTest(Disk* disk) override {
     if (disks_.find(disk->device_path()) != disks_.end()) {
       LOG(ERROR) << "Attempt to add a duplicate disk";
       return false;
     }
 
     disks_.insert(std::make_pair(disk->device_path(), disk));
     return true;
   }
 
   // DiskMountManager override.
   // Corresponding disk should be added to the manager before this is called.
   virtual bool AddMountPointForTest(
-      const MountPointInfo& mount_point) OVERRIDE {
+      const MountPointInfo& mount_point) override {
     if (mount_points_.find(mount_point.mount_path) != mount_points_.end()) {
       LOG(ERROR) << "Attempt to add a duplicate mount point";
       return false;
     }
     if (mount_point.mount_type == chromeos::MOUNT_TYPE_DEVICE &&
         disks_.find(mount_point.source_path) == disks_.end()) {
       LOG(ERROR) << "Device mount points must have a disk entry.";
       return false;
     }
 
@@ skipping 499 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos