Move chromeos_mount.cc from libcros to Chrome tree

chrome/browser/chromeos/dbus/cros_disks_client.h

 // 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.
 
-#ifndef CHROME_BROWSER_CHROMEOS_CROS_MOUNT_LIBRARY_H_
-#define CHROME_BROWSER_CHROMEOS_CROS_MOUNT_LIBRARY_H_
+#ifndef CHROME_BROWSER_CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
+#define CHROME_BROWSER_CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
 #pragma once
 
 #include <map>
 #include <string>
+#include <vector>
 
-#include "base/memory/singleton.h"
-#include "base/observer_list.h"
-#include "base/time.h"
-#include "third_party/cros/chromeos_mount.h"
+#include "base/basictypes.h"
+
+namespace dbus {
+class Bus;
+}
 
 namespace chromeos {
 
-typedef enum MountLibraryEventType {
+enum MountType {
+  MOUNT_TYPE_INVALID,
+  MOUNT_TYPE_DEVICE,
+  MOUNT_TYPE_ARCHIVE,
+  MOUNT_TYPE_NETWORK_STORAGE
+};
+
+enum DeviceType {
+  FLASH,
+  HDD,
+  OPTICAL,
+  UNDEFINED
+};
+
+enum MountError {
+  MOUNT_ERROR_NONE = 0,
+  MOUNT_ERROR_UNKNOWN = 1,
+  MOUNT_ERROR_INTERNAL = 2,
+  MOUNT_ERROR_UNKNOWN_FILESYSTEM = 101,
+  MOUNT_ERROR_UNSUPORTED_FILESYSTEM = 102,
+  MOUNT_ERROR_INVALID_ARCHIVE = 201,
+  MOUNT_ERROR_LIBRARY_NOT_LOADED = 501,
+  MOUNT_ERROR_PATH_UNMOUNTED = 901
+  // TODO(tbarzic): Add more error codes as they get added to cros-disks and
+  // consider doing explicit translation from cros-disks error_types.
+};
+
+typedef std::vector<std::pair<std::string, std::string> > MountPathOptions;
+
+enum CrosDisksClientEventType {
   MOUNT_DISK_ADDED,
   MOUNT_DISK_REMOVED,
   MOUNT_DISK_CHANGED,
   MOUNT_DISK_MOUNTED,
   MOUNT_DISK_UNMOUNTED,
   MOUNT_DEVICE_ADDED,
   MOUNT_DEVICE_REMOVED,
   MOUNT_DEVICE_SCANNED,
   MOUNT_FORMATTING_STARTED,
   MOUNT_FORMATTING_FINISHED
-} MountLibraryEventType;
+};
 
-typedef enum MountCondition {
+enum MountCondition {
   MOUNT_CONDITION_NONE,
   MOUNT_CONDITION_UNKNOWN_FILESYSTEM,
   MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM
-} MountCondition;
-
-class MountLibcrosProxy {
- public:
-  virtual ~MountLibcrosProxy() {}
-  virtual void CallMountPath(const char* source_path,
-                             MountType type,
-                             const MountPathOptions& options,
-                             MountCompletedMonitor callback,
-                             void* object) = 0;
-  virtual void CallUnmountPath(const char* path,
-                               UnmountRequestCallback callback,
-                               void* object) = 0;
-  virtual void CallRequestMountInfo(RequestMountInfoCallback callback,
-                                    void* object) = 0;
-  virtual void CallFormatDevice(const char* device_path,
-                                const char* filesystem,
-                                FormatRequestCallback callback,
-                                void* object) = 0;
-  virtual void CallGetDiskProperties(const char* device_path,
-                                     GetDiskPropertiesCallback callback,
-                                     void* object) = 0;
-  virtual MountEventConnection MonitorCrosDisks(MountEventMonitor monitor,
-      MountCompletedMonitor mount_complete_monitor,
-      void* object) = 0;
-  virtual void DisconnectCrosDisksMonitorIfSet(MountEventConnection connection)
-      = 0;
 };
 
-// This class handles the interaction with the ChromeOS mount library APIs.
-// Classes can add themselves as observers. Users can get an instance of this
-// library class like this: chromeos::CrosLibrary::Get()->GetMountLibrary()
-class MountLibrary {
+// This class handles the interaction with cros-disks.
+// Classes can add themselves as observers.
+class CrosDisksClient {
  public:
   enum MountEvent {
     MOUNTING,
     UNMOUNTING
   };
   // Used to house an instance of each found mount device.
   class Disk {
    public:
     Disk(const std::string& device_path,
          const std::string& mount_path,
          const std::string& system_path,
          const std::string& file_path,
          const std::string& device_label,
          const std::string& drive_label,
          const std::string& parent_path,
          const std::string& system_path_prefix,
          DeviceType device_type,
          uint64 total_size,
          bool is_parent,
          bool is_read_only,
          bool has_media,
          bool on_boot_device,
          bool is_hidden);

[satorux1, 2011/11/07 23:21:55]

Wow, 15 parameters including 5 booleans. I know it's inheriting from the
original code, but you might want to clean them up in a separate patch. I'd do
something like 

 uint64 total_size,
 // The options are OR'ed values of DiskOptions below.
 int options);

enum DiskOptions {
  IS_PARENT = 1 << 0;
  IS_READ_ONLY = 1 << 1;
  HAS_MEDIA = 1 << 2;
  ...
};

You can instead five separate enum types for them.

See also:

http://www.chromium.org/developers/coding-style

Begin to prefer enumerated values (e.g. "DELETE_AFTER_USE/KEEP_ALIVE_AFTER_USE")
to booleans ("bool delete_after_use") as function arguments 

[hashimoto, 2011/11/08 07:31:05]

Sounds good.

     ~Disk();
 
     // The path of the device, used by devicekit-disks.
     const std::string& device_path() const { return device_path_; }
     // The path to the mount point of this device. Will be empty if not mounted.
     const std::string&  mount_path() const { return mount_path_; }
     // The path of the device according to the udev system.
     const std::string& system_path() const { return system_path_; }
     // The path of the device according to filesystem.
     const std::string& file_path() const { return file_path_; }
@@ skipping 15 matching lines @@
     bool is_parent() const { return is_parent_; }
     // Is the device read only.
     bool is_read_only() const { return is_read_only_; }
     // Does the device contains media.
     bool has_media() const { return has_media_; }
     // Is the device on the boot device.
     bool on_boot_device() const { return on_boot_device_; }
     // Shoud the device be shown in the UI, or automounted.
     bool is_hidden() const { return is_hidden_; }
 
-    void set_mount_path(const char* mount_path) { mount_path_ = mount_path; }
+    void set_mount_path(const std::string& mount_path) {
+      mount_path_ = mount_path;
+    }
     void clear_mount_path() { mount_path_.clear(); }
 
    private:
     std::string device_path_;
     std::string mount_path_;
     std::string system_path_;
     std::string file_path_;
     std::string device_label_;
     std::string drive_label_;
     std::string parent_path_;
     std::string system_path_prefix_;
     DeviceType device_type_;
     uint64 total_size_;
     bool is_parent_;
     bool is_read_only_;
     bool has_media_;
     bool on_boot_device_;
     bool is_hidden_;
   };
   typedef std::map<std::string, Disk*> DiskMap;
   typedef std::map<std::string, std::string> PathMap;
 
   struct MountPointInfo {
     std::string source_path;
     std::string mount_path;
     MountType mount_type;
     MountCondition mount_condition;
 
-    MountPointInfo(const char* source, const char* mount, const MountType type,
-        MountCondition condition)
-        : source_path(source ? source : ""),
-          mount_path(mount ? mount : ""),
+    MountPointInfo(const std::string& source, const std::string& mount,
+                   const MountType type, MountCondition condition)
+        : source_path(source),
+          mount_path(mount),
           mount_type(type),
           mount_condition(condition) {
     }
   };
 
   // MountPointMap key is mount_path.
   typedef std::map<std::string, MountPointInfo> MountPointMap;
 
   typedef void(*UnmountDeviceRecursiveCallbackType)(void*, bool);
 
   class Observer {
    public:
     virtual ~Observer() {}
     // Async API events.
-    virtual void DiskChanged(MountLibraryEventType event,
+    virtual void DiskChanged(CrosDisksClientEventType event,
                              const Disk* disk) = 0;
-    virtual void DeviceChanged(MountLibraryEventType event,
+    virtual void DeviceChanged(CrosDisksClientEventType event,
                                const std::string& device_path) = 0;
     virtual void MountCompleted(MountEvent event_type,
                                 MountError error_code,
                                 const MountPointInfo& mount_info) = 0;
   };
 
-  virtual ~MountLibrary() {}
-  virtual void Init() = 0;
+  virtual ~CrosDisksClient() {}
   virtual void AddObserver(Observer* observer) = 0;
   virtual void RemoveObserver(Observer* observer) = 0;
   virtual const DiskMap& disks() const = 0;
   virtual const MountPointMap& mount_points() const = 0;
 
   virtual void RequestMountInfoRefresh() = 0;
-  virtual void MountPath(const char* source_path,
+  virtual void MountPath(const std::string& source_path,
                          MountType type,
                          const MountPathOptions& options) = 0;
   // |path| is device's mount path.
-  virtual void UnmountPath(const char* path) = 0;
+  virtual void UnmountPath(const std::string& path) = 0;
 
   // Retrieves total and remaining available size on |mount_path|.
-  virtual void GetSizeStatsOnFileThread(const char* mount_path,
+  virtual void GetSizeStatsOnFileThread(const std::string& mount_path,
                                         size_t* total_size_kb,
                                         size_t* remaining_size_kb) = 0;
 
   // Formats device given its file path.
   // Example: file_path: /dev/sdb1
-  virtual void FormatUnmountedDevice(const char* file_path) = 0;
+  virtual void FormatUnmountedDevice(const std::string& file_path) = 0;
 
   // Formats Device given its mount path. Unmount's the device
   // Example: mount_path: /media/VOLUME_LABEL
-  virtual void FormatMountedDevice(const char* mount_path) = 0;
+  virtual void FormatMountedDevice(const std::string& mount_path) = 0;
 
   // Unmounts device_poath and all of its known children.
-  virtual void UnmountDeviceRecursive(const char* device_path,
+  virtual void UnmountDeviceRecursive(const std::string& device_path,
       UnmountDeviceRecursiveCallbackType callback, void* user_data) = 0;
 
   // Helper functions for parameter conversions.
   static std::string MountTypeToString(MountType type);
   static MountType MountTypeFromString(const std::string& type_str);
   static std::string MountConditionToString(MountCondition type);

[satorux1, 2011/11/07 23:21:55]

Do we need to expose these methods? Otherwise, you might want to put them in
anonymous namespace in  the.cc file.

[hashimoto, 2011/11/08 07:31:05]

They are used by extension_file_browser_private_api.cc and
file_browser_event_router.cc

 
-  // Used in testing. Enables mocking libcros.
-  virtual void SetLibcrosProxy(MountLibcrosProxy* proxy) {}
-
   // Factory function, creates a new instance and returns ownership.
-  // For normal usage, access the singleton via CrosLibrary::Get().
-  static MountLibrary* GetImpl(bool stub);
+  // For normal usage, access the singleton via DBusThreadManager::Get().
+  static CrosDisksClient* Create(dbus::Bus* bus);
 };
 
 }  // namespace chromeos
 
-#endif  // CHROME_BROWSER_CHROMEOS_CROS_MOUNT_LIBRARY_H_
+#endif  // CHROME_BROWSER_CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_