Retrieve per host storage usage from QuotaManager.

webkit/quota/quota_manager.cc

 // Copyright (c) 2011 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/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <set>
 
@@ skipping 272 matching lines @@
   int64 host_usage_;
   QuotaStatusCode quota_status_;
   CallbackList callbacks_;
   CallbackList unlimited_callbacks_;
   int waiting_callbacks_;
   ScopedCallbackFactory<UsageAndQuotaDispatcherTask> callback_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaDispatcherTask);
 };
 
+class QuotaManager::GetUsageTask : public QuotaTask {
+ private:
+  typedef QuotaManager::GetUsageTask self_type;
+
+ public:
+  GetUsageTask(
+      QuotaManager* manager,
+      GetUsageCallback* callback)
+      : QuotaTask(manager),
+        callback_(callback),
+        callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+  }
+ protected:
+  virtual void Run() OVERRIDE {
+    remaining_trackers_ = 2;
+    // This will populate cached hosts and usage info.
+    manager()->temporary_usage_tracker_->GetGlobalUsage(
+        callback_factory_.NewCallback(&GetUsageTask::DidGetGlobalUsage));
+    manager()->persistent_usage_tracker_->GetGlobalUsage(
+        callback_factory_.NewCallback(&GetUsageTask::DidGetGlobalUsage));
+  }
+
+  virtual void Completed() OVERRIDE {
+  }
+
+  virtual void Aborted() OVERRIDE {
+    callback_->Run(UsageInfoEntries());
+    DeleteSoon();
+  }
+
+ private:
+  void AddEntries(StorageType type, UsageTracker* tracker) {
+    std::map<std::string, int64> host_usage;
+    tracker->GetCachedHostsUsage(&host_usage);
+    for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
+         iter != host_usage.end();
+         ++iter) {
+      entries_.push_back(UsageInfo(iter->first, type, iter->second));
+    }
+    if (--remaining_trackers_ == 0) {
+      callback_->Run(entries_);
+      DeleteSoon();
+    }
+  }
+
+  void DidGetGlobalUsage(StorageType type, int64, int64) {
+    if (type == kStorageTypeTemporary) {
+      AddEntries(type, manager()->temporary_usage_tracker_.get());
+    } else if (type == kStorageTypePersistent) {
+      AddEntries(type, manager()->persistent_usage_tracker_.get());

[kinuko, 2011/10/03 07:49:20]

You can use manager()->GetUsageTracker(type) here

[mnaganov (inactive), 2011/10/04 03:00:40]

Neat! Thanks.

+    }
+  }
+
+  QuotaManager* manager() const {
+    return static_cast<QuotaManager*>(observer());
+  }
+
+  scoped_ptr<GetUsageCallback> callback_;
+  UsageInfoEntries entries_;
+  base::ScopedCallbackFactory<GetUsageTask> callback_factory_;
+  int remaining_trackers_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetUsageTask);
+};
+
 class QuotaManager::UsageAndQuotaDispatcherTaskForTemporary
     : public QuotaManager::UsageAndQuotaDispatcherTask {
  public:
   UsageAndQuotaDispatcherTaskForTemporary(
       QuotaManager* manager, const std::string& host)
       : UsageAndQuotaDispatcherTask(manager, host, kStorageTypeTemporary) {}
 
  protected:
   virtual void RunBody() OVERRIDE {
     manager()->temporary_usage_tracker_->GetGlobalUsage(
@@ skipping 654 matching lines @@
 
 QuotaManager::~QuotaManager() {
   DCHECK(io_thread_->BelongsToCurrentThread());
   proxy_->manager_ = NULL;
   std::for_each(clients_.begin(), clients_.end(),
                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
   if (database_.get())
     db_thread_->DeleteSoon(FROM_HERE, database_.release());
 }
 
+void QuotaManager::GetUsage(GetUsageCallback* callback) {
+  LazyInitialize();
+  GetUsageTask* get_usage = new GetUsageTask(this, callback);
+  get_usage->Start();
+}
+
 void QuotaManager::GetUsageAndQuota(
     const GURL& origin, StorageType type,
     GetUsageAndQuotaCallback* callback_ptr) {
   scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);
   LazyInitialize();
 
   if (type == kStorageTypeUnknown) {
     // Quota only supports temporary/persistent types.
     callback->Run(kQuotaErrorNotSupported, 0, 0);
     return;
@@ skipping 590 matching lines @@
 
 QuotaManagerProxy::QuotaManagerProxy(
     QuotaManager* manager, base::MessageLoopProxy* io_thread)
     : manager_(manager), io_thread_(io_thread) {
 }
 
 QuotaManagerProxy::~QuotaManagerProxy() {
 }
 
 }  // namespace quota