storage/browser/quota/storage_monitor.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef STORAGE_BROWSER_QUOTA_STORAGE_MONITOR_H_
   6 #define STORAGE_BROWSER_QUOTA_STORAGE_MONITOR_H_
   7
   8 #include <map>
   9
  10 #include "base/memory/weak_ptr.h"
  11 #include "base/time/time.h"
  12 #include "base/timer/timer.h"
  13 #include "storage/browser/quota/storage_observer.h"
  14
  15 namespace content {
  16 class StorageMonitorTestBase;
  17 }
  18
  19 namespace storage {
  20
  21 class QuotaManager;
  22
  23 // This class dispatches storage events to observers of a common
  24 // StorageObserver::Filter.
  25 class STORAGE_EXPORT_PRIVATE StorageObserverList {
  26  public:
  27   StorageObserverList();
  28   virtual ~StorageObserverList();
  29
  30   // Adds/removes an observer.
  31   void AddObserver(StorageObserver* observer,
  32                    const StorageObserver::MonitorParams& params);
  33   void RemoveObserver(StorageObserver* observer);
  34
  35   // Returns the number of observers.
  36   int ObserverCount() const;
  37
  38   // Forwards a storage change to observers. The event may be dispatched
  39   // immediately to an observer or after a delay, depending on the desired event
  40   // rate of the observer.
  41   void OnStorageChange(const StorageObserver::Event& event);
  42
  43   // Dispatch an event to observers that require it.
  44   void MaybeDispatchEvent(const StorageObserver::Event& event);
  45
  46   // Ensure the specified observer receives the next dispatched event.
  47   void ScheduleUpdateForObserver(StorageObserver* observer);
  48
  49  private:
  50   struct STORAGE_EXPORT_PRIVATE ObserverState {
  51     GURL origin;
  52     base::TimeTicks last_notification_time;
  53     base::TimeDelta rate;
  54     bool requires_update;
  55
  56     ObserverState();
  57   };
  58   typedef std::map<StorageObserver*, ObserverState> StorageObserverStateMap;
  59
  60   void DispatchPendingEvent();
  61
  62   StorageObserverStateMap observers_;
  63   base::OneShotTimer<StorageObserverList> notification_timer_;
  64   StorageObserver::Event pending_event_;
  65
  66   friend class content::StorageMonitorTestBase;
  67
  68   DISALLOW_COPY_AND_ASSIGN(StorageObserverList);
  69 };
  70
  71
  72 // Manages the storage observers of a common host. Caches the usage and quota of
  73 // the host to avoid accumulating for every change.
  74 class STORAGE_EXPORT_PRIVATE HostStorageObservers {
  75  public:
  76   explicit HostStorageObservers(QuotaManager* quota_manager);
  77   virtual ~HostStorageObservers();
  78
  79   bool is_initialized() const { return initialized_; }
  80
  81   // Adds/removes an observer.
  82   void AddObserver(
  83       StorageObserver* observer,
  84       const StorageObserver::MonitorParams& params);
  85   void RemoveObserver(StorageObserver* observer);
  86   bool ContainsObservers() const;
  87
  88   // Handles a usage change.
  89   void NotifyUsageChange(const StorageObserver::Filter& filter, int64 delta);
  90
  91  private:
  92   void StartInitialization(const StorageObserver::Filter& filter);
  93   void GotHostUsageAndQuota(const StorageObserver::Filter& filter,
  94                             QuotaStatusCode status,
  95                             int64 usage,
  96                             int64 quota);
  97   void DispatchEvent(const StorageObserver::Filter& filter, bool is_update);
  98
  99   QuotaManager* quota_manager_;
 100   StorageObserverList observers_;
 101
 102   // Flags used during initialization of the cached properties.
 103   bool initialized_;
 104   bool initializing_;
 105   bool event_occurred_before_init_;
 106   int64 usage_deltas_during_init_;
 107
 108   // Cached accumulated usage and quota for the host.
 109   int64 cached_usage_;
 110   int64 cached_quota_;
 111
 112   base::WeakPtrFactory<HostStorageObservers> weak_factory_;
 113
 114   friend class content::StorageMonitorTestBase;
 115
 116   DISALLOW_COPY_AND_ASSIGN(HostStorageObservers);
 117 };
 118
 119
 120 // Manages the observers of a common storage type.
 121 class STORAGE_EXPORT_PRIVATE StorageTypeObservers {
 122  public:
 123   explicit StorageTypeObservers(QuotaManager* quota_manager);
 124   virtual ~StorageTypeObservers();
 125
 126   // Adds and removes an observer.
 127   void AddObserver(StorageObserver* observer,
 128                    const StorageObserver::MonitorParams& params);
 129   void RemoveObserver(StorageObserver* observer);
 130   void RemoveObserverForFilter(StorageObserver* observer,
 131                                const StorageObserver::Filter& filter);
 132
 133   // Returns the observers of a specific host.
 134   const HostStorageObservers* GetHostObservers(const std::string& host) const;
 135
 136   // Handles a usage change.
 137   void NotifyUsageChange(const StorageObserver::Filter& filter, int64 delta);
 138
 139  private:
 140   typedef std::map<std::string, HostStorageObservers*> HostObserversMap;
 141
 142   QuotaManager* quota_manager_;
 143   HostObserversMap host_observers_map_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(StorageTypeObservers);
 146 };
 147
 148
 149 // Storage monitor manages observers and dispatches storage events to them.
 150 class STORAGE_EXPORT_PRIVATE StorageMonitor {
 151  public:
 152   explicit StorageMonitor(QuotaManager* quota_manager);
 153   virtual ~StorageMonitor();
 154
 155   // Adds and removes an observer.
 156   void AddObserver(StorageObserver* observer,
 157                    const StorageObserver::MonitorParams& params);
 158   void RemoveObserver(StorageObserver* observer);
 159   void RemoveObserverForFilter(StorageObserver* observer,
 160                                const StorageObserver::Filter& filter);
 161
 162   // Returns the observers of a specific storage type.
 163   const StorageTypeObservers* GetStorageTypeObservers(
 164       StorageType storage_type) const;
 165
 166   // Handles a usage change.
 167   void NotifyUsageChange(const StorageObserver::Filter& filter, int64 delta);
 168
 169  private:
 170   typedef std::map<StorageType, StorageTypeObservers*> StorageTypeObserversMap;
 171
 172   QuotaManager* quota_manager_;
 173   StorageTypeObserversMap storage_type_observers_map_;
 174
 175   DISALLOW_COPY_AND_ASSIGN(StorageMonitor);
 176 };
 177
 178 }  // namespace storage
 179
 180 #endif  // STORAGE_BROWSER_QUOTA_STORAGE_MONITOR_H_