Formatting feature initial commit for ChromeOS Tree

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 <vector>
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "content/browser/browser_thread.h"
 
 const char* kLibraryNotLoaded = "Cros Library not loaded";
 const char* kDeviceNotFound = "Device could not be found";
 
 namespace chromeos {
@@ skipping 92 matching lines @@
       OnUnmountRemovableDevice(device_path,
                                MOUNT_METHOD_ERROR_LOCAL,
                                kLibraryNotLoaded);
       return;
     }
     UnmountRemovableDevice(device_path,
                            &MountLibraryImpl::UnmountRemovableDeviceCallback,
                            this);
   }
 
+  virtual void FormatUnmountedDevice(const char* file_path) OVERRIDE {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!CrosLibrary::Get()->EnsureLoaded()) {
+      OnFormatDevice(file_path,
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     kLibraryNotLoaded);
+      return;
+    }
+    for (MountLibrary::DiskMap::iterator it = disks_.begin();
+        it != disks_.end(); ++it) {
+      if (it->second->file_path().compare(file_path) == 0 &&
+          !it->second->mount_path().empty()) {
+        OnFormatDevice(file_path,
+                       false,
+                       MOUNT_METHOD_ERROR_LOCAL,
+                       "Device is still mounted.");
+      }
+    }
+    FormatDevice(file_path,
+                 "vfat",      // currently format in vfat by default
+                 &MountLibraryImpl::FormatDeviceCallback,
+                 this);
+  }
+
+  virtual void FormatMountedDevice(const char* mount_path) OVERRIDE {
+    DCHECK(mount_path);
+    std::string device_path, file_path;
+    for (MountLibrary::DiskMap::iterator it = disks_.begin();
+        it != disks_.end(); ++it) {
+      if (it->second->mount_path().compare(mount_path) == 0) {
+        device_path = it->second->device_path();
+        file_path = it->second->file_path();

[tbarzic, 2011/07/26 22:49:50]

are you missing break here?

[sidor, 2011/07/28 00:20:51]

Done.

+      }
+    }
+    if (device_path.empty()) {
+      OnFormatDevice(device_path.c_str(),
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     "Device with this mount path not found.");
+      return;
+    }
+    if (formatting_pending_.find(device_path) != formatting_pending_.end()) {
+      OnFormatDevice(device_path.c_str(),
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     "Formatting is already pending.");
+      return;
+    }
+    // Formatting process continues, after unmounting.
+    formatting_pending_[device_path] = file_path;
+    UnmountPath(device_path.c_str());
+  }
+
   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()) {
       success = false;
       error_message = kLibraryNotLoaded;
@@ skipping 70 matching lines @@
                                              const char* mount_path,
                                              MountMethodErrorType error,
                                              const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnUnmountRemovableDevice(device_path,
                                    error,
                                    error_message);
   }
 
+  // Callback for FormatRemovableDevice method.
+  static void FormatDeviceCallback(void* object,
+                                   const char* device_path,
+                                   bool success,
+                                   MountMethodErrorType error,
+                                   const char* error_message) {
+    DCHECK(object);
+    MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
+    self->OnFormatDevice(device_path, success, 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);
     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--;
 
     if (cb_data->pending_callbacks_count == 0) {
       cb_data->callback(cb_data->user_data, cb_data->success);
       delete cb_data;
     }
   }
@@ skipping 68 matching lines @@
       std::string path(device_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);
+      // Check if there is a formatting scheduled
+      PathMap::iterator it = formatting_pending_.find(device_path);
+      if (it != formatting_pending_.end()) {
+        const std::string file_path = it->second;
+        formatting_pending_.erase(it);
+        FormatUnmountedDevice(file_path.c_str());
+      }
     } else {
       LOG(WARNING) << "Unmount request failed for device "
                    << device_path << ", with error: "
                    << (error_message ? error_message : "Unknown");
     }
   }
 
+  void OnFormatDevice(const char* device_path,
+                      bool success,
+                      MountMethodErrorType error,
+                      const char* error_message) {
+    DCHECK(device_path);
+
+    if (error == MOUNT_METHOD_ERROR_NONE && device_path && success) {
+      FireDeviceStatusUpdate(MOUNT_FORMATTING_STARTED, device_path);
+    } else {
+      FireDeviceStatusUpdate(MOUNT_FORMATTING_STARTED,
+                             std::string("!") + device_path);
+      LOG(WARNING) << "Format request failed for device "
+                   << device_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) {
       // TODO(zelidrag): Find a better way to filter these out before we
       // fetch the properties:
       // Ignore disks coming from the device we booted the system from.
 
@@ skipping 135 matching lines @@
         break;
       }
       case DEVICE_REMOVED: {
         type = MOUNT_DEVICE_REMOVED;
         break;
       }
       case DEVICE_SCANNED: {
         type = MOUNT_DEVICE_SCANNED;
         break;
       }
+      case FORMATTING_FINISHED: {
+        type = MOUNT_FORMATTING_FINISHED;
+        break;
+      }
     }
     FireDeviceStatusUpdate(type, std::string(device_path));
   }
 
   void Init() {
     // Getting the monitor status so that the daemon starts up.
     mount_status_connection_ = MonitorMountEvents(
         &MonitorMountEventsHandler, this);
   }
 
@@ skipping 16 matching lines @@
   // 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_;
 
+  // Set of devices that are supposed to be formated, but are currently waiting
+  // to be unmounted. When device is in this map, the formatting process HAVEN'T
+  // started yet.
+  PathMap formatting_pending_; 
+
   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 void RequestMountInfoRefresh() OVERRIDE {}
   virtual void MountPath(const char* device_path) OVERRIDE {}
   virtual void UnmountPath(const char* device_path) OVERRIDE {}
+  virtual void FormatUnmountedDevice(const char* device_path) OVERRIDE {}
+  virtual void FormatMountedDevice(const char* mount_path) OVERRIDE {}
   virtual void UnmountDeviceRecursive(const char* device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data)
       OVERRIDE {}
 
  private:
   // The list of disks found.
   DiskMap disks_;
 
   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);