src/storage/browser/quota/quota_manager.cc

   1 // Copyright 2013 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 "storage/browser/quota/quota_manager.h"
   6
   7 #include <algorithm>
   8 #include <deque>
   9 #include <functional>
  10 #include <set>
  11
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/callback.h"
  15 #include "base/command_line.h"
  16 #include "base/files/file_path.h"
  17 #include "base/files/file_util.h"
  18 #include "base/metrics/histogram.h"
  19 #include "base/sequenced_task_runner.h"
  20 #include "base/single_thread_task_runner.h"
  21 #include "base/strings/string_number_conversions.h"
  22 #include "base/sys_info.h"
  23 #include "base/task_runner_util.h"
  24 #include "base/time/time.h"
  25 #include "net/base/net_util.h"
  26 #include "storage/browser/quota/quota_database.h"
  27 #include "storage/browser/quota/quota_manager_proxy.h"
  28 #include "storage/browser/quota/quota_temporary_storage_evictor.h"
  29 #include "storage/browser/quota/storage_monitor.h"
  30 #include "storage/browser/quota/usage_tracker.h"
  31 #include "storage/common/quota/quota_types.h"
  32
  33 #define UMA_HISTOGRAM_MBYTES(name, sample)          \
  34   UMA_HISTOGRAM_CUSTOM_COUNTS(                      \
  35       (name), static_cast<int>((sample) / kMBytes), \
  36       1, 10 * 1024 * 1024 /* 10TB */, 100)
  37
  38 namespace storage {
  39
  40 namespace {
  41
  42 const int64 kMBytes = 1024 * 1024;
  43 const int kMinutesInMilliSeconds = 60 * 1000;
  44
  45 const int64 kReportHistogramInterval = 60 * 60 * 1000;  // 1 hour
  46 const double kTemporaryQuotaRatioToAvail = 1.0 / 3.0;  // 33%
  47
  48 }  // namespace
  49
  50 // Arbitrary for now, but must be reasonably small so that
  51 // in-memory databases can fit.
  52 // TODO(kinuko): Refer SysInfo::AmountOfPhysicalMemory() to determine this.
  53 const int64 QuotaManager::kIncognitoDefaultQuotaLimit = 100 * kMBytes;
  54
  55 const int64 QuotaManager::kNoLimit = kint64max;
  56
  57 const int QuotaManager::kPerHostTemporaryPortion = 5;  // 20%
  58
  59 // Cap size for per-host persistent quota determined by the histogram.
  60 // This is a bit lax value because the histogram says nothing about per-host
  61 // persistent storage usage and we determined by global persistent storage
  62 // usage that is less than 10GB for almost all users.
  63 const int64 QuotaManager::kPerHostPersistentQuotaLimit = 10 * 1024 * kMBytes;
  64
  65 const char QuotaManager::kDatabaseName[] = "QuotaManager";
  66
  67 const int QuotaManager::kThresholdOfErrorsToBeBlacklisted = 3;
  68
  69 // Preserve kMinimumPreserveForSystem disk space for system book-keeping
  70 // when returning the quota to unlimited apps/extensions.
  71 // TODO(kinuko): This should be like 10% of the actual disk space.
  72 // For now we simply use a constant as getting the disk size needs
  73 // platform-dependent code. (http://crbug.com/178976)
  74 int64 QuotaManager::kMinimumPreserveForSystem = 1024 * kMBytes;
  75
  76 const int QuotaManager::kEvictionIntervalInMilliSeconds =
  77     30 * kMinutesInMilliSeconds;
  78
  79 // Heuristics: assuming average cloud server allows a few Gigs storage
  80 // on the server side and the storage needs to be shared for user data
  81 // and by multiple apps.
  82 int64 QuotaManager::kSyncableStorageDefaultHostQuota = 500 * kMBytes;
  83
  84 namespace {
  85
  86 void CountOriginType(const std::set<GURL>& origins,
  87                      SpecialStoragePolicy* policy,
  88                      size_t* protected_origins,
  89                      size_t* unlimited_origins) {
  90   DCHECK(protected_origins);
  91   DCHECK(unlimited_origins);
  92   *protected_origins = 0;
  93   *unlimited_origins = 0;
  94   if (!policy)
  95     return;
  96   for (std::set<GURL>::const_iterator itr = origins.begin();
  97        itr != origins.end();
  98        ++itr) {
  99     if (policy->IsStorageProtected(*itr))
 100       ++*protected_origins;
 101     if (policy->IsStorageUnlimited(*itr))
 102       ++*unlimited_origins;
 103   }
 104 }
 105
 106 bool SetTemporaryGlobalOverrideQuotaOnDBThread(int64* new_quota,
 107                                                QuotaDatabase* database) {
 108   DCHECK(database);
 109   if (!database->SetQuotaConfigValue(
 110           QuotaDatabase::kTemporaryQuotaOverrideKey, *new_quota)) {
 111     *new_quota = -1;
 112     return false;
 113   }
 114   return true;
 115 }
 116
 117 bool GetPersistentHostQuotaOnDBThread(const std::string& host,
 118                                       int64* quota,
 119                                       QuotaDatabase* database) {
 120   DCHECK(database);
 121   database->GetHostQuota(host, kStorageTypePersistent, quota);
 122   return true;
 123 }
 124
 125 bool SetPersistentHostQuotaOnDBThread(const std::string& host,
 126                                       int64* new_quota,
 127                                       QuotaDatabase* database) {
 128   DCHECK(database);
 129   if (database->SetHostQuota(host, kStorageTypePersistent, *new_quota))
 130     return true;
 131   *new_quota = 0;
 132   return false;
 133 }
 134
 135 bool InitializeOnDBThread(int64* temporary_quota_override,
 136                           int64* desired_available_space,
 137                           QuotaDatabase* database) {
 138   DCHECK(database);
 139   database->GetQuotaConfigValue(QuotaDatabase::kTemporaryQuotaOverrideKey,
 140                                 temporary_quota_override);
 141   database->GetQuotaConfigValue(QuotaDatabase::kDesiredAvailableSpaceKey,
 142                                 desired_available_space);
 143   return true;
 144 }
 145
 146 bool GetLRUOriginOnDBThread(StorageType type,
 147                             std::set<GURL>* exceptions,
 148                             SpecialStoragePolicy* policy,
 149                             GURL* url,
 150                             QuotaDatabase* database) {
 151   DCHECK(database);
 152   database->GetLRUOrigin(type, *exceptions, policy, url);
 153   return true;
 154 }
 155
 156 bool DeleteOriginInfoOnDBThread(const GURL& origin,
 157                                 StorageType type,
 158                                 QuotaDatabase* database) {
 159   DCHECK(database);
 160   return database->DeleteOriginInfo(origin, type);
 161 }
 162
 163 bool InitializeTemporaryOriginsInfoOnDBThread(const std::set<GURL>* origins,
 164                                               QuotaDatabase* database) {
 165   DCHECK(database);
 166   if (database->IsOriginDatabaseBootstrapped())
 167     return true;
 168
 169   // Register existing origins with 0 last time access.
 170   if (database->RegisterInitialOriginInfo(*origins, kStorageTypeTemporary)) {
 171     database->SetOriginDatabaseBootstrapped(true);
 172     return true;
 173   }
 174   return false;
 175 }
 176
 177 bool UpdateAccessTimeOnDBThread(const GURL& origin,
 178                                 StorageType type,
 179                                 base::Time accessed_time,
 180                                 QuotaDatabase* database) {
 181   DCHECK(database);
 182   return database->SetOriginLastAccessTime(origin, type, accessed_time);
 183 }
 184
 185 bool UpdateModifiedTimeOnDBThread(const GURL& origin,
 186                                   StorageType type,
 187                                   base::Time modified_time,
 188                                   QuotaDatabase* database) {
 189   DCHECK(database);
 190   return database->SetOriginLastModifiedTime(origin, type, modified_time);
 191 }
 192
 193 int64 CallSystemGetAmountOfFreeDiskSpace(const base::FilePath& profile_path) {
 194   // Ensure the profile path exists.
 195   if (!base::CreateDirectory(profile_path)) {
 196     LOG(WARNING) << "Create directory failed for path" << profile_path.value();
 197     return 0;
 198   }
 199   return base::SysInfo::AmountOfFreeDiskSpace(profile_path);
 200 }
 201
 202 int64 CalculateTemporaryGlobalQuota(int64 global_limited_usage,
 203                                     int64 available_space) {
 204   DCHECK_GE(global_limited_usage, 0);
 205   int64 avail_space = available_space;
 206   if (avail_space < kint64max - global_limited_usage) {
 207     // We basically calculate the temporary quota by
 208     // [available_space + space_used_for_temp] * kTempQuotaRatio,
 209     // but make sure we'll have no overflow.
 210     avail_space += global_limited_usage;
 211   }
 212   return avail_space * kTemporaryQuotaRatioToAvail;
 213 }
 214
 215 void DispatchTemporaryGlobalQuotaCallback(
 216     const QuotaCallback& callback,
 217     QuotaStatusCode status,
 218     const UsageAndQuota& usage_and_quota) {
 219   if (status != kQuotaStatusOk) {
 220     callback.Run(status, 0);
 221     return;
 222   }
 223
 224   callback.Run(status, CalculateTemporaryGlobalQuota(
 225       usage_and_quota.global_limited_usage,
 226       usage_and_quota.available_disk_space));
 227 }
 228
 229 int64 CalculateQuotaWithDiskSpace(
 230     int64 available_disk_space, int64 usage, int64 quota) {
 231   if (available_disk_space < QuotaManager::kMinimumPreserveForSystem) {
 232     LOG(WARNING)
 233         << "Running out of disk space for profile."
 234         << " QuotaManager starts forbidding further quota consumption.";
 235     return usage;
 236   }
 237
 238   if (quota < usage) {
 239     // No more space; cap the quota to the current usage.
 240     return usage;
 241   }
 242
 243   available_disk_space -= QuotaManager::kMinimumPreserveForSystem;
 244   if (available_disk_space < quota - usage)
 245     return available_disk_space + usage;
 246
 247   return quota;
 248 }
 249
 250 int64 CalculateTemporaryHostQuota(int64 host_usage,
 251                                   int64 global_quota,
 252                                   int64 global_limited_usage) {
 253   DCHECK_GE(global_limited_usage, 0);
 254   int64 host_quota = global_quota / QuotaManager::kPerHostTemporaryPortion;
 255   if (global_limited_usage > global_quota)
 256     host_quota = std::min(host_quota, host_usage);
 257   return host_quota;
 258 }
 259
 260 void DispatchUsageAndQuotaForWebApps(
 261     StorageType type,
 262     bool is_incognito,
 263     bool is_unlimited,
 264     bool can_query_disk_size,
 265     const QuotaManager::GetUsageAndQuotaCallback& callback,
 266     QuotaStatusCode status,
 267     const UsageAndQuota& usage_and_quota) {
 268   if (status != kQuotaStatusOk) {
 269     callback.Run(status, 0, 0);
 270     return;
 271   }
 272
 273   int64 usage = usage_and_quota.usage;
 274   int64 quota = usage_and_quota.quota;
 275
 276   if (type == kStorageTypeTemporary && !is_unlimited) {
 277     quota = CalculateTemporaryHostQuota(
 278         usage, quota, usage_and_quota.global_limited_usage);
 279   }
 280
 281   if (is_incognito) {
 282     quota = std::min(quota, QuotaManager::kIncognitoDefaultQuotaLimit);
 283     callback.Run(status, usage, quota);
 284     return;
 285   }
 286
 287   // For apps with unlimited permission or can_query_disk_size is true (and not
 288   // in incognito mode).
 289   // We assume we can expose the actual disk size for them and cap the quota by
 290   // the available disk space.
 291   if (is_unlimited || can_query_disk_size) {
 292     callback.Run(
 293         status, usage,
 294         CalculateQuotaWithDiskSpace(
 295             usage_and_quota.available_disk_space,
 296             usage, quota));
 297     return;
 298   }
 299
 300   callback.Run(status, usage, quota);
 301 }
 302
 303 }  // namespace
 304
 305 UsageAndQuota::UsageAndQuota()
 306     : usage(0),
 307       global_limited_usage(0),
 308       quota(0),
 309       available_disk_space(0) {
 310 }
 311
 312 UsageAndQuota::UsageAndQuota(
 313     int64 usage,
 314     int64 global_limited_usage,
 315     int64 quota,
 316     int64 available_disk_space)
 317     : usage(usage),
 318       global_limited_usage(global_limited_usage),
 319       quota(quota),
 320       available_disk_space(available_disk_space) {
 321 }
 322
 323 class UsageAndQuotaCallbackDispatcher
 324     : public QuotaTask,
 325       public base::SupportsWeakPtr<UsageAndQuotaCallbackDispatcher> {
 326  public:
 327   explicit UsageAndQuotaCallbackDispatcher(QuotaManager* manager)
 328       : QuotaTask(manager),
 329         has_usage_(false),
 330         has_global_limited_usage_(false),
 331         has_quota_(false),
 332         has_available_disk_space_(false),
 333         status_(kQuotaStatusUnknown),
 334         usage_and_quota_(-1, -1, -1, -1),
 335         waiting_callbacks_(1) {}
 336
 337   virtual ~UsageAndQuotaCallbackDispatcher() {}
 338
 339   void WaitForResults(const QuotaManager::UsageAndQuotaCallback& callback) {
 340     callback_ = callback;
 341     Start();
 342   }
 343
 344   void set_usage(int64 usage) {
 345     usage_and_quota_.usage = usage;
 346     has_usage_ = true;
 347   }
 348
 349   void set_global_limited_usage(int64 global_limited_usage) {
 350     usage_and_quota_.global_limited_usage = global_limited_usage;
 351     has_global_limited_usage_ = true;
 352   }
 353
 354   void set_quota(int64 quota) {
 355     usage_and_quota_.quota = quota;
 356     has_quota_ = true;
 357   }
 358
 359   void set_available_disk_space(int64 available_disk_space) {
 360     usage_and_quota_.available_disk_space = available_disk_space;
 361     has_available_disk_space_ = true;
 362   }
 363
 364   UsageCallback GetHostUsageCallback() {
 365     ++waiting_callbacks_;
 366     has_usage_ = true;
 367     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetHostUsage,
 368                       AsWeakPtr());
 369   }
 370
 371   UsageCallback GetGlobalLimitedUsageCallback() {
 372     ++waiting_callbacks_;
 373     has_global_limited_usage_ = true;
 374     return base::Bind(
 375         &UsageAndQuotaCallbackDispatcher::DidGetGlobalLimitedUsage,
 376         AsWeakPtr());
 377   }
 378
 379   QuotaCallback GetQuotaCallback() {
 380     ++waiting_callbacks_;
 381     has_quota_ = true;
 382     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetQuota,
 383                       AsWeakPtr());
 384   }
 385
 386   QuotaCallback GetAvailableSpaceCallback() {
 387     ++waiting_callbacks_;
 388     has_available_disk_space_ = true;
 389     return base::Bind(&UsageAndQuotaCallbackDispatcher::DidGetAvailableSpace,
 390                       AsWeakPtr());
 391   }
 392
 393  private:
 394   void DidGetHostUsage(int64 usage) {
 395     if (status_ == kQuotaStatusUnknown)
 396       status_ = kQuotaStatusOk;
 397     usage_and_quota_.usage = usage;
 398     CheckCompleted();
 399   }
 400
 401   void DidGetGlobalLimitedUsage(int64 limited_usage) {
 402     if (status_ == kQuotaStatusUnknown)
 403       status_ = kQuotaStatusOk;
 404     usage_and_quota_.global_limited_usage = limited_usage;
 405     CheckCompleted();
 406   }
 407
 408   void DidGetQuota(QuotaStatusCode status, int64 quota) {
 409     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
 410       status_ = status;
 411     usage_and_quota_.quota = quota;
 412     CheckCompleted();
 413   }
 414
 415   void DidGetAvailableSpace(QuotaStatusCode status, int64 space) {
 416     DCHECK_GE(space, 0);
 417     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
 418       status_ = status;
 419     usage_and_quota_.available_disk_space = space;
 420     CheckCompleted();
 421   }
 422
 423   virtual void Run() OVERRIDE {
 424     // We initialize waiting_callbacks to 1 so that we won't run
 425     // the completion callback until here even some of the callbacks
 426     // are dispatched synchronously.
 427     CheckCompleted();
 428   }
 429
 430   virtual void Aborted() OVERRIDE {
 431     callback_.Run(kQuotaErrorAbort, UsageAndQuota());
 432     DeleteSoon();
 433   }
 434
 435   virtual void Completed() OVERRIDE {
 436     DCHECK(!has_usage_ || usage_and_quota_.usage >= 0);
 437     DCHECK(!has_global_limited_usage_ ||
 438            usage_and_quota_.global_limited_usage >= 0);
 439     DCHECK(!has_quota_ || usage_and_quota_.quota >= 0);
 440     DCHECK(!has_available_disk_space_ ||
 441            usage_and_quota_.available_disk_space >= 0);
 442
 443     callback_.Run(status_, usage_and_quota_);
 444     DeleteSoon();
 445   }
 446
 447   void CheckCompleted() {
 448     if (--waiting_callbacks_ <= 0)
 449       CallCompleted();
 450   }
 451
 452   // For sanity checks, they're checked only when DCHECK is on.
 453   bool has_usage_;
 454   bool has_global_limited_usage_;
 455   bool has_quota_;
 456   bool has_available_disk_space_;
 457
 458   QuotaStatusCode status_;
 459   UsageAndQuota usage_and_quota_;
 460   QuotaManager::UsageAndQuotaCallback callback_;
 461   int waiting_callbacks_;
 462
 463   DISALLOW_COPY_AND_ASSIGN(UsageAndQuotaCallbackDispatcher);
 464 };
 465
 466 class QuotaManager::GetUsageInfoTask : public QuotaTask {
 467  public:
 468   GetUsageInfoTask(
 469       QuotaManager* manager,
 470       const GetUsageInfoCallback& callback)
 471       : QuotaTask(manager),
 472         callback_(callback),
 473         weak_factory_(this) {
 474   }
 475
 476  protected:
 477   virtual void Run() OVERRIDE {
 478     remaining_trackers_ = 3;
 479     // This will populate cached hosts and usage info.
 480     manager()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
 481         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
 482                    weak_factory_.GetWeakPtr(),
 483                    kStorageTypeTemporary));
 484     manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
 485         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
 486                    weak_factory_.GetWeakPtr(),
 487                    kStorageTypePersistent));
 488     manager()->GetUsageTracker(kStorageTypeSyncable)->GetGlobalUsage(
 489         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
 490                    weak_factory_.GetWeakPtr(),
 491                    kStorageTypeSyncable));
 492   }
 493
 494   virtual void Completed() OVERRIDE {
 495     callback_.Run(entries_);
 496     DeleteSoon();
 497   }
 498
 499   virtual void Aborted() OVERRIDE {
 500     callback_.Run(UsageInfoEntries());
 501     DeleteSoon();
 502   }
 503
 504  private:
 505   void AddEntries(StorageType type, UsageTracker* tracker) {
 506     std::map<std::string, int64> host_usage;
 507     tracker->GetCachedHostsUsage(&host_usage);
 508     for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
 509          iter != host_usage.end();
 510          ++iter) {
 511       entries_.push_back(UsageInfo(iter->first, type, iter->second));
 512     }
 513     if (--remaining_trackers_ == 0)
 514       CallCompleted();
 515   }
 516
 517   void DidGetGlobalUsage(StorageType type, int64, int64) {
 518     DCHECK(manager()->GetUsageTracker(type));
 519     AddEntries(type, manager()->GetUsageTracker(type));
 520   }
 521
 522   QuotaManager* manager() const {
 523     return static_cast<QuotaManager*>(observer());
 524   }
 525
 526   GetUsageInfoCallback callback_;
 527   UsageInfoEntries entries_;
 528   int remaining_trackers_;
 529   base::WeakPtrFactory<GetUsageInfoTask> weak_factory_;
 530
 531   DISALLOW_COPY_AND_ASSIGN(GetUsageInfoTask);
 532 };
 533
 534 class QuotaManager::OriginDataDeleter : public QuotaTask {
 535  public:
 536   OriginDataDeleter(QuotaManager* manager,
 537                     const GURL& origin,
 538                     StorageType type,
 539                     int quota_client_mask,
 540                     const StatusCallback& callback)
 541       : QuotaTask(manager),
 542         origin_(origin),
 543         type_(type),
 544         quota_client_mask_(quota_client_mask),
 545         error_count_(0),
 546         remaining_clients_(-1),
 547         skipped_clients_(0),
 548         callback_(callback),
 549         weak_factory_(this) {}
 550
 551  protected:
 552   virtual void Run() OVERRIDE {
 553     error_count_ = 0;
 554     remaining_clients_ = manager()->clients_.size();
 555     for (QuotaClientList::iterator iter = manager()->clients_.begin();
 556          iter != manager()->clients_.end(); ++iter) {
 557       if (quota_client_mask_ & (*iter)->id()) {
 558         (*iter)->DeleteOriginData(
 559             origin_, type_,
 560             base::Bind(&OriginDataDeleter::DidDeleteOriginData,
 561                        weak_factory_.GetWeakPtr()));
 562       } else {
 563         ++skipped_clients_;
 564         if (--remaining_clients_ == 0)
 565           CallCompleted();
 566       }
 567     }
 568   }
 569
 570   virtual void Completed() OVERRIDE {
 571     if (error_count_ == 0) {
 572       // Only remove the entire origin if we didn't skip any client types.
 573       if (skipped_clients_ == 0)
 574         manager()->DeleteOriginFromDatabase(origin_, type_);
 575       callback_.Run(kQuotaStatusOk);
 576     } else {
 577       callback_.Run(kQuotaErrorInvalidModification);
 578     }
 579     DeleteSoon();
 580   }
 581
 582   virtual void Aborted() OVERRIDE {
 583     callback_.Run(kQuotaErrorAbort);
 584     DeleteSoon();
 585   }
 586
 587  private:
 588   void DidDeleteOriginData(QuotaStatusCode status) {
 589     DCHECK_GT(remaining_clients_, 0);
 590
 591     if (status != kQuotaStatusOk)
 592       ++error_count_;
 593
 594     if (--remaining_clients_ == 0)
 595       CallCompleted();
 596   }
 597
 598   QuotaManager* manager() const {
 599     return static_cast<QuotaManager*>(observer());
 600   }
 601
 602   GURL origin_;
 603   StorageType type_;
 604   int quota_client_mask_;
 605   int error_count_;
 606   int remaining_clients_;
 607   int skipped_clients_;
 608   StatusCallback callback_;
 609
 610   base::WeakPtrFactory<OriginDataDeleter> weak_factory_;
 611   DISALLOW_COPY_AND_ASSIGN(OriginDataDeleter);
 612 };
 613
 614 class QuotaManager::HostDataDeleter : public QuotaTask {
 615  public:
 616   HostDataDeleter(QuotaManager* manager,
 617                   const std::string& host,
 618                   StorageType type,
 619                   int quota_client_mask,
 620                   const StatusCallback& callback)
 621       : QuotaTask(manager),
 622         host_(host),
 623         type_(type),
 624         quota_client_mask_(quota_client_mask),
 625         error_count_(0),
 626         remaining_clients_(-1),
 627         remaining_deleters_(-1),
 628         callback_(callback),
 629         weak_factory_(this) {}
 630
 631  protected:
 632   virtual void Run() OVERRIDE {
 633     error_count_ = 0;
 634     remaining_clients_ = manager()->clients_.size();
 635     for (QuotaClientList::iterator iter = manager()->clients_.begin();
 636          iter != manager()->clients_.end(); ++iter) {
 637       (*iter)->GetOriginsForHost(
 638           type_, host_,
 639           base::Bind(&HostDataDeleter::DidGetOriginsForHost,
 640                      weak_factory_.GetWeakPtr()));
 641     }
 642   }
 643
 644   virtual void Completed() OVERRIDE {
 645     if (error_count_ == 0) {
 646       callback_.Run(kQuotaStatusOk);
 647     } else {
 648       callback_.Run(kQuotaErrorInvalidModification);
 649     }
 650     DeleteSoon();
 651   }
 652
 653   virtual void Aborted() OVERRIDE {
 654     callback_.Run(kQuotaErrorAbort);
 655     DeleteSoon();
 656   }
 657
 658  private:
 659   void DidGetOriginsForHost(const std::set<GURL>& origins) {
 660     DCHECK_GT(remaining_clients_, 0);
 661
 662     origins_.insert(origins.begin(), origins.end());
 663
 664     if (--remaining_clients_ == 0) {
 665       if (!origins_.empty())
 666         ScheduleOriginsDeletion();
 667       else
 668         CallCompleted();
 669     }
 670   }
 671
 672   void ScheduleOriginsDeletion() {
 673     remaining_deleters_ = origins_.size();
 674     for (std::set<GURL>::const_iterator p = origins_.begin();
 675          p != origins_.end();
 676          ++p) {
 677       OriginDataDeleter* deleter =
 678           new OriginDataDeleter(
 679               manager(), *p, type_, quota_client_mask_,
 680               base::Bind(&HostDataDeleter::DidDeleteOriginData,
 681                          weak_factory_.GetWeakPtr()));
 682       deleter->Start();
 683     }
 684   }
 685
 686   void DidDeleteOriginData(QuotaStatusCode status) {
 687     DCHECK_GT(remaining_deleters_, 0);
 688
 689     if (status != kQuotaStatusOk)
 690       ++error_count_;
 691
 692     if (--remaining_deleters_ == 0)
 693       CallCompleted();
 694   }
 695
 696   QuotaManager* manager() const {
 697     return static_cast<QuotaManager*>(observer());
 698   }
 699
 700   std::string host_;
 701   StorageType type_;
 702   int quota_client_mask_;
 703   std::set<GURL> origins_;
 704   int error_count_;
 705   int remaining_clients_;
 706   int remaining_deleters_;
 707   StatusCallback callback_;
 708
 709   base::WeakPtrFactory<HostDataDeleter> weak_factory_;
 710   DISALLOW_COPY_AND_ASSIGN(HostDataDeleter);
 711 };
 712
 713 class QuotaManager::GetModifiedSinceHelper {
 714  public:
 715   bool GetModifiedSinceOnDBThread(StorageType type,
 716                                   base::Time modified_since,
 717                                   QuotaDatabase* database) {
 718     DCHECK(database);
 719     return database->GetOriginsModifiedSince(type, &origins_, modified_since);
 720   }
 721
 722   void DidGetModifiedSince(const base::WeakPtr<QuotaManager>& manager,
 723                            const GetOriginsCallback& callback,
 724                            StorageType type,
 725                            bool success) {
 726     if (!manager) {
 727       // The operation was aborted.
 728       callback.Run(std::set<GURL>(), type);
 729       return;
 730     }
 731     manager->DidDatabaseWork(success);
 732     callback.Run(origins_, type);
 733   }
 734
 735  private:
 736   std::set<GURL> origins_;
 737 };
 738
 739 class QuotaManager::DumpQuotaTableHelper {
 740  public:
 741   bool DumpQuotaTableOnDBThread(QuotaDatabase* database) {
 742     DCHECK(database);
 743     return database->DumpQuotaTable(
 744         base::Bind(&DumpQuotaTableHelper::AppendEntry, base::Unretained(this)));
 745   }
 746
 747   void DidDumpQuotaTable(const base::WeakPtr<QuotaManager>& manager,
 748                          const DumpQuotaTableCallback& callback,
 749                          bool success) {
 750     if (!manager) {
 751       // The operation was aborted.
 752       callback.Run(QuotaTableEntries());
 753       return;
 754     }
 755     manager->DidDatabaseWork(success);
 756     callback.Run(entries_);
 757   }
 758
 759  private:
 760   bool AppendEntry(const QuotaTableEntry& entry) {
 761     entries_.push_back(entry);
 762     return true;
 763   }
 764
 765   QuotaTableEntries entries_;
 766 };
 767
 768 class QuotaManager::DumpOriginInfoTableHelper {
 769  public:
 770   bool DumpOriginInfoTableOnDBThread(QuotaDatabase* database) {
 771     DCHECK(database);
 772     return database->DumpOriginInfoTable(
 773         base::Bind(&DumpOriginInfoTableHelper::AppendEntry,
 774                    base::Unretained(this)));
 775   }
 776
 777   void DidDumpOriginInfoTable(const base::WeakPtr<QuotaManager>& manager,
 778                               const DumpOriginInfoTableCallback& callback,
 779                               bool success) {
 780     if (!manager) {
 781       // The operation was aborted.
 782       callback.Run(OriginInfoTableEntries());
 783       return;
 784     }
 785     manager->DidDatabaseWork(success);
 786     callback.Run(entries_);
 787   }
 788
 789  private:
 790   bool AppendEntry(const OriginInfoTableEntry& entry) {
 791     entries_.push_back(entry);
 792     return true;
 793   }
 794
 795   OriginInfoTableEntries entries_;
 796 };
 797
 798 // QuotaManager ---------------------------------------------------------------
 799
 800 QuotaManager::QuotaManager(
 801     bool is_incognito,
 802     const base::FilePath& profile_path,
 803     const scoped_refptr<base::SingleThreadTaskRunner>& io_thread,
 804     const scoped_refptr<base::SequencedTaskRunner>& db_thread,
 805     const scoped_refptr<SpecialStoragePolicy>& special_storage_policy)
 806     : is_incognito_(is_incognito),
 807       profile_path_(profile_path),
 808       proxy_(new QuotaManagerProxy(this, io_thread)),
 809       db_disabled_(false),
 810       eviction_disabled_(false),
 811       io_thread_(io_thread),
 812       db_thread_(db_thread),
 813       temporary_quota_initialized_(false),
 814       temporary_quota_override_(-1),
 815       desired_available_space_(-1),
 816       special_storage_policy_(special_storage_policy),
 817       get_disk_space_fn_(&CallSystemGetAmountOfFreeDiskSpace),
 818       storage_monitor_(new StorageMonitor(this)),
 819       weak_factory_(this) {
 820 }
 821
 822 void QuotaManager::GetUsageInfo(const GetUsageInfoCallback& callback) {
 823   LazyInitialize();
 824   GetUsageInfoTask* get_usage_info = new GetUsageInfoTask(this, callback);
 825   get_usage_info->Start();
 826 }
 827
 828 void QuotaManager::GetUsageAndQuotaForWebApps(
 829     const GURL& origin,
 830     StorageType type,
 831     const GetUsageAndQuotaCallback& callback) {
 832   if (type != kStorageTypeTemporary &&
 833       type != kStorageTypePersistent &&
 834       type != kStorageTypeSyncable) {
 835     callback.Run(kQuotaErrorNotSupported, 0, 0);
 836     return;
 837   }
 838
 839   DCHECK(origin == origin.GetOrigin());
 840   LazyInitialize();
 841
 842   bool unlimited = IsStorageUnlimited(origin, type);
 843   bool can_query_disk_size = CanQueryDiskSize(origin);
 844
 845   UsageAndQuotaCallbackDispatcher* dispatcher =
 846       new UsageAndQuotaCallbackDispatcher(this);
 847
 848   UsageAndQuota usage_and_quota;
 849   if (unlimited) {
 850     dispatcher->set_quota(kNoLimit);
 851   } else {
 852     if (type == kStorageTypeTemporary) {
 853       GetUsageTracker(type)->GetGlobalLimitedUsage(
 854           dispatcher->GetGlobalLimitedUsageCallback());
 855       GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
 856     } else if (type == kStorageTypePersistent) {
 857       GetPersistentHostQuota(net::GetHostOrSpecFromURL(origin),
 858                              dispatcher->GetQuotaCallback());
 859     } else {
 860       dispatcher->set_quota(kSyncableStorageDefaultHostQuota);
 861     }
 862   }
 863
 864   DCHECK(GetUsageTracker(type));
 865   GetUsageTracker(type)->GetHostUsage(net::GetHostOrSpecFromURL(origin),
 866                                       dispatcher->GetHostUsageCallback());
 867
 868   if (!is_incognito_ && (unlimited || can_query_disk_size))
 869     GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
 870
 871   dispatcher->WaitForResults(base::Bind(
 872       &DispatchUsageAndQuotaForWebApps,
 873       type, is_incognito_, unlimited, can_query_disk_size,
 874       callback));
 875 }
 876
 877 void QuotaManager::GetUsageAndQuota(
 878     const GURL& origin, StorageType type,
 879     const GetUsageAndQuotaCallback& callback) {
 880   DCHECK(origin == origin.GetOrigin());
 881
 882   if (IsStorageUnlimited(origin, type)) {
 883     callback.Run(kQuotaStatusOk, 0, kNoLimit);
 884     return;
 885   }
 886
 887   GetUsageAndQuotaForWebApps(origin, type, callback);
 888 }
 889
 890 void QuotaManager::NotifyStorageAccessed(
 891     QuotaClient::ID client_id,
 892     const GURL& origin, StorageType type) {
 893   DCHECK(origin == origin.GetOrigin());
 894   NotifyStorageAccessedInternal(client_id, origin, type, base::Time::Now());
 895 }
 896
 897 void QuotaManager::NotifyStorageModified(
 898     QuotaClient::ID client_id,
 899     const GURL& origin, StorageType type, int64 delta) {
 900   DCHECK(origin == origin.GetOrigin());
 901   NotifyStorageModifiedInternal(client_id, origin, type, delta,
 902                                 base::Time::Now());
 903 }
 904
 905 void QuotaManager::NotifyOriginInUse(const GURL& origin) {
 906   DCHECK(io_thread_->BelongsToCurrentThread());
 907   origins_in_use_[origin]++;
 908 }
 909
 910 void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
 911   DCHECK(io_thread_->BelongsToCurrentThread());
 912   DCHECK(IsOriginInUse(origin));
 913   int& count = origins_in_use_[origin];
 914   if (--count == 0)
 915     origins_in_use_.erase(origin);
 916 }
 917
 918 void QuotaManager::SetUsageCacheEnabled(QuotaClient::ID client_id,
 919                                         const GURL& origin,
 920                                         StorageType type,
 921                                         bool enabled) {
 922   LazyInitialize();
 923   DCHECK(GetUsageTracker(type));
 924   GetUsageTracker(type)->SetUsageCacheEnabled(client_id, origin, enabled);
 925 }
 926
 927 void QuotaManager::DeleteOriginData(
 928     const GURL& origin, StorageType type, int quota_client_mask,
 929     const StatusCallback& callback) {
 930   LazyInitialize();
 931
 932   if (origin.is_empty() || clients_.empty()) {
 933     callback.Run(kQuotaStatusOk);
 934     return;
 935   }
 936
 937   DCHECK(origin == origin.GetOrigin());
 938   OriginDataDeleter* deleter =
 939       new OriginDataDeleter(this, origin, type, quota_client_mask, callback);
 940   deleter->Start();
 941 }
 942
 943 void QuotaManager::DeleteHostData(const std::string& host,
 944                                   StorageType type,
 945                                   int quota_client_mask,
 946                                   const StatusCallback& callback) {
 947   LazyInitialize();
 948
 949   if (host.empty() || clients_.empty()) {
 950     callback.Run(kQuotaStatusOk);
 951     return;
 952   }
 953
 954   HostDataDeleter* deleter =
 955       new HostDataDeleter(this, host, type, quota_client_mask, callback);
 956   deleter->Start();
 957 }
 958
 959 void QuotaManager::GetAvailableSpace(const AvailableSpaceCallback& callback) {
 960   if (!available_space_callbacks_.Add(callback))
 961     return;
 962
 963   PostTaskAndReplyWithResult(db_thread_.get(),
 964                              FROM_HERE,
 965                              base::Bind(get_disk_space_fn_, profile_path_),
 966                              base::Bind(&QuotaManager::DidGetAvailableSpace,
 967                                         weak_factory_.GetWeakPtr()));
 968 }
 969
 970 void QuotaManager::GetTemporaryGlobalQuota(const QuotaCallback& callback) {
 971   LazyInitialize();
 972   if (!temporary_quota_initialized_) {
 973     db_initialization_callbacks_.Add(base::Bind(
 974         &QuotaManager::GetTemporaryGlobalQuota,
 975         weak_factory_.GetWeakPtr(), callback));
 976     return;
 977   }
 978
 979   if (temporary_quota_override_ > 0) {
 980     callback.Run(kQuotaStatusOk, temporary_quota_override_);
 981     return;
 982   }
 983
 984   UsageAndQuotaCallbackDispatcher* dispatcher =
 985       new UsageAndQuotaCallbackDispatcher(this);
 986   GetUsageTracker(kStorageTypeTemporary)->
 987       GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
 988   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
 989   dispatcher->WaitForResults(
 990       base::Bind(&DispatchTemporaryGlobalQuotaCallback, callback));
 991 }
 992
 993 void QuotaManager::SetTemporaryGlobalOverrideQuota(
 994     int64 new_quota, const QuotaCallback& callback) {
 995   LazyInitialize();
 996
 997   if (new_quota < 0) {
 998     if (!callback.is_null())
 999       callback.Run(kQuotaErrorInvalidModification, -1);
1000     return;
1001   }
1002
1003   if (db_disabled_) {
1004     if (!callback.is_null())
1005       callback.Run(kQuotaErrorInvalidAccess, -1);
1006     return;
1007   }
1008
1009   int64* new_quota_ptr = new int64(new_quota);
1010   PostTaskAndReplyWithResultForDBThread(
1011       FROM_HERE,
1012       base::Bind(&SetTemporaryGlobalOverrideQuotaOnDBThread,
1013                  base::Unretained(new_quota_ptr)),
1014       base::Bind(&QuotaManager::DidSetTemporaryGlobalOverrideQuota,
1015                  weak_factory_.GetWeakPtr(),
1016                  callback,
1017                  base::Owned(new_quota_ptr)));
1018 }
1019
1020 void QuotaManager::GetPersistentHostQuota(const std::string& host,
1021                                           const QuotaCallback& callback) {
1022   LazyInitialize();
1023   if (host.empty()) {
1024     // This could happen if we are called on file:///.
1025     // TODO(kinuko) We may want to respect --allow-file-access-from-files
1026     // command line switch.
1027     callback.Run(kQuotaStatusOk, 0);
1028     return;
1029   }
1030
1031   if (!persistent_host_quota_callbacks_.Add(host, callback))
1032     return;
1033
1034   int64* quota_ptr = new int64(0);
1035   PostTaskAndReplyWithResultForDBThread(
1036       FROM_HERE,
1037       base::Bind(&GetPersistentHostQuotaOnDBThread,
1038                  host,
1039                  base::Unretained(quota_ptr)),
1040       base::Bind(&QuotaManager::DidGetPersistentHostQuota,
1041                  weak_factory_.GetWeakPtr(),
1042                  host,
1043                  base::Owned(quota_ptr)));
1044 }
1045
1046 void QuotaManager::SetPersistentHostQuota(const std::string& host,
1047                                           int64 new_quota,
1048                                           const QuotaCallback& callback) {
1049   LazyInitialize();
1050   if (host.empty()) {
1051     // This could happen if we are called on file:///.
1052     callback.Run(kQuotaErrorNotSupported, 0);
1053     return;
1054   }
1055
1056   if (new_quota < 0) {
1057     callback.Run(kQuotaErrorInvalidModification, -1);
1058     return;
1059   }
1060
1061   if (kPerHostPersistentQuotaLimit < new_quota) {
1062     // Cap the requested size at the per-host quota limit.
1063     new_quota = kPerHostPersistentQuotaLimit;
1064   }
1065
1066   if (db_disabled_) {
1067     callback.Run(kQuotaErrorInvalidAccess, -1);
1068     return;
1069   }
1070
1071   int64* new_quota_ptr = new int64(new_quota);
1072   PostTaskAndReplyWithResultForDBThread(
1073       FROM_HERE,
1074       base::Bind(&SetPersistentHostQuotaOnDBThread,
1075                  host,
1076                  base::Unretained(new_quota_ptr)),
1077       base::Bind(&QuotaManager::DidSetPersistentHostQuota,
1078                  weak_factory_.GetWeakPtr(),
1079                  host,
1080                  callback,
1081                  base::Owned(new_quota_ptr)));
1082 }
1083
1084 void QuotaManager::GetGlobalUsage(StorageType type,
1085                                   const GlobalUsageCallback& callback) {
1086   LazyInitialize();
1087   DCHECK(GetUsageTracker(type));
1088   GetUsageTracker(type)->GetGlobalUsage(callback);
1089 }
1090
1091 void QuotaManager::GetHostUsage(const std::string& host,
1092                                 StorageType type,
1093                                 const UsageCallback& callback) {
1094   LazyInitialize();
1095   DCHECK(GetUsageTracker(type));
1096   GetUsageTracker(type)->GetHostUsage(host, callback);
1097 }
1098
1099 void QuotaManager::GetHostUsage(const std::string& host,
1100                                 StorageType type,
1101                                 QuotaClient::ID client_id,
1102                                 const UsageCallback& callback) {
1103   LazyInitialize();
1104   DCHECK(GetUsageTracker(type));
1105   ClientUsageTracker* tracker =
1106       GetUsageTracker(type)->GetClientTracker(client_id);
1107   if (!tracker) {
1108     callback.Run(0);
1109     return;
1110   }
1111   tracker->GetHostUsage(host, callback);
1112 }
1113
1114 bool QuotaManager::IsTrackingHostUsage(StorageType type,
1115                                        QuotaClient::ID client_id) const {
1116   UsageTracker* tracker = GetUsageTracker(type);
1117   return tracker && tracker->GetClientTracker(client_id);
1118 }
1119
1120 void QuotaManager::GetStatistics(
1121     std::map<std::string, std::string>* statistics) {
1122   DCHECK(statistics);
1123   if (temporary_storage_evictor_) {
1124     std::map<std::string, int64> stats;
1125     temporary_storage_evictor_->GetStatistics(&stats);
1126     for (std::map<std::string, int64>::iterator p = stats.begin();
1127          p != stats.end();
1128          ++p)
1129       (*statistics)[p->first] = base::Int64ToString(p->second);
1130   }
1131 }
1132
1133 bool QuotaManager::IsStorageUnlimited(const GURL& origin,
1134                                       StorageType type) const {
1135   // For syncable storage we should always enforce quota (since the
1136   // quota must be capped by the server limit).
1137   if (type == kStorageTypeSyncable)
1138     return false;
1139   if (type == kStorageTypeQuotaNotManaged)
1140     return true;
1141   return special_storage_policy_.get() &&
1142          special_storage_policy_->IsStorageUnlimited(origin);
1143 }
1144
1145 void QuotaManager::GetOriginsModifiedSince(StorageType type,
1146                                            base::Time modified_since,
1147                                            const GetOriginsCallback& callback) {
1148   LazyInitialize();
1149   GetModifiedSinceHelper* helper = new GetModifiedSinceHelper;
1150   PostTaskAndReplyWithResultForDBThread(
1151       FROM_HERE,
1152       base::Bind(&GetModifiedSinceHelper::GetModifiedSinceOnDBThread,
1153                  base::Unretained(helper),
1154                  type,
1155                  modified_since),
1156       base::Bind(&GetModifiedSinceHelper::DidGetModifiedSince,
1157                  base::Owned(helper),
1158                  weak_factory_.GetWeakPtr(),
1159                  callback,
1160                  type));
1161 }
1162
1163 bool QuotaManager::ResetUsageTracker(StorageType type) {
1164   DCHECK(GetUsageTracker(type));
1165   if (GetUsageTracker(type)->IsWorking())
1166     return false;
1167   switch (type) {
1168     case kStorageTypeTemporary:
1169       temporary_usage_tracker_.reset(new UsageTracker(
1170           clients_, kStorageTypeTemporary, special_storage_policy_.get(),
1171           storage_monitor_.get()));
1172       return true;
1173     case kStorageTypePersistent:
1174       persistent_usage_tracker_.reset(new UsageTracker(
1175           clients_, kStorageTypePersistent, special_storage_policy_.get(),
1176           storage_monitor_.get()));
1177       return true;
1178     case kStorageTypeSyncable:
1179       syncable_usage_tracker_.reset(new UsageTracker(
1180           clients_, kStorageTypeSyncable, special_storage_policy_.get(),
1181           storage_monitor_.get()));
1182       return true;
1183     default:
1184       NOTREACHED();
1185   }
1186   return true;
1187 }
1188
1189 void QuotaManager::AddStorageObserver(
1190     StorageObserver* observer, const StorageObserver::MonitorParams& params) {
1191   DCHECK(observer);
1192   storage_monitor_->AddObserver(observer, params);
1193 }
1194
1195 void QuotaManager::RemoveStorageObserver(StorageObserver* observer) {
1196   DCHECK(observer);
1197   storage_monitor_->RemoveObserver(observer);
1198 }
1199
1200 void QuotaManager::RemoveStorageObserverForFilter(
1201     StorageObserver* observer, const StorageObserver::Filter& filter) {
1202   DCHECK(observer);
1203   storage_monitor_->RemoveObserverForFilter(observer, filter);
1204 }
1205
1206 QuotaManager::~QuotaManager() {
1207   proxy_->manager_ = NULL;
1208   std::for_each(clients_.begin(), clients_.end(),
1209                 std::mem_fun(&QuotaClient::OnQuotaManagerDestroyed));
1210   if (database_)
1211     db_thread_->DeleteSoon(FROM_HERE, database_.release());
1212 }
1213
1214 QuotaManager::EvictionContext::EvictionContext()
1215     : evicted_type(kStorageTypeUnknown) {
1216 }
1217
1218 QuotaManager::EvictionContext::~EvictionContext() {
1219 }
1220
1221 void QuotaManager::LazyInitialize() {
1222   DCHECK(io_thread_->BelongsToCurrentThread());
1223   if (database_) {
1224     // Initialization seems to be done already.
1225     return;
1226   }
1227
1228   // Use an empty path to open an in-memory only databse for incognito.
1229   database_.reset(new QuotaDatabase(is_incognito_ ? base::FilePath() :
1230       profile_path_.AppendASCII(kDatabaseName)));
1231
1232   temporary_usage_tracker_.reset(new UsageTracker(
1233       clients_, kStorageTypeTemporary, special_storage_policy_.get(),
1234       storage_monitor_.get()));
1235   persistent_usage_tracker_.reset(new UsageTracker(
1236       clients_, kStorageTypePersistent, special_storage_policy_.get(),
1237       storage_monitor_.get()));
1238   syncable_usage_tracker_.reset(new UsageTracker(
1239       clients_, kStorageTypeSyncable, special_storage_policy_.get(),
1240       storage_monitor_.get()));
1241
1242   int64* temporary_quota_override = new int64(-1);
1243   int64* desired_available_space = new int64(-1);
1244   PostTaskAndReplyWithResultForDBThread(
1245       FROM_HERE,
1246       base::Bind(&InitializeOnDBThread,
1247                  base::Unretained(temporary_quota_override),
1248                  base::Unretained(desired_available_space)),
1249       base::Bind(&QuotaManager::DidInitialize,
1250                  weak_factory_.GetWeakPtr(),
1251                  base::Owned(temporary_quota_override),
1252                  base::Owned(desired_available_space)));
1253 }
1254
1255 void QuotaManager::RegisterClient(QuotaClient* client) {
1256   DCHECK(!database_.get());
1257   clients_.push_back(client);
1258 }
1259
1260 UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
1261   switch (type) {
1262     case kStorageTypeTemporary:
1263       return temporary_usage_tracker_.get();
1264     case kStorageTypePersistent:
1265       return persistent_usage_tracker_.get();
1266     case kStorageTypeSyncable:
1267       return syncable_usage_tracker_.get();
1268     case kStorageTypeQuotaNotManaged:
1269       return NULL;
1270     case kStorageTypeUnknown:
1271       NOTREACHED();
1272   }
1273   return NULL;
1274 }
1275
1276 void QuotaManager::GetCachedOrigins(
1277     StorageType type, std::set<GURL>* origins) {
1278   DCHECK(origins);
1279   LazyInitialize();
1280   DCHECK(GetUsageTracker(type));
1281   GetUsageTracker(type)->GetCachedOrigins(origins);
1282 }
1283
1284 void QuotaManager::NotifyStorageAccessedInternal(
1285     QuotaClient::ID client_id,
1286     const GURL& origin, StorageType type,
1287     base::Time accessed_time) {
1288   LazyInitialize();
1289   if (type == kStorageTypeTemporary && !lru_origin_callback_.is_null()) {
1290     // Record the accessed origins while GetLRUOrigin task is runing
1291     // to filter out them from eviction.
1292     access_notified_origins_.insert(origin);
1293   }
1294
1295   if (db_disabled_)
1296     return;
1297   PostTaskAndReplyWithResultForDBThread(
1298       FROM_HERE,
1299       base::Bind(&UpdateAccessTimeOnDBThread, origin, type, accessed_time),
1300       base::Bind(&QuotaManager::DidDatabaseWork,
1301                  weak_factory_.GetWeakPtr()));
1302 }
1303
1304 void QuotaManager::NotifyStorageModifiedInternal(
1305     QuotaClient::ID client_id,
1306     const GURL& origin,
1307     StorageType type,
1308     int64 delta,
1309     base::Time modified_time) {
1310   LazyInitialize();
1311   DCHECK(GetUsageTracker(type));
1312   GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
1313
1314   PostTaskAndReplyWithResultForDBThread(
1315       FROM_HERE,
1316       base::Bind(&UpdateModifiedTimeOnDBThread, origin, type, modified_time),
1317       base::Bind(&QuotaManager::DidDatabaseWork,
1318                  weak_factory_.GetWeakPtr()));
1319 }
1320
1321 void QuotaManager::DumpQuotaTable(const DumpQuotaTableCallback& callback) {
1322   DumpQuotaTableHelper* helper = new DumpQuotaTableHelper;
1323   PostTaskAndReplyWithResultForDBThread(
1324       FROM_HERE,
1325       base::Bind(&DumpQuotaTableHelper::DumpQuotaTableOnDBThread,
1326                  base::Unretained(helper)),
1327       base::Bind(&DumpQuotaTableHelper::DidDumpQuotaTable,
1328                  base::Owned(helper),
1329                  weak_factory_.GetWeakPtr(),
1330                  callback));
1331 }
1332
1333 void QuotaManager::DumpOriginInfoTable(
1334     const DumpOriginInfoTableCallback& callback) {
1335   DumpOriginInfoTableHelper* helper = new DumpOriginInfoTableHelper;
1336   PostTaskAndReplyWithResultForDBThread(
1337       FROM_HERE,
1338       base::Bind(&DumpOriginInfoTableHelper::DumpOriginInfoTableOnDBThread,
1339                  base::Unretained(helper)),
1340       base::Bind(&DumpOriginInfoTableHelper::DidDumpOriginInfoTable,
1341                  base::Owned(helper),
1342                  weak_factory_.GetWeakPtr(),
1343                  callback));
1344 }
1345
1346 void QuotaManager::StartEviction() {
1347   DCHECK(!temporary_storage_evictor_.get());
1348   temporary_storage_evictor_.reset(new QuotaTemporaryStorageEvictor(
1349       this, kEvictionIntervalInMilliSeconds));
1350   if (desired_available_space_ >= 0)
1351     temporary_storage_evictor_->set_min_available_disk_space_to_start_eviction(
1352         desired_available_space_);
1353   temporary_storage_evictor_->Start();
1354 }
1355
1356 void QuotaManager::DeleteOriginFromDatabase(
1357     const GURL& origin, StorageType type) {
1358   LazyInitialize();
1359   if (db_disabled_)
1360     return;
1361
1362   PostTaskAndReplyWithResultForDBThread(
1363       FROM_HERE,
1364       base::Bind(&DeleteOriginInfoOnDBThread, origin, type),
1365       base::Bind(&QuotaManager::DidDatabaseWork,
1366                  weak_factory_.GetWeakPtr()));
1367 }
1368
1369 void QuotaManager::DidOriginDataEvicted(QuotaStatusCode status) {
1370   DCHECK(io_thread_->BelongsToCurrentThread());
1371
1372   // We only try evict origins that are not in use, so basically
1373   // deletion attempt for eviction should not fail.  Let's record
1374   // the origin if we get error and exclude it from future eviction
1375   // if the error happens consistently (> kThresholdOfErrorsToBeBlacklisted).
1376   if (status != kQuotaStatusOk)
1377     origins_in_error_[eviction_context_.evicted_origin]++;
1378
1379   eviction_context_.evict_origin_data_callback.Run(status);
1380   eviction_context_.evict_origin_data_callback.Reset();
1381 }
1382
1383 void QuotaManager::ReportHistogram() {
1384   GetGlobalUsage(kStorageTypeTemporary,
1385                  base::Bind(
1386                      &QuotaManager::DidGetTemporaryGlobalUsageForHistogram,
1387                      weak_factory_.GetWeakPtr()));
1388   GetGlobalUsage(kStorageTypePersistent,
1389                  base::Bind(
1390                      &QuotaManager::DidGetPersistentGlobalUsageForHistogram,
1391                      weak_factory_.GetWeakPtr()));
1392 }
1393
1394 void QuotaManager::DidGetTemporaryGlobalUsageForHistogram(
1395     int64 usage,
1396     int64 unlimited_usage) {
1397   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfTemporaryStorage", usage);
1398
1399   std::set<GURL> origins;
1400   GetCachedOrigins(kStorageTypeTemporary, &origins);
1401
1402   size_t num_origins = origins.size();
1403   size_t protected_origins = 0;
1404   size_t unlimited_origins = 0;
1405   CountOriginType(origins,
1406                   special_storage_policy_.get(),
1407                   &protected_origins,
1408                   &unlimited_origins);
1409
1410   UMA_HISTOGRAM_COUNTS("Quota.NumberOfTemporaryStorageOrigins",
1411                        num_origins);
1412   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedTemporaryStorageOrigins",
1413                        protected_origins);
1414   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedTemporaryStorageOrigins",
1415                        unlimited_origins);
1416 }
1417
1418 void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
1419     int64 usage,
1420     int64 unlimited_usage) {
1421   UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
1422
1423   std::set<GURL> origins;
1424   GetCachedOrigins(kStorageTypePersistent, &origins);
1425
1426   size_t num_origins = origins.size();
1427   size_t protected_origins = 0;
1428   size_t unlimited_origins = 0;
1429   CountOriginType(origins,
1430                   special_storage_policy_.get(),
1431                   &protected_origins,
1432                   &unlimited_origins);
1433
1434   UMA_HISTOGRAM_COUNTS("Quota.NumberOfPersistentStorageOrigins",
1435                        num_origins);
1436   UMA_HISTOGRAM_COUNTS("Quota.NumberOfProtectedPersistentStorageOrigins",
1437                        protected_origins);
1438   UMA_HISTOGRAM_COUNTS("Quota.NumberOfUnlimitedPersistentStorageOrigins",
1439                        unlimited_origins);
1440 }
1441
1442 void QuotaManager::GetLRUOrigin(
1443     StorageType type,
1444     const GetLRUOriginCallback& callback) {
1445   LazyInitialize();
1446   // This must not be called while there's an in-flight task.
1447   DCHECK(lru_origin_callback_.is_null());
1448   lru_origin_callback_ = callback;
1449   if (db_disabled_) {
1450     lru_origin_callback_.Run(GURL());
1451     lru_origin_callback_.Reset();
1452     return;
1453   }
1454
1455   std::set<GURL>* exceptions = new std::set<GURL>;
1456   for (std::map<GURL, int>::const_iterator p = origins_in_use_.begin();
1457        p != origins_in_use_.end();
1458        ++p) {
1459     if (p->second > 0)
1460       exceptions->insert(p->first);
1461   }
1462   for (std::map<GURL, int>::const_iterator p = origins_in_error_.begin();
1463        p != origins_in_error_.end();
1464        ++p) {
1465     if (p->second > QuotaManager::kThresholdOfErrorsToBeBlacklisted)
1466       exceptions->insert(p->first);
1467   }
1468
1469   GURL* url = new GURL;
1470   PostTaskAndReplyWithResultForDBThread(
1471       FROM_HERE,
1472       base::Bind(&GetLRUOriginOnDBThread,
1473                  type,
1474                  base::Owned(exceptions),
1475                  special_storage_policy_,
1476                  base::Unretained(url)),
1477       base::Bind(&QuotaManager::DidGetLRUOrigin,
1478                  weak_factory_.GetWeakPtr(),
1479                  base::Owned(url)));
1480 }
1481
1482 void QuotaManager::EvictOriginData(
1483     const GURL& origin,
1484     StorageType type,
1485     const EvictOriginDataCallback& callback) {
1486   DCHECK(io_thread_->BelongsToCurrentThread());
1487   DCHECK_EQ(type, kStorageTypeTemporary);
1488
1489   eviction_context_.evicted_origin = origin;
1490   eviction_context_.evicted_type = type;
1491   eviction_context_.evict_origin_data_callback = callback;
1492
1493   DeleteOriginData(origin, type, QuotaClient::kAllClientsMask,
1494       base::Bind(&QuotaManager::DidOriginDataEvicted,
1495                  weak_factory_.GetWeakPtr()));
1496 }
1497
1498 void QuotaManager::GetUsageAndQuotaForEviction(
1499     const UsageAndQuotaCallback& callback) {
1500   DCHECK(io_thread_->BelongsToCurrentThread());
1501   LazyInitialize();
1502
1503   UsageAndQuotaCallbackDispatcher* dispatcher =
1504       new UsageAndQuotaCallbackDispatcher(this);
1505   GetUsageTracker(kStorageTypeTemporary)->
1506       GetGlobalLimitedUsage(dispatcher->GetGlobalLimitedUsageCallback());
1507   GetTemporaryGlobalQuota(dispatcher->GetQuotaCallback());
1508   GetAvailableSpace(dispatcher->GetAvailableSpaceCallback());
1509   dispatcher->WaitForResults(callback);
1510 }
1511
1512 void QuotaManager::DidSetTemporaryGlobalOverrideQuota(
1513     const QuotaCallback& callback,
1514     const int64* new_quota,
1515     bool success) {
1516   QuotaStatusCode status = kQuotaErrorInvalidAccess;
1517   DidDatabaseWork(success);
1518   if (success) {
1519     temporary_quota_override_ = *new_quota;
1520     status = kQuotaStatusOk;
1521   }
1522
1523   if (callback.is_null())
1524     return;
1525
1526   callback.Run(status, *new_quota);
1527 }
1528
1529 void QuotaManager::DidGetPersistentHostQuota(const std::string& host,
1530                                              const int64* quota,
1531                                              bool success) {
1532   DidDatabaseWork(success);
1533   persistent_host_quota_callbacks_.Run(
1534       host, MakeTuple(kQuotaStatusOk, *quota));
1535 }
1536
1537 void QuotaManager::DidSetPersistentHostQuota(const std::string& host,
1538                                              const QuotaCallback& callback,
1539                                              const int64* new_quota,
1540                                              bool success) {
1541   DidDatabaseWork(success);
1542   callback.Run(success ? kQuotaStatusOk : kQuotaErrorInvalidAccess, *new_quota);
1543 }
1544
1545 void QuotaManager::DidInitialize(int64* temporary_quota_override,
1546                                  int64* desired_available_space,
1547                                  bool success) {
1548   temporary_quota_override_ = *temporary_quota_override;
1549   desired_available_space_ = *desired_available_space;
1550   temporary_quota_initialized_ = true;
1551   DidDatabaseWork(success);
1552
1553   histogram_timer_.Start(FROM_HERE,
1554                          base::TimeDelta::FromMilliseconds(
1555                              kReportHistogramInterval),
1556                          this, &QuotaManager::ReportHistogram);
1557
1558   db_initialization_callbacks_.Run(MakeTuple());
1559   GetTemporaryGlobalQuota(
1560       base::Bind(&QuotaManager::DidGetInitialTemporaryGlobalQuota,
1561                  weak_factory_.GetWeakPtr()));
1562 }
1563
1564 void QuotaManager::DidGetLRUOrigin(const GURL* origin,
1565                                    bool success) {
1566   DidDatabaseWork(success);
1567   // Make sure the returned origin is (still) not in the origin_in_use_ set
1568   // and has not been accessed since we posted the task.
1569   if (origins_in_use_.find(*origin) != origins_in_use_.end() ||
1570       access_notified_origins_.find(*origin) != access_notified_origins_.end())
1571     lru_origin_callback_.Run(GURL());
1572   else
1573     lru_origin_callback_.Run(*origin);
1574   access_notified_origins_.clear();
1575   lru_origin_callback_.Reset();
1576 }
1577
1578 void QuotaManager::DidGetInitialTemporaryGlobalQuota(
1579     QuotaStatusCode status, int64 quota_unused) {
1580   if (eviction_disabled_)
1581     return;
1582
1583   std::set<GURL>* origins = new std::set<GURL>;
1584   temporary_usage_tracker_->GetCachedOrigins(origins);
1585   // This will call the StartEviction() when initial origin registration
1586   // is completed.
1587   PostTaskAndReplyWithResultForDBThread(
1588       FROM_HERE,
1589       base::Bind(&InitializeTemporaryOriginsInfoOnDBThread,
1590                  base::Owned(origins)),
1591       base::Bind(&QuotaManager::DidInitializeTemporaryOriginsInfo,
1592                  weak_factory_.GetWeakPtr()));
1593 }
1594
1595 void QuotaManager::DidInitializeTemporaryOriginsInfo(bool success) {
1596   DidDatabaseWork(success);
1597   if (success)
1598     StartEviction();
1599 }
1600
1601 void QuotaManager::DidGetAvailableSpace(int64 space) {
1602   available_space_callbacks_.Run(MakeTuple(kQuotaStatusOk, space));
1603 }
1604
1605 void QuotaManager::DidDatabaseWork(bool success) {
1606   db_disabled_ = !success;
1607 }
1608
1609 void QuotaManager::DeleteOnCorrectThread() const {
1610   if (!io_thread_->BelongsToCurrentThread() &&
1611       io_thread_->DeleteSoon(FROM_HERE, this)) {
1612     return;
1613   }
1614   delete this;
1615 }
1616
1617 void QuotaManager::PostTaskAndReplyWithResultForDBThread(
1618     const tracked_objects::Location& from_here,
1619     const base::Callback<bool(QuotaDatabase*)>& task,
1620     const base::Callback<void(bool)>& reply) {
1621   // Deleting manager will post another task to DB thread to delete
1622   // |database_|, therefore we can be sure that database_ is alive when this
1623   // task runs.
1624   base::PostTaskAndReplyWithResult(
1625       db_thread_.get(),
1626       from_here,
1627       base::Bind(task, base::Unretained(database_.get())),
1628       reply);
1629 }
1630
1631 }  // namespace storage