Some linked_ptr removal in chromeos file_browser_handler.

chrome/browser/chromeos/file_manager/volume_manager.cc

 // Copyright 2013 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 "chrome/browser/chromeos/file_manager/volume_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 150 matching lines @@
       is_read_only_removable_device_(false),
       has_media_(false),
       configurable_(false),
       watchable_(false) {
 }
 
 Volume::~Volume() {
 }
 
 // static
-Volume* Volume::CreateForDrive(Profile* profile) {
+std::unique_ptr<Volume> Volume::CreateForDrive(Profile* profile) {
   const base::FilePath& drive_path =
       drive::util::GetDriveMountPointPath(profile);
-  Volume* const volume = new Volume;
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = VOLUME_TYPE_GOOGLE_DRIVE;
   volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
   volume->source_path_ = drive_path;
   volume->source_ = SOURCE_NETWORK;
   volume->mount_path_ = drive_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->volume_id_ = GenerateVolumeId(*volume);
   volume->watchable_ = true;
   return volume;
 }
 
 // static
-Volume* Volume::CreateForDownloads(const base::FilePath& downloads_path) {
-  Volume* const volume = new Volume;
+std::unique_ptr<Volume> Volume::CreateForDownloads(
+    const base::FilePath& downloads_path) {
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = VOLUME_TYPE_DOWNLOADS_DIRECTORY;
   volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
   // Keep source_path empty.
   volume->source_ = SOURCE_SYSTEM;
   volume->mount_path_ = downloads_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->volume_id_ = GenerateVolumeId(*volume);
   volume->watchable_ = true;
   return volume;
 }
 
 // static
-Volume* Volume::CreateForRemovable(
+std::unique_ptr<Volume> Volume::CreateForRemovable(
     const chromeos::disks::DiskMountManager::MountPointInfo& mount_point,
     const chromeos::disks::DiskMountManager::Disk* disk) {
-  Volume* const volume = new Volume;
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = MountTypeToVolumeType(mount_point.mount_type);
   volume->source_path_ = base::FilePath(mount_point.source_path);
   volume->source_ = mount_point.mount_type == chromeos::MOUNT_TYPE_ARCHIVE
                         ? SOURCE_FILE
                         : SOURCE_DEVICE;
   volume->mount_path_ = base::FilePath(mount_point.mount_path);
   volume->mount_condition_ = mount_point.mount_condition;
   volume->volume_label_ = volume->mount_path().BaseName().AsUTF8Unsafe();
   if (disk) {
     volume->device_type_ = disk->device_type();
     volume->system_path_prefix_ = base::FilePath(disk->system_path_prefix());
     volume->is_parent_ = disk->is_parent();
     volume->is_read_only_ = disk->is_read_only();
     volume->is_read_only_removable_device_ = disk->is_read_only_hardware();
     volume->has_media_ = disk->has_media();
   } else {
     volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
     volume->is_read_only_ =
         (mount_point.mount_type == chromeos::MOUNT_TYPE_ARCHIVE);
   }
   volume->volume_id_ = GenerateVolumeId(*volume);
   volume->watchable_ = true;
   return volume;
 }
 
 // static
-Volume* Volume::CreateForProvidedFileSystem(
+std::unique_ptr<Volume> Volume::CreateForProvidedFileSystem(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     MountContext mount_context) {
-  Volume* const volume = new Volume;
+  std::unique_ptr<Volume> volume(new Volume());
   volume->file_system_id_ = file_system_info.file_system_id();
   volume->extension_id_ = file_system_info.extension_id();
   switch (file_system_info.source()) {
     case extensions::SOURCE_FILE:
       volume->source_ = SOURCE_FILE;
       break;
     case extensions::SOURCE_DEVICE:
       volume->source_ = SOURCE_DEVICE;
       break;
     case extensions::SOURCE_NETWORK:
       volume->source_ = SOURCE_NETWORK;
       break;
   }
   volume->volume_label_ = file_system_info.display_name();
   volume->type_ = VOLUME_TYPE_PROVIDED;
   volume->mount_path_ = file_system_info.mount_path();
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->mount_context_ = mount_context;
   volume->is_parent_ = true;
   volume->is_read_only_ = !file_system_info.writable();
   volume->configurable_ = file_system_info.configurable();
   volume->watchable_ = file_system_info.watchable();
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
-Volume* Volume::CreateForMTP(const base::FilePath& mount_path,
-                             const std::string& label,
-                             bool read_only) {
-  Volume* const volume = new Volume;
+std::unique_ptr<Volume> Volume::CreateForMTP(const base::FilePath& mount_path,
+                                             const std::string& label,
+                                             bool read_only) {
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = VOLUME_TYPE_MTP;
   volume->mount_path_ = mount_path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->is_parent_ = true;
   volume->is_read_only_ = read_only;
   volume->volume_id_ = kMtpVolumeIdPrefix + label;
   volume->volume_label_ = label;
   volume->source_path_ = mount_path;
   volume->source_ = SOURCE_DEVICE;
   volume->device_type_ = chromeos::DEVICE_TYPE_MOBILE;
   return volume;
 }
 
 // static
-Volume* Volume::CreateForMediaView(const std::string& root_document_id) {
-  Volume* const volume = new Volume;
+std::unique_ptr<Volume> Volume::CreateForMediaView(
+    const std::string& root_document_id) {
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = VOLUME_TYPE_MEDIA_VIEW;
   volume->device_type_ = chromeos::DEVICE_TYPE_UNKNOWN;
   volume->source_ = SOURCE_SYSTEM;
   volume->mount_path_ = arc::GetDocumentsProviderMountPath(
       arc::kMediaDocumentsProviderAuthority, root_document_id);
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->volume_label_ = root_document_id;
   volume->is_read_only_ = true;
   volume->watchable_ = false;
   volume->volume_id_ = arc::GetMediaViewVolumeId(root_document_id);
   return volume;
 }
 
 // static
-Volume* Volume::CreateForTesting(const base::FilePath& path,
-                                 VolumeType volume_type,
-                                 chromeos::DeviceType device_type,
-                                 bool read_only) {
-  Volume* const volume = new Volume;
+std::unique_ptr<Volume> Volume::CreateForTesting(
+    const base::FilePath& path,
+    VolumeType volume_type,
+    chromeos::DeviceType device_type,
+    bool read_only) {
+  std::unique_ptr<Volume> volume(new Volume());
   volume->type_ = volume_type;
   volume->device_type_ = device_type;
   // Keep source_path empty.
   volume->source_ = SOURCE_DEVICE;
   volume->mount_path_ = path;
   volume->mount_condition_ = chromeos::disks::MOUNT_CONDITION_NONE;
   volume->is_read_only_ = read_only;
   volume->volume_id_ = GenerateVolumeId(*volume);
   return volume;
 }
 
 // static
-Volume* Volume::CreateForTesting(const base::FilePath& device_path,
-                                 const base::FilePath& mount_path) {
-  Volume* const volume = new Volume;
+std::unique_ptr<Volume> Volume::CreateForTesting(
+    const base::FilePath& device_path,
+    const base::FilePath& mount_path) {
+  std::unique_ptr<Volume> volume(new Volume());
   volume->system_path_prefix_ = device_path;
   volume->mount_path_ = mount_path;
   return volume;
 }
 
 VolumeManager::VolumeManager(
     Profile* profile,
     drive::DriveIntegrationService* drive_integration_service,
     chromeos::PowerManagerClient* power_manager_client,
     chromeos::disks::DiskMountManager* disk_mount_manager,
@@ skipping 21 matching lines @@
   if (chromeos::ProfileHelper::IsSigninProfile(profile_))
     return;
 
   // Register 'Downloads' folder for the profile to the file system.
   const base::FilePath downloads =
       file_manager::util::GetDownloadsFolderForProfile(profile_);
   const bool success = RegisterDownloadsMountPoint(profile_, downloads);
   DCHECK(success);
 
   DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-               make_linked_ptr(Volume::CreateForDownloads(downloads)));
+               Volume::CreateForDownloads(downloads));
 
   // Subscribe to DriveIntegrationService.
   if (drive_integration_service_) {
     drive_integration_service_->AddObserver(this);
     if (drive_integration_service_->IsMounted()) {
       DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                   make_linked_ptr(Volume::CreateForDrive(profile_)));
+                   Volume::CreateForDrive(profile_));
     }
   }
 
   // Subscribe to DiskMountManager.
   disk_mount_manager_->AddObserver(this);
   disk_mount_manager_->EnsureMountInfoRefreshed(
       base::Bind(&VolumeManager::OnDiskMountManagerRefreshed,
                  weak_ptr_factory_.GetWeakPtr()),
       false /* force */);
 
   // Subscribe to FileSystemProviderService and register currently mounted
   // volumes for the profile.
   if (file_system_provider_service_) {
     using chromeos::file_system_provider::ProvidedFileSystemInfo;
     file_system_provider_service_->AddObserver(this);
 
     std::vector<ProvidedFileSystemInfo> file_system_info_list =
         file_system_provider_service_->GetProvidedFileSystemInfoList();
     for (size_t i = 0; i < file_system_info_list.size(); ++i) {
-      linked_ptr<Volume> volume(Volume::CreateForProvidedFileSystem(
-          file_system_info_list[i], MOUNT_CONTEXT_AUTO));
-      DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+      std::unique_ptr<Volume> volume = Volume::CreateForProvidedFileSystem(
+          file_system_info_list[i], MOUNT_CONTEXT_AUTO);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE, std::move(volume));
     }
   }
 
   // Subscribe to Profile Preference change.
   pref_change_registrar_.Init(profile_->GetPrefs());
   pref_change_registrar_.Add(
       prefs::kExternalStorageDisabled,
       base::Bind(&VolumeManager::OnExternalStorageDisabledChanged,
                  weak_ptr_factory_.GetWeakPtr()));
   pref_change_registrar_.Add(
@@ skipping 52 matching lines @@
 void VolumeManager::RemoveObserver(VolumeManagerObserver* observer) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(observer);
   observers_.RemoveObserver(observer);
 }
 
 std::vector<base::WeakPtr<Volume>> VolumeManager::GetVolumeList() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::vector<base::WeakPtr<Volume>> result;
+  result.reserve(mounted_volumes_.size());
   for (const auto& pair : mounted_volumes_) {
     result.push_back(pair.second->AsWeakPtr());
   }
   return result;
 }
 
 base::WeakPtr<Volume> VolumeManager::FindVolumeById(
     const std::string& volume_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   const auto it = mounted_volumes_.find(volume_id);
   if (it != mounted_volumes_.end())
     return it->second->AsWeakPtr();
   return base::WeakPtr<Volume>();
 }
 
 bool VolumeManager::RegisterDownloadsDirectoryForTesting(
     const base::FilePath& path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   base::FilePath old_path;
   if (FindDownloadsMountPointPath(profile_, &old_path)) {
     DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
-                   make_linked_ptr(Volume::CreateForDownloads(old_path)));
+                   *Volume::CreateForDownloads(old_path));
   }
 
   bool success = RegisterDownloadsMountPoint(profile_, path);
   DoMountEvent(
       success ? chromeos::MOUNT_ERROR_NONE : chromeos::MOUNT_ERROR_INVALID_PATH,
-      make_linked_ptr(Volume::CreateForDownloads(path)));
+      Volume::CreateForDownloads(path));
   return success;
 }
 
 void VolumeManager::AddVolumeForTesting(const base::FilePath& path,
                                         VolumeType volume_type,
                                         chromeos::DeviceType device_type,
                                         bool read_only) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-               make_linked_ptr(Volume::CreateForTesting(
-                   path, volume_type, device_type, read_only)));
+  DoMountEvent(
+      chromeos::MOUNT_ERROR_NONE,
+      Volume::CreateForTesting(path, volume_type, device_type, read_only));
 }
 
