Revert 94812 - 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 119 matching lines @@
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!CrosLibrary::Get()->EnsureLoaded()) {
       OnUnmountPath(path,
                     MOUNT_METHOD_ERROR_LOCAL,
                     kLibraryNotLoaded);
       return;
     }
     UnmountMountPoint(path, &MountLibraryImpl::UnmountMountPointCallback, 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.");
-        return;
-      }
-    }
-    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();
-        break;
-      }
-    }
-    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 67 matching lines @@
   // Callback for UnmountRemovableDevice method.
   static void UnmountMountPointCallback(void* object,
                                         const char* device_path,
                                         MountMethodErrorType error,
                                         const char* error_message) {
     DCHECK(object);
     MountLibraryImpl* self = static_cast<MountLibraryImpl*>(object);
     self->OnUnmountPath(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,
                                              MountMethodErrorType error,
                                              const char* error_message) {
     DCHECK(object);
     UnmountDeviceRecursiveCallbackData* cb_data =
         static_cast<UnmountDeviceRecursiveCallbackData*>(object);
 
     // Do standard processing for Unmount event.
     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--;
 
     if (cb_data->pending_callbacks_count == 0) {
       cb_data->callback(cb_data->user_data, cb_data->success);
       delete cb_data;
     }
   }
@@ skipping 89 matching lines @@
       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);
-      // Check if there is a formatting scheduled
-      PathMap::iterator it = formatting_pending_.find(source_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 "
                    << source_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;
-      }
       default: {
         return;
       }
     }
     FireDeviceStatusUpdate(type, std::string(device_path));
   }
 
   void Init() {
     // Getting the monitor status so that the daemon starts up.
     mount_status_connection_ = MonitorAllMountEvents(
@@ skipping 31 matching lines @@
   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_;
-  // 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 const MountPointMap& mount_points() const OVERRIDE {
     return mount_points_;
   }
   virtual void RequestMountInfoRefresh() OVERRIDE {}
   virtual void MountPath(const char* source_path, MountType type,
                          const MountPathOptions& options) OVERRIDE {}
   virtual void UnmountPath(const char* 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_;
   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);