Adding support for mount point different from removable devices to MountLibrary

chrome/browser/chromeos/cros/mount_library.cc

 // Copyright (c) 2011 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/cros/mount_library.h"
 
 #include <set>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
@@ skipping 72 matching lines @@
 
   // MountLibrary overrides.
   virtual void AddObserver(Observer* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
-  virtual void MountPath(const char* device_path) OVERRIDE {
+  virtual std::string MountTypeToString(MountType type)  const OVERRIDE {
+    switch (type) {
+      case MOUNT_TYPE_DEVICE:
+        return "device";
+      case MOUNT_TYPE_ARCHIVE:
+        return "file";
+      case MOUNT_TYPE_NETWORK_STORAGE:
+        return "network";
+      case MOUNT_TYPE_INVALID:
+        return "invalid";
+      default:
+        NOTREACHED();
+    }
+    return "";
+  }
+
+  virtual MountType MountTypeFromString(const std::string& type_str) const
+      OVERRIDE {
+    if (type_str == "device") {
+      return MOUNT_TYPE_DEVICE;
+    } else if (type_str == "network") {
+      return MOUNT_TYPE_NETWORK_STORAGE;
+    } else if (type_str == "file") {
+      return MOUNT_TYPE_ARCHIVE;
+    } else {
+      return MOUNT_TYPE_INVALID;
+    }
+  }
+
+  virtual void MountPath(const char* source_path,
+                         MountType type,
+                         const MountPathOptions& options) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnMountRemovableDevice(device_path,
-                             NULL,
-                             MOUNT_METHOD_ERROR_LOCAL,
-                             kLibraryNotLoaded);
+      OnMountCompleted(MOUNT_ERROR_LIBRARY_NOT_LOADED,
+                       MountPointInfo(source_path, NULL, type));
       return;
     }
-    MountRemovableDevice(device_path,
-                         &MountLibraryImpl::MountRemovableDeviceCallback,
-                         this);
+    MountSourcePath(source_path, type, options, &MountCompletedHandler, this);
   }
 
-  virtual void UnmountPath(const char* device_path) OVERRIDE {
+  virtual void UnmountPath(const char* path) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
-      OnUnmountRemovableDevice(device_path,
-                               MOUNT_METHOD_ERROR_LOCAL,
-                               kLibraryNotLoaded);
+      OnUnmountPath(path,
+                    MOUNT_METHOD_ERROR_LOCAL,
+                    kLibraryNotLoaded);
       return;
     }
-    UnmountRemovableDevice(device_path,
-                           &MountLibraryImpl::UnmountRemovableDeviceCallback,
-                           this);
+    UnmountMountPoint(path, &MountLibraryImpl::UnmountMountPointCallback, this);
   }
 
   virtual void UnmountDeviceRecursive(const char* device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data)
       OVERRIDE {
     bool success = true;
     const char* error_message = NULL;
     std::vector<const char*> devices_to_unmount;
 
     if (!CrosLibrary::Get()->EnsureLoaded()) {
@@ skipping 16 matching lines @@
       }
     }
 
     if (success) {
       // We will send the same callback data object to all Unmount calls and use
       // it to syncronize callbacks.
       UnmountDeviceRecursiveCallbackData*
           cb_data = new UnmountDeviceRecursiveCallbackData(this, user_data,
           callback, devices_to_unmount.size());
       for (std::vector<const char*>::iterator it = devices_to_unmount.begin();
-          it != devices_to_unmount.end();
-          ++it) {
-        UnmountRemovableDevice(*it,
+           it != devices_to_unmount.end();
+           ++it) {
+        UnmountMountPoint(
+            *it,
             &MountLibraryImpl::UnmountDeviceRecursiveCallback,
             cb_data);
       }
     } else {
       LOG(WARNING) << "Unmount recursive request failed for device "
                    << device_path << ", with error: " << error_message;
       callback(user_data, false);
     }
   }
 
   virtual void RequestMountInfoRefresh() OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
       OnRequestMountInfo(NULL,
                          0,
                          MOUNT_METHOD_ERROR_LOCAL,
                          kLibraryNotLoaded);
       return;
     }
     RequestMountInfo(&MountLibraryImpl::RequestMountInfoCallback,
                      this);
   }
 
   const DiskMap& disks() const OVERRIDE { return disks_; }
+  const MountPointMap& mount_points() const OVERRIDE { return mount_points_; }
 
  private:
