Adding a format device button to UI.

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"
@@ skipping 162 matching lines @@
   virtual void FormatMountedDevice(const char* mount_path) OVERRIDE {
     DCHECK(mount_path);
     Disk* disk = NULL;
     for (MountLibrary::DiskMap::iterator it = disks_.begin();
         it != disks_.end(); ++it) {
       if (it->second->mount_path().compare(mount_path) == 0) {
         disk = it->second;
         break;
       }
     }
-
     if (!disk) {
-      OnFormatDevice(disk->device_path().c_str(),
+      OnFormatDevice(mount_path,
                      false,
                      MOUNT_METHOD_ERROR_LOCAL,
                      "Device with this mount path not found.");
       return;
     }
     if (formatting_pending_.find(disk->device_path()) !=
         formatting_pending_.end()) {
-      OnFormatDevice(disk->device_path().c_str(),
+      OnFormatDevice(mount_path,
                      false,
                      MOUNT_METHOD_ERROR_LOCAL,
                      "Formatting is already pending.");
       return;
     }
     // Formatting process continues, after unmounting.
     formatting_pending_[disk->device_path()] = disk->file_path();
     UnmountPath(disk->mount_path().c_str());
   }
 
@@ skipping 61 matching lines @@
                          kLibraryNotLoaded);
       return;
     }
     RequestMountInfo(&MountLibraryImpl::RequestMountInfoCallback,
                      this);
   }
 
   const DiskMap& disks() const OVERRIDE { return disks_; }
   const MountPointMap& mount_points() const OVERRIDE { return mount_points_; }
 
  private:

[tbarzic, 2011/08/12 19:31:13]

add comment // static.

[sidor.dev, 2011/08/12 20:27:09]

no.

+  virtual std::string FilePathToDevicePath(std::string file_path) OVERRIDE {
+    for (MountLibrary::DiskMap::iterator it = disks_.begin();
+         it != disks_.end(); ++it) {
+      if (it->second->file_path().compare(file_path) == 0)
+        return it->second->device_path();
+    }
+    return NULL;
+  }
+
   // 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->OnMountCompleted(static_cast<MountError>(error_code),
                            MountPointInfo(source_path, mount_path, type));
   }
 
   // Callback for UnmountRemovableDevice method.
   static void UnmountMountPointCallback(void* object,
                                         const char* mount_path,
                                         MountMethodErrorType error,
                                         const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnUnmountPath(mount_path, error, error_message);
   }
 
   // Callback for FormatRemovableDevice method.
   static void FormatDeviceCallback(void* object,
-                                   const char* device_path,
+                                   const char* file_path,
                                    bool success,
                                    MountMethodErrorType error,
                                    const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
+    const char* device_path = self->FilePathToDevicePath(file_path).c_str();
+    if (!device_path) {
+      LOG(ERROR) << "Error while handling disks metadata. Cannot find " <<
+          "device that is being formatted.";
+      return;
+    }
     self->OnFormatDevice(device_path, success, error, error_message);
   }
 
   // Callback for UnmountDeviceRecursive.
   static void UnmountDeviceRecursiveCallback(void* object,
                                              const char* mount_path,
                                              MountMethodErrorType error,
                                              const char* error_message) {
     DCHECK(object);
     UnmountDeviceRecursiveCallbackData* cb_data =
@@ skipping 292 matching lines @@
       }
       case DEVICE_REMOVED: {
         type = MOUNT_DEVICE_REMOVED;
         break;
       }
       case DEVICE_SCANNED: {
         type = MOUNT_DEVICE_SCANNED;
         break;
       }
       case FORMATTING_FINISHED: {
+        // FORMATTING_FINISHED actually returns file path instead of device
+        // path.
+        device_path = FilePathToDevicePath(device_path).c_str();
+        if (!device_path) {
+          LOG(ERROR) << "Error while handling disks metadata. Cannot find " <<
+              "device that is being formatted.";
+          return;
+        }
         type = MOUNT_FORMATTING_FINISHED;
         break;
       }
       default: {
         return;
       }
     }
     FireDeviceStatusUpdate(type, std::string(device_path));
   }
 
@@ skipping 65 matching lines @@
   virtual void MountPath(const char* source_path, MountType type,
                          const MountPathOptions& options) OVERRIDE {}
   virtual void UnmountPath(const char* mount_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:
+  virtual std::string FilePathToDevicePath(std::string file_path) OVERRIDE {
+    return "";
+  }
   // 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);