Add EnumerateMountEntries method in CrosDisksClient.

chromeos/dbus/cros_disks_client.cc

 // 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.
 
 #include "chromeos/dbus/cros_disks_client.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 130 matching lines @@
                                  cros_disks::kEnumerateAutoMountableDevices);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&CrosDisksClientImpl::OnEnumerateAutoMountableDevices,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // CrosDisksClient override.
+  virtual void EnumerateMountEntries(
+      const EnumerateMountEntriesCallback& callback,
+      const base::Closure& error_callback) OVERRIDE {
+    dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
+                                 cros_disks::kEnumerateMountEntries);
+    proxy_->CallMethod(
+        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
+        base::Bind(&CrosDisksClientImpl::OnEnumerateMountEntries,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   callback,
+                   error_callback));
+  }
+
+  // CrosDisksClient override.
   virtual void Format(const std::string& device_path,
                       const std::string& filesystem,
                       const base::Closure& callback,
                       const base::Closure& error_callback) OVERRIDE {
     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
                                  cros_disks::kFormat);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(device_path);
     writer.AppendString(filesystem);
     // No format option is currently specified, but we can later use this
@@ skipping 96 matching lines @@
   void OnMount(const base::Closure& callback,
                const base::Closure& error_callback,
                dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
     callback.Run();
   }
 
-  // Handles the result of Unount and calls |callback| or |error_callback|.
+  // Handles the result of Unmount and calls |callback| or |error_callback|.
   void OnUnmount(const base::Closure& callback,
                  const base::Closure& error_callback,
                  dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
     // Temporarly allow Unmount method to report failure both by setting dbus
     // error (in which case response is not set) and by returning mount error
@@ skipping 27 matching lines @@
     dbus::MessageReader reader(response);
     std::vector<std::string> device_paths;
     if (!reader.PopArrayOfStrings(&device_paths)) {
       LOG(ERROR) << "Invalid response: " << response->ToString();
       error_callback.Run();
       return;
     }
     callback.Run(device_paths);
   }
 
+  // Handles the result of EnumerateMountEntries and calls |callback| or
+  // |error_callback|.
+  void OnEnumerateMountEntries(
+      const EnumerateMountEntriesCallback& callback,
+      const base::Closure& error_callback,
+      dbus::Response* response) {
+    if (!response) {
+      error_callback.Run();
+      return;
+    }
+
+    dbus::MessageReader reader(response);
+    dbus::MessageReader array_reader(NULL);
+    if (!reader.PopArray(&array_reader)) {
+      LOG(ERROR) << "Invalid response: " << response->ToString();
+      error_callback.Run();
+      return;
+    }
+
+    std::vector<MountEntry> entries;
+    while (array_reader.HasMoreData()) {
+      MountEntry entry;
+      dbus::MessageReader sub_reader(NULL);
+      if (!array_reader.PopStruct(&sub_reader) ||
+          !MountEntry::ReadFromDbus(&sub_reader, &entry)) {
+        LOG(ERROR) << "Invalid response: " << response->ToString();
+        error_callback.Run();
+        return;
+      }
+      entries.push_back(entry);
+    }
+    callback.Run(entries);
+  }
+
   // Handles the result of Format and calls |callback| or |error_callback|.
   void OnFormat(const base::Closure& callback,
                 const base::Closure& error_callback,
                 dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
     callback.Run();
   }
