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 190 matching lines @@
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
 
+  int64 GetOriginUsage(const GURL& origin) {
+    scoped_ptr<base::RunLoop> loop(new base::RunLoop());

[Bernhard Bauer, 2015/08/20 11:18:53]

Just allocate the RunLoop directly on the stack.

[jsbell, 2015/08/20 19:04:51]

Done. (Here and elsewhere.)

+    cache_manager_->GetOriginUsage(
+        origin,
+        base::Bind(&CacheStorageManagerTest::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();
+  }
+
+  std::vector<CacheStorageUsageInfo> GetAllOriginsUsage() {
+    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
+    cache_manager_->GetAllOriginsUsage(
+        base::Bind(&CacheStorageManagerTest::AllOriginsUsageCallback,
+                   base::Unretained(this), base::Unretained(loop.get())));
+    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 241 matching lines @@
                  base::Unretained(this), base::Unretained(open_loop.get())));
 
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_cache_);
 
   cache_storage->CompleteAsyncOperationForTesting();
   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());
     quota_client_->GetOriginUsage(
         origin, storage::kStorageTypeTemporary,
-        base::Bind(&CacheStorageQuotaClientTest::UsageCallback,
+        base::Bind(&CacheStorageQuotaClientTest::QuotaUsageCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
-    return callback_usage_;
+    return callback_quota_usage_;
   }
 
   size_t QuotaGetOriginsForType() {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
     quota_client_->GetOriginsForType(
         storage::kStorageTypeTemporary,
         base::Bind(&CacheStorageQuotaClientTest::OriginsCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
     return callback_origins_.size();
@@ skipping 19 matching lines @@
     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