[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 94 matching lines @@
     if (!MemoryOnly())
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     CreateStorageManager();
   }
 
   void TearDown() override { DestroyStorageManager(); }
 
   virtual bool MemoryOnly() { return false; }
 
+  virtual bool PadResources() const { return false; }

[jkarlin, 2017/06/09 15:26:20]

This isn't used anywhere?

[cmumford, 2017/06/12 18:09:32]

Not meaningfully, so I reverted it.

+
   void BoolCallback(base::RunLoop* run_loop, bool value) {
     callback_bool_ = value;
     run_loop->Quit();
   }
 
   void BoolAndErrorCallback(base::RunLoop* run_loop,
                             bool value,
                             CacheStorageError error) {
     callback_bool_ = value;
     callback_error_ = error;
@@ skipping 372 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageManagerTest);
 };
 
 class CacheStorageManagerMemoryOnlyTest : public CacheStorageManagerTest {
  public:
   bool MemoryOnly() override { return true; }
 };
 
+enum class CacheLocation { IN_MEMORY, ON_DISK };
+
+enum class PadType { ADD_PADDING, NO_PADDING };
+
 class CacheStorageManagerTestP : public CacheStorageManagerTest,
-                                 public testing::WithParamInterface<bool> {
+                                 public testing::WithParamInterface<
+                                     testing::tuple<CacheLocation, PadType>> {
  public:
-  bool MemoryOnly() override { return !GetParam(); }
+  bool MemoryOnly() override {
+    return testing::get<0>(GetParam()) == CacheLocation::IN_MEMORY;
+  }
+
+  bool PadResources() const override {
+    return testing::get<1>(GetParam()) == PadType::ADD_PADDING;
+  }
 };
 
 TEST_F(CacheStorageManagerTest, TestsRunOnIOThread) {
   EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 TEST_P(CacheStorageManagerTestP, OpenCache) {
   EXPECT_TRUE(Open(origin1_, "foo"));
 }
 
@@ skipping 880 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CacheStorageQuotaClientTest);
 };
 
 class CacheStorageQuotaClientDiskOnlyTest : public CacheStorageQuotaClientTest {
  public:
   bool MemoryOnly() override { return false; }
 };
 
-class CacheStorageQuotaClientTestP : public CacheStorageQuotaClientTest,
-                                     public testing::WithParamInterface<bool> {
-  bool MemoryOnly() override { return !GetParam(); }
+class CacheStorageQuotaClientTestP
+    : public CacheStorageQuotaClientTest,
+      public testing::WithParamInterface<
+          testing::tuple<CacheLocation, PadType>> {
+  bool MemoryOnly() override {
+    return testing::get<0>(GetParam()) == CacheLocation::IN_MEMORY;
+  }
+
+  bool PadResources() const override {
+    return testing::get<1>(GetParam()) == PadType::ADD_PADDING;
+  }
 };
 
 TEST_P(CacheStorageQuotaClientTestP, QuotaID) {
   EXPECT_EQ(storage::QuotaClient::kServiceWorkerCache, quota_client_->id());
 }
 
 TEST_P(CacheStorageQuotaClientTestP, QuotaGetOriginUsage) {
   EXPECT_EQ(0, QuotaGetOriginUsage(origin1_));
   EXPECT_TRUE(Open(origin1_, "foo"));
   EXPECT_TRUE(CachePut(callback_cache_handle_->value(),
@@ skipping 69 matching lines @@
 }
 
 TEST_P(CacheStorageQuotaClientTestP, QuotaDoesSupport) {
   EXPECT_TRUE(QuotaDoesSupport(storage::kStorageTypeTemporary));
   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypePersistent));
   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeSyncable));
   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeQuotaNotManaged));
   EXPECT_FALSE(QuotaDoesSupport(storage::kStorageTypeUnknown));
 }
 
-INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
-                        CacheStorageManagerTestP,
-                        ::testing::Values(false, true));
+INSTANTIATE_TEST_CASE_P(
+    CacheStorageManagerTests,
+    CacheStorageManagerTestP,
+    ::testing::Combine(
+        ::testing::Values(CacheLocation::IN_MEMORY, CacheLocation::ON_DISK),
+        ::testing::Values(PadType::ADD_PADDING, PadType::NO_PADDING)));
 
-INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
-                        CacheStorageQuotaClientTestP,
-                        ::testing::Values(false, true));
+INSTANTIATE_TEST_CASE_P(
+    CacheStorageQuotaClientTests,
+    CacheStorageQuotaClientTestP,
+    ::testing::Combine(
+        ::testing::Values(CacheLocation::IN_MEMORY, CacheLocation::ON_DISK),
+        ::testing::Values(PadType::ADD_PADDING, PadType::NO_PADDING)));
 
 }  // namespace content