Provide monitoring of usage for a storage type and origin

webkit/browser/quota/quota_manager.cc

 // Copyright 2013 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 "webkit/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <functional>
 #include <set>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/time/time.h"
 #include "net/base/net_util.h"
 #include "webkit/browser/quota/quota_database.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 #include "webkit/browser/quota/quota_temporary_storage_evictor.h"
+#include "webkit/browser/quota/storage_monitor.h"
 #include "webkit/browser/quota/usage_tracker.h"
 #include "webkit/common/quota/quota_types.h"
 
 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
       (name), static_cast<int>((sample) / kMBytes), \
       1, 10 * 1024 * 1024 /* 10TB */, 100)
 
 namespace quota {
 
@@ skipping 762 matching lines @@
         this, io_thread)),
     db_disabled_(false),
     eviction_disabled_(false),
     io_thread_(io_thread),
     db_thread_(db_thread),
     temporary_quota_initialized_(false),
     temporary_quota_override_(-1),
     desired_available_space_(-1),
     special_storage_policy_(special_storage_policy),
     get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace),
+    storage_monitor_(new StorageMonitor(this)),
     weak_factory_(this) {
 }
 
 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
   LazyInitialize();
   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
   get_usage_info->Start();
 }
 
 void QuotaManager::GetUsageAndQuotaForWebApps(
@@ skipping 331 matching lines @@
                  type));
 }
 
 bool QuotaManager::ResetUsageTracker(StorageType type) {
   DCHECK(GetUsageTracker(type));
   if (GetUsageTracker(type)->IsWorking())
     return false;
   switch (type) {
     case kStorageTypeTemporary:
       temporary_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypeTemporary, special_storage_policy_.get()));
+          clients_, kStorageTypeTemporary, special_storage_policy_.get(),
+          storage_monitor_.get()));
       return true;
     case kStorageTypePersistent:
       persistent_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypePersistent, special_storage_policy_.get()));
+          clients_, kStorageTypePersistent, special_storage_policy_.get(),
+          storage_monitor_.get()));
       return true;
     case kStorageTypeSyncable:
       syncable_usage_tracker_.reset(new UsageTracker(
-          clients_, kStorageTypeSyncable, special_storage_policy_.get()));
+          clients_, kStorageTypeSyncable, special_storage_policy_.get(),
+          storage_monitor_.get()));
       return true;
     default:
       NOTREACHED();
   }
   return true;
 }
 
+void QuotaManager::AddStorageObserver(
+    StorageObserver* observer, const StorageObserver::MonitorParams& params) {
+  DCHECK(observer);
+  storage_monitor_->AddObserver(observer, params);
+}
+
+void QuotaManager::RemoveStorageObserver(StorageObserver* observer) {
+  DCHECK(observer);
+  storage_monitor_->RemoveObserver(observer);
+}
+
+void QuotaManager::RemoveStorageObserverForFilter(
+    StorageObserver* observer, const StorageObserver::Filter& filter) {
+  DCHECK(observer);
+  storage_monitor_->RemoveObserverForFilter(observer, filter);
+}
+
 QuotaManager::~QuotaManager() {
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_)
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
 QuotaManager::EvictionContext::EvictionContext()
     : evicted_type(kStorageTypeUnknown) {
 }
 
 QuotaManager::EvictionContext::~EvictionContext() {
 }
 
 void QuotaManager::LazyInitialize() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   if (database_) {
     // Initialization seems to be done already.
     return;
   }
 
   // Use an empty path to open an in-memory only databse for incognito.
   database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
       profile_path_.AppendASCII(kDatabaseName)));
 
   temporary_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypeTemporary, special_storage_policy_.get()));
+      clients_, kStorageTypeTemporary, special_storage_policy_.get(),
+      storage_monitor_.get()));
   persistent_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypePersistent, special_storage_policy_.get()));
+      clients_, kStorageTypePersistent, special_storage_policy_.get(),
+      storage_monitor_.get()));
   syncable_usage_tracker_.reset(new UsageTracker(
-      clients_, kStorageTypeSyncable, special_storage_policy_.get()));
+      clients_, kStorageTypeSyncable, special_storage_policy_.get(),
+      storage_monitor_.get()));
 
   int64* temporary_quota_override = new int64(-1);
   int64* desired_available_space = new int64(-1);
   PostTaskAndReplyWithResultForDBThread(
       FROM_HERE,
       base::Bind(&InitializeOnDBThread,
                  base::Unretained(temporary_quota_override),
                  base::Unretained(desired_available_space)),
       base::Bind(&QuotaManager::DidInitialize,
                  weak_factory_.GetWeakPtr(),
@@ skipping 371 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace quota