Add EnumerateMountEntries method in CrosDisksClient.

chromeos/disks/disk_mount_manager.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/disks/disk_mount_manager.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 47 matching lines @@
 
   // DiskMountManager override.
   virtual void MountPath(const std::string& source_path,
                          const std::string& source_format,
                          const std::string& mount_label,
                          MountType type) OVERRIDE {
     // Hidden and non-existent devices should not be mounted.
     if (type == MOUNT_TYPE_DEVICE) {
       DiskMap::const_iterator it = disks_.find(source_path);
       if (it == disks_.end() || it->second->is_hidden()) {
-        OnMountCompleted(MOUNT_ERROR_INTERNAL, source_path, type, "");
+        OnMountCompleted(MountEntry(MOUNT_ERROR_INTERNAL, source_path, type,
+                                    ""));
         return;
       }
     }
     cros_disks_client_->Mount(
         source_path,
         source_format,
         mount_label,
         // When succeeds, OnMountCompleted will be called by
         // "MountCompleted" signal instead.
         base::Bind(&base::DoNothing),
         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr(),
-                   MOUNT_ERROR_INTERNAL,
-                   source_path,
-                   type,
-                   ""));
+                   MountEntry(MOUNT_ERROR_INTERNAL, source_path, type, "")));
   }
 
   // DiskMountManager override.
   virtual void UnmountPath(const std::string& mount_path,
                            UnmountOptions options,
                            const UnmountPathCallback& callback) OVERRIDE {
     UnmountChildMounts(mount_path);
     cros_disks_client_->Unmount(mount_path, options,
                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
                                            weak_ptr_factory_.GetWeakPtr(),
@@ skipping 198 matching lines @@
     if (cb_data->num_pending_callbacks == 0) {
       // This code has a problem that the |success| status used here is for the
       // last "unmount" callback, but not whether all unmounting is succeeded.
       // TODO(hidehiko): Fix the issue.
       cb_data->callback.Run(success);
       delete cb_data;
     }
   }
 
   // Callback to handle MountCompleted signal and Mount method call failure.
-  void OnMountCompleted(MountError error_code,
-                        const std::string& source_path,
-                        MountType mount_type,
-                        const std::string& mount_path) {
+  void OnMountCompleted(const MountEntry& entry) {
     MountCondition mount_condition = MOUNT_CONDITION_NONE;
-    if (mount_type == MOUNT_TYPE_DEVICE) {
-      if (error_code == MOUNT_ERROR_UNKNOWN_FILESYSTEM) {
+    if (entry.mount_type() == MOUNT_TYPE_DEVICE) {
+      if (entry.error_code() == MOUNT_ERROR_UNKNOWN_FILESYSTEM) {
         mount_condition = MOUNT_CONDITION_UNKNOWN_FILESYSTEM;
       }
-      if (error_code == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
+      if (entry.error_code() == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
         mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
       }
     }
-    const MountPointInfo mount_info(source_path, mount_path, mount_type,
+    const MountPointInfo mount_info(entry.source_path(),
+                                    entry.mount_path(),
+                                    entry.mount_type(),
                                     mount_condition);
 
-    NotifyMountStatusUpdate(MOUNTING, error_code, mount_info);
+    NotifyMountStatusUpdate(MOUNTING, entry.error_code(), mount_info);
 
     // If the device is corrupted but it's still possible to format it, it will
     // be fake mounted.
-    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
+    if ((entry.error_code() == MOUNT_ERROR_NONE ||
+         mount_info.mount_condition) &&
         mount_points_.find(mount_info.mount_path) == mount_points_.end()) {
       mount_points_.insert(MountPointMap::value_type(mount_info.mount_path,
                                                      mount_info));
     }
-    if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
+    if ((entry.error_code() == MOUNT_ERROR_NONE ||
+         mount_info.mount_condition) &&
         mount_info.mount_type == MOUNT_TYPE_DEVICE &&
         !mount_info.source_path.empty() &&
         !mount_info.mount_path.empty()) {
       DiskMap::iterator iter = disks_.find(mount_info.source_path);
       if (iter == disks_.end()) {
         // disk might have been removed by now?
         return;
       }
       Disk* disk = iter->second;
       DCHECK(disk);
@@ skipping 362 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos