Extend the capability of SystemMonitor to support watching storage free space change

base/system_monitor/system_monitor.cc

Index: base/system_monitor/system_monitor.cc
diff --git a/base/system_monitor/system_monitor.cc b/base/system_monitor/system_monitor.cc
index f30c8935c9a999b38382f78e879c9319a4eba13f..019bbdd0d573f9906a35e98faebc94d10c05483e 100644
--- a/base/system_monitor/system_monitor.cc
+++ b/base/system_monitor/system_monitor.cc
@@ -39,7 +39,8 @@ SystemMonitor::SystemMonitor()
       devices_changed_observer_list_(
           new ObserverListThreadSafe<DevicesChangedObserver>()),
       battery_in_use_(false),
-      suspended_(false) {
+      suspended_(false),
+      free_space_delegate_(NULL) {
   DCHECK(!g_system_monitor);
   g_system_monitor = this;
 
@@ -121,6 +122,30 @@ void SystemMonitor::ProcessRemovableStorageDetached(const std::string& id) {
   NotifyRemovableStorageDetached(id);
 }
 
+void SystemMonitor::ProcessStorageFreeSpaceMessage(const FilePath& path,
+                                                   int64 available_capacity,
+                                                   bool error) {
+  scoped_refptr<StorageFreeSpaceObserverList> observers;
+  {
+    base::AutoLock lock(free_space_observers_lock_);
+    StorageFreeSpaceObserverListMap::iterator it =
+      free_space_observer_list_map_.find(path);
+    if (it == free_space_observer_list_map_.end())
+      return;
+    observers = it->second;
+  }
+  if (error)
+    NotifyStorageFreeSpaceChanged(observers, path, available_capacity);
+  else
+    NotifyStorageFreeSpaceWatchingError(observers, path);
+}
+
+void SystemMonitor::set_storage_free_space_delegate(
+    StorageFreeSpaceDelegate* delegate) {
+  DCHECK(free_space_delegate_ == NULL || delegate == NULL);
+  free_space_delegate_ = delegate;
+}
+
 std::vector<SystemMonitor::RemovableStorageInfo>
 SystemMonitor::GetAttachedRemovableStorage() const {
   std::vector<RemovableStorageInfo> results;
@@ -148,6 +173,66 @@ void SystemMonitor::RemoveDevicesChangedObserver(DevicesChangedObserver* obs) {
   devices_changed_observer_list_->RemoveObserver(obs);
 }
 
+void SystemMonitor::AddStorageFreeSpaceObserver(const FilePath& path,
+                                                StorageFreeSpaceObserver* obs) {
+  scoped_refptr<StorageFreeSpaceObserverList> observers;
+  {
+    base::AutoLock lock(free_space_observers_lock_);
+
+    // Try to start watching the given storage |path| if the first observer
+    // will be added.
+    if (!ContainsKey(free_space_observer_map_, path)) {
+      free_space_delegate_->StartWatchingStorage(path);

[vandebo (ex-Chrome), 2012/09/13 19:57:34]

Can you put this on line 191?

+    }
+
+    StorageFreeSpaceObserverListMap::iterator iter =
+        free_space_observer_list_map_.find(path);
+    if (iter == free_space_observer_list_map_.end()) {
+      observers = new StorageFreeSpaceObserverList;
+      free_space_observer_list_map_.insert(std::make_pair(path, observers));
+    } else {
+      observers = iter->second;
+    }
+
+    free_space_observer_map_.insert(std::make_pair(path, obs));
+  }
+  observers->AddObserver(obs);
+}
+
+void SystemMonitor::RemoveStorageFreeSpaceObserver(
+    const FilePath& path,
+    StorageFreeSpaceObserver* obs) {
+  scoped_refptr<StorageFreeSpaceObserverList> observers;
+  {
+    base::AutoLock lock(free_space_observers_lock_);
+    StorageFreeSpaceObserverListMap::iterator it =
+      free_space_observer_list_map_.find(path);
+    // In case of no observer is interested in the given storage |path|.
+    if (it == free_space_observer_list_map_.end()) {
+      DCHECK(free_space_observer_map_.find(path) ==

[vandebo (ex-Chrome), 2012/09/13 19:57:34]

This case shouldn't happen, right?

+             free_space_observer_map_.end());
+      return;
+    }
+
+    // Remove the (path, obs) pair from |free_space_observer_map_|.
+    std::pair<StorageFreeSpaceObserverMap::iterator,
+      StorageFreeSpaceObserverMap::iterator> range_pair =
+        free_space_observer_map_.equal_range(path);
+    StorageFreeSpaceObserverMap::iterator mit;
+    for (mit = range_pair.first; mit != range_pair.second; ++mit) {
+      if (mit->second == obs) break;
+    }
+    free_space_observer_map_.erase(mit);
+
+    // If the last observer is removed, stop watching the storage |path|.
+    if (!ContainsKey(free_space_observer_map_, path))
+      free_space_delegate_->StopWatchingStorage(path);
+
+    observers = it->second;
+  }
+  observers->RemoveObserver(obs);
+}
+
 void SystemMonitor::NotifyDevicesChanged(DeviceType device_type) {
   DVLOG(1) << "DevicesChanged with device type " << device_type;
   devices_changed_observer_list_->Notify(
@@ -187,6 +272,26 @@ void SystemMonitor::NotifyResume() {
   power_observer_list_->Notify(&PowerObserver::OnResume);
 }
 
+void SystemMonitor::NotifyStorageFreeSpaceChanged(
+    scoped_refptr<StorageFreeSpaceObserverList> observers,
+    const FilePath& path,
+    int64 available_capacity) {
+  DVLOG(1) << "Free Space Change: " << path.value() << " "
+           << available_capacity << " bytes";
+  if (observers.get())
+    observers->Notify(&StorageFreeSpaceObserver::OnFreeSpaceChanged,
+        path, available_capacity);
+}
+
+void SystemMonitor::NotifyStorageFreeSpaceWatchingError(
+    scoped_refptr<StorageFreeSpaceObserverList> observers,
+    const FilePath& path) {
+  DVLOG(1) << "Failed to watch free space change for " << path.value();
+  if (observers.get())
+    observers->Notify(&StorageFreeSpaceObserver::OnFreeSpaceWatchingError,
+                      path);
+}
+
 void SystemMonitor::BatteryCheck() {
   ProcessPowerMessage(SystemMonitor::POWER_STATE_EVENT);
 }