Cache Storage API: Hook up to chrome://settings/cookies

content/browser/cache_storage/cache_storage_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/cache_storage/cache_storage_manager.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/browser/cache_storage/cache_storage_quota_client.h"
 #include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/quota/mock_quota_manager_proxy.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/cache_storage_usage_info.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 class CacheStorageManagerTest : public testing::Test {
@@ skipping 71 matching lines @@
       CacheStorageError error,
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
     callback_error_ = error;
     callback_cache_response_ = response.Pass();
     // Deliberately drop the data handle as only the url is being tested.
     run_loop->Quit();
   }
 
   bool Open(const GURL& origin, const std::string& cache_name) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->OpenCache(
         origin, cache_name,
         base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     bool error = callback_error_ != CACHE_STORAGE_OK;
     if (error)
       EXPECT_TRUE(!callback_cache_.get());
     else
       EXPECT_TRUE(callback_cache_.get());
     return !error;
   }
 
   bool Has(const GURL& origin, const std::string& cache_name) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->HasCache(
         origin, cache_name,
         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_bool_;
   }
 
   bool Delete(const GURL& origin, const std::string& cache_name) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->DeleteCache(
         origin, cache_name,
         base::Bind(&CacheStorageManagerTest::BoolAndErrorCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_bool_;
   }
 
   bool Keys(const GURL& origin) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->EnumerateCaches(
-        origin,
-        base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+        origin, base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
+                           base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatch(const GURL& origin,
                     const std::string& cache_name,
                     const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->MatchCache(
         origin, cache_name, request.Pass(),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatchAll(const GURL& origin, const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache_manager_->MatchAllCaches(
         origin, request.Pass(),
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CachePut(const scoped_refptr<CacheStorageCache>& cache,
                 const GURL& url) {
     ServiceWorkerFetchRequest request;
     ServiceWorkerResponse response;
     request.url = url;
     response.url = url;
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     cache->BatchOperation(
         std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageManagerTest::CachePutCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CacheMatch(const scoped_refptr<CacheStorageCache>& cache,
                   const GURL& url) {
     scoped_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    cache->Match(
-        request.Pass(),
-        base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+    base::RunLoop loop;
+    cache->Match(request.Pass(),
+                 base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
+                            base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
 
+  int64 GetOriginUsage(const GURL& origin) {
+    base::RunLoop loop;
+    cache_manager_->GetOriginUsage(
+        origin, base::Bind(&CacheStorageManagerTest::UsageCallback,
+                           base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
+    return callback_usage_;
+  }
+
+  void UsageCallback(base::RunLoop* run_loop, int64 usage) {
+    callback_usage_ = usage;
+    run_loop->Quit();
+  }
+
+  std::vector<CacheStorageUsageInfo> GetAllOriginsUsage() {
+    base::RunLoop loop;
+    cache_manager_->GetAllOriginsUsage(
+        base::Bind(&CacheStorageManagerTest::AllOriginsUsageCallback,
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
+    return callback_all_origins_usage_;
+  }
+
+  void AllOriginsUsageCallback(
+      base::RunLoop* run_loop,
+      const std::vector<CacheStorageUsageInfo>& usage) {
+    callback_all_origins_usage_ = usage;
+    run_loop->Quit();
+  }
+
  protected:
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
 
   base::ScopedTempDir temp_dir_;
   scoped_refptr<MockQuotaManagerProxy> quota_manager_proxy_;
   scoped_ptr<CacheStorageManager> cache_manager_;
 
   scoped_refptr<CacheStorageCache> callback_cache_;
   int callback_bool_;
   CacheStorageError callback_error_;
   scoped_ptr<ServiceWorkerResponse> callback_cache_response_;
   std::vector<std::string> callback_strings_;
 
   const GURL origin1_;
   const GURL origin2_;
 
+  int64 callback_usage_;
+  std::vector<CacheStorageUsageInfo> callback_all_origins_usage_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
 };
 
 class CacheStorageManagerMemoryOnlyTest : public CacheStorageManagerTest {
+ public:
   bool MemoryOnly() override { return true; }
 };
 
 class CacheStorageManagerTestP : public CacheStorageManagerTest,
                                  public testing::WithParamInterface<bool> {
+ public:
   bool MemoryOnly() override { return !GetParam(); }
 };
 
 TEST_F(CacheStorageManagerTest, TestsRunOnIOThread) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 TEST_P(CacheStorageManagerTestP, OpenCache) {
   EXPECT_TRUE(Open(origin1_, "foo"));
 }
@@ skipping 227 matching lines @@
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(Delete(origin1_, "foo"));
   EXPECT_TRUE(callback_cache_->AsWeakPtr());
 }
 
 TEST_P(CacheStorageManagerTestP, OpenRunsSerially) {
   EXPECT_FALSE(Delete(origin1_, "tmp"));  // Init storage.
   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
   cache_storage->StartAsyncOperationForTesting();
 
-  scoped_ptr<base::RunLoop> open_loop(new base::RunLoop());
+  base::RunLoop open_loop;
   cache_manager_->OpenCache(
       origin1_, "foo",
       base::Bind(&CacheStorageManagerTest::CacheAndErrorCallback,
-                 base::Unretained(this), base::Unretained(open_loop.get())));
+                 base::Unretained(this), base::Unretained(&open_loop)));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_cache_);
 
   cache_storage->CompleteAsyncOperationForTesting();
-  open_loop->Run();
+  open_loop.Run();
   EXPECT_TRUE(callback_cache_);
 }
 
+TEST_P(CacheStorageManagerTestP, GetOriginUsage) {
+  EXPECT_EQ(0, GetOriginUsage(origin1_));
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
+  EXPECT_LT(0, GetOriginUsage(origin1_));
+  EXPECT_EQ(0, GetOriginUsage(origin2_));
+}
+
+TEST_P(CacheStorageManagerTestP, GetAllOriginsUsage) {
+  EXPECT_EQ(0ULL, GetAllOriginsUsage().size());
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_, GURL("http://example.com/foo")));
+  std::vector<CacheStorageUsageInfo> usage = GetAllOriginsUsage();
+  EXPECT_EQ(1ULL, usage.size());
+  const CacheStorageUsageInfo& info = usage[0];
+  EXPECT_EQ(origin1_, info.origin);
+  EXPECT_LT(0, info.total_size_bytes);
+  if (MemoryOnly())
+    EXPECT_TRUE(info.last_modified.is_null());
+  else
+    EXPECT_FALSE(info.last_modified.is_null());
+}
+
 TEST_F(CacheStorageManagerMemoryOnlyTest, MemoryBackedSize) {
   CacheStorage* cache_storage = CacheStorageForOrigin(origin1_);
   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 
   EXPECT_TRUE(Open(origin1_, "foo"));
   scoped_refptr<CacheStorageCache> foo_cache = callback_cache_;
   EXPECT_TRUE(Open(origin1_, "bar"));
   scoped_refptr<CacheStorageCache> bar_cache = callback_cache_;
   EXPECT_EQ(0, cache_storage->MemoryBackedSize());
 
@@ skipping 36 matching lines @@
     ASSERT_TRUE(base::DirectoryExists(new_path_));
 
     quota_manager_proxy_->SimulateQuotaManagerDestroyed();
     cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
 
     ASSERT_TRUE(base::Move(new_path_, legacy_path_));
     ASSERT_TRUE(base::DirectoryExists(legacy_path_));
     ASSERT_FALSE(base::DirectoryExists(new_path_));
   }
 
-  int64 GetOriginUsage(const GURL& origin) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    cache_manager_->GetOriginUsage(
-        origin,
-        base::Bind(&CacheStorageMigrationTest::UsageCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
-    return callback_usage_;
-  }
-
-  void UsageCallback(base::RunLoop* run_loop, int64 usage) {
-    callback_usage_ = usage;
-    run_loop->Quit();
-  }
-
   base::FilePath legacy_path_;
   base::FilePath new_path_;
 
   const std::string cache1_;
   const std::string cache2_;
 
-  int64 callback_usage_;
-
   DISALLOW_COPY_AND_ASSIGN(CacheStorageMigrationTest);
 };
 
 TEST_F(CacheStorageMigrationTest, OpenCache) {
   EXPECT_TRUE(Open(origin1_, cache1_));
   EXPECT_FALSE(base::DirectoryExists(legacy_path_));
   EXPECT_TRUE(base::DirectoryExists(new_path_));
 
   EXPECT_TRUE(Keys(origin1_));
   std::vector<std::string> expected_keys;
@@ skipping 44 matching lines @@
 class CacheStorageQuotaClientTest : public CacheStorageManagerTest {
  protected:
   CacheStorageQuotaClientTest() {}
 
   void SetUp() override {
     CacheStorageManagerTest::SetUp();
     quota_client_.reset(
         new CacheStorageQuotaClient(cache_manager_->AsWeakPtr()));
   }
 
-  void UsageCallback(base::RunLoop* run_loop, int64 usage) {
-    callback_usage_ = usage;
+  void QuotaUsageCallback(base::RunLoop* run_loop, int64 usage) {
+    callback_quota_usage_ = usage;
     run_loop->Quit();
   }
 
   void OriginsCallback(base::RunLoop* run_loop, const std::set<GURL>& origins) {
     callback_origins_ = origins;
     run_loop->Quit();
   }
 
   void DeleteOriginCallback(base::RunLoop* run_loop,
                             storage::QuotaStatusCode status) {
     callback_status_ = status;
     run_loop->Quit();
   }
 
   int64 QuotaGetOriginUsage(const GURL& origin) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     quota_client_->GetOriginUsage(
         origin, storage::kStorageTypeTemporary,
-        base::Bind(&CacheStorageQuotaClientTest::UsageCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
-    return callback_usage_;
+        base::Bind(&CacheStorageQuotaClientTest::QuotaUsageCallback,
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
+    return callback_quota_usage_;
   }
 
   size_t QuotaGetOriginsForType() {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     quota_client_->GetOriginsForType(
         storage::kStorageTypeTemporary,
         base::Bind(&CacheStorageQuotaClientTest::OriginsCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
     return callback_origins_.size();
   }
 
   size_t QuotaGetOriginsForHost(const std::string& host) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     quota_client_->GetOriginsForHost(
         storage::kStorageTypeTemporary, host,
         base::Bind(&CacheStorageQuotaClientTest::OriginsCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
     return callback_origins_.size();
   }
 
   bool QuotaDeleteOriginData(const GURL& origin) {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    base::RunLoop loop;
     quota_client_->DeleteOriginData(
         origin, storage::kStorageTypeTemporary,
         base::Bind(&CacheStorageQuotaClientTest::DeleteOriginCallback,
-                   base::Unretained(this), base::Unretained(loop.get())));
-    loop->Run();
+                   base::Unretained(this), base::Unretained(&loop)));
+    loop.Run();
     return callback_status_ == storage::kQuotaStatusOk;
   }
 
   bool QuotaDoesSupport(storage::StorageType type) {
     return quota_client_->DoesSupport(type);
   }
 
   scoped_ptr<CacheStorageQuotaClient> quota_client_;
 
   storage::QuotaStatusCode callback_status_;
-  int64 callback_usage_;
+  int64 callback_quota_usage_ = 0;
   std::set<GURL> callback_origins_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheStorageQuotaClientTest);
 };
 
 class CacheStorageQuotaClientTestP : public CacheStorageQuotaClientTest,
                                      public testing::WithParamInterface<bool> {
   bool MemoryOnly() override { return !GetParam(); }
 };
 
@@ skipping 58 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content