-void VolumeManager::AddVolumeForTesting(const linked_ptr<Volume>& volume) {
+void VolumeManager::AddVolumeForTesting(std::unique_ptr<Volume> volume) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, std::move(volume));
 }
 
 void VolumeManager::OnFileSystemMounted() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Raise mount event.
   // We can pass chromeos::MOUNT_ERROR_NONE even when authentication is failed
   // or network is unreachable. These two errors will be handled later.
-  linked_ptr<Volume> volume(Volume::CreateForDrive(profile_));
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, Volume::CreateForDrive(profile_));
 }
 
 void VolumeManager::OnFileSystemBeingUnmounted() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
-  linked_ptr<Volume> volume(Volume::CreateForDrive(profile_));
-  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+  DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, *Volume::CreateForDrive(profile_));
 }
 
 void VolumeManager::OnDiskEvent(
     chromeos::disks::DiskMountManager::DiskEvent event,
     const chromeos::disks::DiskMountManager::Disk* disk) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // Disregard hidden devices.
   if (disk->is_hidden())
     return;
@@ skipping 89 matching lines @@
         file_system->MarkCacheFileAsUnmounted(
             base::FilePath(mount_info.source_path),
             base::Bind(&drive::util::EmptyFileOperationCallback));
       }
     }
   }
 
   // Notify a mounting/unmounting event to observers.
   const chromeos::disks::DiskMountManager::Disk* const disk =
       disk_mount_manager_->FindDiskBySourcePath(mount_info.source_path);
-  linked_ptr<Volume> volume(Volume::CreateForRemovable(mount_info, disk));
+  std::unique_ptr<Volume> volume = Volume::CreateForRemovable(mount_info, disk);
   switch (event) {
     case chromeos::disks::DiskMountManager::MOUNTING: {
-      DoMountEvent(error_code, volume);
+      DoMountEvent(error_code, std::move(volume));
       return;
     }
     case chromeos::disks::DiskMountManager::UNMOUNTING:
-      DoUnmountEvent(error_code, volume);
+      DoUnmountEvent(error_code, *volume);
       return;
   }
   NOTREACHED();
 }
 
 void VolumeManager::OnFormatEvent(
     chromeos::disks::DiskMountManager::FormatEvent event,
     chromeos::FormatError error_code,
     const std::string& device_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 37 matching lines @@
   MountContext volume_context = MOUNT_CONTEXT_UNKNOWN;
   switch (context) {
     case chromeos::file_system_provider::MOUNT_CONTEXT_USER:
       volume_context = MOUNT_CONTEXT_USER;
       break;
     case chromeos::file_system_provider::MOUNT_CONTEXT_RESTORE:
       volume_context = MOUNT_CONTEXT_AUTO;
       break;
   }
 
-  linked_ptr<Volume> volume(
-      Volume::CreateForProvidedFileSystem(file_system_info, volume_context));
+  std::unique_ptr<Volume> volume =
+      Volume::CreateForProvidedFileSystem(file_system_info, volume_context);
 
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   chromeos::MountError mount_error;
   switch (error) {
     case base::File::FILE_OK:
       mount_error = chromeos::MOUNT_ERROR_NONE;
       break;
     case base::File::FILE_ERROR_EXISTS:
       mount_error = chromeos::MOUNT_ERROR_PATH_ALREADY_MOUNTED;
       break;
     default:
       mount_error = chromeos::MOUNT_ERROR_UNKNOWN;
       break;
   }
 
-  DoMountEvent(mount_error, volume);
+  DoMountEvent(mount_error, std::move(volume));
 }
 
 void VolumeManager::OnProvidedFileSystemUnmount(
     const chromeos::file_system_provider::ProvidedFileSystemInfo&
         file_system_info,
     base::File::Error error) {
   // TODO(mtomasz): Introduce own type, and avoid using MountError internally,
   // since it is related to cros disks only.
   const chromeos::MountError mount_error = error == base::File::FILE_OK
                                                ? chromeos::MOUNT_ERROR_NONE
                                                : chromeos::MOUNT_ERROR_UNKNOWN;
-  linked_ptr<Volume> volume(Volume::CreateForProvidedFileSystem(
-      file_system_info, MOUNT_CONTEXT_UNKNOWN));
-  DoUnmountEvent(mount_error, volume);
+  std::unique_ptr<Volume> volume = Volume::CreateForProvidedFileSystem(
+      file_system_info, MOUNT_CONTEXT_UNKNOWN);
+  DoUnmountEvent(mount_error, *volume);
 }
 
 void VolumeManager::OnExternalStorageDisabledChangedUnmountCallback(
     chromeos::MountError error_code) {
   if (disk_mount_manager_->mount_points().empty())
     return;
   // Repeat until unmount all paths
   const std::string& mount_path =
       disk_mount_manager_->mount_points().begin()->second.mount_path;
   disk_mount_manager_->UnmountPath(
       mount_path, chromeos::UNMOUNT_OPTIONS_NONE,
       base::Bind(
           &VolumeManager::OnExternalStorageDisabledChangedUnmountCallback,
           weak_ptr_factory_.GetWeakPtr()));
 }
 
 void VolumeManager::OnArcPlayStoreEnabledChanged(bool enabled) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(base::FeatureList::IsEnabled(arc::kMediaViewFeature));
   DCHECK(arc::IsArcAllowedForProfile(profile_));
 
   if (enabled == arc_volumes_mounted_)
     return;
 
   if (enabled) {
     DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                 linked_ptr<Volume>(
-                     Volume::CreateForMediaView(arc::kImagesRootDocumentId)));
+                 Volume::CreateForMediaView(arc::kImagesRootDocumentId));
     DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                 linked_ptr<Volume>(
-                     Volume::CreateForMediaView(arc::kVideosRootDocumentId)));
+                 Volume::CreateForMediaView(arc::kVideosRootDocumentId));
     DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                 linked_ptr<Volume>(
-                     Volume::CreateForMediaView(arc::kAudioRootDocumentId)));
+                 Volume::CreateForMediaView(arc::kAudioRootDocumentId));
   } else {
     DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
-                   linked_ptr<Volume>(
-                       Volume::CreateForMediaView(arc::kImagesRootDocumentId)));
+                   *Volume::CreateForMediaView(arc::kImagesRootDocumentId));
     DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
