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