Add a method in DiskMountManager to refresh mount entries in addition to devices.

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"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 namespace chromeos {
 namespace disks {
 
 namespace {
 
 const char kDeviceNotFound[] = "Device could not be found";
 
 DiskMountManager* g_disk_mount_manager = NULL;
 
 // The DiskMountManager implementation.
 class DiskMountManagerImpl : public DiskMountManager {
  public:
-  DiskMountManagerImpl() : weak_ptr_factory_(this) {
+  DiskMountManagerImpl() :
+    already_refreshed_(false),
+    weak_ptr_factory_(this) {
     DBusThreadManager* dbus_thread_manager = DBusThreadManager::Get();
     DCHECK(dbus_thread_manager);
     cros_disks_client_ = dbus_thread_manager->GetCrosDisksClient();
     DCHECK(cros_disks_client_);
     cros_disks_client_->SetMountEventHandler(
         base::Bind(&DiskMountManagerImpl::OnMountEvent,
                    weak_ptr_factory_.GetWeakPtr()));
     cros_disks_client_->SetMountCompletedHandler(
         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 108 matching lines @@
         callback.Run(false);
         return;
       }
 
       // Nothing to unmount.
       callback.Run(true);
       return;
     }
 
     // We will send the same callback data object to all Unmount calls and use
-    // it to syncronize callbacks.
+    // it to synchronize callbacks.
     // Note: this implementation has a potential memory leak issue. For
     // example if this instance is destructed before all the callbacks for
     // Unmount are invoked, the memory pointed by |cb_data| will be leaked.
     // It is because the UnmountDeviceRecursivelyCallbackData keeps how
     // many times OnUnmountDeviceRecursively callback is called and when
     // all the callbacks are called, |cb_data| will be deleted in the method.
     // However destructing the instance before all callback invocations will
     // cancel all pending callbacks, so that the |cb_data| would never be
     // deleted.
     // Fortunately, in the real scenario, the instance will be destructed
@@ skipping 13 matching lines @@
                      devices_to_unmount[i]),
           base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursively,
                      weak_ptr_factory_.GetWeakPtr(),
                      cb_data,
                      false,
                      devices_to_unmount[i]));
     }
   }
 
   // DiskMountManager override.
