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::GetUsageInfoTask : public QuotaTask {
+ private:
+  typedef QuotaManager::GetUsageInfoTask self_type;
+
+ public:
+  GetUsageInfoTask(
+      QuotaManager* manager,
+      GetUsageInfoCallback* 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()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
+        callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
+    manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
+        callback_factory_.NewCallback(&GetUsageInfoTask::DidGetGlobalUsage));
+  }
+
+  virtual void Completed() OVERRIDE {
+    callback_->Run(entries_);
+    DeleteSoon();
+  }
+
+  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)
+      CallCompleted();
+  }
+
+  void DidGetGlobalUsage(StorageType type, int64, int64) {
+    AddEntries(type, manager()->GetUsageTracker(type));
+  }
+
+  QuotaManager* manager() const {
+    return static_cast<QuotaManager*>(observer());
+  }
+
+  scoped_ptr<GetUsageInfoCallback> callback_;
+  UsageInfoEntries entries_;
+  base::ScopedCallbackFactory<GetUsageInfoTask> callback_factory_;
+  int remaining_trackers_;
+
+  DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
+};
+
 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::GetUsageInfo(GetUsageInfoCallback* callback) {
+  LazyInitialize();
+  GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
+  get_usage_info->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