chrome/browser/ui/webui/quota_internals/quota_internals_proxy.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/quota_internals/quota_internals_proxy.h"
   6
   7 #include <set>
   8 #include <string>
   9
  10 #include "base/bind.h"
  11 #include "chrome/browser/ui/webui/quota_internals/quota_internals_handler.h"
  12 #include "chrome/browser/ui/webui/quota_internals/quota_internals_types.h"
  13 #include "net/base/net_util.h"
  14
  15 using content::BrowserThread;
  16
  17 namespace quota_internals {
  18
  19 QuotaInternalsProxy::QuotaInternalsProxy(QuotaInternalsHandler* handler)
  20     : handler_(handler),
  21       weak_factory_(this) {
  22 }
  23
  24 void QuotaInternalsProxy::RequestInfo(
  25     scoped_refptr<quota::QuotaManager> quota_manager) {
  26   DCHECK(quota_manager.get());
  27   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
  28     BrowserThread::PostTask(
  29         BrowserThread::IO, FROM_HERE,
  30         base::Bind(&QuotaInternalsProxy::RequestInfo, this, quota_manager));
  31     return;
  32   }
  33
  34   quota_manager_ = quota_manager;
  35   quota_manager_->GetAvailableSpace(
  36       base::Bind(&QuotaInternalsProxy::DidGetAvailableSpace,
  37                  weak_factory_.GetWeakPtr()));
  38
  39   quota_manager_->GetTemporaryGlobalQuota(
  40       base::Bind(&QuotaInternalsProxy::DidGetGlobalQuota,
  41                  weak_factory_.GetWeakPtr(), quota::kStorageTypeTemporary));
  42
  43   quota_manager_->GetGlobalUsage(
  44       quota::kStorageTypeTemporary,
  45       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  46                  weak_factory_.GetWeakPtr(),
  47                  quota::kStorageTypeTemporary));
  48
  49   quota_manager_->GetGlobalUsage(
  50       quota::kStorageTypePersistent,
  51       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  52                  weak_factory_.GetWeakPtr(),
  53                  quota::kStorageTypePersistent));
  54
  55   quota_manager_->GetGlobalUsage(
  56       quota::kStorageTypeSyncable,
  57       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  58                  weak_factory_.GetWeakPtr(),
  59                  quota::kStorageTypeSyncable));
  60
  61   quota_manager_->DumpQuotaTable(
  62       base::Bind(&QuotaInternalsProxy::DidDumpQuotaTable,
  63                  weak_factory_.GetWeakPtr()));
  64
  65   quota_manager_->DumpOriginInfoTable(
  66       base::Bind(&QuotaInternalsProxy::DidDumpOriginInfoTable,
  67                  weak_factory_.GetWeakPtr()));
  68
  69   std::map<std::string, std::string> stats;
  70   quota_manager_->GetStatistics(&stats);
  71   ReportStatistics(stats);
  72 }
  73
  74 QuotaInternalsProxy::~QuotaInternalsProxy() {}
  75
  76 #define RELAY_TO_HANDLER(func, arg_t) \
  77   void QuotaInternalsProxy::func(arg_t arg) {                 \
  78     if (!handler_)                                            \
  79       return;                                                 \
  80     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {     \
  81       BrowserThread::PostTask(                                \
  82           BrowserThread::UI, FROM_HERE,                       \
  83           base::Bind(&QuotaInternalsProxy::func, this, arg)); \
  84       return;                                                 \
  85     }                                                         \
  86                                                               \
  87     handler_->func(arg);                                      \
  88   }
  89
  90 RELAY_TO_HANDLER(ReportAvailableSpace, int64)
  91 RELAY_TO_HANDLER(ReportGlobalInfo, const GlobalStorageInfo&)
  92 RELAY_TO_HANDLER(ReportPerHostInfo, const std::vector<PerHostStorageInfo>&)
  93 RELAY_TO_HANDLER(ReportPerOriginInfo, const std::vector<PerOriginStorageInfo>&)
  94 RELAY_TO_HANDLER(ReportStatistics, const Statistics&)
  95
  96 #undef RELAY_TO_HANDLER
  97
  98 void QuotaInternalsProxy::DidGetAvailableSpace(quota::QuotaStatusCode status,
  99                                                int64 space) {
 100   if (status == quota::kQuotaStatusOk)
 101     ReportAvailableSpace(space);
 102 }
 103
 104 void QuotaInternalsProxy::DidGetGlobalQuota(quota::StorageType type,
 105                                             quota::QuotaStatusCode status,
 106                                             int64 quota) {
 107   if (status == quota::kQuotaStatusOk) {
 108     GlobalStorageInfo info(type);
 109     info.set_quota(quota);
 110     ReportGlobalInfo(info);
 111   }
 112 }
 113
 114 void QuotaInternalsProxy::DidGetGlobalUsage(quota::StorageType type,
 115                                             int64 usage,
 116                                             int64 unlimited_usage) {
 117   GlobalStorageInfo info(type);
 118   info.set_usage(usage);
 119   info.set_unlimited_usage(unlimited_usage);
 120
 121   ReportGlobalInfo(info);
 122   RequestPerOriginInfo(type);
 123 }
 124
 125 void QuotaInternalsProxy::DidDumpQuotaTable(const QuotaTableEntries& entries) {
 126   std::vector<PerHostStorageInfo> host_info;
 127   host_info.reserve(entries.size());
 128
 129   typedef QuotaTableEntries::const_iterator iterator;
 130   for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
 131     PerHostStorageInfo info(itr->host, itr->type);
 132     info.set_quota(itr->quota);
 133     host_info.push_back(info);
 134   }
 135
 136   ReportPerHostInfo(host_info);
 137 }
 138
 139 void QuotaInternalsProxy::DidDumpOriginInfoTable(
 140     const OriginInfoTableEntries& entries) {
 141   std::vector<PerOriginStorageInfo> origin_info;
 142   origin_info.reserve(entries.size());
 143
 144   typedef OriginInfoTableEntries::const_iterator iterator;
 145   for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
 146     PerOriginStorageInfo info(itr->origin, itr->type);
 147     info.set_used_count(itr->used_count);
 148     info.set_last_access_time(itr->last_access_time);
 149     info.set_last_modified_time(itr->last_modified_time);
 150
 151     origin_info.push_back(info);
 152   }
 153
 154   ReportPerOriginInfo(origin_info);
 155 }
 156
 157 void QuotaInternalsProxy::DidGetHostUsage(const std::string& host,
 158                                           quota::StorageType type,
 159                                           int64 usage) {
 160   DCHECK(type == quota::kStorageTypeTemporary ||
 161          type == quota::kStorageTypePersistent ||
 162          type == quota::kStorageTypeSyncable);
 163
 164   PerHostStorageInfo info(host, type);
 165   info.set_usage(usage);
 166
 167   report_pending_.push_back(info);
 168   hosts_pending_.erase(make_pair(host, type));
 169   if (report_pending_.size() >= 10 || hosts_pending_.empty()) {
 170     ReportPerHostInfo(report_pending_);
 171     report_pending_.clear();
 172   }
 173
 174   if (!hosts_pending_.empty())
 175     GetHostUsage(hosts_pending_.begin()->first,
 176                  hosts_pending_.begin()->second);
 177 }
 178
 179 void QuotaInternalsProxy::RequestPerOriginInfo(quota::StorageType type) {
 180   DCHECK(quota_manager_.get());
 181
 182   std::set<GURL> origins;
 183   quota_manager_->GetCachedOrigins(type, &origins);
 184
 185   std::vector<PerOriginStorageInfo> origin_info;
 186   origin_info.reserve(origins.size());
 187
 188   std::set<std::string> hosts;
 189   std::vector<PerHostStorageInfo> host_info;
 190
 191   for (std::set<GURL>::iterator itr(origins.begin());
 192        itr != origins.end(); ++itr) {
 193     PerOriginStorageInfo info(*itr, type);
 194     info.set_in_use(quota_manager_->IsOriginInUse(*itr));
 195     origin_info.push_back(info);
 196
 197     std::string host(net::GetHostOrSpecFromURL(*itr));
 198     if (hosts.insert(host).second) {
 199       PerHostStorageInfo info(host, type);
 200       host_info.push_back(info);
 201       VisitHost(host, type);
 202     }
 203   }
 204   ReportPerOriginInfo(origin_info);
 205   ReportPerHostInfo(host_info);
 206 }
 207
 208 void QuotaInternalsProxy::VisitHost(const std::string& host,
 209                                     quota::StorageType type) {
 210   if (hosts_visited_.insert(std::make_pair(host, type)).second) {
 211     hosts_pending_.insert(std::make_pair(host, type));
 212     if (hosts_pending_.size() == 1) {
 213       GetHostUsage(host, type);
 214     }
 215   }
 216 }
 217
 218 void QuotaInternalsProxy::GetHostUsage(const std::string& host,
 219                                        quota::StorageType type) {
 220   DCHECK(quota_manager_.get());
 221   quota_manager_->GetHostUsage(host,
 222                                type,
 223                                base::Bind(&QuotaInternalsProxy::DidGetHostUsage,
 224                                           weak_factory_.GetWeakPtr(),
 225                                           host,
 226                                           type));
 227 }
 228
 229 }  // namespace quota_internals