@@ skipping 21 matching lines @@
     if (!reader.PopString(&device)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
     handler.Run(event_type, device);
   }
 
   // Handles MountCompleted signal and calls |handler|.
   void OnMountCompleted(MountCompletedHandler handler, dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
-    uint32 error_code = 0;
-    std::string source_path;
-    uint32 mount_type = 0;
-    std::string mount_path;
-    if (!reader.PopUint32(&error_code) ||
-        !reader.PopString(&source_path) ||
-        !reader.PopUint32(&mount_type) ||
-        !reader.PopString(&mount_path)) {
+    MountEntry entry;
+    if (!MountEntry::ReadFromDbus(&reader, &entry)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
     }
-    handler.Run(static_cast<MountError>(error_code), source_path,
-                static_cast<MountType>(mount_type), mount_path);
+    handler.Run(entry);
   }
 
   // Handles FormatCompleted signal and calls |handler|.
   void OnFormatCompleted(FormatCompletedHandler handler, dbus::Signal* signal) {
     dbus::MessageReader reader(signal);
     uint32 error_code = 0;
     std::string device_path;
     if (!reader.PopUint32(&error_code) || !reader.PopString(&device_path)) {
       LOG(ERROR) << "Invalid signal: " << signal->ToString();
       return;
@@ skipping 82 matching lines @@
   }
 
   virtual void EnumerateAutoMountableDevices(
       const EnumerateAutoMountableDevicesCallback& callback,
       const base::Closure& error_callback) OVERRIDE {
     std::vector<std::string> device_paths;
     base::MessageLoopProxy::current()->PostTask(
         FROM_HERE, base::Bind(callback, device_paths));
   }
 
+  virtual void EnumerateMountEntries(
+      const EnumerateMountEntriesCallback& callback,
+      const base::Closure& error_callback) OVERRIDE {
+    std::vector<MountEntry> entries;
+    base::MessageLoopProxy::current()->PostTask(
+        FROM_HERE, base::Bind(callback, entries));
+  }
+
   virtual void Format(const std::string& device_path,
                       const std::string& filesystem,
                       const base::Closure& callback,
                       const base::Closure& error_callback) OVERRIDE {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
   }
 
   virtual void GetDeviceProperties(
       const std::string& device_path,
       const GetDevicePropertiesCallback& callback,
@@ skipping 67 matching lines @@
   void FinishMount(MountError error,
                    const std::string& source_path,
                    MountType type,
                    const std::string& mounted_path,
                    const base::Closure& callback) {
     base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback);
     if (!mount_completed_handler_.is_null()) {
       base::MessageLoopProxy::current()->PostTask(
           FROM_HERE,
           base::Bind(mount_completed_handler_,
-                     error, source_path, type, mounted_path));
+                     MountEntry(error, source_path, type, mounted_path)));
     }
   }
 
   // Mounted path to source path map.
   std::map<std::string, std::string> mounted_to_source_path_map_;
 
   MountEventHandler mount_event_handler_;
   MountCompletedHandler mount_completed_handler_;
   FormatCompletedHandler format_completed_handler_;
 
@@ skipping 163 matching lines @@
                                                 &media_type_double))
     device_type_ = DeviceMediaTypeToDeviceType(media_type_double);
 
   base::ListValue* mount_paths = NULL;
   if (properties->GetListWithoutPathExpansion(cros_disks::kDeviceMountPaths,
                                               &mount_paths))
     mount_paths->GetString(0, &mount_path_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// MountEntry
+
+MountEntry::MountEntry()
+    : error_code_(MOUNT_ERROR_UNKNOWN), mount_type_(MOUNT_TYPE_INVALID) {
+}
+
+MountEntry::MountEntry(MountError error_code,
+                       const std::string& source_path,
+                       MountType mount_type,
+                       const std::string& mount_path)
+    : error_code_(error_code),
+      source_path_(source_path),
+      mount_type_(mount_type),
+      mount_path_(mount_path) {
+}
+
+MountEntry::~MountEntry() {
+}
+
+// static
+bool MountEntry::ReadFromDbus(dbus::MessageReader* reader, MountEntry* entry) {

[stevenjb, 2014/05/14 17:45:11]

If this is only used in this file we can just make it a file local method in an
anonymous namespace, ReadMountEntryFromDbus.

[kinaba, 2014/05/15 02:14:59]

Done.

+  uint32 error_code = 0;
+  std::string source_path;
+  uint32 mount_type = 0;
+  std::string mount_path;
+  if (!reader->PopUint32(&error_code) ||
+      !reader->PopString(&source_path) ||
+      !reader->PopUint32(&mount_type) ||
+      !reader->PopString(&mount_path)) {
+    return false;
+  }
+  *entry = MountEntry(static_cast<MountError>(error_code), source_path,
+                      static_cast<MountType>(mount_type), mount_path);
+  return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // CrosDisksClient
 
 CrosDisksClient::CrosDisksClient() {}
 
 CrosDisksClient::~CrosDisksClient() {}
 
 // static
 CrosDisksClient* CrosDisksClient::Create(DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new CrosDisksClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new CrosDisksClientStubImpl();
 }
 
 // static
 base::FilePath CrosDisksClient::GetArchiveMountPoint() {
   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/archive") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/archive"));
 }
 
 // static
 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
                         FILE_PATH_LITERAL("/media/removable") :
                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 }
 
 }  // namespace chromeos