Adding usage and quota entry to chrome://settings/cookies.

chrome/browser/browsing_data_quota_helper_impl.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 "chrome/browser/browsing_data_quota_helper_impl.h"
+
+#include <map>
+#include <set>
+
+#include "base/logging.h"
+#include "chrome/browser/profiles/profile.h"
+#include "webkit/quota/quota_manager.h"
+
+// static
+BrowsingDataQuotaHelper* BrowsingDataQuotaHelper::Create(Profile* profile) {
+  return new BrowsingDataQuotaHelperImpl(
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::UI),
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO),
+      profile->GetQuotaManager());
+}
+
+BrowsingDataQuotaHelperImpl::BrowsingDataQuotaHelperImpl(
+    base::MessageLoopProxy* ui_thread,
+    base::MessageLoopProxy* io_thread,
+    quota::QuotaManager* quota_manager)
+    : BrowsingDataQuotaHelper(io_thread),
+      quota_manager_(quota_manager),
+      is_fetching_(false),
+      ui_thread_(ui_thread),
+      io_thread_(io_thread),
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+  DCHECK(quota_manager);
+}
+
+BrowsingDataQuotaHelperImpl::~BrowsingDataQuotaHelperImpl() {}
+
+void BrowsingDataQuotaHelperImpl::StartFetching(FetchResultCallback* callback) {
+  DCHECK(callback);
+  DCHECK(!callback_.get());
+  DCHECK(!is_fetching_);
+  callback_.reset(callback);
+  quota_info_.clear();
+  is_fetching_ = true;
+
+  FetchQuotaInfo();
+}
+
+void BrowsingDataQuotaHelperImpl::CancelNotification() {
+  callback_.reset();
+}
+
+void BrowsingDataQuotaHelperImpl::FetchQuotaInfo() {
+  if (!io_thread_->BelongsToCurrentThread()) {
+    io_thread_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(
+            this,
+            &BrowsingDataQuotaHelperImpl::FetchQuotaInfo));
+    return;
+  }
+
+  quota_manager_->GetOriginsModifiedSince(
+      quota::kStorageTypeTemporary,
+      base::Time(),
+      callback_factory_.NewCallback(
+          &BrowsingDataQuotaHelperImpl::GotOrigins));
+}
+
+void BrowsingDataQuotaHelperImpl::GotOrigins(
+    const std::set<GURL>& origins, quota::StorageType type) {
+  for (std::set<GURL>::const_iterator itr = origins.begin();
+       itr != origins.end();
+       ++itr)
+    pending_hosts_.insert(std::make_pair(itr->host(), type));
+
+  DCHECK(type == quota::kStorageTypeTemporary ||
+         type == quota::kStorageTypePersistent);
+
+  if (type == quota::kStorageTypeTemporary) {
+    quota_manager_->GetOriginsModifiedSince(
+        quota::kStorageTypePersistent,
+        base::Time(),
+        callback_factory_.NewCallback(
+            &BrowsingDataQuotaHelperImpl::GotOrigins));
+  } else {  // type == quota::kStorageTypePersistent

[kinuko, 2011/08/03 06:20:35]

nit: mind moving this comment to the next line?

[tzik, 2011/08/03 06:52:04]

Done.

+    ProcessPendingHosts();
+  }
+}
+
+void BrowsingDataQuotaHelperImpl::ProcessPendingHosts() {
+  if (pending_hosts_.empty()) {
+    OnComplete();
+    return;
+  }
+
+  PendingHosts::iterator itr = pending_hosts_.begin();
+  std::string host = itr->first;
+  quota::StorageType type = itr->second;
+  pending_hosts_.erase(itr);
+  GetHostUsage(host, type);
+}
+
+void BrowsingDataQuotaHelperImpl::GetHostUsage(const std::string& host,
+                                               quota::StorageType type) {
+  DCHECK(quota_manager_.get());
+  quota_manager_->GetHostUsage(
+      host, type,
+      callback_factory_.NewCallback(
+          &BrowsingDataQuotaHelperImpl::GotHostUsage));
+}
+
+void BrowsingDataQuotaHelperImpl::GotHostUsage(const std::string& host,
+                                               quota::StorageType type,
+                                               int64 usage) {
+  switch (type) {
+    case quota::kStorageTypeTemporary:
+      quota_info_[host].temporary_usage = usage;
+      break;
+    case quota::kStorageTypePersistent:
+      quota_info_[host].persistent_usage = usage;
+      break;
+    default:
+      NOTREACHED();
+  }
+  ProcessPendingHosts();
+}
+
+void BrowsingDataQuotaHelperImpl::OnComplete() {
+  // Check if CancelNotification was called
+  if (!callback_.get())
+    return;
+
+  if (!ui_thread_->BelongsToCurrentThread()) {
+    ui_thread_->PostTask(
+        FROM_HERE,
+        NewRunnableMethod(
+            this,
+            &BrowsingDataQuotaHelperImpl::OnComplete));
+    return;
+  }
+
+  is_fetching_ = false;
+
+  QuotaInfoList result;
+  result.reserve(quota_info_.size());
+
+  for (std::map<std::string, QuotaInfo>::iterator itr = quota_info_.begin();
+       itr != quota_info_.end();
+       ++itr) {
+    QuotaInfo* info = &itr->second;
+    // Skip unused entries
+    if (info->temporary_usage <= 0 &&
+        info->persistent_usage <= 0)
+      continue;
+
+    info->host = itr->first;
+    result.push_back(*info);
+  }
+
+  callback_->Run(result);
+  callback_.reset();
+}