chromeos: Fix malfunctioning CrosDisksClientStubImpl::Unmount

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/chromeos/chromeos_version.h"
@@ skipping 397 matching lines @@
 
   virtual ~CrosDisksClientStubImpl() {}
 
   // CrosDisksClient overrides:
   virtual void Mount(const std::string& source_path,
                      const std::string& source_format,
                      const std::string& mount_label,
                      MountType type,
                      const MountCallback& callback,
                      const ErrorCallback& error_callback) OVERRIDE {
-    // Already mounted path.
-    if (mounted_paths_.count(source_path) != 0) {
-      FinishMount(MOUNT_ERROR_PATH_ALREADY_MOUNTED, source_path, type,
-                  std::string(), callback);
-      return;
-    }
-
     // This stub implementation only accepts archive mount requests.
     if (type != MOUNT_TYPE_ARCHIVE) {
       FinishMount(MOUNT_ERROR_INTERNAL, source_path, type, std::string(),
                   callback);
       return;
     }
 
     const base::FilePath mounted_path = GetArchiveMountPoint().Append(
         base::FilePath::FromUTF8Unsafe(mount_label));
 
+    // Already mounted path.
+    if (source_paths_.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 */),
         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 UnmountCallback& callback,
                        const UnmountCallback& error_callback) OVERRIDE {
     // Not mounted.
-    if (mounted_paths_.count(device_path) == 0) {
+    if (source_paths_.count(device_path) == 0) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE, base::Bind(error_callback, device_path));
       return;
     }
 
-    const base::FilePath mounted_path = mounted_paths_[device_path];
-    mounted_paths_.erase(device_path);
+    source_paths_.erase(device_path);
 
     // Remove the directory created in Mount().
-    base::WorkerPool::PostTask(
+    base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&file_util::Delete),
-                   mounted_path,
+                   base::FilePath::FromUTF8Unsafe(device_path),
                    true /* recursive */),
+        base::Bind(callback, device_path),
         true /* task_is_slow */);
-
-    base::MessageLoopProxy::current()->PostTask(
-        FROM_HERE, base::Bind(callback, device_path));
   }
 
   virtual void EnumerateAutoMountableDevices(
       const EnumerateAutoMountableDevicesCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE {
     std::vector<std::string> device_paths;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, device_paths));
   }
 
@@ skipping 52 matching lines @@
   // Part of Mount() implementation.
   void ContinueMount(const std::string& source_path,
                      MountType type,
                      const MountCallback& callback,
                      const base::FilePath& mounted_path,
                      MountError mount_error) {
     if (mount_error != MOUNT_ERROR_NONE) {
       FinishMount(mount_error, source_path, type, std::string(), callback);
       return;
     }
-    mounted_paths_[source_path] = mounted_path;
+    source_paths_[mounted_path.value()] = source_path;
     FinishMount(MOUNT_ERROR_NONE, source_path, type,
                 mounted_path.AsUTF8Unsafe(), callback);
   }
 
   // Runs |callback| and sends MountCompleted signal.
   // Part of Mount() implementation.
   void FinishMount(MountError error,
                    const std::string& source_path,
                    MountType type,
                    const std::string& mounted_path,
                    const MountCallback& callback) {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback);
     if (!mount_completed_handler_.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(mount_completed_handler_,
                      error, source_path, type, mounted_path));
     }
   }
 
-  // Source path to mounted path map.
-  std::map<std::string, base::FilePath> mounted_paths_;
+  // Mounted path to source path map.
+  std::map<std::string, std::string> source_paths_;

[satorux1, 2013/03/07 03:18:30]

mount_to_source_path_map_ ?

[hashimoto, 2013/03/07 03:31:50]

Done.

 
   MountEventHandler mount_event_handler_;
   MountCompletedHandler mount_completed_handler_;
 
   base::WeakPtrFactory<CrosDisksClientStubImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(CrosDisksClientStubImpl);
 };
 
 }  // namespace
@@ skipping 186 matching lines @@
 }
 
 // static
 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
   return base::FilePath(base::chromeos::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/removable") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 }
 
 }  // namespace chromeos