-                   linked_ptr<Volume>(
-                       Volume::CreateForMediaView(arc::kVideosRootDocumentId)));
+                   *Volume::CreateForMediaView(arc::kVideosRootDocumentId));
     DoUnmountEvent(chromeos::MOUNT_ERROR_NONE,
-                   linked_ptr<Volume>(
-                       Volume::CreateForMediaView(arc::kAudioRootDocumentId)));
+                   *Volume::CreateForMediaView(arc::kAudioRootDocumentId));
   }
 
   arc_volumes_mounted_ = enabled;
 }
 
 void VolumeManager::OnExternalStorageDisabledChanged() {
   // If the policy just got disabled we have to unmount every device currently
   // mounted. The opposite is fine - we can let the user re-plug their device to
   // make it available.
   if (profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
@@ skipping 67 matching lines @@
           kFilesystemTypeGenericHierarchical ||
       GetExternalStorageAccessMode(profile_) ==
           chromeos::MOUNT_ACCESS_MODE_READ_ONLY;
 
   content::BrowserThread::PostTask(
       content::BrowserThread::IO, FROM_HERE,
       base::Bind(&MTPDeviceMapService::RegisterMTPFileSystem,
                  base::Unretained(MTPDeviceMapService::GetInstance()),
                  info.location(), fsid, read_only));
 
-  linked_ptr<Volume> volume(Volume::CreateForMTP(path, label, read_only));
-  DoMountEvent(chromeos::MOUNT_ERROR_NONE, volume);
+  std::unique_ptr<Volume> volume = Volume::CreateForMTP(path, label, read_only);
+  DoMountEvent(chromeos::MOUNT_ERROR_NONE, std::move(volume));
 }
 
 void VolumeManager::OnRemovableStorageDetached(
     const storage_monitor::StorageInfo& info) {
   if (!storage_monitor::StorageInfo::IsMTPDevice(info.device_id()))
     return;
 
-  for (const auto mounted_volume : mounted_volumes_) {
+  for (const auto& mounted_volume : mounted_volumes_) {
     if (mounted_volume.second->source_path().value() == info.location()) {
-      DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, mounted_volume.second);
+      DoUnmountEvent(chromeos::MOUNT_ERROR_NONE, *mounted_volume.second.get());
 
       const std::string fsid = GetMountPointNameForMediaStorage(info);
       storage::ExternalMountPoints::GetSystemInstance()->RevokeFileSystem(fsid);
       content::BrowserThread::PostTask(
           content::BrowserThread::IO, FROM_HERE, base::Bind(
               &MTPDeviceMapService::RevokeMTPFileSystem,
               base::Unretained(MTPDeviceMapService::GetInstance()),
               fsid));
       return;
     }
   }
 }
 
 void VolumeManager::OnDiskMountManagerRefreshed(bool success) {
   if (!success) {
     LOG(ERROR) << "Failed to refresh disk mount manager";
     return;
   }
 
-  std::vector<linked_ptr<Volume>> archives;
+  std::vector<std::unique_ptr<Volume>> archives;
 
   const chromeos::disks::DiskMountManager::MountPointMap& mount_points =
       disk_mount_manager_->mount_points();
   for (chromeos::disks::DiskMountManager::MountPointMap::const_iterator it =
            mount_points.begin();
        it != mount_points.end();
        ++it) {
     if (it->second.mount_type == chromeos::MOUNT_TYPE_ARCHIVE) {
       // Archives are mounted after other types of volume. See below.
-      archives.push_back(
-          make_linked_ptr(Volume::CreateForRemovable(it->second, NULL)));
+      archives.push_back(Volume::CreateForRemovable(it->second, nullptr));
       continue;
     }
-    DoMountEvent(chromeos::MOUNT_ERROR_NONE,
-                 make_linked_ptr(Volume::CreateForRemovable(
-                     it->second, disk_mount_manager_->FindDiskBySourcePath(
-                                     it->second.source_path))));
+    DoMountEvent(
+        chromeos::MOUNT_ERROR_NONE,
+        Volume::CreateForRemovable(
+            it->second,
+            disk_mount_manager_->FindDiskBySourcePath(it->second.source_path)));
   }
 
   // We mount archives only if they are opened from currently mounted volumes.
   // To check the condition correctly in DoMountEvent, we care about the order.
   std::vector<bool> done(archives.size(), false);
   for (size_t i = 0; i < archives.size(); ++i) {
     if (done[i])
       continue;
 
-    std::vector<linked_ptr<Volume>> chain;
+    std::vector<std::unique_ptr<Volume>> chain;
+    // done[x] = true means archives[x] is null and that volume is in |chain|.
     done[i] = true;
-    chain.push_back(archives[i]);
+    chain.push_back(std::move(archives[i]));
 
     // If archives[i]'s source_path is in another archive, mount it first.
     for (size_t parent = i + 1; parent < archives.size(); ++parent) {
       if (!done[parent] &&
           archives[parent]->mount_path().IsParent(
               chain.back()->source_path())) {
+        // done[parent] started false, so archives[parent] is non-null.
         done[parent] = true;
-        chain.push_back(archives[parent]);
+        chain.push_back(std::move(archives[parent]));
         parent = i + 1;  // Search archives[parent]'s parent from the beginning.
       }
     }
 
     // Mount from the tail of chain.
     for (size_t i = chain.size(); i > 0; --i) {
-      DoMountEvent(chromeos::MOUNT_ERROR_NONE, chain[i - 1]);
+      DoMountEvent(chromeos::MOUNT_ERROR_NONE, std::move(chain[i - 1]));
     }
   }
 }
 
 void VolumeManager::OnStorageMonitorInitialized() {
   std::vector<storage_monitor::StorageInfo> storages =
       storage_monitor::StorageMonitor::GetInstance()->GetAllAvailableStorages();
   for (size_t i = 0; i < storages.size(); ++i)
     OnRemovableStorageAttached(storages[i]);
   storage_monitor::StorageMonitor::GetInstance()->AddObserver(this);
 }
 
 void VolumeManager::DoMountEvent(chromeos::MountError error_code,
-                                 const linked_ptr<Volume>& volume) {
+                                 std::unique_ptr<Volume> volume) {
   // Archive files are mounted globally in system. We however don't want to show
   // archives from profile-specific folders (Drive/Downloads) of other users in
   // multi-profile session. To this end, we filter out archives not on the
   // volumes already mounted on this VolumeManager instance.
   if (volume->type() == VOLUME_TYPE_MOUNTED_ARCHIVE_FILE) {
     // Source may be in Drive cache folder under the current profile directory.
     bool from_current_profile =
         profile_->GetPath().IsParent(volume->source_path());
     for (const auto& mounted_volume : mounted_volumes_) {
       if (mounted_volume.second->mount_path().IsParent(volume->source_path())) {
         from_current_profile = true;
         break;
       }
     }
     if (!from_current_profile)
       return;
   }
 
   // Filter out removable disks if forbidden by policy for this profile.
   if (volume->type() == VOLUME_TYPE_REMOVABLE_DISK_PARTITION &&
       profile_->GetPrefs()->GetBoolean(prefs::kExternalStorageDisabled)) {
     return;
   }
 
+  Volume* raw_volume = volume.get();
   if (error_code == chromeos::MOUNT_ERROR_NONE || volume->mount_condition()) {
-    mounted_volumes_[volume->volume_id()] = volume;
-    UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType", volume->type(),
+    mounted_volumes_[volume->volume_id()] = std::move(volume);
+    UMA_HISTOGRAM_ENUMERATION("FileBrowser.VolumeType", raw_volume->type(),
                               NUM_VOLUME_TYPE);
   }
 
   for (auto& observer : observers_)
-    observer.OnVolumeMounted(error_code, *volume);
+    observer.OnVolumeMounted(error_code, *raw_volume);
 }
 
 void VolumeManager::DoUnmountEvent(chromeos::MountError error_code,
-                                   const linked_ptr<Volume>& volume) {
-  if (mounted_volumes_.find(volume->volume_id()) == mounted_volumes_.end())
+                                   const Volume& volume) {
+  auto iter = mounted_volumes_.find(volume.volume_id());
+  if (iter == mounted_volumes_.end())
     return;
   if (error_code == chromeos::MOUNT_ERROR_NONE)
-    mounted_volumes_.erase(volume->volume_id());
+    mounted_volumes_.erase(iter);
 
   for (auto& observer : observers_)
-    observer.OnVolumeUnmounted(error_code, *volume.get());
+    observer.OnVolumeUnmounted(error_code, volume);
 }
 
 }  // namespace file_manager