content/browser/cache_storage/cache_storage_manager_unittest.cc

   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 "content/browser/cache_storage/cache_storage_manager.h"
   6
   7 #include "base/files/file_path.h"
   8 #include "base/files/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/run_loop.h"
  11 #include "base/stl_util.h"
  12 #include "base/thread_task_runner_handle.h"
  13 #include "content/browser/cache_storage/cache_storage_quota_client.h"
  14 #include "content/browser/fileapi/chrome_blob_storage_context.h"
  15 #include "content/browser/quota/mock_quota_manager_proxy.h"
  16 #include "content/public/browser/browser_thread.h"
  17 #include "content/public/test/test_browser_context.h"
  18 #include "content/public/test/test_browser_thread_bundle.h"
  19 #include "net/url_request/url_request_context_getter.h"
  20 #include "storage/browser/blob/blob_storage_context.h"
  21 #include "storage/browser/quota/quota_manager_proxy.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 namespace content {
  25
  26 class CacheStorageManagerTest : public testing::Test {
  27  public:
  28   CacheStorageManagerTest()
  29       : browser_thread_bundle_(TestBrowserThreadBundle::IO_MAINLOOP),
  30         callback_bool_(false),
  31         callback_error_(CACHE_STORAGE_OK),
  32         origin1_("http://example1.com"),
  33         origin2_("http://example2.com") {}
  34
  35   void SetUp() override {
  36     ChromeBlobStorageContext* blob_storage_context(
  37         ChromeBlobStorageContext::GetFor(&browser_context_));
  38     // Wait for ChromeBlobStorageContext to finish initializing.
  39     base::RunLoop().RunUntilIdle();
  40
  41     quota_manager_proxy_ = new MockQuotaManagerProxy(
  42         nullptr, base::ThreadTaskRunnerHandle::Get().get());
  43
  44     if (MemoryOnly()) {
  45       cache_manager_ = CacheStorageManager::Create(
  46           base::FilePath(), base::ThreadTaskRunnerHandle::Get(),
  47           quota_manager_proxy_);
  48     } else {
  49       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  50       cache_manager_ = CacheStorageManager::Create(
  51           temp_dir_.path(), base::ThreadTaskRunnerHandle::Get(),
  52           quota_manager_proxy_);
  53     }
  54
  55     cache_manager_->SetBlobParametersForCache(
  56         browser_context_.GetRequestContext(),
  57         blob_storage_context->context()->AsWeakPtr());
  58   }
  59
  60   void TearDown() override {
  61     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
  62     base::RunLoop().RunUntilIdle();
  63   }
  64
  65   virtual bool MemoryOnly() { return false; }
  66
  67   void BoolAndErrorCallback(base::RunLoop* run_loop,
  68                             bool value,
  69                             CacheStorageError error) {
  70     callback_bool_ = value;
  71     callback_error_ = error;
  72     run_loop->Quit();
  73   }
  74
  75   void CacheAndErrorCallback(base::RunLoop* run_loop,
  76                              const scoped_refptr<CacheStorageCache>& cache,
  77                              CacheStorageError error) {
  78     callback_cache_ = cache;
  79     callback_error_ = error;
  80     run_loop->Quit();
  81   }
  82
  83   void StringsAndErrorCallback(base::RunLoop* run_loop,
  84                                const std::vector<std::string>& strings,
  85                                CacheStorageError error) {
  86     callback_strings_ = strings;
  87     callback_error_ = error;
  88     run_loop->Quit();
  89   }
  90
  91   void CachePutCallback(base::RunLoop* run_loop, CacheStorageError error) {
  92     callback_error_ = error;
  93     run_loop->Quit();
  94   }
  95
  96   void CacheMatchCallback(
  97       base::RunLoop* run_loop,
  98       CacheStorageError error,
  99       scoped_ptr<ServiceWorkerResponse> response,
 100       scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
 101     callback_error_ = error;
 102     callback_cache_response_ = response.Pass();
 103     // Deliberately drop the data handle as only the url is being tested.
 104     run_loop->Quit();
 105   }
 106
 107   bool Open(const GURL& origin, const std::string& cache_name) {
 108     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 109     cache_manager_->OpenCache(
 110         origin, cache_name,
 111         base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
 112                    base::Unretained(this), base::Unretained(loop.get())));
 113     loop->Run();
 114
 115     bool error = callback_error_ != CACHE_STORAGE_OK;
 116     if (error)
 117       EXPECT_TRUE(!callback_cache_.get());
 118     else
 119       EXPECT_TRUE(callback_cache_.get());
 120     return !error;
 121   }
 122
 123   bool Has(const GURL& origin, const std::string& cache_name) {
 124     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 125     cache_manager_->HasCache(
 126         origin, cache_name,
 127         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
 128                    base::Unretained(this), base::Unretained(loop.get())));
 129     loop->Run();
 130
 131     return callback_bool_;
 132   }
 133
 134   bool Delete(const GURL& origin, const std::string& cache_name) {
 135     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 136     cache_manager_->DeleteCache(
 137         origin, cache_name,
 138         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
 139                    base::Unretained(this), base::Unretained(loop.get())));
 140     loop->Run();
 141
 142     return callback_bool_;
 143   }
 144
 145   bool Keys(const GURL& origin) {
 146     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 147     cache_manager_->EnumerateCaches(
 148         origin,
 149         base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
 150                    base::Unretained(this), base::Unretained(loop.get())));
 151     loop->Run();
 152
 153     return callback_error_ == CACHE_STORAGE_OK;
 154   }
 155
 156   bool StorageMatch(const GURL& origin,
 157                     const std::string& cache_name,
 158                     const GURL& url) {
 159     scoped_ptr<ServiceWorkerFetchRequest> request(
 160         new ServiceWorkerFetchRequest());
 161     request->url = url;
 162     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 163     cache_manager_->MatchCache(
 164         origin, cache_name, request.Pass(),
 165         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
 166                    base::Unretained(this), base::Unretained(loop.get())));
 167     loop->Run();
 168
 169     return callback_error_ == CACHE_STORAGE_OK;
 170   }
 171
 172   bool StorageMatchAll(const GURL& origin, const GURL& url) {
 173     scoped_ptr<ServiceWorkerFetchRequest> request(
 174         new ServiceWorkerFetchRequest());
 175     request->url = url;
 176     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 177     cache_manager_->MatchAllCaches(
 178         origin, request.Pass(),
 179         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
 180                    base::Unretained(this), base::Unretained(loop.get())));
 181     loop->Run();
 182
 183     return callback_error_ == CACHE_STORAGE_OK;
 184   }
 185
 186   bool CachePut(const scoped_refptr<CacheStorageCache>& cache,
 187                 const GURL& url) {
 188     ServiceWorkerFetchRequest request;
 189     ServiceWorkerResponse response;
 190     request.url = url;
 191     response.url = url;
 192
 193     CacheStorageBatchOperation operation;
 194     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
 195     operation.request = request;
 196     operation.response = response;
 197
 198     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 199     cache->BatchOperation(
 200         std::vector<CacheStorageBatchOperation>(1, operation),
 201         base::Bind(&CacheStorageManagerTest::CachePutCallback,
 202                    base::Unretained(this), base::Unretained(loop.get())));
 203     loop->Run();
 204
 205     return callback_error_ == CACHE_STORAGE_OK;
 206   }
 207
 208   bool CacheMatch(const scoped_refptr<CacheStorageCache>& cache,
 209                   const GURL& url) {
 210     scoped_ptr<ServiceWorkerFetchRequest> request(
 211         new ServiceWorkerFetchRequest());
 212     request->url = url;
 213     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 214     cache->Match(
 215         request.Pass(),
 216         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
 217                    base::Unretained(this), base::Unretained(loop.get())));
 218     loop->Run();
 219
 220     return callback_error_ == CACHE_STORAGE_OK;
 221   }
 222
 223   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
 224     return cache_manager_->FindOrCreateCacheStorage(origin);
 225   }
 226
 227  protected:
 228   TestBrowserContext browser_context_;
 229   TestBrowserThreadBundle browser_thread_bundle_;
 230
 231   base::ScopedTempDir temp_dir_;
 232   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
 233   scoped_ptr<CacheStorageManager> cache_manager_;
 234
 235   scoped_refptr<CacheStorageCache> callback_cache_;
 236   int callback_bool_;
 237   CacheStorageError callback_error_;
 238   scoped_ptr<ServiceWorkerResponse> callback_cache_response_;
 239   std::vector<std::string> callback_strings_;
 240
 241   const GURL origin1_;
 242   const GURL origin2_;
 243
 244  private:
 245   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
 246 };
 247
 248 class CacheStorageManagerMemoryOnlyTest : public CacheStorageManagerTest {
 249   bool MemoryOnly() override { return true; }
 250 };
 251
 252 class CacheStorageManagerTestP : public CacheStorageManagerTest,
 253                                  public testing::WithParamInterface<bool> {
 254   bool MemoryOnly() override { return !GetParam(); }
 255 };
 256
 257 TEST_F(CacheStorageManagerTest, TestsRunOnIOThread) {
 258   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
 259 }
 260
 261 TEST_P(CacheStorageManagerTestP, OpenCache) {
 262   EXPECT_TRUE(Open(origin1_, "foo"));
 263 }
 264
 265 TEST_P(CacheStorageManagerTestP, OpenTwoCaches) {
 266   EXPECT_TRUE(Open(origin1_, "foo"));
 267   EXPECT_TRUE(Open(origin1_, "bar"));
 268 }
 269
 270 TEST_P(CacheStorageManagerTestP, CachePointersDiffer) {
 271   EXPECT_TRUE(Open(origin1_, "foo"));
 272   scoped_refptr<CacheStorageCache> cache = callback_cache_;
 273   EXPECT_TRUE(Open(origin1_, "bar"));
 274   EXPECT_NE(callback_cache_.get(), cache.get());
 275 }
 276
 277 TEST_P(CacheStorageManagerTestP, Open2CachesSameNameDiffOrigins) {
 278   EXPECT_TRUE(Open(origin1_, "foo"));
 279   scoped_refptr<CacheStorageCache> cache = callback_cache_;
 280   EXPECT_TRUE(Open(origin2_, "foo"));
 281   EXPECT_NE(cache.get(), callback_cache_.get());
 282 }
 283
 284 TEST_P(CacheStorageManagerTestP, OpenExistingCache) {
 285   EXPECT_TRUE(Open(origin1_, "foo"));
 286   scoped_refptr<CacheStorageCache> cache = callback_cache_;
 287   EXPECT_TRUE(Open(origin1_, "foo"));
 288   EXPECT_EQ(callback_cache_.get(), cache.get());
 289 }
 290
 291 TEST_P(CacheStorageManagerTestP, HasCache) {
 292   EXPECT_TRUE(Open(origin1_, "foo"));
 293   EXPECT_TRUE(Has(origin1_, "foo"));
 294   EXPECT_TRUE(callback_bool_);
 295 }
 296
 297 TEST_P(CacheStorageManagerTestP, HasNonExistent) {
 298   EXPECT_FALSE(Has(origin1_, "foo"));
 299 }
 300
 301 TEST_P(CacheStorageManagerTestP, DeleteCache) {
 302   EXPECT_TRUE(Open(origin1_, "foo"));
 303   EXPECT_TRUE(Delete(origin1_, "foo"));
 304   EXPECT_FALSE(Has(origin1_, "foo"));
 305 }
 306
 307 TEST_P(CacheStorageManagerTestP, DeleteTwice) {
 308   EXPECT_TRUE(Open(origin1_, "foo"));
 309   EXPECT_TRUE(Delete(origin1_, "foo"));
 310   EXPECT_FALSE(Delete(origin1_, "foo"));
 311   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 312 }
 313
 314 TEST_P(CacheStorageManagerTestP, EmptyKeys) {
 315   EXPECT_TRUE(Keys(origin1_));
 316   EXPECT_TRUE(callback_strings_.empty());
 317 }
 318
 319 TEST_P(CacheStorageManagerTestP, SomeKeys) {
 320   EXPECT_TRUE(Open(origin1_, "foo"));
 321   EXPECT_TRUE(Open(origin1_, "bar"));
 322   EXPECT_TRUE(Open(origin2_, "baz"));
 323   EXPECT_TRUE(Keys(origin1_));
 324   EXPECT_EQ(2u, callback_strings_.size());
 325   std::vector<std::string> expected_keys;
 326   expected_keys.push_back("foo");
 327   expected_keys.push_back("bar");
 328   EXPECT_EQ(expected_keys, callback_strings_);
 329   EXPECT_TRUE(Keys(origin2_));
 330   EXPECT_EQ(1u, callback_strings_.size());
 331   EXPECT_STREQ("baz", callback_strings_[0].c_str());
 332 }
 333
 334 TEST_P(CacheStorageManagerTestP, DeletedKeysGone) {
 335   EXPECT_TRUE(Open(origin1_, "foo"));
 336   EXPECT_TRUE(Open(origin1_, "bar"));
 337   EXPECT_TRUE(Open(origin2_, "baz"));
 338   EXPECT_TRUE(Delete(origin1_, "bar"));
 339   EXPECT_TRUE(Keys(origin1_));
 340   EXPECT_EQ(1u, callback_strings_.size());
 341   EXPECT_STREQ("foo", callback_strings_[0].c_str());
 342 }
 343
 344 TEST_P(CacheStorageManagerTestP, StorageMatchEntryExists) {
 345   EXPECT_TRUE(Open(origin1_, "foo"));
 346   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 347   EXPECT_TRUE(StorageMatch(origin1_, "foo", GURL("http://example.com/foo")));
 348 }
 349
 350 TEST_P(CacheStorageManagerTestP, StorageMatchNoEntry) {
 351   EXPECT_TRUE(Open(origin1_, "foo"));
 352   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 353   EXPECT_FALSE(StorageMatch(origin1_, "foo", GURL("http://example.com/bar")));
 354   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 355 }
 356
 357 TEST_P(CacheStorageManagerTestP, StorageMatchNoCache) {
 358   EXPECT_TRUE(Open(origin1_, "foo"));
 359   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 360   EXPECT_FALSE(StorageMatch(origin1_, "bar", GURL("http://example.com/foo")));
 361   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 362 }
 363
 364 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExists) {
 365   EXPECT_TRUE(Open(origin1_, "foo"));
 366   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 367   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 368 }
 369
 370 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoEntry) {
 371   EXPECT_TRUE(Open(origin1_, "foo"));
 372   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 373   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/bar")));
 374   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 375 }
 376
 377 TEST_P(CacheStorageManagerTestP, StorageMatchAllNoCaches) {
 378   EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 379   EXPECT_EQ(CACHE_STORAGE_ERROR_NOT_FOUND, callback_error_);
 380 }
 381
 382 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExistsTwice) {
 383   EXPECT_TRUE(Open(origin1_, "foo"));
 384   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 385   EXPECT_TRUE(Open(origin1_, "bar"));
 386   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 387
 388   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 389 }
 390
 391 TEST_P(CacheStorageManagerTestP, StorageMatchInOneOfMany) {
 392   EXPECT_TRUE(Open(origin1_, "foo"));
 393   EXPECT_TRUE(Open(origin1_, "bar"));
 394   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 395   EXPECT_TRUE(Open(origin1_, "baz"));
 396
 397   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 398 }
 399
 400 TEST_P(CacheStorageManagerTestP, Chinese) {
 401   EXPECT_TRUE(Open(origin1_, "你好"));
 402   scoped_refptr<CacheStorageCache> cache = callback_cache_;
 403   EXPECT_TRUE(Open(origin1_, "你好"));
 404   EXPECT_EQ(callback_cache_.get(), cache.get());
 405   EXPECT_TRUE(Keys(origin1_));
 406   EXPECT_EQ(1u, callback_strings_.size());
 407   EXPECT_STREQ("你好", callback_strings_[0].c_str());
 408 }
 409
 410 TEST_F(CacheStorageManagerTest, EmptyKey) {
 411   EXPECT_TRUE(Open(origin1_, ""));
 412   scoped_refptr<CacheStorageCache> cache = callback_cache_;
 413   EXPECT_TRUE(Open(origin1_, ""));
 414   EXPECT_EQ(cache.get(), callback_cache_.get());
 415   EXPECT_TRUE(Keys(origin1_));
 416   EXPECT_EQ(1u, callback_strings_.size());
 417   EXPECT_STREQ("", callback_strings_[0].c_str());
 418   EXPECT_TRUE(Has(origin1_, ""));
 419   EXPECT_TRUE(Delete(origin1_, ""));
 420   EXPECT_TRUE(Keys(origin1_));
 421   EXPECT_EQ(0u, callback_strings_.size());
 422 }
 423
 424 TEST_F(CacheStorageManagerTest, DataPersists) {
 425   EXPECT_TRUE(Open(origin1_, "foo"));
 426   EXPECT_TRUE(Open(origin1_, "bar"));
 427   EXPECT_TRUE(Open(origin1_, "baz"));
 428   EXPECT_TRUE(Open(origin2_, "raz"));
 429   EXPECT_TRUE(Delete(origin1_, "bar"));
 430   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
 431   cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
 432   EXPECT_TRUE(Keys(origin1_));
 433   EXPECT_EQ(2u, callback_strings_.size());
 434   std::vector<std::string> expected_keys;
 435   expected_keys.push_back("foo");
 436   expected_keys.push_back("baz");
 437   EXPECT_EQ(expected_keys, callback_strings_);
 438 }
 439
 440 TEST_F(CacheStorageManagerMemoryOnlyTest, DataLostWhenMemoryOnly) {
 441   EXPECT_TRUE(Open(origin1_, "foo"));
 442   EXPECT_TRUE(Open(origin2_, "baz"));
 443   quota_manager_proxy_->SimulateQuotaManagerDestroyed();
 444   cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
 445   EXPECT_TRUE(Keys(origin1_));
 446   EXPECT_EQ(0u, callback_strings_.size());
 447 }
 448
 449 TEST_F(CacheStorageManagerTest, BadCacheName) {
 450   // Since the implementation writes cache names to disk, ensure that we don't
 451   // escape the directory.
 452   const std::string bad_name = "../../../../../../../../../../../../../../foo";
 453   EXPECT_TRUE(Open(origin1_, bad_name));
 454   EXPECT_TRUE(Keys(origin1_));
 455   EXPECT_EQ(1u, callback_strings_.size());
 456   EXPECT_STREQ(bad_name.c_str(), callback_strings_[0].c_str());
 457 }
 458
 459 TEST_F(CacheStorageManagerTest, BadOriginName) {
 460   // Since the implementation writes origin names to disk, ensure that we don't
 461   // escape the directory.
 462   GURL bad_origin("http://../../../../../../../../../../../../../../foo");
 463   EXPECT_TRUE(Open(bad_origin, "foo"));
 464   EXPECT_TRUE(Keys(bad_origin));
 465   EXPECT_EQ(1u, callback_strings_.size());
 466   EXPECT_STREQ("foo", callback_strings_[0].c_str());
 467 }
 468
 469 // With a persistent cache if the client drops its reference to a
 470 // CacheStorageCache
 471 // it should be deleted.
 472 TEST_F(CacheStorageManagerTest, DropReference) {
 473   EXPECT_TRUE(Open(origin1_, "foo"));
 474   base::WeakPtr<CacheStorageCache> cache = callback_cache_->AsWeakPtr();
 475   callback_cache_ = NULL;
 476   EXPECT_TRUE(!cache);
 477 }
 478
 479 // With a memory cache the cache can't be freed from memory until the client
 480 // calls delete.
 481 TEST_F(CacheStorageManagerMemoryOnlyTest, MemoryLosesReferenceOnlyAfterDelete) {
 482   EXPECT_TRUE(Open(origin1_, "foo"));
 483   base::WeakPtr<CacheStorageCache> cache = callback_cache_->AsWeakPtr();
 484   callback_cache_ = NULL;
 485   EXPECT_TRUE(cache);
 486   EXPECT_TRUE(Delete(origin1_, "foo"));
 487   EXPECT_FALSE(cache);
 488 }
 489
 490 TEST_P(CacheStorageManagerTestP, DeleteBeforeRelease) {
 491   EXPECT_TRUE(Open(origin1_, "foo"));
 492   EXPECT_TRUE(Delete(origin1_, "foo"));
 493   EXPECT_TRUE(callback_cache_->AsWeakPtr());
 494 }
 495
 496 TEST_P(CacheStorageManagerTestP, OpenRunsSerially) {
 497   EXPECT_FALSE(Delete(origin1_, "tmp"));  // Init storage.
 498   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
 499   cache_storage->StartAsyncOperationForTesting();
 500
 501   scoped_ptr<base::RunLoop> open_loop(new base::RunLoop());
 502   cache_manager_->OpenCache(
 503       origin1_, "foo",
 504       base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
 505                  base::Unretained(this), base::Unretained(open_loop.get())));
 506
 507   base::RunLoop().RunUntilIdle();
 508   EXPECT_FALSE(callback_cache_);
 509
 510   cache_storage->CompleteAsyncOperationForTesting();
 511   open_loop->Run();
 512   EXPECT_TRUE(callback_cache_);
 513 }
 514
 515 TEST_F(CacheStorageManagerMemoryOnlyTest, MemoryBackedSize) {
 516   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
 517   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 518
 519   EXPECT_TRUE(Open(origin1_, "foo"));
 520   scoped_refptr<CacheStorageCache> foo_cache = callback_cache_;
 521   EXPECT_TRUE(Open(origin1_, "bar"));
 522   scoped_refptr<CacheStorageCache> bar_cache = callback_cache_;
 523   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 524
 525   EXPECT_TRUE(CachePut(foo_cache, GURL("http://example.com/foo")));
 526   EXPECT_LT(0, cache_storage->MemoryBackedSize());
 527   int64 foo_size = cache_storage->MemoryBackedSize();
 528
 529   EXPECT_TRUE(CachePut(bar_cache, GURL("http://example.com/foo")));
 530   EXPECT_EQ(foo_size * 2, cache_storage->MemoryBackedSize());
 531 }
 532
 533 TEST_F(CacheStorageManagerTest, MemoryBackedSizePersistent) {
 534   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
 535   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 536   EXPECT_TRUE(Open(origin1_, "foo"));
 537   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 538   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 539 }
 540
 541 class CacheStorageMigrationTest : public CacheStorageManagerTest {
 542  protected:
 543   CacheStorageMigrationTest() : cache1_("foo"), cache2_("bar") {}
 544
 545   void SetUp() override {
 546     CacheStorageManagerTest::SetUp();
 547
 548     // Populate a cache, then move it to the "legacy" location
 549     // so that tests can verify the results of migration.
 550     legacy_path_ = CacheStorageManager::ConstructLegacyOriginPath(
 551         cache_manager_->root_path(), origin1_);
 552     new_path_ = CacheStorageManager::ConstructOriginPath(
 553         cache_manager_->root_path(), origin1_);
 554
 555     ASSERT_FALSE(base::DirectoryExists(legacy_path_));
 556     ASSERT_FALSE(base::DirectoryExists(new_path_));
 557     ASSERT_TRUE(Open(origin1_, cache1_));
 558     ASSERT_TRUE(Open(origin1_, cache2_));
 559     callback_cache_ = nullptr;
 560     ASSERT_FALSE(base::DirectoryExists(legacy_path_));
 561     ASSERT_TRUE(base::DirectoryExists(new_path_));
 562
 563     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
 564     cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
 565
 566     ASSERT_TRUE(base::Move(new_path_, legacy_path_));
 567     ASSERT_TRUE(base::DirectoryExists(legacy_path_));
 568     ASSERT_FALSE(base::DirectoryExists(new_path_));
 569   }
 570
 571   int64 GetOriginUsage(const GURL& origin) {
 572     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 573     cache_manager_->GetOriginUsage(
 574         origin,
 575         base::Bind(&CacheStorageMigrationTest::UsageCallback,
 576                    base::Unretained(this), base::Unretained(loop.get())));
 577     loop->Run();
 578     return callback_usage_;
 579   }
 580
 581   void UsageCallback(base::RunLoop* run_loop, int64 usage) {
 582     callback_usage_ = usage;
 583     run_loop->Quit();
 584   }
 585
 586   base::FilePath legacy_path_;
 587   base::FilePath new_path_;
 588
 589   const std::string cache1_;
 590   const std::string cache2_;
 591
 592   int64 callback_usage_;
 593
 594   DISALLOW_COPY_AND_ASSIGN(CacheStorageMigrationTest);
 595 };
 596
 597 TEST_F(CacheStorageMigrationTest, OpenCache) {
 598   EXPECT_TRUE(Open(origin1_, cache1_));
 599   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
 600   EXPECT_TRUE(base::DirectoryExists(new_path_));
 601
 602   EXPECT_TRUE(Keys(origin1_));
 603   std::vector<std::string> expected_keys;
 604   expected_keys.push_back(cache1_);
 605   expected_keys.push_back(cache2_);
 606   EXPECT_EQ(expected_keys, callback_strings_);
 607 }
 608
 609 TEST_F(CacheStorageMigrationTest, DeleteCache) {
 610   EXPECT_TRUE(Delete(origin1_, cache1_));
 611   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
 612   EXPECT_TRUE(base::DirectoryExists(new_path_));
 613
 614   EXPECT_TRUE(Keys(origin1_));
 615   std::vector<std::string> expected_keys;
 616   expected_keys.push_back(cache2_);
 617   EXPECT_EQ(expected_keys, callback_strings_);
 618 }
 619
 620 TEST_F(CacheStorageMigrationTest, GetOriginUsage) {
 621   EXPECT_GT(GetOriginUsage(origin1_), 0);
 622   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
 623   EXPECT_TRUE(base::DirectoryExists(new_path_));
 624 }
 625
 626 TEST_F(CacheStorageMigrationTest, MoveFailure) {
 627   // Revert the migration.
 628   ASSERT_TRUE(base::Move(legacy_path_, new_path_));
 629   ASSERT_FALSE(base::DirectoryExists(legacy_path_));
 630   ASSERT_TRUE(base::DirectoryExists(new_path_));
 631
 632   // Make a dummy legacy directory.
 633   ASSERT_TRUE(base::CreateDirectory(legacy_path_));
 634
 635   // Ensure that migration doesn't stomp existing new directory,
 636   // but does clean up old directory.
 637   EXPECT_TRUE(Open(origin1_, cache1_));
 638   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
 639   EXPECT_TRUE(base::DirectoryExists(new_path_));
 640
 641   EXPECT_TRUE(Keys(origin1_));
 642   std::vector<std::string> expected_keys;
 643   expected_keys.push_back(cache1_);
 644   expected_keys.push_back(cache2_);
 645   EXPECT_EQ(expected_keys, callback_strings_);
 646 }
 647
 648 class CacheStorageQuotaClientTest : public CacheStorageManagerTest {
 649  protected:
 650   CacheStorageQuotaClientTest() {}
 651
 652   void SetUp() override {
 653     CacheStorageManagerTest::SetUp();
 654     quota_client_.reset(
 655         new CacheStorageQuotaClient(cache_manager_->AsWeakPtr()));
 656   }
 657
 658   void UsageCallback(base::RunLoop* run_loop, int64 usage) {
 659     callback_usage_ = usage;
 660     run_loop->Quit();
 661   }
 662
 663   void OriginsCallback(base::RunLoop* run_loop, const std::set<GURL>& origins) {
 664     callback_origins_ = origins;
 665     run_loop->Quit();
 666   }
 667
 668   void DeleteOriginCallback(base::RunLoop* run_loop,
 669                             storage::QuotaStatusCode status) {
 670     callback_status_ = status;
 671     run_loop->Quit();
 672   }
 673
 674   int64 QuotaGetOriginUsage(const GURL& origin) {
 675     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 676     quota_client_->GetOriginUsage(
 677         origin, storage::kStorageTypeTemporary,
 678         base::Bind(&CacheStorageQuotaClientTest::UsageCallback,
 679                    base::Unretained(this), base::Unretained(loop.get())));
 680     loop->Run();
 681     return callback_usage_;
 682   }
 683
 684   size_t QuotaGetOriginsForType() {
 685     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 686     quota_client_->GetOriginsForType(
 687         storage::kStorageTypeTemporary,
 688         base::Bind(&CacheStorageQuotaClientTest::OriginsCallback,
 689                    base::Unretained(this), base::Unretained(loop.get())));
 690     loop->Run();
 691     return callback_origins_.size();
 692   }
 693
 694   size_t QuotaGetOriginsForHost(const std::string& host) {
 695     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 696     quota_client_->GetOriginsForHost(
 697         storage::kStorageTypeTemporary, host,
 698         base::Bind(&CacheStorageQuotaClientTest::OriginsCallback,
 699                    base::Unretained(this), base::Unretained(loop.get())));
 700     loop->Run();
 701     return callback_origins_.size();
 702   }
 703
 704   bool QuotaDeleteOriginData(const GURL& origin) {
 705     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 706     quota_client_->DeleteOriginData(
 707         origin, storage::kStorageTypeTemporary,
 708         base::Bind(&CacheStorageQuotaClientTest::DeleteOriginCallback,
 709                    base::Unretained(this), base::Unretained(loop.get())));
 710     loop->Run();
 711     return callback_status_ == storage::kQuotaStatusOk;
 712   }
 713
 714   bool QuotaDoesSupport(storage::StorageType type) {
 715     return quota_client_->DoesSupport(type);
 716   }
 717
 718   scoped_ptr<CacheStorageQuotaClient> quota_client_;
 719
 720   storage::QuotaStatusCode callback_status_;
 721   int64 callback_usage_;
 722   std::set<GURL> callback_origins_;
 723
 724   DISALLOW_COPY_AND_ASSIGN(CacheStorageQuotaClientTest);
 725 };
 726
 727 class CacheStorageQuotaClientTestP : public CacheStorageQuotaClientTest,
 728                                      public testing::WithParamInterface<bool> {
 729   bool MemoryOnly() override { return !GetParam(); }
 730 };
 731
 732 TEST_P(CacheStorageQuotaClientTestP, QuotaID) {
 733   EXPECT_EQ(storage::QuotaClient::kServiceWorkerCache, quota_client_->id());
 734 }
 735
 736 TEST_P(CacheStorageQuotaClientTestP, QuotaGetOriginUsage) {
 737   EXPECT_EQ(0, QuotaGetOriginUsage(origin1_));
 738   EXPECT_TRUE(Open(origin1_, "foo"));
 739   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 740   EXPECT_LT(0, QuotaGetOriginUsage(origin1_));
 741 }
 742
 743 TEST_P(CacheStorageQuotaClientTestP, QuotaGetOriginsForType) {
 744   EXPECT_EQ(0u, QuotaGetOriginsForType());
 745   EXPECT_TRUE(Open(origin1_, "foo"));
 746   EXPECT_TRUE(Open(origin1_, "bar"));
 747   EXPECT_TRUE(Open(origin2_, "foo"));
 748   EXPECT_EQ(2u, QuotaGetOriginsForType());
 749 }
 750
 751 TEST_P(CacheStorageQuotaClientTestP, QuotaGetOriginsForHost) {
 752   EXPECT_EQ(0u, QuotaGetOriginsForHost("example.com"));
 753   EXPECT_TRUE(Open(GURL("http://example.com:8080"), "foo"));
 754   EXPECT_TRUE(Open(GURL("http://example.com:9000"), "foo"));
 755   EXPECT_TRUE(Open(GURL("ftp://example.com"), "foo"));
 756   EXPECT_TRUE(Open(GURL("http://example2.com"), "foo"));
 757   EXPECT_EQ(3u, QuotaGetOriginsForHost("example.com"));
 758   EXPECT_EQ(1u, QuotaGetOriginsForHost("example2.com"));
 759   EXPECT_TRUE(callback_origins_.find(GURL("http://example2.com")) !=
 760               callback_origins_.end());
 761   EXPECT_EQ(0u, QuotaGetOriginsForHost("unknown.com"));
 762 }
 763
 764 TEST_P(CacheStorageQuotaClientTestP, QuotaDeleteOriginData) {
 765   EXPECT_TRUE(Open(origin1_, "foo"));
 766   // Call put to test that initialized caches are properly deleted too.
 767   EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
 768   EXPECT_TRUE(Open(origin1_, "bar"));
 769   EXPECT_TRUE(Open(origin2_, "baz"));
 770
 771   EXPECT_TRUE(QuotaDeleteOriginData(origin1_));
 772
 773   EXPECT_FALSE(Has(origin1_, "foo"));
 774   EXPECT_FALSE(Has(origin1_, "bar"));
 775   EXPECT_TRUE(Has(origin2_, "baz"));
 776   EXPECT_TRUE(Open(origin1_, "foo"));
 777 }
 778
 779 TEST_P(CacheStorageQuotaClientTestP, QuotaDeleteEmptyOrigin) {
 780   EXPECT_TRUE(QuotaDeleteOriginData(origin1_));
 781 }
 782
 783 TEST_P(CacheStorageQuotaClientTestP, QuotaDoesSupport) {
 784   EXPECT_TRUE(QuotaDoesSupport(storage::kStorageTypeTemporary));
 785   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypePersistent));
 786   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeSyncable));
 787   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeQuotaNotManaged));
 788   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeUnknown));
 789 }
 790
 791 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
 792                         CacheStorageManagerTestP,
 793                         ::testing::Values(false, true));
 794
 795 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
 796                         CacheStorageQuotaClientTestP,
 797                         ::testing::Values(false, true));
 798
 799 }  // namespace content