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

base/system_monitor/system_monitor.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 "base/system_monitor/system_monitor.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 16 matching lines @@
 
 SystemMonitor::RemovableStorageInfo::RemovableStorageInfo(
     const std::string& id,
     const string16& device_name,
     const FilePath::StringType& device_location)
     : device_id(id),
       name(device_name),
       location(device_location) {
 }
 
-SystemMonitor::SystemMonitor()
+SystemMonitor::SystemMonitor(StorageFreeSpaceDelegate* delegate)
     : power_observer_list_(new ObserverListThreadSafe<PowerObserver>()),
       devices_changed_observer_list_(
           new ObserverListThreadSafe<DevicesChangedObserver>()),
       battery_in_use_(false),
-      suspended_(false) {
+      suspended_(false),
+      free_space_delegate_(delegate) {
   DCHECK(!g_system_monitor);
   g_system_monitor = this;
 
   DCHECK(MessageLoop::current());
 #if defined(ENABLE_BATTERY_MONITORING)
   delayed_battery_check_.Start(FROM_HERE,
       base::TimeDelta::FromMilliseconds(kDelayedBatteryCheckMs), this,
       &SystemMonitor::BatteryCheck);
 #endif  // defined(ENABLE_BATTERY_MONITORING)
 #if defined(OS_MACOSX)
@@ skipping 67 matching lines @@
   {
     base::AutoLock lock(removable_storage_lock_);
     RemovableStorageMap::iterator it = removable_storage_map_.find(id);
     if (it == removable_storage_map_.end())
       return;
     removable_storage_map_.erase(it);
   }
   NotifyRemovableStorageDetached(id);
 }
 
+void SystemMonitor::ProcessStorageFreeSpaceChanged(const FilePath& path,
+                                                   int64 available_capacity) {
+  DVLOG(1) << "Free Space Change: " << path.value() << " "
+           << available_capacity << " bytes";
+  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.observer_list;
+  }
+  if (observers.get())
+    observers->Notify(&StorageFreeSpaceObserver::OnFreeSpaceChanged,
+        path, available_capacity);
+}
+
+void SystemMonitor::ProcessStorageFreeSpaceChangeError(const FilePath& path) {
+  DVLOG(1) << "Failed to watch free space change for " << path.value();
+  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.observer_list;
+  }
+  if (observers.get())
+    observers->Notify(&StorageFreeSpaceObserver::OnFreeSpaceChangeError,
+                      path);
+}
+
 std::vector<SystemMonitor::RemovableStorageInfo>
 SystemMonitor::GetAttachedRemovableStorage() const {
   std::vector<RemovableStorageInfo> results;
 
   base::AutoLock lock(removable_storage_lock_);
   for (RemovableStorageMap::const_iterator it = removable_storage_map_.begin();
        it != removable_storage_map_.end();
        ++it) {
     results.push_back(it->second);
   }
   return results;
 }
 
 void SystemMonitor::AddPowerObserver(PowerObserver* obs) {
   power_observer_list_->AddObserver(obs);
 }
 
 void SystemMonitor::RemovePowerObserver(PowerObserver* obs) {
   power_observer_list_->RemoveObserver(obs);
 }
 
 void SystemMonitor::AddDevicesChangedObserver(DevicesChangedObserver* obs) {
   devices_changed_observer_list_->AddObserver(obs);
 }
 
 void SystemMonitor::RemoveDevicesChangedObserver(DevicesChangedObserver* obs) {
   devices_changed_observer_list_->RemoveObserver(obs);
 }
 
+void SystemMonitor::AddStorageFreeSpaceObserver(const FilePath& path,
+                                                StorageFreeSpaceObserver* obs) {
+  DCHECK(free_space_delegate_ != NULL);
+  if (!free_space_delegate_)
+    return;
+  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.
+    StorageFreeSpaceObserverListMap::iterator iter =
+        free_space_observer_list_map_.find(path);
+    if (iter == free_space_observer_list_map_.end()) {
+      PathObserverPair pair;
+      pair.observer_list = observers = new StorageFreeSpaceObserverList;
+      pair.observer_set.insert(obs);
+      free_space_observer_list_map_.insert(std::make_pair(path, pair));
+      free_space_delegate_->StartWatchingStorage(path);
+    } else {
+      observers = iter->second.observer_list;
+      iter->second.observer_set.insert(obs);
+    }
+  }
+  observers->AddObserver(obs);
+}
+
+void SystemMonitor::RemoveStorageFreeSpaceObserver(
+    const FilePath& path,
+    StorageFreeSpaceObserver* obs) {
+  DCHECK(free_space_delegate_ != NULL);
+  if (!free_space_delegate_)
+    return;
+  scoped_refptr<StorageFreeSpaceObserverList> observers;
+  {
+    base::AutoLock lock(free_space_observers_lock_);
+    StorageFreeSpaceObserverListMap::iterator iter =
+      free_space_observer_list_map_.find(path);
+    // In case of no observer is interested in the given storage |path|.
+    if (iter == free_space_observer_list_map_.end()) {
+      return;
+    }
+
+    StorageFreeSpaceObserverSet::iterator sit
+        = iter->second.observer_set.find(obs);
+    // No the given observer is found.
+    if (sit == iter->second.observer_set.end())
+      return;
+    iter->second.observer_set.erase(sit);
+    // Try to stop watching in case of the last observer is removed.
+    if (iter->second.observer_set.size() == 0) {
+      free_space_delegate_->StopWatchingStorage(path);
+      free_space_observer_list_map_.erase(path);
+      return;
+    }
+    observers = iter->second.observer_list;
+  }
+  observers->RemoveObserver(obs);
+}
+
 void SystemMonitor::NotifyDevicesChanged(DeviceType device_type) {
   DVLOG(1) << "DevicesChanged with device type " << device_type;
   devices_changed_observer_list_->Notify(
       &DevicesChangedObserver::OnDevicesChanged, device_type);
 }
 
 void SystemMonitor::NotifyRemovableStorageAttached(
     const std::string& id,
     const string16& name,
     const FilePath::StringType& location) {
@@ skipping 24 matching lines @@
 void SystemMonitor::NotifyResume() {
   DVLOG(1) << "Power Resuming";
   power_observer_list_->Notify(&PowerObserver::OnResume);
 }
 
 void SystemMonitor::BatteryCheck() {
   ProcessPowerMessage(SystemMonitor::POWER_STATE_EVENT);
 }
 
 }  // namespace base