Revert of [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,
-                FetchResponseType response_type = FetchResponseType::kDefault) {
+  bool CachePut(CacheStorageCache* cache, const GURL& url) {
     ServiceWorkerFetchRequest request;
     request.url = url;
 
-    return CachePutWithStatusCode(cache, request, 200, response_type);
+    return CachePutWithStatusCode(cache, request, 200);
   }
 
   bool CachePutWithRequestAndHeaders(
       CacheStorageCache* cache,
       const ServiceWorkerFetchRequest& request,
-      const ServiceWorkerHeaderMap& response_headers,
-      FetchResponseType response_type = FetchResponseType::kDefault) {
-    return CachePutWithStatusCode(cache, request, 200, response_type,
-                                  response_headers);
+      const ServiceWorkerHeaderMap& response_headers) {
+    return CachePutWithStatusCode(cache, request, 200, response_headers);
   }
 
-  bool CachePutWithStatusCode(
-      CacheStorageCache* cache,
-      const ServiceWorkerFetchRequest& request,
-      int status_code,
-      FetchResponseType response_type = FetchResponseType::kDefault,
-      const ServiceWorkerHeaderMap& response_headers =
-          ServiceWorkerHeaderMap()) {
+  bool CachePutWithStatusCode(CacheStorageCache* cache,
+                              const ServiceWorkerFetchRequest& request,
+                              int status_code,
+                              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", response_type,
+        std::move(url_list), status_code, "OK",
+        network::mojom::FetchResponseType::kDefault,
         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