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<storage::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(),
  42                  storage::kStorageTypeTemporary));
  43
  44   quota_manager_->GetGlobalUsage(
  45       storage::kStorageTypeTemporary,
  46       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  47                  weak_factory_.GetWeakPtr(),
  48                  storage::kStorageTypeTemporary));
  49
  50   quota_manager_->GetGlobalUsage(
  51       storage::kStorageTypePersistent,
  52       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  53                  weak_factory_.GetWeakPtr(),
  54                  storage::kStorageTypePersistent));
  55
  56   quota_manager_->GetGlobalUsage(
  57       storage::kStorageTypeSyncable,
  58       base::Bind(&QuotaInternalsProxy::DidGetGlobalUsage,
  59                  weak_factory_.GetWeakPtr(),
  60                  storage::kStorageTypeSyncable));
  61
  62   quota_manager_->DumpQuotaTable(
  63       base::Bind(&QuotaInternalsProxy::DidDumpQuotaTable,
  64                  weak_factory_.GetWeakPtr()));
  65
  66   quota_manager_->DumpOriginInfoTable(
  67       base::Bind(&QuotaInternalsProxy::DidDumpOriginInfoTable,
  68                  weak_factory_.GetWeakPtr()));
  69
  70   std::map<std::string, std::string> stats;
  71   quota_manager_->GetStatistics(&stats);
  72   ReportStatistics(stats);
  73 }
  74
  75 QuotaInternalsProxy::~QuotaInternalsProxy() {}
  76
  77 #define RELAY_TO_HANDLER(func, arg_t) \
  78   void QuotaInternalsProxy::func(arg_t arg) {                 \
  79     if (!handler_)                                            \
  80       return;                                                 \
  81     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {     \
  82       BrowserThread::PostTask(                                \
  83           BrowserThread::UI, FROM_HERE,                       \
  84           base::Bind(&QuotaInternalsProxy::func, this, arg)); \
  85       return;                                                 \
  86     }                                                         \
  87                                                               \
  88     handler_->func(arg);                                      \
  89   }
  90
  91 RELAY_TO_HANDLER(ReportAvailableSpace, int64)
  92 RELAY_TO_HANDLER(ReportGlobalInfo, const GlobalStorageInfo&)
  93 RELAY_TO_HANDLER(ReportPerHostInfo, const std::vector<PerHostStorageInfo>&)
  94 RELAY_TO_HANDLER(ReportPerOriginInfo, const std::vector<PerOriginStorageInfo>&)
  95 RELAY_TO_HANDLER(ReportStatistics, const Statistics&)
  96
  97 #undef RELAY_TO_HANDLER
  98
  99 void QuotaInternalsProxy::DidGetAvailableSpace(storage::QuotaStatusCode status,
 100                                                int64 space) {
 101   if (status == storage::kQuotaStatusOk)
 102     ReportAvailableSpace(space);
 103 }
 104
 105 void QuotaInternalsProxy::DidGetGlobalQuota(storage::StorageType type,
 106                                             storage::QuotaStatusCode status,
 107                                             int64 quota) {
 108   if (status == storage::kQuotaStatusOk) {
 109     GlobalStorageInfo info(type);
 110     info.set_quota(quota);
 111     ReportGlobalInfo(info);
 112   }
 113 }
 114
 115 void QuotaInternalsProxy::DidGetGlobalUsage(storage::StorageType type,
 116                                             int64 usage,
 117                                             int64 unlimited_usage) {
 118   GlobalStorageInfo info(type);
 119   info.set_usage(usage);
 120   info.set_unlimited_usage(unlimited_usage);
 121
 122   ReportGlobalInfo(info);
 123   RequestPerOriginInfo(type);
 124 }
 125
 126 void QuotaInternalsProxy::DidDumpQuotaTable(const QuotaTableEntries& entries) {
 127   std::vector<PerHostStorageInfo> host_info;
 128   host_info.reserve(entries.size());
 129
 130   typedef QuotaTableEntries::const_iterator iterator;
 131   for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
 132     PerHostStorageInfo info(itr->host, itr->type);
 133     info.set_quota(itr->quota);
 134     host_info.push_back(info);
 135   }
 136
 137   ReportPerHostInfo(host_info);
 138 }
 139
 140 void QuotaInternalsProxy::DidDumpOriginInfoTable(
 141     const OriginInfoTableEntries& entries) {
 142   std::vector<PerOriginStorageInfo> origin_info;
 143   origin_info.reserve(entries.size());
 144
 145   typedef OriginInfoTableEntries::const_iterator iterator;
 146   for (iterator itr(entries.begin()); itr != entries.end(); ++itr) {
 147     PerOriginStorageInfo info(itr->origin, itr->type);
 148     info.set_used_count(itr->used_count);
 149     info.set_last_access_time(itr->last_access_time);
 150     info.set_last_modified_time(itr->last_modified_time);
 151
 152     origin_info.push_back(info);
 153   }
 154
 155   ReportPerOriginInfo(origin_info);
 156 }
 157
 158 void QuotaInternalsProxy::DidGetHostUsage(const std::string& host,
 159                                           storage::StorageType type,
 160                                           int64 usage) {
 161   DCHECK(type == storage::kStorageTypeTemporary ||
 162          type == storage::kStorageTypePersistent ||
 163          type == storage::kStorageTypeSyncable);
 164
 165   PerHostStorageInfo info(host, type);
 166   info.set_usage(usage);
 167
 168   report_pending_.push_back(info);
 169   hosts_pending_.erase(make_pair(host, type));
 170   if (report_pending_.size() >= 10 || hosts_pending_.empty()) {
 171     ReportPerHostInfo(report_pending_);
 172     report_pending_.clear();
 173   }
 174
 175   if (!hosts_pending_.empty())
 176     GetHostUsage(hosts_pending_.begin()->first,
 177                  hosts_pending_.begin()->second);
 178 }
 179
 180 void QuotaInternalsProxy::RequestPerOriginInfo(storage::StorageType type) {
 181   DCHECK(quota_manager_.get());
 182
 183   std::set<GURL> origins;
 184   quota_manager_->GetCachedOrigins(type, &origins);
 185
 186   std::vector<PerOriginStorageInfo> origin_info;
 187   origin_info.reserve(origins.size());
 188
 189   std::set<std::string> hosts;
 190   std::vector<PerHostStorageInfo> host_info;
 191
 192   for (std::set<GURL>::iterator itr(origins.begin());
 193        itr != origins.end(); ++itr) {
 194     PerOriginStorageInfo info(*itr, type);
 195     info.set_in_use(quota_manager_->IsOriginInUse(*itr));
 196     origin_info.push_back(info);
 197
 198     std::string host(net::GetHostOrSpecFromURL(*itr));
 199     if (hosts.insert(host).second) {
 200       PerHostStorageInfo info(host, type);
 201       host_info.push_back(info);
 202       VisitHost(host, type);
 203     }
 204   }
 205   ReportPerOriginInfo(origin_info);
 206   ReportPerHostInfo(host_info);
 207 }
 208
 209 void QuotaInternalsProxy::VisitHost(const std::string& host,
 210                                     storage::StorageType type) {
 211   if (hosts_visited_.insert(std::make_pair(host, type)).second) {
 212     hosts_pending_.insert(std::make_pair(host, type));
 213     if (hosts_pending_.size() == 1) {
 214       GetHostUsage(host, type);
 215     }
 216   }
 217 }
 218
 219 void QuotaInternalsProxy::GetHostUsage(const std::string& host,
 220                                        storage::StorageType type) {
 221   DCHECK(quota_manager_.get());
 222   quota_manager_->GetHostUsage(host,
 223                                type,
 224                                base::Bind(&QuotaInternalsProxy::DidGetHostUsage,
 225                                           weak_factory_.GetWeakPtr(),
 226                                           host,
 227                                           type));
 228 }
 229
 230 }  // namespace quota_internals