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