[CacheStorage] Pad and bin opaque resource sizes.

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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 32 matching lines @@
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 #include "storage/browser/test/mock_quota_manager_proxy.h"
 #include "storage/browser/test/mock_special_storage_policy.h"
 #include "storage/common/blob_storage/blob_handle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using network::mojom::FetchResponseType;
+
 namespace content {
 
 namespace {
 
 bool IsIndexFileCurrent(const base::FilePath& cache_dir) {
   base::File::Info info;
   const base::FilePath index_path =
       cache_dir.AppendASCII(CacheStorage::kIndexFileName);
   if (!GetFileInfo(index_path, &info))
     return false;
@@ skipping 285 matching lines @@
     base::RunLoop loop;
     cache_manager_->MatchAllCaches(
         origin, std::move(unique_request), match_params,
         base::BindOnce(&CacheStorageManagerTest::CacheMatchCallback,
                        base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
-  bool CachePut(CacheStorageCache* cache, const GURL& url) {
+  bool CachePut(CacheStorageCache* cache,
+                const GURL& url,
+                FetchResponseType response_type = FetchResponseType::kDefault) {
     ServiceWorkerFetchRequest request;
     request.url = url;
 
-    return CachePutWithStatusCode(cache, request, 200);
+    return CachePutWithStatusCode(cache, request, 200, response_type);
   }
 
   bool CachePutWithRequestAndHeaders(
       CacheStorageCache* cache,
       const ServiceWorkerFetchRequest& request,
-      const ServiceWorkerHeaderMap& response_headers) {
-    return CachePutWithStatusCode(cache, request, 200, response_headers);
+      const ServiceWorkerHeaderMap& response_headers,
+      FetchResponseType response_type = FetchResponseType::kDefault) {
+    return CachePutWithStatusCode(cache, request, 200, response_type,
+                                  response_headers);
   }
 
-  bool CachePutWithStatusCode(CacheStorageCache* cache,
-                              const ServiceWorkerFetchRequest& request,
-                              int status_code,
-                              const ServiceWorkerHeaderMap& response_headers =
-                                  ServiceWorkerHeaderMap()) {
+  bool CachePutWithStatusCode(
+      CacheStorageCache* cache,
+      const ServiceWorkerFetchRequest& request,
+      int status_code,
+      FetchResponseType response_type = FetchResponseType::kDefault,
+      const ServiceWorkerHeaderMap& response_headers =
+          ServiceWorkerHeaderMap()) {
     std::unique_ptr<storage::BlobDataBuilder> blob_data(
         new storage::BlobDataBuilder(base::GenerateGUID()));
     blob_data->AppendData(request.url.spec());
 
     std::unique_ptr<storage::BlobDataHandle> blob_handle =
         blob_storage_context_->AddFinishedBlob(blob_data.get());
     std::unique_ptr<std::vector<GURL>> url_list =
         base::MakeUnique<std::vector<GURL>>();
     url_list->push_back(request.url);
     ServiceWorkerResponse response(
-        std::move(url_list), status_code, "OK",
-        network::mojom::FetchResponseType::kDefault,
+        std::move(url_list), status_code, "OK", response_type,
         base::MakeUnique<ServiceWorkerHeaderMap>(response_headers),
         blob_handle->uuid(), request.url.spec().size(), nullptr /* blob */,
         blink::kWebServiceWorkerResponseErrorUnknown, base::Time(),
         false /* is_in_cache_storage */,
         std::string() /* cache_storage_cache_name */,
         base::MakeUnique<
             ServiceWorkerHeaderList>() /* cors_exposed_header_names */);
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
@@ skipping 70 matching lines @@
 
   int64_t Size(const GURL& origin) {
     base::RunLoop loop;
     CacheStorage* cache_storage = CacheStorageForOrigin(origin);
     cache_storage->Size(base::BindOnce(&CacheStorageManagerTest::UsageCallback,
                                        base::Unretained(this), &loop));
     loop.Run();
     return callback_usage_;
   }
 
+  int64_t GetQuotaOriginUsage(const GURL& origin) {
+    int64_t usage(CacheStorage::kSizeUnknown);
+    base::RunLoop loop;
+    quota_manager_proxy_->GetUsageAndQuota(
+        base::ThreadTaskRunnerHandle::Get().get(), origin,
+        StorageType::kStorageTypeTemporary,
+        base::Bind(&CacheStorageManagerTest::DidGetQuotaOriginUsage,
+                   base::Unretained(this), base::Unretained(&usage), &loop));
+    loop.Run();
+    return usage;
+  }
+
+  void DidGetQuotaOriginUsage(int64_t* out_usage,
+                              base::RunLoop* run_loop,
+                              QuotaStatusCode status_code,
+                              int64_t usage,
+                              int64_t quota) {
+    if (status_code == storage::kQuotaStatusOk)
+      *out_usage = usage;
+    run_loop->Quit();
+  }
+
  protected:
   // Temporary directory must be allocated first so as to be destroyed last.
   base::ScopedTempDir temp_dir_;
 
   TestBrowserThreadBundle browser_thread_bundle_;
   TestBrowserContext browser_context_;
   std::unique_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
   storage::BlobStorageContext* blob_storage_context_;
 
   scoped_refptr<MockSpecialStoragePolicy> quota_policy_;
@@ skipping 429 matching lines @@
   auto size_before_close = Size(origin1_);
   EXPECT_GT(size_before_close, 0);
 
   DestroyStorageManager();
   CreateStorageManager();
 
   EXPECT_TRUE(Open(origin1_, kCacheName));
   EXPECT_EQ(size_before_close, Size(origin1_));
 }
 
+TEST_F(CacheStorageManagerTest, CacheSizePaddedAfterReopen) {
+  const GURL kFooURL = origin1_.Resolve("foo");
+  const std::string kCacheName = "foo";
+
+  int64_t put_delta = quota_manager_proxy_->last_notified_delta();
+  EXPECT_EQ(0, put_delta);
+  EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
+
+  EXPECT_TRUE(Open(origin1_, kCacheName));
+  std::unique_ptr<CacheStorageCacheHandle> original_handle =
+      std::move(callback_cache_handle_);
+
+  base::RunLoop().RunUntilIdle();
+  put_delta += quota_manager_proxy_->last_notified_delta();
+  EXPECT_EQ(0, put_delta);
+  EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
+
+  EXPECT_TRUE(
+      CachePut(original_handle->value(), kFooURL, FetchResponseType::kOpaque));
+  int64_t cache_size_before_close = Size(origin1_);
+  base::FilePath storage_dir = original_handle->value()->path().DirName();
+  original_handle = nullptr;
+  EXPECT_GT(cache_size_before_close, 0);
+
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(cache_size_before_close, GetQuotaOriginUsage(origin1_));
+
+  base::RunLoop().RunUntilIdle();
+  put_delta = quota_manager_proxy_->last_notified_delta();
+  EXPECT_GT(put_delta, 0);
+  EXPECT_EQ(1, quota_manager_proxy_->notify_storage_modified_count());
+
+  EXPECT_EQ(GetQuotaOriginUsage(origin1_), put_delta);
+
+  // Close the caches and cache manager.
+  EXPECT_TRUE(FlushCacheStorageIndex(origin1_));
+  DestroyStorageManager();
+
+  // Create a new CacheStorageManager that hasn't yet loaded the origin.
+  CreateStorageManager();
+  quota_manager_proxy_->SimulateQuotaManagerDestroyed();
+  cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
+  EXPECT_TRUE(Open(origin1_, kCacheName));
+
+  base::RunLoop().RunUntilIdle();
+  put_delta = quota_manager_proxy_->last_notified_delta();
+  EXPECT_EQ(0, put_delta);
+  EXPECT_EQ(0, quota_manager_proxy_->notify_storage_modified_count());
+
+  EXPECT_EQ(cache_size_before_close, Size(origin1_));
+}
+
+TEST_F(CacheStorageManagerTest, PersistedCacheKeyUsed) {
+  const GURL kFooURL = origin1_.Resolve("foo");
+  const std::string kCacheName = "foo";
+
+  EXPECT_TRUE(Open(origin1_, kCacheName));
+  std::unique_ptr<CacheStorageCacheHandle> original_handle =
+      std::move(callback_cache_handle_);
+
+  EXPECT_TRUE(
+      CachePut(original_handle->value(), kFooURL, FetchResponseType::kOpaque));
+
+  int64_t cache_size_after_put = Size(origin1_);
+  EXPECT_LT(0, cache_size_after_put);
+
+  // Close the caches and cache manager.
+  EXPECT_TRUE(FlushCacheStorageIndex(origin1_));
+  DestroyStorageManager();
+
+  // GenerateNewKeyForTest isn't thread safe so
+  base::RunLoop().RunUntilIdle();
+  CacheStorage::GenerateNewKeyForTesting();
+
+  // Create a new CacheStorageManager that hasn't yet loaded the origin.
+  CreateStorageManager();
+  quota_manager_proxy_->SimulateQuotaManagerDestroyed();
+  cache_manager_ = CacheStorageManager::Create(cache_manager_.get());
+
+  // Reopening the origin/cache creates a new CacheStorage instance with a new
+  // random key.
+  EXPECT_TRUE(Open(origin1_, kCacheName));
+
+  // Size (before any change) should be the same as before it was closed.
+  EXPECT_EQ(cache_size_after_put, Size(origin1_));
+
+  // Delete the value. If the new padding key was used to deduct the padded size
+  // then after deletion we would expect to see a non-zero cache size.
+  EXPECT_TRUE(Delete(origin1_, "foo"));
+  EXPECT_EQ(0, Size(origin1_));
+
+  // Now put the exact same resource back into the cache. This time we expect to
+  // see a different size as the padding is calculated with a different key.
+  std::unique_ptr<CacheStorageCacheHandle> new_handle =
+      std::move(callback_cache_handle_);
+  EXPECT_TRUE(
+      CachePut(new_handle->value(), kFooURL, FetchResponseType::kOpaque));
+
+  EXPECT_NE(cache_size_after_put, Size(origin1_));
+}
+
 // With a memory cache the cache can't be freed from memory until the client
 // calls delete.
 TEST_F(CacheStorageManagerMemoryOnlyTest, MemoryLosesReferenceOnlyAfterDelete) {
   EXPECT_TRUE(Open(origin1_, "foo"));
   base::WeakPtr<CacheStorageCache> cache =
       callback_cache_handle_->value()->AsWeakPtr();
   callback_cache_handle_ = nullptr;
   EXPECT_TRUE(cache);
   EXPECT_TRUE(Delete(origin1_, "foo"));
   base::RunLoop().RunUntilIdle();
@@ skipping 572 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content