Add callback to DiskMountManager::UnmountPath

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 65 matching lines @@
         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
                    MOUNT_ERROR_INTERNAL,
                    source_path,
                    type,
                    ""));
   }
 
   // DiskMountManager override.
   virtual void UnmountPath(const std::string& mount_path,
-                           UnmountOptions options) OVERRIDE {
+                           UnmountOptions options,
+                           const UnmountPathCallback& callback) OVERRIDE {
     UnmountChildMounts(mount_path);
     cros_disks_client_->Unmount(mount_path, options,
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
+                                           callback,
                                            true),
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
+                                           callback,
                                            false));
   }
 
   // DiskMountManager 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.";
       OnFormatDevice(mount_path, false);
       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.";
       OnFormatDevice(device_path, false);
       return;
     }
 
-    if (formatting_pending_.find(device_path) != formatting_pending_.end()) {
-      LOG(ERROR) << "Formatting is already pending: " << mount_path;
-      OnFormatDevice(device_path, false);
-      return;
-    }
-
-    // Formatting process continues, after unmounting.
-    formatting_pending_.insert(device_path);
-    UnmountPath(disk->second->mount_path(), UNMOUNT_OPTIONS_NONE);
+    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 {
     std::vector<std::string> devices_to_unmount;
 
     // Get list of all devices to unmount.
     int device_path_len = device_path.length();
@@ skipping 118 matching lines @@
     std::string mount_path = mount_path_in;
     // Let's make sure mount path has trailing slash.
     if (mount_path[mount_path.length() - 1] != '/')
       mount_path += '/';
 
     for (MountPointMap::iterator it = mount_points_.begin();
          it != mount_points_.end();
          ++it) {
       if (StartsWithASCII(it->second.source_path, mount_path,
                           true /*case sensitive*/)) {
-        UnmountPath(it->second.mount_path, UNMOUNT_OPTIONS_NONE);
+        // TODO(tbarzic): Handle the case where this fails.
+        UnmountPath(it->second.mount_path,
+                    UNMOUNT_OPTIONS_NONE,
+                    UnmountPathCallback());
       }
     }
   }
 
   // Callback for UnmountDeviceRecursively.
   void OnUnmountDeviceRecursively(
       UnmountDeviceRecursivelyCallbackData* cb_data,
       bool success,
       const std::string& mount_path) {
     if (success) {
       // Do standard processing for Unmount event.
-      OnUnmountPath(true, mount_path);
+      OnUnmountPath(UnmountPathCallback(), true, mount_path);
       LOG(INFO) << mount_path <<  " unmounted.";
     }
     // This is safe as long as all callbacks are called on the same thread as
     // UnmountDeviceRecursively.
     cb_data->num_pending_callbacks--;
 
     if (cb_data->num_pending_callbacks == 0) {
       // This code has a problem that the |success| status used here is for the
       // last "unmount" callback, but not whether all unmounting is succeeded.
       // TODO(hidehiko): Fix the issue.
@@ skipping 37 matching lines @@
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
       disk->set_mount_path(mount_info.mount_path);
     }
   }
 
   // Callback for UnmountPath.
-  void OnUnmountPath(bool success, const std::string& mount_path) {
+  void OnUnmountPath(const UnmountPathCallback& callback,
+                     bool success,
+                     const std::string& mount_path) {
     MountPointMap::iterator mount_points_it = mount_points_.find(mount_path);
-    if (mount_points_it == mount_points_.end())
+    if (mount_points_it == mount_points_.end()) {
+      // The path was unmounted, but not as a result of this unmount request,
+      // so return error.
+      if (!callback.is_null())
+        callback.Run(MOUNT_ERROR_INTERNAL);
       return;
+    }
 
     NotifyMountStatusUpdate(
         UNMOUNTING,
         success ? MOUNT_ERROR_NONE : MOUNT_ERROR_INTERNAL,
         MountPointInfo(mount_points_it->second.source_path,
                        mount_points_it->second.mount_path,
                        mount_points_it->second.mount_type,
                        mount_points_it->second.mount_condition));
 
     std::string path(mount_points_it->second.source_path);
     if (success)
       mount_points_.erase(mount_points_it);
 
     DiskMap::iterator disk_iter = disks_.find(path);
     if (disk_iter != disks_.end()) {
       DCHECK(disk_iter->second);
       if (success)
         disk_iter->second->clear_mount_path();
     }
 
-    FormatTaskSet::iterator format_iter = formatting_pending_.find(path);
-    // Check if there is a formatting scheduled.
-    if (format_iter != formatting_pending_.end()) {
-      formatting_pending_.erase(format_iter);
-      if (success && disk_iter != disks_.end()) {
-        FormatUnmountedDevice(path);
-      } else {
-        OnFormatDevice(path, false);
-      }
+    if (!callback.is_null())
+      callback.Run(success ? MOUNT_ERROR_NONE : MOUNT_ERROR_INTERNAL);
+  }
+
+  void OnUnmountPathForFormat(const std::string& device_path,
+                              MountError error_code) {
+    if (error_code == MOUNT_ERROR_NONE &&
+        disks_.find(device_path) != disks_.end()) {
+      FormatUnmountedDevice(device_path);
+    } else {
+      OnFormatDevice(device_path, false);
     }
   }
 
   // Starts device formatting.
   void FormatUnmountedDevice(const std::string& device_path) {
     DiskMap::const_iterator disk = disks_.find(device_path);
     DCHECK(disk != disks_.end() && disk->second->mount_path().empty());
 
     const char kFormatVFAT[] = "vfat";
     cros_disks_client_->FormatDevice(
@@ skipping 213 matching lines @@
   CrosDisksClient* cros_disks_client_;
 
   // The list of disks found.
   DiskMountManager::DiskMap disks_;
 
   DiskMountManager::MountPointMap mount_points_;
 
   typedef std::set<std::string> SystemPathPrefixSet;
   SystemPathPrefixSet system_path_prefixes_;
 
-  // A map from device path (e.g. /sys/devices/pci0000:00/.../sdb/sdb1)) to file
-  // path (e.g. /dev/sdb).
-  // Devices in this map are supposed to be formatted, but are currently waiting
-  // to be unmounted. When device is in this map, the formatting process HAVEN'T
-  // started yet.
-  typedef std::set<std::string> FormatTaskSet;
-  FormatTaskSet formatting_pending_;
-
   base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DiskMountManagerImpl);
 };
 
 }  // namespace
 
 DiskMountManager::Disk::Disk(const std::string& device_path,
                              const std::string& mount_path,
                              const std::string& system_path,
@@ skipping 140 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos