Add chrome://quota-internals/

chrome/browser/ui/webui/quota_internals_proxy.cc

Index: chrome/browser/ui/webui/quota_internals_proxy.cc
diff --git a/chrome/browser/ui/webui/quota_internals_proxy.cc b/chrome/browser/ui/webui/quota_internals_proxy.cc
new file mode 100644
index 0000000000000000000000000000000000000000..4e06249878f15c7fbe641c1445e1ec3622babe63
--- /dev/null
+++ b/chrome/browser/ui/webui/quota_internals_proxy.cc
@@ -0,0 +1,249 @@
+// 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/ui/webui/quota_internals_proxy.h"
+
+#include <set>
+#include <string>
+
+#include "chrome/browser/ui/webui/quota_internals_handler.h"
+#include "chrome/browser/ui/webui/quota_internals_types.h"
+#include "net/base/net_util.h"
+
+namespace quota_internals {
+
+QuotaInternalsProxy::QuotaInternalsProxy(QuotaInternalsHandler* handler)
+    : handler_(handler),
+      callback_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+void QuotaInternalsProxy::ReportAvailableSpace(int64 available_space) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &QuotaInternalsProxy::RunReportAvailableSpaceOnUIThread,
+          available_space));

[kinuko, 2011/07/01 06:51:37]

nit: there seem to be so many mostly-empty relaying methods in this class.  For
the sake of simplicity, is it possible/reasonable to merge some of those
methods?

like:
QuotaInternalsProxy::ReportFooToUIThread(...) {
  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
    BrowserThread::PostTask(... /* call this method on UI thread*/);
    return;
  }
  if (handler_)
    handler_->ReportFoo(...);
}

[tzik, 2011/07/01 18:17:00]

Done.

+}
+
+void QuotaInternalsProxy::ReportGlobalData(const GlobalData& data) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &QuotaInternalsProxy::RunReportGlobalDataOnUIThread,
+          data));
+}
+
+void QuotaInternalsProxy::ReportHostData(const std::vector<HostData>& hosts) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &QuotaInternalsProxy::RunReportHostDataOnUIThread,
+          hosts));
+}
+
+void QuotaInternalsProxy::ReportOriginData(
+    const std::vector<OriginData>& origins) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &QuotaInternalsProxy::RunReportOriginDataOnUIThread,
+          origins));
+}
+
+void QuotaInternalsProxy::ReportStatistics(const Statistics& stats) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      NewRunnableMethod(
+          this, &QuotaInternalsProxy::RunReportStatisticsOnUIThread,
+          stats));
+}
+
+void QuotaInternalsProxy::RequestData(quota::QuotaManager* quota_manager) {
+  DCHECK(quota_manager);
+  quota_manager_ = quota_manager;
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &QuotaInternalsProxy::RunRequestDataOnIOThread));
+}
+
+void QuotaInternalsProxy::RunReportAvailableSpaceOnUIThread(
+    int64 available_space) {
+  if (handler_)
+    handler_->ReportAvailableSpace(available_space);
+}
+
+void QuotaInternalsProxy::RunReportGlobalDataOnUIThread(
+    const GlobalData& data) {
+  if (handler_)
+    handler_->ReportGlobalData(data);
+}
+
+void QuotaInternalsProxy::RunReportHostDataOnUIThread(
+    const std::vector<HostData>& hosts) {
+  if (handler_)
+    handler_->ReportHostData(hosts);
+}
+
+void QuotaInternalsProxy::RunReportOriginDataOnUIThread(
+    const std::vector<OriginData>& origins) {
+  if (handler_)
+    handler_->ReportOriginData(origins);
+}
+
+void QuotaInternalsProxy::RunReportStatisticsOnUIThread(
+    const Statistics& stats) {
+  if (handler_)
+    handler_->ReportStatistics(stats);
+}
+
+void QuotaInternalsProxy::RunRequestDataOnIOThread() {
+  DCHECK(quota_manager_);
+  quota_manager_->GetAvailableSpace(
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidGetAvailableSpace));
+
+  quota_manager_->GetTemporaryGlobalQuota(
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidGetGlobalQuota));
+
+  quota_manager_->GetGlobalUsage(
+      quota::kStorageTypeTemporary,
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidGetGlobalUsage));
+
+  quota_manager_->GetGlobalUsage(
+      quota::kStorageTypePersistent,
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidGetGlobalUsage));
+
+  quota_manager_->DumpQuotaTable(
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidDumpQuotaTable));
+
+  quota_manager_->DumpOriginInfoTable(
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidDumpOriginInfoTable));
+
+  std::map<std::string, std::string> stats;
+  quota_manager_->GetStatistics(&stats);
+  ReportStatistics(stats);
+}
+
+void QuotaInternalsProxy::DidGetAvailableSpace(quota::QuotaStatusCode status,
+                                               int64 space) {
+  if (status == quota::kQuotaStatusOk)
+    ReportAvailableSpace(space);
+}
+
+void QuotaInternalsProxy::DidGetGlobalQuota(quota::QuotaStatusCode status,
+                                            quota::StorageType type,
+                                            int64 quota) {
+  if (status == quota::kQuotaStatusOk)
+    ReportGlobalData(GlobalData(type, -1, -1, quota));
+}
+
+void QuotaInternalsProxy::DidGetGlobalUsage(quota::StorageType type,
+                                            int64 usage,
+                                            int64 unlimited_usage) {
+  ReportGlobalData(GlobalData(type, usage, unlimited_usage, -1));
+  RequestPerOriginData(type);
+}
+
+void QuotaInternalsProxy::DidDumpQuotaTable(const QuotaTableEntries& entries) {
+  std::vector<HostData> host_data;
+  host_data.reserve(entries.size());
+
+  typedef QuotaTableEntries::const_iterator iterator;
+  for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
+    host_data.push_back(HostData(itr->host, itr->type, -1, itr->quota));
+  }
+
+  ReportHostData(host_data);
+}
+
+void QuotaInternalsProxy::DidDumpOriginInfoTable(
+    const OriginInfoTableEntries& entries) {
+  std::vector<OriginData> origin_data;
+  origin_data.reserve(entries.size());
+
+  typedef OriginInfoTableEntries::const_iterator iterator;
+  for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
+    origin_data.push_back(
+        OriginData(itr->origin, itr->type,
+                   -1, itr->used_count,
+                   itr->last_access_time,
+                   itr->last_modified_time));
+  }
+
+  ReportOriginData(origin_data);
+}
+
+void QuotaInternalsProxy::DidGetHostUsage(const std::string& host,
+                                          quota::StorageType type,
+                                          int64 usage) {
+  DCHECK(type == quota::kStorageTypeTemporary ||
+         type == quota::kStorageTypePersistent);
+
+  report_pending_.push_back(HostData(host, type, usage, -1));
+  hosts_pending_.erase(make_pair(host, type));
+  if (report_pending_.size() >= 10 || hosts_pending_.empty()) {
+    ReportHostData(report_pending_);
+    report_pending_.clear();
+  }
+
+  if (!hosts_pending_.empty())
+    GetHostUsage(hosts_pending_.begin()->first,
+                 hosts_pending_.begin()->second);
+}
+
+void QuotaInternalsProxy::VisitHost(const std::string& host,
+                                    quota::StorageType type) {
+  if (hosts_visited_.insert(std::make_pair(host, type)).second) {
+    hosts_pending_.insert(std::make_pair(host, type));
+    if (hosts_pending_.size() == 1) {
+      GetHostUsage(host, type);
+    }
+  }
+}
+
+void QuotaInternalsProxy::GetHostUsage(const std::string& host,
+                                       quota::StorageType type) {
+  DCHECK(quota_manager_);
+  quota_manager_->GetHostUsage(
+      host, type,
+      callback_factory_.NewCallback(
+          &QuotaInternalsProxy::DidGetHostUsage));
+}
+
+void QuotaInternalsProxy::RequestPerOriginData(quota::StorageType type) {
+  DCHECK(quota_manager_);
+
+  std::set<GURL> origins;
+  quota_manager_->GetCachedOrigins(type, &origins);
+
+  std::vector<OriginData> origin_data;
+  origin_data.reserve(origins.size());
+
+  std::set<std::string> hosts;
+  std::vector<HostData> host_data;
+
+  for (std::set<GURL>::iterator itr(origins.begin());
+       itr != origins.end(); ++itr) {
+    origin_data.push_back(
+        OriginData(*itr, type,
+                   quota_manager_->IsOriginInUse(*itr) ? 1 : 0, -1,
+                   base::Time(),
+                   base::Time()));
+
+    std::string host(net::GetHostOrSpecFromURL(*itr));
+    if (hosts.insert(host).second) {
+      host_data.push_back(HostData(host, type, -1, -1));
+      VisitHost(host, type);
+    }
+  }
+  ReportOriginData(origin_data);
+  ReportHostData(host_data);
+}
+
+}  // namespace quota_internals