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

base/system_monitor/system_monitor.h

 // 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.
 
 #ifndef BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 #define BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/string16.h"
 #include "build/build_config.h"
 
 // Windows HiRes timers drain the battery faster so we need to know the battery
@@ skipping 32 matching lines @@
     RESUME_EVENT        // The system is being resumed.
   };
 
   // Type of devices whose change need to be monitored, such as add/remove.
   enum DeviceType {
     DEVTYPE_AUDIO_CAPTURE,  // Audio capture device, e.g., microphone.
     DEVTYPE_VIDEO_CAPTURE,  // Video capture device, e.g., webcam.
     DEVTYPE_UNKNOWN,  // Other devices.
   };
 
+  // The delegate for watching the storage free space changes. If it starts

[vandebo (ex-Chrome), 2012/09/10 21:52:49]

This isn't for watching storage free space changes, this is for the
implementation to know when to notify.  Make the comment and class name more
clear.

+  // watching a storage device, all DevicesChangedObserver added to the
+  // SystemMonitor will be received OnStorageFreeChanged notification in case
+  // of the free space of the storage being watched is changed.
+  class BASE_EXPORT StorageFreeSpaceDelegate {
+   public:
+    virtual ~StorageFreeSpaceDelegate() {}
+
+    // Start watching the storage device identified by the |path| parameter.
+    // Return true if it succeeds to start, otherwise, false is returned.
+    virtual bool StartWatchingStorage(const FilePath::StringType& path) = 0;
+
+    // Stop watching the storage device identified by the |path| paramter.
+    virtual bool StopWatchingStorage(const FilePath::StringType& path) = 0;
+  };
+
   struct BASE_EXPORT RemovableStorageInfo {
     RemovableStorageInfo();
     RemovableStorageInfo(const std::string& id,
                          const string16& device_name,
                          const FilePath::StringType& device_location);
 
     // Unique device id - persists between device attachments.
     std::string device_id;
 
     // Human readable removable storage device name.
@@ skipping 57 matching lines @@
    protected:
     virtual ~PowerObserver() {}
   };
 
   class BASE_EXPORT DevicesChangedObserver {
    public:
     // Notification that the devices connected to the system have changed.
     // This is only implemented on Windows currently.
     virtual void OnDevicesChanged(DeviceType device_type) {}
 
+    // Get triggered when the free space of the storage |path| is changed.
+    virtual void OnStorageFreeSpaceChanged(const FilePath::StringType& path) {}
+
     // When a removable storage device is attached or detached, one of these
     // two events is triggered.
     virtual void OnRemovableStorageAttached(
         const std::string& id,
         const string16& name,
         const FilePath::StringType& location) {}
     virtual void OnRemovableStorageDetached(const std::string& id) {}
 
    protected:
     virtual ~DevicesChangedObserver() {}
@@ skipping 21 matching lines @@
   // Cross-platform handling of a power event.
   void ProcessPowerMessage(PowerEvent event_id);
 
   // Cross-platform handling of a device change event.
   void ProcessDevicesChanged(DeviceType device_type);
   void ProcessRemovableStorageAttached(const std::string& id,
                                        const string16& name,
                                        const FilePath::StringType& location);
   void ProcessRemovableStorageDetached(const std::string& id);
 
+  void ProcessStorageFreeSpaceChanged(const FilePath::StringType& path);
+
+  void set_storage_free_space_delegate(StorageFreeSpaceDelegate* delegate) {
+    free_space_delegate_ = delegate;
+  }
+

[Hongbo Min, 2012/09/10 14:37:50]

vandebo, here I add these two methods for the client code to start and stop the
free space watching process instead of implicitly start/stop when
adding/removing device observers, as discuss in http://crbug.com/141229.

The reason is, the SystemMonitor consumer may want to only watch a specific
storage device, not all storage devices attached to the system, it is the
responsibility of the client code to start/stop the watching process for the
given storage. The implicit way can not satisfy this more-grained requirement.

[vandebo (ex-Chrome), 2012/09/10 21:52:49]

I guess that's a fair point, but there's a lot of coordination here to make
things happen correctly and it's a bit fragile....  For example, if you had two
things that wanted to watch for free space, the first one to stop would call
stop and the second one would stop getting notifications.

Instead, lets give up on including free space changed as part of
DevicesChangedObserver.  So we'll have:

class StorageFreeSpaceChangedObserver; with one method and two methods to
register for it:
AddStorageFreeSpaceChangedObserver(const FilePath::StringType& device,
StorageFreeSpaceChangedObserver*);
RemoveStorageFreeSpaceChangedObserver(const FilePath::StringType& device,
StorageFreeSpaceChangedObserver*);

This way there can be a dynamic set of observer lists and when one of them is
empty, we'll tell the delegate to stop notifying about that one.

+  bool StartWatchingStorage(const FilePath::StringType& path);
+  bool StopWatchingStorage(const FilePath::StringType& path);
+
  private:
   // Mapping of unique device id to device info tuple.
   typedef std::map<std::string, RemovableStorageInfo> RemovableStorageMap;
 
 #if defined(OS_MACOSX)
   void PlatformInit();
   void PlatformDestroy();
 #endif
 
   // Platform-specific method to check whether the system is currently
@@ skipping 26 matching lines @@
 #endif
 
 #if defined(OS_IOS)
   // Holds pointers to system event notification observers.
   std::vector<id> notification_observers_;
 #endif
 
   // Map of all the attached removable storage devices.
   RemovableStorageMap removable_storage_map_;
 
+  // The delegate instance for watching storage free space changes.
+  StorageFreeSpaceDelegate* free_space_delegate_;
+
+  // The set of the storage devices being watched.
+  std::multiset<FilePath::StringType> watched_storages_;
+
   DISALLOW_COPY_AND_ASSIGN(SystemMonitor);
 };
 
 }  // namespace base
 
 #endif  // BASE_SYSTEM_MONITOR_SYSTEM_MONITOR_H_