-  virtual void RequestMountInfoRefresh() OVERRIDE {
-    cros_disks_client_->EnumerateAutoMountableDevices(
-        base::Bind(&DiskMountManagerImpl::OnRequestMountInfo,
-                   weak_ptr_factory_.GetWeakPtr()),
-        base::Bind(&base::DoNothing));
+  virtual void EnsureMountInfoRefreshed(
+      const EnsureMountInfoRefreshedCallback& callback) OVERRIDE {
+    if (already_refreshed_) {
+      callback.Run(true);
+      return;
+    }
+
+    refresh_callbacks_.push_back(callback);
+    if (refresh_callbacks_.size() == 1) {
+      // If there's no in-flight refreshing task, start it.
+      cros_disks_client_->EnumerateAutoMountableDevices(
+          base::Bind(&DiskMountManagerImpl::RefreshAfterEnumerateDevices,
+                     weak_ptr_factory_.GetWeakPtr()),
+          base::Bind(&DiskMountManagerImpl::RefreshCompleted,
+                     weak_ptr_factory_.GetWeakPtr(), false));
+    }
   }
 
   // DiskMountManager override.
   virtual const DiskMap& disks() const OVERRIDE { return disks_; }
 
   // DiskMountManager override.
   virtual const Disk* FindDiskBySourcePath(const std::string& source_path)
       const OVERRIDE {
     DiskMap::const_iterator disk_it = disks_.find(source_path);
     return disk_it == disks_.end() ? NULL : disk_it->second;
@@ skipping 200 matching lines @@
   void OnFormatStarted(const std::string& device_path) {
     NotifyFormatStatusUpdate(FORMAT_STARTED, FORMAT_ERROR_NONE, device_path);
   }
 
   // Callback to handle FormatCompleted signal and Format method call failure.
   void OnFormatCompleted(FormatError error_code,
                          const std::string& device_path) {
     NotifyFormatStatusUpdate(FORMAT_COMPLETED, error_code, device_path);
   }
 
-  // Callbcak for GetDeviceProperties.
+  // Callback for GetDeviceProperties.
   void OnGetDeviceProperties(const DiskInfo& disk_info) {
     // 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.
     if (disk_info.on_boot_device())
       return;
 
     LOG(WARNING) << "Found disk " << disk_info.device_path();
     // Delete previous disk info for this path:
     bool is_new = true;
@@ skipping 19 matching lines @@
                           disk_info.total_size_in_bytes(),
                           disk_info.is_drive(),
                           disk_info.is_read_only(),
                           disk_info.has_media(),
                           disk_info.on_boot_device(),
                           disk_info.is_hidden());
     disks_.insert(std::make_pair(disk_info.device_path(), disk));
     NotifyDiskStatusUpdate(is_new ? DISK_ADDED : DISK_CHANGED, disk);
   }
 
-  // Callbcak for RequestMountInfo.
-  void OnRequestMountInfo(const std::vector<std::string>& devices) {
-    std::set<std::string> current_device_set;
-    if (!devices.empty()) {
-      // Initiate properties fetch for all removable disks,
-      for (size_t i = 0; i < devices.size(); i++) {
-        current_device_set.insert(devices[i]);
-        // Initiate disk property retrieval for each relevant device path.
-        cros_disks_client_->GetDeviceProperties(
-            devices[i],
-            base::Bind(&DiskMountManagerImpl::OnGetDeviceProperties,
-                       weak_ptr_factory_.GetWeakPtr()),
-            base::Bind(&base::DoNothing));
-      }
-    }
-    // Search and remove disks that are no longer present.
+  // Part of EnsureMountInfoRefreshed(). Called after the list of devices are
+  // enumerated.
+  void RefreshAfterEnumerateDevices(const std::vector<std::string>& devices) {
+    std::set<std::string> current_device_set(devices.begin(), devices.end());
     for (DiskMap::iterator iter = disks_.begin(); iter != disks_.end(); ) {
       if (current_device_set.find(iter->first) == current_device_set.end()) {
-        Disk* disk = iter->second;
-        NotifyDiskStatusUpdate(DISK_REMOVED, disk);
         delete iter->second;
         disks_.erase(iter++);
       } else {
         ++iter;
       }
     }
+    RefreshDeviceAtIndex(devices, 0);
+  }
+
+  // Part of EnsureMountInfoRefreshed(). Called for each device to refresh info.
+  void RefreshDeviceAtIndex(const std::vector<std::string>& devices,
+                            size_t index) {
+    if (index == devices.size()) {
+      // All devices info retrieved. Proceed to enumerate mount point info.
+      cros_disks_client_->EnumerateMountEntries(
+          base::Bind(&DiskMountManagerImpl::RefreshAfterEnumerateMountEntries,
+                     weak_ptr_factory_.GetWeakPtr()),
+          base::Bind(&DiskMountManagerImpl::RefreshCompleted,
+                     weak_ptr_factory_.GetWeakPtr(), false));
+      return;
+    }
+
+    cros_disks_client_->GetDeviceProperties(
+        devices[index],
+        base::Bind(&DiskMountManagerImpl::RefreshAfterGetDeviceProperties,
+                   weak_ptr_factory_.GetWeakPtr(), devices, index + 1),
+        base::Bind(&DiskMountManagerImpl::RefreshCompleted,
+                   weak_ptr_factory_.GetWeakPtr(), false));
+  }
+
+  // Part of EnsureMountInfoRefreshed().
+  void RefreshAfterGetDeviceProperties(const std::vector<std::string>& devices,
+                                       size_t next_index,
+                                       const DiskInfo& disk_info) {
+    OnGetDeviceProperties(disk_info);
+    RefreshDeviceAtIndex(devices, next_index);
+  }
+
+  // Part of EnsureMountInfoRefreshed(). Called after mount entries are listed.
+  void RefreshAfterEnumerateMountEntries(
+      const std::vector<MountEntry>& entries) {
+    for (size_t i = 0; i < entries.size(); ++i)
+      OnMountCompleted(entries[i]);
+    RefreshCompleted(true);
+  }
+
+  // Part of EnsureMountInfoRefreshed(). Called when the refreshing is done.
+  void RefreshCompleted(bool success) {
+    already_refreshed_ = true;
+    for (size_t i = 0; i < refresh_callbacks_.size(); ++i)
+      refresh_callbacks_[i].Run(success);
+    refresh_callbacks_.clear();
   }
 
   // Callback to handle mount event signals.
   void OnMountEvent(MountEventType event, const std::string& device_path_arg) {
     // Take a copy of the argument so we can modify it below.
     std::string device_path = device_path_arg;
     switch (event) {
       case CROS_DISKS_DISK_ADDED: {
         cros_disks_client_->GetDeviceProperties(
             device_path,
@@ skipping 80 matching lines @@
   CrosDisksClient* cros_disks_client_;
 
   // The list of disks found.
   DiskMountManager::DiskMap disks_;
 
   DiskMountManager::MountPointMap mount_points_;
 
   typedef std::set<std::string> SystemPathPrefixSet;
   SystemPathPrefixSet system_path_prefixes_;
 
+  bool already_refreshed_;
+  std::vector<EnsureMountInfoRefreshedCallback> refresh_callbacks_;
+
   base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DiskMountManagerImpl);
 };
 
 }  // namespace
 
 DiskMountManager::Disk::Disk(const std::string& device_path,
                              const std::string& mount_path,
                              const std::string& system_path,
@@ skipping 107 matching lines @@
   VLOG(1) << "DiskMountManager Shutdown completed";
 }
 
 // static
 DiskMountManager* DiskMountManager::GetInstance() {
   return g_disk_mount_manager;
 }
 
 }  // namespace disks
 }  // namespace chromeos