-  // Callback for MountRemovableDevice method.
-  static void MountRemovableDeviceCallback(void* object,
-                                           const char* device_path,
-                                           const char* mount_path,
-                                           MountMethodErrorType error,
-                                           const char* error_message) {
+  // Callback for MountComplete signal and MountSourcePath method.
+  static void MountCompletedHandler(void* object,
+                                    MountError error_code,
+                                    const char* source_path,
+                                    MountType type,
+                                    const char* mount_path) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
-    self->OnMountRemovableDevice(device_path,
-                                 mount_path,
-                                 error,
-                                 error_message);
+    self->OnMountCompleted(static_cast<MountError>(error_code),
+                           MountPointInfo(source_path, mount_path, type));
   }
 
   // Callback for UnmountRemovableDevice method.
-  static void UnmountRemovableDeviceCallback(void* object,
-                                             const char* device_path,
-                                             const char* mount_path,
-                                             MountMethodErrorType error,
-                                             const char* error_message) {
+  static void UnmountMountPointCallback(void* object,
+                                        const char* device_path,
+                                        MountMethodErrorType error,
+                                        const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
-    self->OnUnmountRemovableDevice(device_path,
-                                   error,
-                                   error_message);
+    self->OnUnmountPath(device_path, error, error_message);
   }
 
   // Callback for UnmountDeviceRecursive.
   static void UnmountDeviceRecursiveCallback(void* object,
                                              const char* device_path,
-                                             const char* mount_path,
                                              MountMethodErrorType error,
                                              const char* error_message) {
     DCHECK(object);
     UnmountDeviceRecursiveCallbackData* cb_data =
         static_cast<UnmountDeviceRecursiveCallbackData*>(object);
 
     // Do standard processing for Unmount event.
-    cb_data->object->OnUnmountRemovableDevice(device_path,
-                                              error,
-                                              error_message);
+    cb_data->object->OnUnmountPath(device_path,
+                                   error,
+                                   error_message);
     if (error == MOUNT_METHOD_ERROR_LOCAL) {
       cb_data->success = false;
     } else if (error == MOUNT_METHOD_ERROR_NONE) {
       LOG(WARNING) << device_path <<  " unmounted.";
    }
 
     // This is safe as long as all callbacks are called on the same thread as
     // UnmountDeviceRecursive.
     cb_data->pending_callbacks_count--;
 
@@ skipping 34 matching lines @@
   // This method will receive events that are caused by drive status changes.
   static void MonitorMountEventsHandler(void* object,
                                         MountEventType evt,
                                         const char* device_path) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnMountEvent(evt, device_path);
   }
 
 
-  void OnMountRemovableDevice(const char* device_path,
-                              const char* mount_path,
-                              MountMethodErrorType error,
-                              const char* error_message) {
-    DCHECK(device_path);
+  void OnMountCompleted(MountError error_code,
+                        const MountPointInfo& mount_info) {
+    DCHECK(!mount_info.source_path.empty());
 
-    if (error == MOUNT_METHOD_ERROR_NONE && device_path && mount_path) {
-      std::string path(device_path);
+    FireMountCompleted(MOUNTING,
+                       error_code,
+                       mount_info);
+
+    if (error_code == MOUNT_ERROR_NONE &&
+        mount_points_.find(mount_info.source_path) == mount_points_.end()) {
+      mount_points_.insert(MountPointMap::value_type(
+                               mount_info.source_path.c_str(),
+                               mount_info));
+    }
+
+    if (error_code == MOUNT_ERROR_NONE &&
+        mount_info.mount_type == MOUNT_TYPE_DEVICE &&
+        !mount_info.source_path.empty() &&
+        !mount_info.mount_path.empty()) {
+      std::string path(mount_info.source_path);
       DiskMap::iterator iter = disks_.find(path);
       if (iter == disks_.end()) {
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
-      disk->set_mount_path(mount_path);
+      disk->set_mount_path(mount_info.mount_path.c_str());
       FireDiskStatusUpdate(MOUNT_DISK_MOUNTED, disk);
-    } else {
-      LOG(WARNING) << "Mount request failed for device "
-                   << device_path << ", with error: "
-                   << (error_message ? error_message : "Unknown");
     }
   }
 
-  void OnUnmountRemovableDevice(const char* device_path,
-                                MountMethodErrorType error,
-                                const char* error_message) {
-    DCHECK(device_path);
-    if (error == MOUNT_METHOD_ERROR_NONE && device_path) {
-      std::string path(device_path);
+  void OnUnmountPath(const char* source_path,
+                     MountMethodErrorType error,
+                     const char* error_message) {
+    DCHECK(source_path);
+
+    if (error == MOUNT_METHOD_ERROR_NONE && source_path) {
+      MountPointMap::iterator mount_points_it = mount_points_.find(source_path);
+      if (mount_points_it == mount_points_.end())
+        return;
+      // TODO(tbarzic): Add separate, PathUnmounted event to Observer.
+      FireMountCompleted(
+          UNMOUNTING,
+          MOUNT_ERROR_NONE,
+          MountPointInfo(mount_points_it->second.source_path.c_str(),
+                         mount_points_it->second.mount_path.c_str(),
+                         mount_points_it->second.mount_type));
+      mount_points_.erase(mount_points_it);
+
+      std::string path(source_path);
       DiskMap::iterator iter = disks_.find(path);
       if (iter == disks_.end()) {
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
       disk->clear_mount_path();
       FireDiskStatusUpdate(MOUNT_DISK_UNMOUNTED, disk);
     } else {
       LOG(WARNING) << "Unmount request failed for device "
-                   << device_path << ", with error: "
+                   << source_path << ", with error: "
                    << (error_message ? error_message : "Unknown");
     }
   }
 
   void OnGetDiskProperties(const char* device_path,
                            const DiskInfo* disk1,
                            MountMethodErrorType error,
                            const char* error_message) {
     DCHECK(device_path);
     if (error == MOUNT_METHOD_ERROR_NONE && device_path) {
@@ skipping 139 matching lines @@
         break;
       }
       case DEVICE_REMOVED: {
         type = MOUNT_DEVICE_REMOVED;
         break;
       }
       case DEVICE_SCANNED: {
         type = MOUNT_DEVICE_SCANNED;
         break;
       }
-      default:
+      default: {
         return;
+      }
     }
     FireDeviceStatusUpdate(type, std::string(device_path));
   }
 
   void Init() {
     // Getting the monitor status so that the daemon starts up.
-    mount_status_connection_ = MonitorMountEvents(
-        &MonitorMountEventsHandler, this);
+    mount_status_connection_ = MonitorAllMountEvents(
+        &MonitorMountEventsHandler, &MountCompletedHandler, this);
   }
 
   void FireDiskStatusUpdate(MountLibraryEventType evt,
                             const Disk* disk) {
     // Make sure we run on UI thread.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     FOR_EACH_OBSERVER(
         Observer, observers_, DiskChanged(evt, disk));
   }
 
   void FireDeviceStatusUpdate(MountLibraryEventType evt,
                               const std::string& device_path) {
     // Make sure we run on UI thread.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     FOR_EACH_OBSERVER(
         Observer, observers_, DeviceChanged(evt, device_path));
   }
 
+  void FireMountCompleted(MountEvent event_type,
+                          MountError error_code,
+                          const MountPointInfo& mount_info) {
+    // Make sure we run on UI thread.
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    FOR_EACH_OBSERVER(
+        Observer, observers_, MountCompleted(event_type,
+                                             error_code,
+                                             mount_info));
+  }
+
   // Mount event change observers.
   ObserverList<Observer> observers_;
 
   // A reference to the  mount api, to allow callbacks when the mount
   // status changes.
   MountEventConnection mount_status_connection_;
 
   // The list of disks found.
   MountLibrary::DiskMap disks_;
 
+  MountLibrary::MountPointMap mount_points_;
+
   DISALLOW_COPY_AND_ASSIGN(MountLibraryImpl);
 };
 
 class MountLibraryStubImpl : public MountLibrary {
  public:
   MountLibraryStubImpl() {}
   virtual ~MountLibraryStubImpl() {}
 
   // MountLibrary overrides.
   virtual void AddObserver(Observer* observer) OVERRIDE {}
   virtual void RemoveObserver(Observer* observer) OVERRIDE {}
   virtual const DiskMap& disks() const OVERRIDE { return disks_; }
+  virtual const MountPointMap& mount_points() const OVERRIDE {
+    return mount_points_;
+  }
+  virtual std::string MountTypeToString(MountType type) const OVERRIDE {
+    return "";
+  }
+  virtual MountType MountTypeFromString(const std::string& type_str) const
+      OVERRIDE {
+    return MOUNT_TYPE_INVALID;
+  }
   virtual void RequestMountInfoRefresh() OVERRIDE {}
-  virtual void MountPath(const char* device_path) OVERRIDE {}
-  virtual void UnmountPath(const char* device_path) OVERRIDE {}
+  virtual void MountPath(const char* source_path, MountType type,
+                         const MountPathOptions& options) OVERRIDE {}
+  virtual void UnmountPath(const char* path) OVERRIDE {}
   virtual void UnmountDeviceRecursive(const char* device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data)
       OVERRIDE {}
 
  private:
   // The list of disks found.
   DiskMap disks_;
+  MountPointMap mount_points_;
 
   DISALLOW_COPY_AND_ASSIGN(MountLibraryStubImpl);
 };
 
 // static
 MountLibrary* MountLibrary::GetImpl(bool stub) {
   if (stub)
     return new MountLibraryStubImpl();
   else
     return new MountLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::MountLibraryImpl);