chromeos: Add dbus MTPDClient.

chromeos/dbus/cros_disks_client.h

 // Copyright (c) 2012 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 CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
 #define CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 53 matching lines @@
   FORMATTING_FINISHED,
 };
 
 // A class to represent information about a disk sent from cros-disks.
 class DiskInfo {
  public:
   DiskInfo(const std::string& device_path, dbus::Response* response);
   ~DiskInfo();
 
   // Device path. (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
-  std::string device_path() const { return device_path_; }
+  const std::string& device_path() const { return device_path_; }
 
   // Disk mount path. (e.g. /media/removable/VOLUME)
-  std::string mount_path() const { return mount_path_; }
+  const std::string& mount_path() const { return mount_path_; }
 
   // Disk system path given by udev.
   // (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
-  std::string system_path() const { return system_path_; }
+  const std::string& system_path() const { return system_path_; }
 
   // Is a drive or not. (i.e. true with /dev/sdb, false with /dev/sdb1)
   bool is_drive() const { return is_drive_; }
 
   // Does the disk have media content.
   bool has_media() const { return has_media_; }
 
   // Is the disk on deveice we booted the machine from.
   bool on_boot_device() const { return on_boot_device_; }
 
   // Disk file path (e.g. /dev/sdb).
-  std::string file_path() const { return file_path_; }
+  const std::string& file_path() const { return file_path_; }
 
   // Disk label.
-  std::string label() const { return label_; }
+  const std::string& label() const { return label_; }
 
   // Disk model. (e.g. "TransMemory")
-  std::string drive_label() const { return drive_model_; }
+  const std::string& drive_label() const { return drive_model_; }
 
   // Device type. Not working well, yet.
   DeviceType device_type() const { return device_type_; }
 
   // Total size of the disk in bytes.
   uint64 total_size_in_bytes() const { return total_size_in_bytes_; }
 
   // Is the device read-only.
   bool is_read_only() const { return is_read_only_; }
 
   // Returns true if the device should be hidden from the file browser.
   bool is_hidden() const { return is_hidden_; }
 
   // Returns file system uuid.
-  std::string uuid() const { return uuid_; }
+  const std::string& uuid() const { return uuid_; }
 
  private:
   void InitializeFromResponse(dbus::Response* response);
 
   std::string device_path_;
   std::string mount_path_;
   std::string system_path_;
   bool is_drive_;
   bool has_media_;
   bool on_boot_device_;
@@ skipping 14 matching lines @@
 class CHROMEOS_EXPORT CrosDisksClient {
  public:
   // A callback to be called when DBus method call fails.
   typedef base::Callback<void()> ErrorCallback;
 
   // A callback to handle the result of Mount.
   typedef base::Callback<void()> MountCallback;
 
   // A callback to handle the result of Unmount.
   // The argument is the device path.
-  typedef base::Callback<void(const std::string&)> UnmountCallback;
+  typedef base::Callback<void(const std::string& device_path)> UnmountCallback;
 
   // A callback to handle the result of EnumerateAutoMountableDevices.
   // The argument is the enumerated device paths.
-  typedef base::Callback<void(const std::vector<std::string>&)
+  typedef base::Callback<void(const std::vector<std::string>& device_paths)
                          > EnumerateAutoMountableDevicesCallback;
 
   // A callback to handle the result of FormatDevice.
   // The first argument is the device path.
   // The second argument is true when formatting succeeded, false otherwise.
-  typedef base::Callback<void(const std::string&, bool)> FormatDeviceCallback;
+  typedef base::Callback<void(const std::string& device_path,
+                              bool format_succeeded)> FormatDeviceCallback;
 
   // A callback to handle the result of GetDeviceProperties.
   // The argument is the information about the specified device.
-  typedef base::Callback<void(const DiskInfo&)> GetDevicePropertiesCallback;
+  typedef base::Callback<void(const DiskInfo& disk_info)
+                         > GetDevicePropertiesCallback;
 
   // A callback to handle MountCompleted signal.
   // The first argument is the error code.
   // The second argument is the source path.
   // The third argument is the mount type.
   // The fourth argument is the mount path.
-  typedef base::Callback<void(MountError, const std::string&, MountType,
-                              const std::string&)> MountCompletedHandler;
+  typedef base::Callback<void(MountError error_code,
+                              const std::string& source_path,
+                              MountType mount_type,
+                              const std::string& mount_path)
+                         > MountCompletedHandler;
 
   // A callback to handle mount events.
   // The first argument is the event type.
   // The second argument is the device path.
-  typedef base::Callback<void(MountEventType, const std::string&)
+  typedef base::Callback<void(MountEventType event_type,
+                              const std::string& device_path)
                          > MountEventHandler;
 
   virtual ~CrosDisksClient();
 
   // Calls Mount method.  |callback| is called after the method call succeeds,
   // otherwise, |error_callback| is called.
   // When mounting an archive, caller may set two optional arguments:
   // - The |source_format| argument passes the file extension (with the leading
   //   dot, for example ".zip"). If |source_format| is empty then the source
   //   format is auto-detected.
@@ skipping 48 matching lines @@
   // Create() should be used instead.
   CrosDisksClient();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CrosDisksClient);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_CROS_DISKS_CLIENT_H_