src/webkit/browser/quota/quota_manager_unittest.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 <algorithm>
   6 #include <set>
   7 #include <sstream>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/file_util.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/message_loop/message_loop_proxy.h"
  16 #include "base/run_loop.h"
  17 #include "base/stl_util.h"
  18 #include "base/sys_info.h"
  19 #include "base/time/time.h"
  20 #include "testing/gtest/include/gtest/gtest.h"
  21 #include "url/gurl.h"
  22 #include "webkit/browser/quota/mock_special_storage_policy.h"
  23 #include "webkit/browser/quota/mock_storage_client.h"
  24 #include "webkit/browser/quota/quota_database.h"
  25 #include "webkit/browser/quota/quota_manager.h"
  26 #include "webkit/browser/quota/quota_manager_proxy.h"
  27
  28 using base::MessageLoopProxy;
  29
  30 namespace quota {
  31
  32 namespace {
  33
  34 // For shorter names.
  35 const StorageType kTemp = kStorageTypeTemporary;
  36 const StorageType kPerm = kStorageTypePersistent;
  37 const StorageType kSync = kStorageTypeSyncable;
  38
  39 const int kAllClients = QuotaClient::kAllClientsMask;
  40
  41 const int64 kAvailableSpaceForApp = 13377331U;
  42
  43 const int64 kMinimumPreserveForSystem = QuotaManager::kMinimumPreserveForSystem;
  44 const int kPerHostTemporaryPortion = QuotaManager::kPerHostTemporaryPortion;
  45
  46 // Returns a deterministic value for the amount of available disk space.
  47 int64 GetAvailableDiskSpaceForTest(const base::FilePath&) {
  48   return kAvailableSpaceForApp + kMinimumPreserveForSystem;
  49 }
  50
  51 }  // namespace
  52
  53 class QuotaManagerTest : public testing::Test {
  54  protected:
  55   typedef QuotaManager::QuotaTableEntry QuotaTableEntry;
  56   typedef QuotaManager::QuotaTableEntries QuotaTableEntries;
  57   typedef QuotaManager::OriginInfoTableEntries OriginInfoTableEntries;
  58
  59  public:
  60   QuotaManagerTest()
  61       : mock_time_counter_(0),
  62         weak_factory_(this) {
  63   }
  64
  65   virtual void SetUp() {
  66     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
  67     mock_special_storage_policy_ = new MockSpecialStoragePolicy;
  68     ResetQuotaManager(false /* is_incognito */);
  69   }
  70
  71   virtual void TearDown() {
  72     // Make sure the quota manager cleans up correctly.
  73     quota_manager_ = NULL;
  74     base::RunLoop().RunUntilIdle();
  75   }
  76
  77  protected:
  78   void ResetQuotaManager(bool is_incognito) {
  79     quota_manager_ = new QuotaManager(is_incognito,
  80                                       data_dir_.path(),
  81                                       MessageLoopProxy::current().get(),
  82                                       MessageLoopProxy::current().get(),
  83                                       mock_special_storage_policy_.get());
  84     // Don't (automatically) start the eviction for testing.
  85     quota_manager_->eviction_disabled_ = true;
  86     // Don't query the hard disk for remaining capacity.
  87     quota_manager_->get_disk_space_fn_ = &GetAvailableDiskSpaceForTest;
  88     additional_callback_count_ = 0;
  89   }
  90
  91   MockStorageClient* CreateClient(
  92       const MockOriginData* mock_data,
  93       size_t mock_data_size,
  94       QuotaClient::ID id) {
  95     return new MockStorageClient(quota_manager_->proxy(),
  96                                  mock_data, id, mock_data_size);
  97   }
  98
  99   void RegisterClient(MockStorageClient* client) {
 100     quota_manager_->proxy()->RegisterClient(client);
 101   }
 102
 103   void GetUsageInfo() {
 104     usage_info_.clear();
 105     quota_manager_->GetUsageInfo(
 106         base::Bind(&QuotaManagerTest::DidGetUsageInfo,
 107                    weak_factory_.GetWeakPtr()));
 108   }
 109
 110   void GetUsageAndQuotaForWebApps(const GURL& origin,
 111                                   StorageType type) {
 112     quota_status_ = kQuotaStatusUnknown;
 113     usage_ = -1;
 114     quota_ = -1;
 115     quota_manager_->GetUsageAndQuotaForWebApps(
 116         origin, type, base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
 117                                  weak_factory_.GetWeakPtr()));
 118   }
 119
 120   void GetUsageAndQuotaForStorageClient(const GURL& origin,
 121                                         StorageType type) {
 122     quota_status_ = kQuotaStatusUnknown;
 123     usage_ = -1;
 124     quota_ = -1;
 125     quota_manager_->GetUsageAndQuota(
 126         origin, type, base::Bind(&QuotaManagerTest::DidGetUsageAndQuota,
 127                                  weak_factory_.GetWeakPtr()));
 128   }
 129
 130   void GetTemporaryGlobalQuota() {
 131     quota_status_ = kQuotaStatusUnknown;
 132     quota_ = -1;
 133     quota_manager_->GetTemporaryGlobalQuota(
 134         base::Bind(&QuotaManagerTest::DidGetQuota,
 135                    weak_factory_.GetWeakPtr()));
 136   }
 137
 138   void SetTemporaryGlobalQuota(int64 new_quota) {
 139     quota_status_ = kQuotaStatusUnknown;
 140     quota_ = -1;
 141     quota_manager_->SetTemporaryGlobalOverrideQuota(
 142         new_quota,
 143         base::Bind(&QuotaManagerTest::DidGetQuota,
 144                    weak_factory_.GetWeakPtr()));
 145   }
 146
 147   void GetPersistentHostQuota(const std::string& host) {
 148     quota_status_ = kQuotaStatusUnknown;
 149     quota_ = -1;
 150     quota_manager_->GetPersistentHostQuota(
 151         host,
 152         base::Bind(&QuotaManagerTest::DidGetHostQuota,
 153                    weak_factory_.GetWeakPtr()));
 154   }
 155
 156   void SetPersistentHostQuota(const std::string& host, int64 new_quota) {
 157     quota_status_ = kQuotaStatusUnknown;
 158     quota_ = -1;
 159     quota_manager_->SetPersistentHostQuota(
 160         host, new_quota,
 161         base::Bind(&QuotaManagerTest::DidGetHostQuota,
 162                    weak_factory_.GetWeakPtr()));
 163   }
 164
 165   void GetGlobalUsage(StorageType type) {
 166     usage_ = -1;
 167     unlimited_usage_ = -1;
 168     quota_manager_->GetGlobalUsage(
 169         type,
 170         base::Bind(&QuotaManagerTest::DidGetGlobalUsage,
 171                    weak_factory_.GetWeakPtr()));
 172   }
 173
 174   void GetHostUsage(const std::string& host, StorageType type) {
 175     usage_ = -1;
 176     quota_manager_->GetHostUsage(
 177         host, type,
 178         base::Bind(&QuotaManagerTest::DidGetHostUsage,
 179                    weak_factory_.GetWeakPtr()));
 180   }
 181
 182   void RunAdditionalUsageAndQuotaTask(const GURL& origin, StorageType type) {
 183     quota_manager_->GetUsageAndQuota(
 184         origin, type,
 185         base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaAdditional,
 186                    weak_factory_.GetWeakPtr()));
 187   }
 188
 189   void DeleteClientOriginData(QuotaClient* client,
 190                               const GURL& origin,
 191                               StorageType type) {
 192     DCHECK(client);
 193     quota_status_ = kQuotaStatusUnknown;
 194     client->DeleteOriginData(
 195         origin, type,
 196         base::Bind(&QuotaManagerTest::StatusCallback,
 197                    weak_factory_.GetWeakPtr()));
 198   }
 199
 200   void EvictOriginData(const GURL& origin,
 201                        StorageType type) {
 202     quota_status_ = kQuotaStatusUnknown;
 203     quota_manager_->EvictOriginData(
 204         origin, type,
 205         base::Bind(&QuotaManagerTest::StatusCallback,
 206                    weak_factory_.GetWeakPtr()));
 207   }
 208
 209   void DeleteOriginData(const GURL& origin,
 210                         StorageType type,
 211                         int quota_client_mask) {
 212     quota_status_ = kQuotaStatusUnknown;
 213     quota_manager_->DeleteOriginData(
 214         origin, type, quota_client_mask,
 215         base::Bind(&QuotaManagerTest::StatusCallback,
 216                    weak_factory_.GetWeakPtr()));
 217   }
 218
 219   void DeleteHostData(const std::string& host,
 220                       StorageType type,
 221                       int quota_client_mask) {
 222     quota_status_ = kQuotaStatusUnknown;
 223     quota_manager_->DeleteHostData(
 224         host, type, quota_client_mask,
 225         base::Bind(&QuotaManagerTest::StatusCallback,
 226                    weak_factory_.GetWeakPtr()));
 227   }
 228
 229   void GetAvailableSpace() {
 230     quota_status_ = kQuotaStatusUnknown;
 231     available_space_ = -1;
 232     quota_manager_->GetAvailableSpace(
 233         base::Bind(&QuotaManagerTest::DidGetAvailableSpace,
 234                    weak_factory_.GetWeakPtr()));
 235   }
 236
 237   void GetUsageAndQuotaForEviction() {
 238     quota_status_ = kQuotaStatusUnknown;
 239     usage_ = -1;
 240     unlimited_usage_ = -1;
 241     quota_ = -1;
 242     available_space_ = -1;
 243     quota_manager_->GetUsageAndQuotaForEviction(
 244         base::Bind(&QuotaManagerTest::DidGetUsageAndQuotaForEviction,
 245                    weak_factory_.GetWeakPtr()));
 246   }
 247
 248   void GetCachedOrigins(StorageType type, std::set<GURL>* origins) {
 249     ASSERT_TRUE(origins != NULL);
 250     origins->clear();
 251     quota_manager_->GetCachedOrigins(type, origins);
 252   }
 253
 254   void NotifyStorageAccessed(QuotaClient* client,
 255                              const GURL& origin,
 256                              StorageType type) {
 257     DCHECK(client);
 258     quota_manager_->NotifyStorageAccessedInternal(
 259         client->id(), origin, type, IncrementMockTime());
 260   }
 261
 262   void DeleteOriginFromDatabase(const GURL& origin, StorageType type) {
 263     quota_manager_->DeleteOriginFromDatabase(origin, type);
 264   }
 265
 266   void GetLRUOrigin(StorageType type) {
 267     lru_origin_ = GURL();
 268     quota_manager_->GetLRUOrigin(
 269         type,
 270         base::Bind(&QuotaManagerTest::DidGetLRUOrigin,
 271                    weak_factory_.GetWeakPtr()));
 272   }
 273
 274   void NotifyOriginInUse(const GURL& origin) {
 275     quota_manager_->NotifyOriginInUse(origin);
 276   }
 277
 278   void NotifyOriginNoLongerInUse(const GURL& origin) {
 279     quota_manager_->NotifyOriginNoLongerInUse(origin);
 280   }
 281
 282   void GetOriginsModifiedSince(StorageType type, base::Time modified_since) {
 283     modified_origins_.clear();
 284     modified_origins_type_ = kStorageTypeUnknown;
 285     quota_manager_->GetOriginsModifiedSince(
 286         type, modified_since,
 287         base::Bind(&QuotaManagerTest::DidGetModifiedOrigins,
 288                    weak_factory_.GetWeakPtr()));
 289   }
 290
 291   void DumpQuotaTable() {
 292     quota_entries_.clear();
 293     quota_manager_->DumpQuotaTable(
 294         base::Bind(&QuotaManagerTest::DidDumpQuotaTable,
 295                    weak_factory_.GetWeakPtr()));
 296   }
 297
 298   void DumpOriginInfoTable() {
 299     origin_info_entries_.clear();
 300     quota_manager_->DumpOriginInfoTable(
 301         base::Bind(&QuotaManagerTest::DidDumpOriginInfoTable,
 302                    weak_factory_.GetWeakPtr()));
 303   }
 304
 305   void DidGetUsageInfo(const UsageInfoEntries& entries) {
 306     usage_info_.insert(usage_info_.begin(), entries.begin(), entries.end());
 307   }
 308
 309   void DidGetUsageAndQuota(QuotaStatusCode status, int64 usage, int64 quota) {
 310     quota_status_ = status;
 311     usage_ = usage;
 312     quota_ = quota;
 313   }
 314
 315   void DidGetQuota(QuotaStatusCode status,
 316                    int64 quota) {
 317     quota_status_ = status;
 318     quota_ = quota;
 319   }
 320
 321   void DidGetAvailableSpace(QuotaStatusCode status, int64 available_space) {
 322     quota_status_ = status;
 323     available_space_ = available_space;
 324   }
 325
 326   void DidGetHostQuota(QuotaStatusCode status,
 327                        int64 quota) {
 328     quota_status_ = status;
 329     quota_ = quota;
 330   }
 331
 332   void DidGetGlobalUsage(int64 usage,
 333                          int64 unlimited_usage) {
 334     usage_ = usage;
 335     unlimited_usage_ = unlimited_usage;
 336   }
 337
 338   void DidGetHostUsage(int64 usage) {
 339     usage_ = usage;
 340   }
 341
 342   void StatusCallback(QuotaStatusCode status) {
 343     ++status_callback_count_;
 344     quota_status_ = status;
 345   }
 346
 347   void DidGetUsageAndQuotaForEviction(QuotaStatusCode status,
 348                                       const UsageAndQuota& usage_and_quota) {
 349     quota_status_ = status;
 350     limited_usage_ = usage_and_quota.global_limited_usage;
 351     quota_ = usage_and_quota.quota;
 352     available_space_ = usage_and_quota.available_disk_space;
 353   }
 354
 355   void DidGetLRUOrigin(const GURL& origin) {
 356     lru_origin_ = origin;
 357   }
 358
 359   void DidGetModifiedOrigins(const std::set<GURL>& origins, StorageType type) {
 360     modified_origins_ = origins;
 361     modified_origins_type_ = type;
 362   }
 363
 364   void DidDumpQuotaTable(const QuotaTableEntries& entries) {
 365     quota_entries_ = entries;
 366   }
 367
 368   void DidDumpOriginInfoTable(const OriginInfoTableEntries& entries) {
 369     origin_info_entries_ = entries;
 370   }
 371
 372   void GetUsage_WithModifyTestBody(const StorageType type);
 373
 374   void set_additional_callback_count(int c) { additional_callback_count_ = c; }
 375   int additional_callback_count() const { return additional_callback_count_; }
 376   void DidGetUsageAndQuotaAdditional(
 377       QuotaStatusCode status, int64 usage, int64 quota) {
 378     ++additional_callback_count_;
 379   }
 380
 381   QuotaManager* quota_manager() const { return quota_manager_.get(); }
 382   void set_quota_manager(QuotaManager* quota_manager) {
 383     quota_manager_ = quota_manager;
 384   }
 385
 386   MockSpecialStoragePolicy* mock_special_storage_policy() const {
 387     return mock_special_storage_policy_.get();
 388   }
 389
 390   QuotaStatusCode status() const { return quota_status_; }
 391   const UsageInfoEntries& usage_info() const { return usage_info_; }
 392   int64 usage() const { return usage_; }
 393   int64 limited_usage() const { return limited_usage_; }
 394   int64 unlimited_usage() const { return unlimited_usage_; }
 395   int64 quota() const { return quota_; }
 396   int64 available_space() const { return available_space_; }
 397   const GURL& lru_origin() const { return lru_origin_; }
 398   const std::set<GURL>& modified_origins() const { return modified_origins_; }
 399   StorageType modified_origins_type() const { return modified_origins_type_; }
 400   const QuotaTableEntries& quota_entries() const { return quota_entries_; }
 401   const OriginInfoTableEntries& origin_info_entries() const {
 402     return origin_info_entries_;
 403   }
 404   base::FilePath profile_path() const { return data_dir_.path(); }
 405   int status_callback_count() const { return status_callback_count_; }
 406   void reset_status_callback_count() { status_callback_count_ = 0; }
 407
 408  private:
 409   base::Time IncrementMockTime() {
 410     ++mock_time_counter_;
 411     return base::Time::FromDoubleT(mock_time_counter_ * 10.0);
 412   }
 413
 414   base::MessageLoop message_loop_;
 415   base::ScopedTempDir data_dir_;
 416
 417   scoped_refptr<QuotaManager> quota_manager_;
 418   scoped_refptr<MockSpecialStoragePolicy> mock_special_storage_policy_;
 419
 420   QuotaStatusCode quota_status_;
 421   UsageInfoEntries usage_info_;
 422   int64 usage_;
 423   int64 limited_usage_;
 424   int64 unlimited_usage_;
 425   int64 quota_;
 426   int64 available_space_;
 427   GURL lru_origin_;
 428   std::set<GURL> modified_origins_;
 429   StorageType modified_origins_type_;
 430   QuotaTableEntries quota_entries_;
 431   OriginInfoTableEntries origin_info_entries_;
 432   int status_callback_count_;
 433
 434   int additional_callback_count_;
 435
 436   int mock_time_counter_;
 437
 438   base::WeakPtrFactory<QuotaManagerTest> weak_factory_;
 439
 440   DISALLOW_COPY_AND_ASSIGN(QuotaManagerTest);
 441 };
 442
 443 TEST_F(QuotaManagerTest, GetUsageInfo) {
 444   static const MockOriginData kData1[] = {
 445     { "http://foo.com/",       kTemp,  10 },
 446     { "http://foo.com:8080/",  kTemp,  15 },
 447     { "http://bar.com/",       kTemp,  20 },
 448     { "http://bar.com/",       kPerm,  50 },
 449   };
 450   static const MockOriginData kData2[] = {
 451     { "https://foo.com/",      kTemp,  30 },
 452     { "https://foo.com:8081/", kTemp,  35 },
 453     { "http://bar.com/",       kPerm,  40 },
 454     { "http://example.com/",   kPerm,  40 },
 455   };
 456   RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
 457       QuotaClient::kFileSystem));
 458   RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
 459       QuotaClient::kDatabase));
 460
 461   GetUsageInfo();
 462   base::RunLoop().RunUntilIdle();
 463
 464   EXPECT_EQ(4U, usage_info().size());
 465   for (size_t i = 0; i < usage_info().size(); ++i) {
 466     const UsageInfo& info = usage_info()[i];
 467     if (info.host == "foo.com" && info.type == kTemp) {
 468       EXPECT_EQ(10 + 15 + 30 + 35, info.usage);
 469     } else if (info.host == "bar.com" && info.type == kTemp) {
 470       EXPECT_EQ(20, info.usage);
 471     } else if (info.host == "bar.com" && info.type == kPerm) {
 472       EXPECT_EQ(50 + 40, info.usage);
 473     } else if (info.host == "example.com" && info.type == kPerm) {
 474       EXPECT_EQ(40, info.usage);
 475     } else {
 476       ADD_FAILURE()
 477           << "Unexpected host, type: " << info.host << ", " << info.type;
 478     }
 479   }
 480 }
 481
 482 TEST_F(QuotaManagerTest, GetUsageAndQuota_Simple) {
 483   static const MockOriginData kData[] = {
 484     { "http://foo.com/", kTemp, 10 },
 485     { "http://foo.com/", kPerm, 80 },
 486   };
 487   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 488       QuotaClient::kFileSystem));
 489
 490   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
 491   base::RunLoop().RunUntilIdle();
 492   EXPECT_EQ(kQuotaStatusOk, status());
 493   EXPECT_EQ(80, usage());
 494   EXPECT_EQ(0, quota());
 495
 496   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 497   base::RunLoop().RunUntilIdle();
 498   EXPECT_EQ(kQuotaStatusOk, status());
 499   EXPECT_EQ(10, usage());
 500   EXPECT_LE(0, quota());
 501   int64 quota_returned_for_foo = quota();
 502
 503   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kTemp);
 504   base::RunLoop().RunUntilIdle();
 505   EXPECT_EQ(kQuotaStatusOk, status());
 506   EXPECT_EQ(0, usage());
 507   EXPECT_EQ(quota_returned_for_foo, quota());
 508 }
 509
 510 TEST_F(QuotaManagerTest, GetUsage_NoClient) {
 511   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 512   base::RunLoop().RunUntilIdle();
 513   EXPECT_EQ(kQuotaStatusOk, status());
 514   EXPECT_EQ(0, usage());
 515
 516   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
 517   base::RunLoop().RunUntilIdle();
 518   EXPECT_EQ(kQuotaStatusOk, status());
 519   EXPECT_EQ(0, usage());
 520
 521   GetHostUsage("foo.com", kTemp);
 522   base::RunLoop().RunUntilIdle();
 523   EXPECT_EQ(0, usage());
 524
 525   GetHostUsage("foo.com", kPerm);
 526   base::RunLoop().RunUntilIdle();
 527   EXPECT_EQ(0, usage());
 528
 529   GetGlobalUsage(kTemp);
 530   base::RunLoop().RunUntilIdle();
 531   EXPECT_EQ(0, usage());
 532   EXPECT_EQ(0, unlimited_usage());
 533
 534   GetGlobalUsage(kPerm);
 535   base::RunLoop().RunUntilIdle();
 536   EXPECT_EQ(0, usage());
 537   EXPECT_EQ(0, unlimited_usage());
 538 }
 539
 540 TEST_F(QuotaManagerTest, GetUsage_EmptyClient) {
 541   RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 542   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 543   base::RunLoop().RunUntilIdle();
 544   EXPECT_EQ(kQuotaStatusOk, status());
 545   EXPECT_EQ(0, usage());
 546
 547   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
 548   base::RunLoop().RunUntilIdle();
 549   EXPECT_EQ(kQuotaStatusOk, status());
 550   EXPECT_EQ(0, usage());
 551
 552   GetHostUsage("foo.com", kTemp);
 553   base::RunLoop().RunUntilIdle();
 554   EXPECT_EQ(0, usage());
 555
 556   GetHostUsage("foo.com", kPerm);
 557   base::RunLoop().RunUntilIdle();
 558   EXPECT_EQ(0, usage());
 559
 560   GetGlobalUsage(kTemp);
 561   base::RunLoop().RunUntilIdle();
 562   EXPECT_EQ(0, usage());
 563   EXPECT_EQ(0, unlimited_usage());
 564
 565   GetGlobalUsage(kPerm);
 566   base::RunLoop().RunUntilIdle();
 567   EXPECT_EQ(0, usage());
 568   EXPECT_EQ(0, unlimited_usage());
 569 }
 570
 571 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_MultiOrigins) {
 572   static const MockOriginData kData[] = {
 573     { "http://foo.com/",        kTemp,  10 },
 574     { "http://foo.com:8080/",   kTemp,  20 },
 575     { "http://bar.com/",        kTemp,   5 },
 576     { "https://bar.com/",       kTemp,   7 },
 577     { "http://baz.com/",        kTemp,  30 },
 578     { "http://foo.com/",        kPerm,  40 },
 579   };
 580   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 581       QuotaClient::kFileSystem));
 582
 583   // This time explicitly sets a temporary global quota.
 584   SetTemporaryGlobalQuota(100);
 585   base::RunLoop().RunUntilIdle();
 586   EXPECT_EQ(kQuotaStatusOk, status());
 587   EXPECT_EQ(100, quota());
 588
 589   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 590   base::RunLoop().RunUntilIdle();
 591   EXPECT_EQ(kQuotaStatusOk, status());
 592   EXPECT_EQ(10 + 20, usage());
 593
 594   const int kPerHostQuota = 100 / kPerHostTemporaryPortion;
 595
 596   // The host's quota should be its full portion of the global quota
 597   // since global usage is under the global quota.
 598   EXPECT_EQ(kPerHostQuota, quota());
 599
 600   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kTemp);
 601   base::RunLoop().RunUntilIdle();
 602   EXPECT_EQ(kQuotaStatusOk, status());
 603   EXPECT_EQ(5 + 7, usage());
 604   EXPECT_EQ(kPerHostQuota, quota());
 605 }
 606
 607 TEST_F(QuotaManagerTest, GetUsage_MultipleClients) {
 608   static const MockOriginData kData1[] = {
 609     { "http://foo.com/",              kTemp, 1 },
 610     { "http://bar.com/",              kTemp, 2 },
 611     { "http://bar.com/",              kPerm, 4 },
 612     { "http://unlimited/",            kPerm, 8 },
 613     { "http://installed/",            kPerm, 16 },
 614   };
 615   static const MockOriginData kData2[] = {
 616     { "https://foo.com/",             kTemp, 128 },
 617     { "http://example.com/",          kPerm, 256 },
 618     { "http://unlimited/",            kTemp, 512 },
 619     { "http://installed/",            kTemp, 1024 },
 620   };
 621   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
 622   mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
 623   RegisterClient(CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
 624       QuotaClient::kFileSystem));
 625   RegisterClient(CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
 626       QuotaClient::kDatabase));
 627
 628   const int64 kTempQuotaBase =
 629       GetAvailableDiskSpaceForTest(base::FilePath()) / kPerHostTemporaryPortion;
 630
 631   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 632   base::RunLoop().RunUntilIdle();
 633   EXPECT_EQ(kQuotaStatusOk, status());
 634   EXPECT_EQ(1 + 128, usage());
 635
 636   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), kPerm);
 637   base::RunLoop().RunUntilIdle();
 638   EXPECT_EQ(kQuotaStatusOk, status());
 639   EXPECT_EQ(4, usage());
 640
 641   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
 642   base::RunLoop().RunUntilIdle();
 643   EXPECT_EQ(kQuotaStatusOk, status());
 644   EXPECT_EQ(512, usage());
 645   EXPECT_EQ(std::min(kAvailableSpaceForApp, kTempQuotaBase) + usage(), quota());
 646
 647   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kPerm);
 648   base::RunLoop().RunUntilIdle();
 649   EXPECT_EQ(kQuotaStatusOk, status());
 650   EXPECT_EQ(8, usage());
 651   EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
 652
 653   GetAvailableSpace();
 654   base::RunLoop().RunUntilIdle();
 655   EXPECT_EQ(kQuotaStatusOk, status());
 656   EXPECT_LE(0, available_space());
 657
 658   GetUsageAndQuotaForWebApps(GURL("http://installed/"), kTemp);
 659   base::RunLoop().RunUntilIdle();
 660   EXPECT_EQ(kQuotaStatusOk, status());
 661   EXPECT_EQ(1024, usage());
 662   EXPECT_EQ(std::min(kAvailableSpaceForApp, kTempQuotaBase) + usage(), quota());
 663
 664   GetUsageAndQuotaForWebApps(GURL("http://installed/"), kPerm);
 665   base::RunLoop().RunUntilIdle();
 666   EXPECT_EQ(kQuotaStatusOk, status());
 667   EXPECT_EQ(16, usage());
 668   EXPECT_EQ(usage(), quota());  // Over-budget case.
 669
 670   GetGlobalUsage(kTemp);
 671   base::RunLoop().RunUntilIdle();
 672   EXPECT_EQ(kQuotaStatusOk, status());
 673   EXPECT_EQ(1 + 2 + 128 + 512 + 1024, usage());
 674   EXPECT_EQ(512, unlimited_usage());
 675
 676   GetGlobalUsage(kPerm);
 677   base::RunLoop().RunUntilIdle();
 678   EXPECT_EQ(kQuotaStatusOk, status());
 679   EXPECT_EQ(4 + 8 + 16 + 256, usage());
 680   EXPECT_EQ(8, unlimited_usage());
 681 }
 682
 683 void QuotaManagerTest::GetUsage_WithModifyTestBody(const StorageType type) {
 684   const MockOriginData data[] = {
 685     { "http://foo.com/",   type,  10 },
 686     { "http://foo.com:1/", type,  20 },
 687   };
 688   MockStorageClient* client = CreateClient(data, ARRAYSIZE_UNSAFE(data),
 689       QuotaClient::kFileSystem);
 690   RegisterClient(client);
 691
 692   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), type);
 693   base::RunLoop().RunUntilIdle();
 694   EXPECT_EQ(kQuotaStatusOk, status());
 695   EXPECT_EQ(10 + 20, usage());
 696
 697   client->ModifyOriginAndNotify(GURL("http://foo.com/"), type, 30);
 698   client->ModifyOriginAndNotify(GURL("http://foo.com:1/"), type, -5);
 699   client->AddOriginAndNotify(GURL("https://foo.com/"), type, 1);
 700
 701   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), type);
 702   base::RunLoop().RunUntilIdle();
 703   EXPECT_EQ(kQuotaStatusOk, status());
 704   EXPECT_EQ(10 + 20 + 30 - 5 + 1, usage());
 705   int foo_usage = usage();
 706
 707   client->AddOriginAndNotify(GURL("http://bar.com/"), type, 40);
 708   GetUsageAndQuotaForWebApps(GURL("http://bar.com/"), type);
 709   base::RunLoop().RunUntilIdle();
 710   EXPECT_EQ(kQuotaStatusOk, status());
 711   EXPECT_EQ(40, usage());
 712
 713   GetGlobalUsage(type);
 714   base::RunLoop().RunUntilIdle();
 715   EXPECT_EQ(foo_usage + 40, usage());
 716   EXPECT_EQ(0, unlimited_usage());
 717 }
 718
 719 TEST_F(QuotaManagerTest, GetTemporaryUsage_WithModify) {
 720   GetUsage_WithModifyTestBody(kTemp);
 721 }
 722
 723 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_WithAdditionalTasks) {
 724   static const MockOriginData kData[] = {
 725     { "http://foo.com/",        kTemp, 10 },
 726     { "http://foo.com:8080/",   kTemp, 20 },
 727     { "http://bar.com/",        kTemp, 13 },
 728     { "http://foo.com/",        kPerm, 40 },
 729   };
 730   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 731       QuotaClient::kFileSystem));
 732   SetTemporaryGlobalQuota(100);
 733   base::RunLoop().RunUntilIdle();
 734
 735   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 736
 737   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 738   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 739   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 740   base::RunLoop().RunUntilIdle();
 741   EXPECT_EQ(kQuotaStatusOk, status());
 742   EXPECT_EQ(10 + 20, usage());
 743   EXPECT_EQ(kPerHostQuota, quota());
 744
 745   set_additional_callback_count(0);
 746   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
 747                                  kTemp);
 748   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 749   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kTemp);
 750   base::RunLoop().RunUntilIdle();
 751   EXPECT_EQ(kQuotaStatusOk, status());
 752   EXPECT_EQ(10 + 20, usage());
 753   EXPECT_EQ(kPerHostQuota, quota());
 754   EXPECT_EQ(2, additional_callback_count());
 755 }
 756
 757 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_NukeManager) {
 758   static const MockOriginData kData[] = {
 759     { "http://foo.com/",        kTemp, 10 },
 760     { "http://foo.com:8080/",   kTemp, 20 },
 761     { "http://bar.com/",        kTemp, 13 },
 762     { "http://foo.com/",        kPerm, 40 },
 763   };
 764   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 765       QuotaClient::kFileSystem));
 766   SetTemporaryGlobalQuota(100);
 767   base::RunLoop().RunUntilIdle();
 768
 769   set_additional_callback_count(0);
 770   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
 771   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
 772                                  kTemp);
 773   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"),
 774                                  kTemp);
 775
 776   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
 777   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
 778
 779   // Nuke before waiting for callbacks.
 780   set_quota_manager(NULL);
 781   base::RunLoop().RunUntilIdle();
 782   EXPECT_EQ(kQuotaErrorAbort, status());
 783 }
 784
 785 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Overbudget) {
 786   static const MockOriginData kData[] = {
 787     { "http://usage1/",    kTemp,   1 },
 788     { "http://usage10/",   kTemp,  10 },
 789     { "http://usage200/",  kTemp, 200 },
 790   };
 791   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 792       QuotaClient::kFileSystem));
 793   SetTemporaryGlobalQuota(100);
 794   base::RunLoop().RunUntilIdle();
 795
 796   const int kPerHostQuota = 100 / QuotaManager::kPerHostTemporaryPortion;
 797
 798   GetUsageAndQuotaForWebApps(GURL("http://usage1/"), kTemp);
 799   base::RunLoop().RunUntilIdle();
 800   EXPECT_EQ(kQuotaStatusOk, status());
 801   EXPECT_EQ(1, usage());
 802   EXPECT_EQ(1, quota());  // should be clamped to our current usage
 803
 804   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
 805   base::RunLoop().RunUntilIdle();
 806   EXPECT_EQ(kQuotaStatusOk, status());
 807   EXPECT_EQ(10, usage());
 808   EXPECT_EQ(10, quota());
 809
 810   GetUsageAndQuotaForWebApps(GURL("http://usage200/"), kTemp);
 811   base::RunLoop().RunUntilIdle();
 812   EXPECT_EQ(kQuotaStatusOk, status());
 813   EXPECT_EQ(200, usage());
 814   EXPECT_EQ(kPerHostQuota, quota());  // should be clamped to the nominal quota
 815 }
 816
 817 TEST_F(QuotaManagerTest, GetTemporaryUsageAndQuota_Unlimited) {
 818   static const MockOriginData kData[] = {
 819     { "http://usage10/",   kTemp,    10 },
 820     { "http://usage50/",   kTemp,    50 },
 821     { "http://unlimited/", kTemp,  4000 },
 822   };
 823   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
 824   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
 825       QuotaClient::kFileSystem);
 826   RegisterClient(client);
 827
 828   // Test when not overbugdet.
 829   SetTemporaryGlobalQuota(1000);
 830   base::RunLoop().RunUntilIdle();
 831
 832   GetGlobalUsage(kTemp);
 833   base::RunLoop().RunUntilIdle();
 834   EXPECT_EQ(10 + 50 + 4000, usage());
 835   EXPECT_EQ(4000, unlimited_usage());
 836
 837   const int kPerHostQuotaFor1000 =
 838       1000 / QuotaManager::kPerHostTemporaryPortion;
 839
 840   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
 841   base::RunLoop().RunUntilIdle();
 842   EXPECT_EQ(kQuotaStatusOk, status());
 843   EXPECT_EQ(10, usage());
 844   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 845
 846   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
 847   base::RunLoop().RunUntilIdle();
 848   EXPECT_EQ(kQuotaStatusOk, status());
 849   EXPECT_EQ(50, usage());
 850   EXPECT_EQ(kPerHostQuotaFor1000, quota());
 851
 852   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
 853   base::RunLoop().RunUntilIdle();
 854   EXPECT_EQ(kQuotaStatusOk, status());
 855   EXPECT_EQ(4000, usage());
 856   EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
 857
 858   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kTemp);
 859   base::RunLoop().RunUntilIdle();
 860   EXPECT_EQ(kQuotaStatusOk, status());
 861   EXPECT_EQ(0, usage());
 862   EXPECT_EQ(QuotaManager::kNoLimit, quota());
 863
 864   // Test when overbugdet.
 865   SetTemporaryGlobalQuota(100);
 866   base::RunLoop().RunUntilIdle();
 867
 868   const int kPerHostQuotaFor100 =
 869       100 / QuotaManager::kPerHostTemporaryPortion;
 870
 871   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
 872   base::RunLoop().RunUntilIdle();
 873   EXPECT_EQ(kQuotaStatusOk, status());
 874   EXPECT_EQ(10, usage());
 875   EXPECT_EQ(kPerHostQuotaFor100, quota());
 876
 877   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
 878   base::RunLoop().RunUntilIdle();
 879   EXPECT_EQ(kQuotaStatusOk, status());
 880   EXPECT_EQ(50, usage());
 881   EXPECT_EQ(kPerHostQuotaFor100, quota());
 882
 883   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
 884   base::RunLoop().RunUntilIdle();
 885   EXPECT_EQ(kQuotaStatusOk, status());
 886   EXPECT_EQ(4000, usage());
 887   EXPECT_EQ(kAvailableSpaceForApp + usage(), quota());
 888
 889   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kTemp);
 890   base::RunLoop().RunUntilIdle();
 891   EXPECT_EQ(kQuotaStatusOk, status());
 892   EXPECT_EQ(0, usage());
 893   EXPECT_EQ(QuotaManager::kNoLimit, quota());
 894
 895   // Revoke the unlimited rights and make sure the change is noticed.
 896   mock_special_storage_policy()->Reset();
 897   mock_special_storage_policy()->NotifyCleared();
 898
 899   GetGlobalUsage(kTemp);
 900   base::RunLoop().RunUntilIdle();
 901   EXPECT_EQ(10 + 50 + 4000, usage());
 902   EXPECT_EQ(0, unlimited_usage());
 903
 904   GetUsageAndQuotaForWebApps(GURL("http://usage10/"), kTemp);
 905   base::RunLoop().RunUntilIdle();
 906   EXPECT_EQ(kQuotaStatusOk, status());
 907   EXPECT_EQ(10, usage());
 908   EXPECT_EQ(10, quota());  // should be clamped to our current usage
 909
 910   GetUsageAndQuotaForWebApps(GURL("http://usage50/"), kTemp);
 911   base::RunLoop().RunUntilIdle();
 912   EXPECT_EQ(kQuotaStatusOk, status());
 913   EXPECT_EQ(50, usage());
 914   EXPECT_EQ(kPerHostQuotaFor100, quota());
 915
 916   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kTemp);
 917   base::RunLoop().RunUntilIdle();
 918   EXPECT_EQ(kQuotaStatusOk, status());
 919   EXPECT_EQ(4000, usage());
 920   EXPECT_EQ(kPerHostQuotaFor100, quota());
 921
 922   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kTemp);
 923   base::RunLoop().RunUntilIdle();
 924   EXPECT_EQ(kQuotaStatusOk, status());
 925   EXPECT_EQ(4000, usage());
 926   EXPECT_EQ(kPerHostQuotaFor100, quota());
 927 }
 928
 929 TEST_F(QuotaManagerTest, OriginInUse) {
 930   const GURL kFooOrigin("http://foo.com/");
 931   const GURL kBarOrigin("http://bar.com/");
 932
 933   EXPECT_FALSE(quota_manager()->IsOriginInUse(kFooOrigin));
 934   quota_manager()->NotifyOriginInUse(kFooOrigin);  // count of 1
 935   EXPECT_TRUE(quota_manager()->IsOriginInUse(kFooOrigin));
 936   quota_manager()->NotifyOriginInUse(kFooOrigin);  // count of 2
 937   EXPECT_TRUE(quota_manager()->IsOriginInUse(kFooOrigin));
 938   quota_manager()->NotifyOriginNoLongerInUse(kFooOrigin);  // count of 1
 939   EXPECT_TRUE(quota_manager()->IsOriginInUse(kFooOrigin));
 940
 941   EXPECT_FALSE(quota_manager()->IsOriginInUse(kBarOrigin));
 942   quota_manager()->NotifyOriginInUse(kBarOrigin);
 943   EXPECT_TRUE(quota_manager()->IsOriginInUse(kBarOrigin));
 944   quota_manager()->NotifyOriginNoLongerInUse(kBarOrigin);
 945   EXPECT_FALSE(quota_manager()->IsOriginInUse(kBarOrigin));
 946
 947   quota_manager()->NotifyOriginNoLongerInUse(kFooOrigin);
 948   EXPECT_FALSE(quota_manager()->IsOriginInUse(kFooOrigin));
 949 }
 950
 951 TEST_F(QuotaManagerTest, GetAndSetPerststentHostQuota) {
 952   RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 953
 954   GetPersistentHostQuota("foo.com");
 955   base::RunLoop().RunUntilIdle();
 956   EXPECT_EQ(0, quota());
 957
 958   SetPersistentHostQuota("foo.com", 100);
 959   base::RunLoop().RunUntilIdle();
 960   EXPECT_EQ(100, quota());
 961
 962   GetPersistentHostQuota("foo.com");
 963   SetPersistentHostQuota("foo.com", 200);
 964   GetPersistentHostQuota("foo.com");
 965   SetPersistentHostQuota("foo.com", QuotaManager::kPerHostPersistentQuotaLimit);
 966   GetPersistentHostQuota("foo.com");
 967   base::RunLoop().RunUntilIdle();
 968   EXPECT_EQ(QuotaManager::kPerHostPersistentQuotaLimit, quota());
 969
 970   // Persistent quota should be capped at the per-host quota limit.
 971   SetPersistentHostQuota("foo.com",
 972                          QuotaManager::kPerHostPersistentQuotaLimit + 100);
 973   GetPersistentHostQuota("foo.com");
 974   base::RunLoop().RunUntilIdle();
 975   EXPECT_EQ(QuotaManager::kPerHostPersistentQuotaLimit, quota());
 976 }
 977
 978 TEST_F(QuotaManagerTest, GetAndSetPersistentUsageAndQuota) {
 979   RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
 980
 981   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
 982   base::RunLoop().RunUntilIdle();
 983   EXPECT_EQ(kQuotaStatusOk, status());
 984   EXPECT_EQ(0, usage());
 985   EXPECT_EQ(0, quota());
 986
 987   SetPersistentHostQuota("foo.com", 100);
 988   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
 989   base::RunLoop().RunUntilIdle();
 990   EXPECT_EQ(kQuotaStatusOk, status());
 991   EXPECT_EQ(0, usage());
 992   EXPECT_EQ(100, quota());
 993
 994   // For installed app GetUsageAndQuotaForWebApps returns the capped quota.
 995   mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
 996   SetPersistentHostQuota("installed", kAvailableSpaceForApp + 100);
 997   GetUsageAndQuotaForWebApps(GURL("http://installed/"), kPerm);
 998   base::RunLoop().RunUntilIdle();
 999   EXPECT_EQ(kAvailableSpaceForApp, quota());
1000
1001   // Ditto for unlimited apps.
1002   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
1003   GetUsageAndQuotaForWebApps(GURL("http://unlimited/"), kPerm);
1004   base::RunLoop().RunUntilIdle();
1005   EXPECT_EQ(kAvailableSpaceForApp, quota());
1006
1007   // GetUsageAndQuotaForStorageClient should just return 0 usage and
1008   // kNoLimit quota.
1009   GetUsageAndQuotaForStorageClient(GURL("http://unlimited/"), kPerm);
1010   base::RunLoop().RunUntilIdle();
1011   EXPECT_EQ(0, usage());
1012   EXPECT_EQ(QuotaManager::kNoLimit, quota());
1013 }
1014
1015 TEST_F(QuotaManagerTest, GetSyncableQuota) {
1016   RegisterClient(CreateClient(NULL, 0, QuotaClient::kFileSystem));
1017
1018   // Pre-condition check: available disk space (for testing) is less than
1019   // the default quota for syncable storage.
1020   EXPECT_LE(kAvailableSpaceForApp,
1021             QuotaManager::kSyncableStorageDefaultHostQuota);
1022
1023   // For installed apps the quota manager should return
1024   // kAvailableSpaceForApp as syncable quota (because of the pre-condition).
1025   mock_special_storage_policy()->GrantQueryDiskSize(GURL("http://installed/"));
1026   GetUsageAndQuotaForWebApps(GURL("http://installed/"), kSync);
1027   base::RunLoop().RunUntilIdle();
1028   EXPECT_EQ(kQuotaStatusOk, status());
1029   EXPECT_EQ(0, usage());
1030   EXPECT_EQ(kAvailableSpaceForApp, quota());
1031
1032   // If it's not installed (which shouldn't happen in real case) it
1033   // should just return the default host quota for syncable.
1034   GetUsageAndQuotaForWebApps(GURL("http://foo/"), kSync);
1035   base::RunLoop().RunUntilIdle();
1036   EXPECT_EQ(kQuotaStatusOk, status());
1037   EXPECT_EQ(0, usage());
1038   EXPECT_EQ(QuotaManager::kSyncableStorageDefaultHostQuota, quota());
1039 }
1040
1041 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_MultiOrigins) {
1042   static const MockOriginData kData[] = {
1043     { "http://foo.com/",        kPerm, 10 },
1044     { "http://foo.com:8080/",   kPerm, 20 },
1045     { "https://foo.com/",       kPerm, 13 },
1046     { "https://foo.com:8081/",  kPerm, 19 },
1047     { "http://bar.com/",        kPerm,  5 },
1048     { "https://bar.com/",       kPerm,  7 },
1049     { "http://baz.com/",        kPerm, 30 },
1050     { "http://foo.com/",        kTemp, 40 },
1051   };
1052   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1053       QuotaClient::kFileSystem));
1054
1055   SetPersistentHostQuota("foo.com", 100);
1056   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1057   base::RunLoop().RunUntilIdle();
1058   EXPECT_EQ(kQuotaStatusOk, status());
1059   EXPECT_EQ(10 + 20 + 13 + 19, usage());
1060   EXPECT_EQ(100, quota());
1061 }
1062
1063 TEST_F(QuotaManagerTest, GetPersistentUsage_WithModify) {
1064   GetUsage_WithModifyTestBody(kPerm);
1065 }
1066
1067 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_WithAdditionalTasks) {
1068   static const MockOriginData kData[] = {
1069     { "http://foo.com/",        kPerm,  10 },
1070     { "http://foo.com:8080/",   kPerm,  20 },
1071     { "http://bar.com/",        kPerm,  13 },
1072     { "http://foo.com/",        kTemp,  40 },
1073   };
1074   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1075       QuotaClient::kFileSystem));
1076   SetPersistentHostQuota("foo.com", 100);
1077
1078   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1079   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1080   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1081   base::RunLoop().RunUntilIdle();
1082   EXPECT_EQ(kQuotaStatusOk, status());
1083   EXPECT_EQ(10 + 20, usage());
1084   EXPECT_EQ(100, quota());
1085
1086   set_additional_callback_count(0);
1087   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"),
1088                                  kPerm);
1089   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1090   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
1091   base::RunLoop().RunUntilIdle();
1092   EXPECT_EQ(kQuotaStatusOk, status());
1093   EXPECT_EQ(10 + 20, usage());
1094   EXPECT_EQ(2, additional_callback_count());
1095 }
1096
1097 TEST_F(QuotaManagerTest, GetPersistentUsageAndQuota_NukeManager) {
1098   static const MockOriginData kData[] = {
1099     { "http://foo.com/",        kPerm,  10 },
1100     { "http://foo.com:8080/",   kPerm,  20 },
1101     { "http://bar.com/",        kPerm,  13 },
1102     { "http://foo.com/",        kTemp,  40 },
1103   };
1104   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1105       QuotaClient::kFileSystem));
1106   SetPersistentHostQuota("foo.com", 100);
1107
1108   set_additional_callback_count(0);
1109   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
1110   RunAdditionalUsageAndQuotaTask(GURL("http://foo.com/"), kPerm);
1111   RunAdditionalUsageAndQuotaTask(GURL("http://bar.com/"), kPerm);
1112
1113   // Nuke before waiting for callbacks.
1114   set_quota_manager(NULL);
1115   base::RunLoop().RunUntilIdle();
1116   EXPECT_EQ(kQuotaErrorAbort, status());
1117 }
1118
1119 TEST_F(QuotaManagerTest, GetUsage_Simple) {
1120   static const MockOriginData kData[] = {
1121     { "http://foo.com/",   kPerm,       1 },
1122     { "http://foo.com:1/", kPerm,      20 },
1123     { "http://bar.com/",   kTemp,     300 },
1124     { "https://buz.com/",  kTemp,    4000 },
1125     { "http://buz.com/",   kTemp,   50000 },
1126     { "http://bar.com:1/", kPerm,  600000 },
1127     { "http://foo.com/",   kTemp, 7000000 },
1128   };
1129   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1130       QuotaClient::kFileSystem));
1131
1132   GetGlobalUsage(kPerm);
1133   base::RunLoop().RunUntilIdle();
1134   EXPECT_EQ(usage(), 1 + 20 + 600000);
1135   EXPECT_EQ(0, unlimited_usage());
1136
1137   GetGlobalUsage(kTemp);
1138   base::RunLoop().RunUntilIdle();
1139   EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
1140   EXPECT_EQ(0, unlimited_usage());
1141
1142   GetHostUsage("foo.com", kPerm);
1143   base::RunLoop().RunUntilIdle();
1144   EXPECT_EQ(usage(), 1 + 20);
1145
1146   GetHostUsage("buz.com", kTemp);
1147   base::RunLoop().RunUntilIdle();
1148   EXPECT_EQ(usage(), 4000 + 50000);
1149 }
1150
1151 TEST_F(QuotaManagerTest, GetUsage_WithModification) {
1152   static const MockOriginData kData[] = {
1153     { "http://foo.com/",   kPerm,       1 },
1154     { "http://foo.com:1/", kPerm,      20 },
1155     { "http://bar.com/",   kTemp,     300 },
1156     { "https://buz.com/",  kTemp,    4000 },
1157     { "http://buz.com/",   kTemp,   50000 },
1158     { "http://bar.com:1/", kPerm,  600000 },
1159     { "http://foo.com/",   kTemp, 7000000 },
1160   };
1161
1162   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1163       QuotaClient::kFileSystem);
1164   RegisterClient(client);
1165
1166   GetGlobalUsage(kPerm);
1167   base::RunLoop().RunUntilIdle();
1168   EXPECT_EQ(usage(), 1 + 20 + 600000);
1169   EXPECT_EQ(0, unlimited_usage());
1170
1171   client->ModifyOriginAndNotify(
1172       GURL("http://foo.com/"), kPerm, 80000000);
1173
1174   GetGlobalUsage(kPerm);
1175   base::RunLoop().RunUntilIdle();
1176   EXPECT_EQ(usage(), 1 + 20 + 600000 + 80000000);
1177   EXPECT_EQ(0, unlimited_usage());
1178
1179   GetGlobalUsage(kTemp);
1180   base::RunLoop().RunUntilIdle();
1181   EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000);
1182   EXPECT_EQ(0, unlimited_usage());
1183
1184   client->ModifyOriginAndNotify(
1185       GURL("http://foo.com/"), kTemp, 1);
1186
1187   GetGlobalUsage(kTemp);
1188   base::RunLoop().RunUntilIdle();
1189   EXPECT_EQ(usage(), 300 + 4000 + 50000 + 7000000 + 1);
1190   EXPECT_EQ(0, unlimited_usage());
1191
1192   GetHostUsage("buz.com", kTemp);
1193   base::RunLoop().RunUntilIdle();
1194   EXPECT_EQ(usage(), 4000 + 50000);
1195
1196   client->ModifyOriginAndNotify(
1197       GURL("http://buz.com/"), kTemp, 900000000);
1198
1199   GetHostUsage("buz.com", kTemp);
1200   base::RunLoop().RunUntilIdle();
1201   EXPECT_EQ(usage(), 4000 + 50000 + 900000000);
1202 }
1203
1204 TEST_F(QuotaManagerTest, GetUsage_WithDeleteOrigin) {
1205   static const MockOriginData kData[] = {
1206     { "http://foo.com/",   kTemp,     1 },
1207     { "http://foo.com:1/", kTemp,    20 },
1208     { "http://foo.com/",   kPerm,   300 },
1209     { "http://bar.com/",   kTemp,  4000 },
1210   };
1211   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1212       QuotaClient::kFileSystem);
1213   RegisterClient(client);
1214
1215   GetGlobalUsage(kTemp);
1216   base::RunLoop().RunUntilIdle();
1217   int64 predelete_global_tmp = usage();
1218
1219   GetHostUsage("foo.com", kTemp);
1220   base::RunLoop().RunUntilIdle();
1221   int64 predelete_host_tmp = usage();
1222
1223   GetHostUsage("foo.com", kPerm);
1224   base::RunLoop().RunUntilIdle();
1225   int64 predelete_host_pers = usage();
1226
1227   DeleteClientOriginData(client, GURL("http://foo.com/"),
1228                          kTemp);
1229   base::RunLoop().RunUntilIdle();
1230   EXPECT_EQ(kQuotaStatusOk, status());
1231
1232   GetGlobalUsage(kTemp);
1233   base::RunLoop().RunUntilIdle();
1234   EXPECT_EQ(predelete_global_tmp - 1, usage());
1235
1236   GetHostUsage("foo.com", kTemp);
1237   base::RunLoop().RunUntilIdle();
1238   EXPECT_EQ(predelete_host_tmp - 1, usage());
1239
1240   GetHostUsage("foo.com", kPerm);
1241   base::RunLoop().RunUntilIdle();
1242   EXPECT_EQ(predelete_host_pers, usage());
1243 }
1244
1245 TEST_F(QuotaManagerTest, GetAvailableSpaceTest) {
1246   GetAvailableSpace();
1247   base::RunLoop().RunUntilIdle();
1248   EXPECT_EQ(kQuotaStatusOk, status());
1249   EXPECT_LE(0, available_space());
1250 }
1251
1252 TEST_F(QuotaManagerTest, EvictOriginData) {
1253   static const MockOriginData kData1[] = {
1254     { "http://foo.com/",   kTemp,     1 },
1255     { "http://foo.com:1/", kTemp,    20 },
1256     { "http://foo.com/",   kPerm,   300 },
1257     { "http://bar.com/",   kTemp,  4000 },
1258   };
1259   static const MockOriginData kData2[] = {
1260     { "http://foo.com/",   kTemp, 50000 },
1261     { "http://foo.com:1/", kTemp,  6000 },
1262     { "http://foo.com/",   kPerm,   700 },
1263     { "https://foo.com/",  kTemp,    80 },
1264     { "http://bar.com/",   kTemp,     9 },
1265   };
1266   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
1267       QuotaClient::kFileSystem);
1268   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
1269       QuotaClient::kDatabase);
1270   RegisterClient(client1);
1271   RegisterClient(client2);
1272
1273   GetGlobalUsage(kTemp);
1274   base::RunLoop().RunUntilIdle();
1275   int64 predelete_global_tmp = usage();
1276
1277   GetHostUsage("foo.com", kTemp);
1278   base::RunLoop().RunUntilIdle();
1279   int64 predelete_host_tmp = usage();
1280
1281   GetHostUsage("foo.com", kPerm);
1282   base::RunLoop().RunUntilIdle();
1283   int64 predelete_host_pers = usage();
1284
1285   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
1286     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
1287         GURL(kData1[i].origin), kData1[i].type);
1288   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
1289     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
1290         GURL(kData2[i].origin), kData2[i].type);
1291   base::RunLoop().RunUntilIdle();
1292
1293   EvictOriginData(GURL("http://foo.com/"), kTemp);
1294   base::RunLoop().RunUntilIdle();
1295
1296   DumpOriginInfoTable();
1297   base::RunLoop().RunUntilIdle();
1298
1299   typedef OriginInfoTableEntries::const_iterator iterator;
1300   for (iterator itr(origin_info_entries().begin()),
1301                 end(origin_info_entries().end());
1302        itr != end; ++itr) {
1303     if (itr->type == kTemp)
1304       EXPECT_NE(std::string("http://foo.com/"), itr->origin.spec());
1305   }
1306
1307   GetGlobalUsage(kTemp);
1308   base::RunLoop().RunUntilIdle();
1309   EXPECT_EQ(predelete_global_tmp - (1 + 50000), usage());
1310
1311   GetHostUsage("foo.com", kTemp);
1312   base::RunLoop().RunUntilIdle();
1313   EXPECT_EQ(predelete_host_tmp - (1 + 50000), usage());
1314
1315   GetHostUsage("foo.com", kPerm);
1316   base::RunLoop().RunUntilIdle();
1317   EXPECT_EQ(predelete_host_pers, usage());
1318 }
1319
1320 TEST_F(QuotaManagerTest, EvictOriginDataWithDeletionError) {
1321   static const MockOriginData kData[] = {
1322     { "http://foo.com/",   kTemp,       1 },
1323     { "http://foo.com:1/", kTemp,      20 },
1324     { "http://foo.com/",   kPerm,     300 },
1325     { "http://bar.com/",   kTemp,    4000 },
1326   };
1327   static const int kNumberOfTemporaryOrigins = 3;
1328   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1329       QuotaClient::kFileSystem);
1330   RegisterClient(client);
1331
1332   GetGlobalUsage(kTemp);
1333   base::RunLoop().RunUntilIdle();
1334   int64 predelete_global_tmp = usage();
1335
1336   GetHostUsage("foo.com", kTemp);
1337   base::RunLoop().RunUntilIdle();
1338   int64 predelete_host_tmp = usage();
1339
1340   GetHostUsage("foo.com", kPerm);
1341   base::RunLoop().RunUntilIdle();
1342   int64 predelete_host_pers = usage();
1343
1344   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i)
1345     NotifyStorageAccessed(client, GURL(kData[i].origin), kData[i].type);
1346   base::RunLoop().RunUntilIdle();
1347
1348   client->AddOriginToErrorSet(GURL("http://foo.com/"), kTemp);
1349
1350   for (int i = 0;
1351        i < QuotaManager::kThresholdOfErrorsToBeBlacklisted + 1;
1352        ++i) {
1353     EvictOriginData(GURL("http://foo.com/"), kTemp);
1354     base::RunLoop().RunUntilIdle();
1355     EXPECT_EQ(kQuotaErrorInvalidModification, status());
1356   }
1357
1358   DumpOriginInfoTable();
1359   base::RunLoop().RunUntilIdle();
1360
1361   bool found_origin_in_database = false;
1362   typedef OriginInfoTableEntries::const_iterator iterator;
1363   for (iterator itr(origin_info_entries().begin()),
1364                 end(origin_info_entries().end());
1365        itr != end; ++itr) {
1366     if (itr->type == kTemp &&
1367         GURL("http://foo.com/") == itr->origin) {
1368       found_origin_in_database = true;
1369       break;
1370     }
1371   }
1372   // The origin "http://foo.com/" should be in the database.
1373   EXPECT_TRUE(found_origin_in_database);
1374
1375   for (size_t i = 0; i < kNumberOfTemporaryOrigins - 1; ++i) {
1376     GetLRUOrigin(kTemp);
1377     base::RunLoop().RunUntilIdle();
1378     EXPECT_FALSE(lru_origin().is_empty());
1379     // The origin "http://foo.com/" should not be in the LRU list.
1380     EXPECT_NE(std::string("http://foo.com/"), lru_origin().spec());
1381     DeleteOriginFromDatabase(lru_origin(), kTemp);
1382     base::RunLoop().RunUntilIdle();
1383   }
1384
1385   // Now the LRU list must be empty.
1386   GetLRUOrigin(kTemp);
1387   base::RunLoop().RunUntilIdle();
1388   EXPECT_TRUE(lru_origin().is_empty());
1389
1390   // Deleting origins from the database should not affect the results of the
1391   // following checks.
1392   GetGlobalUsage(kTemp);
1393   base::RunLoop().RunUntilIdle();
1394   EXPECT_EQ(predelete_global_tmp, usage());
1395
1396   GetHostUsage("foo.com", kTemp);
1397   base::RunLoop().RunUntilIdle();
1398   EXPECT_EQ(predelete_host_tmp, usage());
1399
1400   GetHostUsage("foo.com", kPerm);
1401   base::RunLoop().RunUntilIdle();
1402   EXPECT_EQ(predelete_host_pers, usage());
1403 }
1404
1405 TEST_F(QuotaManagerTest, GetUsageAndQuotaForEviction) {
1406   static const MockOriginData kData[] = {
1407     { "http://foo.com/",   kTemp,       1 },
1408     { "http://foo.com:1/", kTemp,      20 },
1409     { "http://foo.com/",   kPerm,     300 },
1410     { "http://unlimited/", kTemp,    4000 },
1411   };
1412
1413   mock_special_storage_policy()->AddUnlimited(GURL("http://unlimited/"));
1414   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1415       QuotaClient::kFileSystem);
1416   RegisterClient(client);
1417
1418   SetTemporaryGlobalQuota(10000000);
1419   base::RunLoop().RunUntilIdle();
1420
1421   GetUsageAndQuotaForEviction();
1422   base::RunLoop().RunUntilIdle();
1423   EXPECT_EQ(kQuotaStatusOk, status());
1424   EXPECT_EQ(21, limited_usage());
1425   EXPECT_EQ(10000000, quota());
1426   EXPECT_LE(0, available_space());
1427 }
1428
1429 TEST_F(QuotaManagerTest, DeleteHostDataSimple) {
1430   static const MockOriginData kData[] = {
1431     { "http://foo.com/",   kTemp,     1 },
1432   };
1433   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1434       QuotaClient::kFileSystem);
1435   RegisterClient(client);
1436
1437   GetGlobalUsage(kTemp);
1438   base::RunLoop().RunUntilIdle();
1439   const int64 predelete_global_tmp = usage();
1440
1441   GetHostUsage("foo.com", kTemp);
1442   base::RunLoop().RunUntilIdle();
1443   int64 predelete_host_tmp = usage();
1444
1445   GetHostUsage("foo.com", kPerm);
1446   base::RunLoop().RunUntilIdle();
1447   int64 predelete_host_pers = usage();
1448
1449   DeleteHostData(std::string(), kTemp, kAllClients);
1450   base::RunLoop().RunUntilIdle();
1451   EXPECT_EQ(kQuotaStatusOk, status());
1452
1453   GetGlobalUsage(kTemp);
1454   base::RunLoop().RunUntilIdle();
1455   EXPECT_EQ(predelete_global_tmp, usage());
1456
1457   GetHostUsage("foo.com", kTemp);
1458   base::RunLoop().RunUntilIdle();
1459   EXPECT_EQ(predelete_host_tmp, usage());
1460
1461   GetHostUsage("foo.com", kPerm);
1462   base::RunLoop().RunUntilIdle();
1463   EXPECT_EQ(predelete_host_pers, usage());
1464
1465   DeleteHostData("foo.com", kTemp, kAllClients);
1466   base::RunLoop().RunUntilIdle();
1467   EXPECT_EQ(kQuotaStatusOk, status());
1468
1469   GetGlobalUsage(kTemp);
1470   base::RunLoop().RunUntilIdle();
1471   EXPECT_EQ(predelete_global_tmp - 1, usage());
1472
1473   GetHostUsage("foo.com", kTemp);
1474   base::RunLoop().RunUntilIdle();
1475   EXPECT_EQ(predelete_host_tmp - 1, usage());
1476
1477   GetHostUsage("foo.com", kPerm);
1478   base::RunLoop().RunUntilIdle();
1479   EXPECT_EQ(predelete_host_pers, usage());
1480 }
1481
1482 TEST_F(QuotaManagerTest, DeleteHostDataMultiple) {
1483   static const MockOriginData kData1[] = {
1484     { "http://foo.com/",   kTemp,     1 },
1485     { "http://foo.com:1/", kTemp,    20 },
1486     { "http://foo.com/",   kPerm,   300 },
1487     { "http://bar.com/",   kTemp,  4000 },
1488   };
1489   static const MockOriginData kData2[] = {
1490     { "http://foo.com/",   kTemp, 50000 },
1491     { "http://foo.com:1/", kTemp,  6000 },
1492     { "http://foo.com/",   kPerm,   700 },
1493     { "https://foo.com/",  kTemp,    80 },
1494     { "http://bar.com/",   kTemp,     9 },
1495   };
1496   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
1497       QuotaClient::kFileSystem);
1498   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
1499       QuotaClient::kDatabase);
1500   RegisterClient(client1);
1501   RegisterClient(client2);
1502
1503   GetGlobalUsage(kTemp);
1504   base::RunLoop().RunUntilIdle();
1505   const int64 predelete_global_tmp = usage();
1506
1507   GetHostUsage("foo.com", kTemp);
1508   base::RunLoop().RunUntilIdle();
1509   const int64 predelete_foo_tmp = usage();
1510
1511   GetHostUsage("bar.com", kTemp);
1512   base::RunLoop().RunUntilIdle();
1513   const int64 predelete_bar_tmp = usage();
1514
1515   GetHostUsage("foo.com", kPerm);
1516   base::RunLoop().RunUntilIdle();
1517   const int64 predelete_foo_pers = usage();
1518
1519   GetHostUsage("bar.com", kPerm);
1520   base::RunLoop().RunUntilIdle();
1521   const int64 predelete_bar_pers = usage();
1522
1523   reset_status_callback_count();
1524   DeleteHostData("foo.com", kTemp, kAllClients);
1525   DeleteHostData("bar.com", kTemp, kAllClients);
1526   DeleteHostData("foo.com", kTemp, kAllClients);
1527   base::RunLoop().RunUntilIdle();
1528
1529   EXPECT_EQ(3, status_callback_count());
1530
1531   DumpOriginInfoTable();
1532   base::RunLoop().RunUntilIdle();
1533
1534   typedef OriginInfoTableEntries::const_iterator iterator;
1535   for (iterator itr(origin_info_entries().begin()),
1536                 end(origin_info_entries().end());
1537        itr != end; ++itr) {
1538     if (itr->type == kTemp) {
1539       EXPECT_NE(std::string("http://foo.com/"), itr->origin.spec());
1540       EXPECT_NE(std::string("http://foo.com:1/"), itr->origin.spec());
1541       EXPECT_NE(std::string("https://foo.com/"), itr->origin.spec());
1542       EXPECT_NE(std::string("http://bar.com/"), itr->origin.spec());
1543     }
1544   }
1545
1546   GetGlobalUsage(kTemp);
1547   base::RunLoop().RunUntilIdle();
1548   EXPECT_EQ(predelete_global_tmp - (1 + 20 + 4000 + 50000 + 6000 + 80 + 9),
1549             usage());
1550
1551   GetHostUsage("foo.com", kTemp);
1552   base::RunLoop().RunUntilIdle();
1553   EXPECT_EQ(predelete_foo_tmp - (1 + 20 + 50000 + 6000 + 80), usage());
1554
1555   GetHostUsage("bar.com", kTemp);
1556   base::RunLoop().RunUntilIdle();
1557   EXPECT_EQ(predelete_bar_tmp - (4000 + 9), usage());
1558
1559   GetHostUsage("foo.com", kPerm);
1560   base::RunLoop().RunUntilIdle();
1561   EXPECT_EQ(predelete_foo_pers, usage());
1562
1563   GetHostUsage("bar.com", kPerm);
1564   base::RunLoop().RunUntilIdle();
1565   EXPECT_EQ(predelete_bar_pers, usage());
1566 }
1567
1568 // Single-run DeleteOriginData cases must be well covered by
1569 // EvictOriginData tests.
1570 TEST_F(QuotaManagerTest, DeleteOriginDataMultiple) {
1571   static const MockOriginData kData1[] = {
1572     { "http://foo.com/",   kTemp,     1 },
1573     { "http://foo.com:1/", kTemp,    20 },
1574     { "http://foo.com/",   kPerm,   300 },
1575     { "http://bar.com/",   kTemp,  4000 },
1576   };
1577   static const MockOriginData kData2[] = {
1578     { "http://foo.com/",   kTemp, 50000 },
1579     { "http://foo.com:1/", kTemp,  6000 },
1580     { "http://foo.com/",   kPerm,   700 },
1581     { "https://foo.com/",  kTemp,    80 },
1582     { "http://bar.com/",   kTemp,     9 },
1583   };
1584   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
1585       QuotaClient::kFileSystem);
1586   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
1587       QuotaClient::kDatabase);
1588   RegisterClient(client1);
1589   RegisterClient(client2);
1590
1591   GetGlobalUsage(kTemp);
1592   base::RunLoop().RunUntilIdle();
1593   const int64 predelete_global_tmp = usage();
1594
1595   GetHostUsage("foo.com", kTemp);
1596   base::RunLoop().RunUntilIdle();
1597   const int64 predelete_foo_tmp = usage();
1598
1599   GetHostUsage("bar.com", kTemp);
1600   base::RunLoop().RunUntilIdle();
1601   const int64 predelete_bar_tmp = usage();
1602
1603   GetHostUsage("foo.com", kPerm);
1604   base::RunLoop().RunUntilIdle();
1605   const int64 predelete_foo_pers = usage();
1606
1607   GetHostUsage("bar.com", kPerm);
1608   base::RunLoop().RunUntilIdle();
1609   const int64 predelete_bar_pers = usage();
1610
1611   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData1); ++i)
1612     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
1613         GURL(kData1[i].origin), kData1[i].type);
1614   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData2); ++i)
1615     quota_manager()->NotifyStorageAccessed(QuotaClient::kUnknown,
1616         GURL(kData2[i].origin), kData2[i].type);
1617   base::RunLoop().RunUntilIdle();
1618
1619   reset_status_callback_count();
1620   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
1621   DeleteOriginData(GURL("http://bar.com/"), kTemp, kAllClients);
1622   DeleteOriginData(GURL("http://foo.com/"), kTemp, kAllClients);
1623   base::RunLoop().RunUntilIdle();
1624
1625   EXPECT_EQ(3, status_callback_count());
1626
1627   DumpOriginInfoTable();
1628   base::RunLoop().RunUntilIdle();
1629
1630   typedef OriginInfoTableEntries::const_iterator iterator;
1631   for (iterator itr(origin_info_entries().begin()),
1632                 end(origin_info_entries().end());
1633        itr != end; ++itr) {
1634     if (itr->type == kTemp) {
1635       EXPECT_NE(std::string("http://foo.com/"), itr->origin.spec());
1636       EXPECT_NE(std::string("http://bar.com/"), itr->origin.spec());
1637     }
1638   }
1639
1640   GetGlobalUsage(kTemp);
1641   base::RunLoop().RunUntilIdle();
1642   EXPECT_EQ(predelete_global_tmp - (1 + 4000 + 50000 + 9), usage());
1643
1644   GetHostUsage("foo.com", kTemp);
1645   base::RunLoop().RunUntilIdle();
1646   EXPECT_EQ(predelete_foo_tmp - (1 + 50000), usage());
1647
1648   GetHostUsage("bar.com", kTemp);
1649   base::RunLoop().RunUntilIdle();
1650   EXPECT_EQ(predelete_bar_tmp - (4000 + 9), usage());
1651
1652   GetHostUsage("foo.com", kPerm);
1653   base::RunLoop().RunUntilIdle();
1654   EXPECT_EQ(predelete_foo_pers, usage());
1655
1656   GetHostUsage("bar.com", kPerm);
1657   base::RunLoop().RunUntilIdle();
1658   EXPECT_EQ(predelete_bar_pers, usage());
1659 }
1660
1661 TEST_F(QuotaManagerTest, GetCachedOrigins) {
1662   static const MockOriginData kData[] = {
1663     { "http://a.com/",   kTemp,       1 },
1664     { "http://a.com:1/", kTemp,      20 },
1665     { "http://b.com/",   kPerm,     300 },
1666     { "http://c.com/",   kTemp,    4000 },
1667   };
1668   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1669       QuotaClient::kFileSystem);
1670   RegisterClient(client);
1671
1672   // TODO(kinuko): Be careful when we add cache pruner.
1673
1674   std::set<GURL> origins;
1675   GetCachedOrigins(kTemp, &origins);
1676   EXPECT_TRUE(origins.empty());
1677
1678   // No matter how we make queries the quota manager tries to cache all
1679   // the origins at startup.
1680   GetHostUsage("a.com", kTemp);
1681   base::RunLoop().RunUntilIdle();
1682   GetCachedOrigins(kTemp, &origins);
1683   EXPECT_EQ(3U, origins.size());
1684
1685   GetHostUsage("b.com", kTemp);
1686   base::RunLoop().RunUntilIdle();
1687   GetCachedOrigins(kTemp, &origins);
1688   EXPECT_EQ(3U, origins.size());
1689
1690   GetCachedOrigins(kPerm, &origins);
1691   EXPECT_TRUE(origins.empty());
1692
1693   GetGlobalUsage(kTemp);
1694   base::RunLoop().RunUntilIdle();
1695   GetCachedOrigins(kTemp, &origins);
1696   EXPECT_EQ(3U, origins.size());
1697
1698   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i) {
1699     if (kData[i].type == kTemp)
1700       EXPECT_TRUE(origins.find(GURL(kData[i].origin)) != origins.end());
1701   }
1702 }
1703
1704 TEST_F(QuotaManagerTest, NotifyAndLRUOrigin) {
1705   static const MockOriginData kData[] = {
1706     { "http://a.com/",   kTemp,  0 },
1707     { "http://a.com:1/", kTemp,  0 },
1708     { "https://a.com/",  kTemp,  0 },
1709     { "http://b.com/",   kPerm,  0 },  // persistent
1710     { "http://c.com/",   kTemp,  0 },
1711   };
1712   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1713       QuotaClient::kFileSystem);
1714   RegisterClient(client);
1715
1716   GURL origin;
1717   GetLRUOrigin(kTemp);
1718   base::RunLoop().RunUntilIdle();
1719   EXPECT_TRUE(lru_origin().is_empty());
1720
1721   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
1722   GetLRUOrigin(kTemp);
1723   base::RunLoop().RunUntilIdle();
1724   EXPECT_EQ("http://a.com/", lru_origin().spec());
1725
1726   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
1727   NotifyStorageAccessed(client, GURL("https://a.com/"), kTemp);
1728   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
1729   GetLRUOrigin(kTemp);
1730   base::RunLoop().RunUntilIdle();
1731   EXPECT_EQ("http://a.com/", lru_origin().spec());
1732
1733   DeleteOriginFromDatabase(lru_origin(), kTemp);
1734   GetLRUOrigin(kTemp);
1735   base::RunLoop().RunUntilIdle();
1736   EXPECT_EQ("https://a.com/", lru_origin().spec());
1737
1738   DeleteOriginFromDatabase(lru_origin(), kTemp);
1739   GetLRUOrigin(kTemp);
1740   base::RunLoop().RunUntilIdle();
1741   EXPECT_EQ("http://c.com/", lru_origin().spec());
1742 }
1743
1744 TEST_F(QuotaManagerTest, GetLRUOriginWithOriginInUse) {
1745   static const MockOriginData kData[] = {
1746     { "http://a.com/",   kTemp,  0 },
1747     { "http://a.com:1/", kTemp,  0 },
1748     { "https://a.com/",  kTemp,  0 },
1749     { "http://b.com/",   kPerm,  0 },  // persistent
1750     { "http://c.com/",   kTemp,  0 },
1751   };
1752   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1753       QuotaClient::kFileSystem);
1754   RegisterClient(client);
1755
1756   GURL origin;
1757   GetLRUOrigin(kTemp);
1758   base::RunLoop().RunUntilIdle();
1759   EXPECT_TRUE(lru_origin().is_empty());
1760
1761   NotifyStorageAccessed(client, GURL("http://a.com/"), kTemp);
1762   NotifyStorageAccessed(client, GURL("http://b.com/"), kPerm);
1763   NotifyStorageAccessed(client, GURL("https://a.com/"), kTemp);
1764   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
1765
1766   GetLRUOrigin(kTemp);
1767   base::RunLoop().RunUntilIdle();
1768   EXPECT_EQ("http://a.com/", lru_origin().spec());
1769
1770   // Notify origin http://a.com is in use.
1771   NotifyOriginInUse(GURL("http://a.com/"));
1772   GetLRUOrigin(kTemp);
1773   base::RunLoop().RunUntilIdle();
1774   EXPECT_EQ("https://a.com/", lru_origin().spec());
1775
1776   // Notify origin https://a.com is in use while GetLRUOrigin is running.
1777   GetLRUOrigin(kTemp);
1778   NotifyOriginInUse(GURL("https://a.com/"));
1779   base::RunLoop().RunUntilIdle();
1780   // Post-filtering must have excluded the returned origin, so we will
1781   // see empty result here.
1782   EXPECT_TRUE(lru_origin().is_empty());
1783
1784   // Notify access for http://c.com while GetLRUOrigin is running.
1785   GetLRUOrigin(kTemp);
1786   NotifyStorageAccessed(client, GURL("http://c.com/"), kTemp);
1787   base::RunLoop().RunUntilIdle();
1788   // Post-filtering must have excluded the returned origin, so we will
1789   // see empty result here.
1790   EXPECT_TRUE(lru_origin().is_empty());
1791
1792   NotifyOriginNoLongerInUse(GURL("http://a.com/"));
1793   NotifyOriginNoLongerInUse(GURL("https://a.com/"));
1794   GetLRUOrigin(kTemp);
1795   base::RunLoop().RunUntilIdle();
1796   EXPECT_EQ("http://a.com/", lru_origin().spec());
1797 }
1798
1799 TEST_F(QuotaManagerTest, GetOriginsModifiedSince) {
1800   static const MockOriginData kData[] = {
1801     { "http://a.com/",   kTemp,  0 },
1802     { "http://a.com:1/", kTemp,  0 },
1803     { "https://a.com/",  kTemp,  0 },
1804     { "http://b.com/",   kPerm,  0 },  // persistent
1805     { "http://c.com/",   kTemp,  0 },
1806   };
1807   MockStorageClient* client = CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
1808       QuotaClient::kFileSystem);
1809   RegisterClient(client);
1810
1811   GetOriginsModifiedSince(kTemp, base::Time());
1812   base::RunLoop().RunUntilIdle();
1813   EXPECT_TRUE(modified_origins().empty());
1814   EXPECT_EQ(modified_origins_type(), kTemp);
1815
1816   base::Time time1 = client->IncrementMockTime();
1817   client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
1818   client->ModifyOriginAndNotify(GURL("http://a.com:1/"), kTemp, 10);
1819   client->ModifyOriginAndNotify(GURL("http://b.com/"), kPerm, 10);
1820   base::Time time2 = client->IncrementMockTime();
1821   client->ModifyOriginAndNotify(GURL("https://a.com/"), kTemp, 10);
1822   client->ModifyOriginAndNotify(GURL("http://c.com/"), kTemp, 10);
1823   base::Time time3 = client->IncrementMockTime();
1824
1825   GetOriginsModifiedSince(kTemp, time1);
1826   base::RunLoop().RunUntilIdle();
1827   EXPECT_EQ(4U, modified_origins().size());
1828   EXPECT_EQ(modified_origins_type(), kTemp);
1829   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kData); ++i) {
1830     if (kData[i].type == kTemp)
1831       EXPECT_EQ(1U, modified_origins().count(GURL(kData[i].origin)));
1832   }
1833
1834   GetOriginsModifiedSince(kTemp, time2);
1835   base::RunLoop().RunUntilIdle();
1836   EXPECT_EQ(2U, modified_origins().size());
1837
1838   GetOriginsModifiedSince(kTemp, time3);
1839   base::RunLoop().RunUntilIdle();
1840   EXPECT_TRUE(modified_origins().empty());
1841   EXPECT_EQ(modified_origins_type(), kTemp);
1842
1843   client->ModifyOriginAndNotify(GURL("http://a.com/"), kTemp, 10);
1844
1845   GetOriginsModifiedSince(kTemp, time3);
1846   base::RunLoop().RunUntilIdle();
1847   EXPECT_EQ(1U, modified_origins().size());
1848   EXPECT_EQ(1U, modified_origins().count(GURL("http://a.com/")));
1849   EXPECT_EQ(modified_origins_type(), kTemp);
1850 }
1851
1852 TEST_F(QuotaManagerTest, DumpQuotaTable) {
1853   SetPersistentHostQuota("example1.com", 1);
1854   SetPersistentHostQuota("example2.com", 20);
1855   SetPersistentHostQuota("example3.com", 300);
1856   base::RunLoop().RunUntilIdle();
1857
1858   DumpQuotaTable();
1859   base::RunLoop().RunUntilIdle();
1860
1861   const QuotaTableEntry kEntries[] = {
1862     QuotaTableEntry("example1.com", kPerm, 1),
1863     QuotaTableEntry("example2.com", kPerm, 20),
1864     QuotaTableEntry("example3.com", kPerm, 300),
1865   };
1866   std::set<QuotaTableEntry> entries
1867       (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
1868
1869   typedef QuotaTableEntries::const_iterator iterator;
1870   for (iterator itr(quota_entries().begin()), end(quota_entries().end());
1871        itr != end; ++itr) {
1872     SCOPED_TRACE(testing::Message()
1873                  << "host = " << itr->host << ", "
1874                  << "quota = " << itr->quota);
1875     EXPECT_EQ(1u, entries.erase(*itr));
1876   }
1877   EXPECT_TRUE(entries.empty());
1878 }
1879
1880 TEST_F(QuotaManagerTest, DumpOriginInfoTable) {
1881   using std::make_pair;
1882
1883   quota_manager()->NotifyStorageAccessed(
1884       QuotaClient::kUnknown,
1885       GURL("http://example.com/"),
1886       kTemp);
1887   quota_manager()->NotifyStorageAccessed(
1888       QuotaClient::kUnknown,
1889       GURL("http://example.com/"),
1890       kPerm);
1891   quota_manager()->NotifyStorageAccessed(
1892       QuotaClient::kUnknown,
1893       GURL("http://example.com/"),
1894       kPerm);
1895   base::RunLoop().RunUntilIdle();
1896
1897   DumpOriginInfoTable();
1898   base::RunLoop().RunUntilIdle();
1899
1900   typedef std::pair<GURL, StorageType> TypedOrigin;
1901   typedef std::pair<TypedOrigin, int> Entry;
1902   const Entry kEntries[] = {
1903     make_pair(make_pair(GURL("http://example.com/"), kTemp), 1),
1904     make_pair(make_pair(GURL("http://example.com/"), kPerm), 2),
1905   };
1906   std::set<Entry> entries
1907       (kEntries, kEntries + ARRAYSIZE_UNSAFE(kEntries));
1908
1909   typedef OriginInfoTableEntries::const_iterator iterator;
1910   for (iterator itr(origin_info_entries().begin()),
1911                 end(origin_info_entries().end());
1912        itr != end; ++itr) {
1913     SCOPED_TRACE(testing::Message()
1914                  << "host = " << itr->origin << ", "
1915                  << "type = " << itr->type << ", "
1916                  << "used_count = " << itr->used_count);
1917     EXPECT_EQ(1u, entries.erase(
1918         make_pair(make_pair(itr->origin, itr->type),
1919                   itr->used_count)));
1920   }
1921   EXPECT_TRUE(entries.empty());
1922 }
1923
1924 TEST_F(QuotaManagerTest, QuotaForEmptyHost) {
1925   GetPersistentHostQuota(std::string());
1926   base::RunLoop().RunUntilIdle();
1927   EXPECT_EQ(kQuotaStatusOk, status());
1928   EXPECT_EQ(0, quota());
1929
1930   SetPersistentHostQuota(std::string(), 10);
1931   base::RunLoop().RunUntilIdle();
1932   EXPECT_EQ(kQuotaErrorNotSupported, status());
1933 }
1934
1935 TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleOrigin) {
1936   static const MockOriginData kData1[] = {
1937     { "http://foo.com/",   kTemp, 1 },
1938   };
1939   static const MockOriginData kData2[] = {
1940     { "http://foo.com/",   kTemp, 2 },
1941   };
1942   static const MockOriginData kData3[] = {
1943     { "http://foo.com/",   kTemp, 4 },
1944   };
1945   static const MockOriginData kData4[] = {
1946     { "http://foo.com/",   kTemp, 8 },
1947   };
1948   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
1949       QuotaClient::kFileSystem);
1950   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
1951       QuotaClient::kAppcache);
1952   MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
1953       QuotaClient::kDatabase);
1954   MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
1955       QuotaClient::kIndexedDatabase);
1956   RegisterClient(client1);
1957   RegisterClient(client2);
1958   RegisterClient(client3);
1959   RegisterClient(client4);
1960
1961   GetHostUsage("foo.com", kTemp);
1962   base::RunLoop().RunUntilIdle();
1963   const int64 predelete_foo_tmp = usage();
1964
1965   DeleteOriginData(GURL("http://foo.com/"), kTemp, QuotaClient::kFileSystem);
1966   base::RunLoop().RunUntilIdle();
1967   GetHostUsage("foo.com", kTemp);
1968   base::RunLoop().RunUntilIdle();
1969   EXPECT_EQ(predelete_foo_tmp - 1, usage());
1970
1971   DeleteOriginData(GURL("http://foo.com/"), kTemp, QuotaClient::kAppcache);
1972   base::RunLoop().RunUntilIdle();
1973   GetHostUsage("foo.com", kTemp);
1974   base::RunLoop().RunUntilIdle();
1975   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
1976
1977   DeleteOriginData(GURL("http://foo.com/"), kTemp, QuotaClient::kDatabase);
1978   base::RunLoop().RunUntilIdle();
1979   GetHostUsage("foo.com", kTemp);
1980   base::RunLoop().RunUntilIdle();
1981   EXPECT_EQ(predelete_foo_tmp - 4 - 2 - 1, usage());
1982
1983   DeleteOriginData(GURL("http://foo.com/"), kTemp,
1984       QuotaClient::kIndexedDatabase);
1985   base::RunLoop().RunUntilIdle();
1986   GetHostUsage("foo.com", kTemp);
1987   base::RunLoop().RunUntilIdle();
1988   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
1989 }
1990
1991 TEST_F(QuotaManagerTest, DeleteSpecificClientTypeSingleHost) {
1992   static const MockOriginData kData1[] = {
1993     { "http://foo.com:1111/",   kTemp, 1 },
1994   };
1995   static const MockOriginData kData2[] = {
1996     { "http://foo.com:2222/",   kTemp, 2 },
1997   };
1998   static const MockOriginData kData3[] = {
1999     { "http://foo.com:3333/",   kTemp, 4 },
2000   };
2001   static const MockOriginData kData4[] = {
2002     { "http://foo.com:4444/",   kTemp, 8 },
2003   };
2004   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
2005       QuotaClient::kFileSystem);
2006   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
2007       QuotaClient::kAppcache);
2008   MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
2009       QuotaClient::kDatabase);
2010   MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
2011       QuotaClient::kIndexedDatabase);
2012   RegisterClient(client1);
2013   RegisterClient(client2);
2014   RegisterClient(client3);
2015   RegisterClient(client4);
2016
2017   GetHostUsage("foo.com", kTemp);
2018   base::RunLoop().RunUntilIdle();
2019   const int64 predelete_foo_tmp = usage();
2020
2021   DeleteHostData("foo.com", kTemp, QuotaClient::kFileSystem);
2022   base::RunLoop().RunUntilIdle();
2023   GetHostUsage("foo.com", kTemp);
2024   base::RunLoop().RunUntilIdle();
2025   EXPECT_EQ(predelete_foo_tmp - 1, usage());
2026
2027   DeleteHostData("foo.com", kTemp, QuotaClient::kAppcache);
2028   base::RunLoop().RunUntilIdle();
2029   GetHostUsage("foo.com", kTemp);
2030   base::RunLoop().RunUntilIdle();
2031   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
2032
2033   DeleteHostData("foo.com", kTemp, QuotaClient::kDatabase);
2034   base::RunLoop().RunUntilIdle();
2035   GetHostUsage("foo.com", kTemp);
2036   base::RunLoop().RunUntilIdle();
2037   EXPECT_EQ(predelete_foo_tmp - 4 - 2 - 1, usage());
2038
2039   DeleteHostData("foo.com", kTemp, QuotaClient::kIndexedDatabase);
2040   base::RunLoop().RunUntilIdle();
2041   GetHostUsage("foo.com", kTemp);
2042   base::RunLoop().RunUntilIdle();
2043   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
2044 }
2045
2046 TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleOrigin) {
2047   static const MockOriginData kData1[] = {
2048     { "http://foo.com/",   kTemp, 1 },
2049   };
2050   static const MockOriginData kData2[] = {
2051     { "http://foo.com/",   kTemp, 2 },
2052   };
2053   static const MockOriginData kData3[] = {
2054     { "http://foo.com/",   kTemp, 4 },
2055   };
2056   static const MockOriginData kData4[] = {
2057     { "http://foo.com/",   kTemp, 8 },
2058   };
2059   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
2060       QuotaClient::kFileSystem);
2061   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
2062       QuotaClient::kAppcache);
2063   MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
2064       QuotaClient::kDatabase);
2065   MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
2066       QuotaClient::kIndexedDatabase);
2067   RegisterClient(client1);
2068   RegisterClient(client2);
2069   RegisterClient(client3);
2070   RegisterClient(client4);
2071
2072   GetHostUsage("foo.com", kTemp);
2073   base::RunLoop().RunUntilIdle();
2074   const int64 predelete_foo_tmp = usage();
2075
2076   DeleteOriginData(GURL("http://foo.com/"), kTemp,
2077       QuotaClient::kFileSystem | QuotaClient::kDatabase);
2078   base::RunLoop().RunUntilIdle();
2079   GetHostUsage("foo.com", kTemp);
2080   base::RunLoop().RunUntilIdle();
2081   EXPECT_EQ(predelete_foo_tmp - 4 - 1, usage());
2082
2083   DeleteOriginData(GURL("http://foo.com/"), kTemp,
2084       QuotaClient::kAppcache | QuotaClient::kIndexedDatabase);
2085   base::RunLoop().RunUntilIdle();
2086   GetHostUsage("foo.com", kTemp);
2087   base::RunLoop().RunUntilIdle();
2088   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
2089 }
2090
2091 TEST_F(QuotaManagerTest, DeleteMultipleClientTypesSingleHost) {
2092   static const MockOriginData kData1[] = {
2093     { "http://foo.com:1111/",   kTemp, 1 },
2094   };
2095   static const MockOriginData kData2[] = {
2096     { "http://foo.com:2222/",   kTemp, 2 },
2097   };
2098   static const MockOriginData kData3[] = {
2099     { "http://foo.com:3333/",   kTemp, 4 },
2100   };
2101   static const MockOriginData kData4[] = {
2102     { "http://foo.com:4444/",   kTemp, 8 },
2103   };
2104   MockStorageClient* client1 = CreateClient(kData1, ARRAYSIZE_UNSAFE(kData1),
2105       QuotaClient::kFileSystem);
2106   MockStorageClient* client2 = CreateClient(kData2, ARRAYSIZE_UNSAFE(kData2),
2107       QuotaClient::kAppcache);
2108   MockStorageClient* client3 = CreateClient(kData3, ARRAYSIZE_UNSAFE(kData3),
2109       QuotaClient::kDatabase);
2110   MockStorageClient* client4 = CreateClient(kData4, ARRAYSIZE_UNSAFE(kData4),
2111       QuotaClient::kIndexedDatabase);
2112   RegisterClient(client1);
2113   RegisterClient(client2);
2114   RegisterClient(client3);
2115   RegisterClient(client4);
2116
2117   GetHostUsage("foo.com", kTemp);
2118   base::RunLoop().RunUntilIdle();
2119   const int64 predelete_foo_tmp = usage();
2120
2121   DeleteHostData("foo.com", kTemp,
2122       QuotaClient::kFileSystem | QuotaClient::kAppcache);
2123   base::RunLoop().RunUntilIdle();
2124   GetHostUsage("foo.com", kTemp);
2125   base::RunLoop().RunUntilIdle();
2126   EXPECT_EQ(predelete_foo_tmp - 2 - 1, usage());
2127
2128   DeleteHostData("foo.com", kTemp,
2129       QuotaClient::kDatabase | QuotaClient::kIndexedDatabase);
2130   base::RunLoop().RunUntilIdle();
2131   GetHostUsage("foo.com", kTemp);
2132   base::RunLoop().RunUntilIdle();
2133   EXPECT_EQ(predelete_foo_tmp - 8 - 4 - 2 - 1, usage());
2134 }
2135
2136 TEST_F(QuotaManagerTest, GetUsageAndQuota_Incognito) {
2137   ResetQuotaManager(true);
2138
2139   static const MockOriginData kData[] = {
2140     { "http://foo.com/", kTemp, 10 },
2141     { "http://foo.com/", kPerm, 80 },
2142   };
2143   RegisterClient(CreateClient(kData, ARRAYSIZE_UNSAFE(kData),
2144       QuotaClient::kFileSystem));
2145
2146   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
2147   base::RunLoop().RunUntilIdle();
2148   EXPECT_EQ(kQuotaStatusOk, status());
2149   EXPECT_EQ(80, usage());
2150   EXPECT_EQ(0, quota());
2151
2152   SetTemporaryGlobalQuota(100);
2153   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
2154   base::RunLoop().RunUntilIdle();
2155   EXPECT_EQ(kQuotaStatusOk, status());
2156   EXPECT_EQ(10, usage());
2157   EXPECT_LE(std::min(static_cast<int64>(100 / kPerHostTemporaryPortion),
2158                      QuotaManager::kIncognitoDefaultQuotaLimit), quota());
2159
2160   mock_special_storage_policy()->AddUnlimited(GURL("http://foo.com/"));
2161   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kPerm);
2162   base::RunLoop().RunUntilIdle();
2163   EXPECT_EQ(kQuotaStatusOk, status());
2164   EXPECT_EQ(80, usage());
2165   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
2166
2167   GetUsageAndQuotaForWebApps(GURL("http://foo.com/"), kTemp);
2168   base::RunLoop().RunUntilIdle();
2169   EXPECT_EQ(kQuotaStatusOk, status());
2170   EXPECT_EQ(10, usage());
2171   EXPECT_EQ(QuotaManager::kIncognitoDefaultQuotaLimit, quota());
2172 }
2173
2174 }  // namespace quota