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* device_path) OVERRIDE {
+    CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));

[achuithb, 2011/07/21 00:58:21]

DCHECK?

[sidor, 2011/07/21 18:24:15]

Done.

+    if (!CrosLibrary::Get()->EnsureLoaded()) {
+      OnFormatDevice(device_path,
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     kLibraryNotLoaded);
+      return;
+    }
+    FormatDevice(device_path,
+                 "vfat",      // currently format in vfat by default
+                 &MountLibraryImpl::FormatDeviceCallback,
+                 this);
+  }
+
+  virtual void FormatMountedDevice(const char* device_mount_path) OVERRIDE {
+    DCHECK(device_mount_path);
+    std::string device_path = "";
+    std::string file_path = "";

[achuithb, 2011/07/21 00:58:21]

Don't need = "", since the empty string is the default.
You can just do:
std::string device_path, file_path;

[sidor, 2011/07/21 18:24:15]

Done.

+    for (MountLibrary::DiskMap::iterator it = disks_.begin();
+        it != disks_.end(); ++it) {
+      if (it->second->mount_path().compare(device_mount_path) == 0) {
+        device_path = it->second->device_path();
+        file_path = it->second->file_path();
+      }
+    }
+    if (device_path.compare("") == 0) {

[achuithb, 2011/07/21 00:58:21]

Use device_path.empty()

[sidor, 2011/07/21 18:24:15]

Done.

+      OnFormatDevice(device_path.c_str(),
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     "Device with this mount path not found.");
+      return;
+    }
+    PathMap::iterator it = to_be_formated_.find(device_path);
+    if (it != to_be_formated_.end()) {

[achuithb, 2011/07/21 00:58:21]

You can just do:
if (to_be_formated_.find(device_path_ != to_be_formated_.end())
You don't need the variable it.

[sidor, 2011/07/21 18:24:15]

Done.

+      OnFormatDevice(device_path.c_str(),
+                     false,
+                     MOUNT_METHOD_ERROR_LOCAL,
+                     "Formatting is already pending.");
+      return;
+    }
+    // Formatting process continues, after unmounting

[achuithb, 2011/07/21 00:58:21]

Period at the end of comments please.

[sidor, 2011/07/21 18:24:15]

Done.

+    to_be_formated_[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 = to_be_formated_.find(device_path);
+      if (it != to_be_formated_.end()) {
+        const std::string* file_path = &(it->second);

[achuithb, 2011/07/21 00:58:21]

I don't think this is safe. You should do
const std::string file_path = it->second;
It looks like you are deleting the string in the following line (unless I'm
missing something).

[sidor, 2011/07/21 18:24:15]

That's really weird. It intuitively it shouldn't work, but hmm after compilation
it works perfectly. Nevertheless I will change it according to what you wrote
just for the sanity sake.

+        to_be_formated_.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("!").append(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

[achuithb, 2011/07/21 00:58:21]

Period at the end of comments please.

[sidor, 2011/07/21 18:24:15]

Done.

+  PathMap to_be_formated_;

[achuithb, 2011/07/21 00:58:21]

Maybe format_pending_?

[sidor, 2011/07/21 18:24:15]

That doesn't sound correct. This is map holding the devices that are currently
being unmounted and will for which formatting process will start after removing
them from this map.

[achuithb, 2011/07/21 22:02:32]

Isn't that what format_pending_ means? Format hasn't started yet?

+
   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* device_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);