Implement in-memory byte hints in SimpleCache

net/disk_cache/simple/simple_index_unittest.cc

Index: net/disk_cache/simple/simple_index_unittest.cc
diff --git a/net/disk_cache/simple/simple_index_unittest.cc b/net/disk_cache/simple/simple_index_unittest.cc
index 9f7d4094e10e6fcded31e3fbb189b8b2334de86d..56d91ae56ba8d6656183a13d33831380d89c92e5 100644
--- a/net/disk_cache/simple/simple_index_unittest.cc
+++ b/net/disk_cache/simple/simple_index_unittest.cc
@@ -31,13 +31,20 @@ namespace {
 const base::Time kTestLastUsedTime =
     base::Time::UnixEpoch() + base::TimeDelta::FromDays(20);
 const uint32_t kTestEntrySize = 789;
+const uint8_t kTestEntryMemoryData = 123;
+
+uint32_t RoundSize(uint32_t in) {
+  return (in + 255u) & 0xFFFFFF00;
+}
 
 }  // namespace
 
 class EntryMetadataTest : public testing::Test {
  public:
   EntryMetadata NewEntryMetadataWithValues() {
-    return EntryMetadata(kTestLastUsedTime, kTestEntrySize);
+    EntryMetadata entry(kTestLastUsedTime, kTestEntrySize);
+    entry.SetMemoryEntryData(kTestEntryMemoryData);
+    return entry;
   }
 
   void CheckEntryMetadataValues(const EntryMetadata& entry_metadata) {
@@ -45,7 +52,8 @@ class EntryMetadataTest : public testing::Test {
               entry_metadata.GetLastUsedTime());
     EXPECT_GT(kTestLastUsedTime + base::TimeDelta::FromSeconds(2),
               entry_metadata.GetLastUsedTime());
-    EXPECT_EQ(kTestEntrySize, entry_metadata.GetEntrySize());
+    EXPECT_EQ(RoundSize(kTestEntrySize), entry_metadata.GetEntrySize());
+    EXPECT_EQ(kTestEntryMemoryData, entry_metadata.GetMemoryEntryData());
   }
 };
 
@@ -173,6 +181,7 @@ TEST_F(EntryMetadataTest, Basics) {
   EntryMetadata entry_metadata;
   EXPECT_EQ(base::Time(), entry_metadata.GetLastUsedTime());
   EXPECT_EQ(0U, entry_metadata.GetEntrySize());
+  EXPECT_EQ(0u, entry_metadata.GetMemoryEntryData());
 
   entry_metadata = NewEntryMetadataWithValues();
   CheckEntryMetadataValues(entry_metadata);
@@ -213,37 +222,50 @@ TEST_F(EntryMetadataTest, Serialize) {
 
   base::PickleIterator it(pickle);
   EntryMetadata new_entry_metadata;
-  new_entry_metadata.Deserialize(&it);
+  new_entry_metadata.Deserialize(&it, true);
   CheckEntryMetadataValues(new_entry_metadata);
+
+  // Test reading of old format --- the modern serialization of above entry
+  // corresponds, in older format, to an entry with size =
+  //   RoundSize(kTestEntrySize) | kTestEntryMemoryData, which then gets
+  // rounded again when stored by EntryMetadata.
+  base::PickleIterator it2(pickle);
+  EntryMetadata new_entry_metadata2;
+  new_entry_metadata2.Deserialize(&it2, false);
+  EXPECT_EQ(RoundSize(RoundSize(kTestEntrySize) | kTestEntryMemoryData),
+            new_entry_metadata2.GetEntrySize());
+  EXPECT_EQ(0, new_entry_metadata2.GetMemoryEntryData());
 }
 
 TEST_F(SimpleIndexTest, IndexSizeCorrectOnMerge) {
-  index()->SetMaxSize(100);
+  const unsigned int kSizeResolution = 256U;
+  index()->SetMaxSize(100 * kSizeResolution);
   index()->Insert(hashes_.at<2>());
-  index()->UpdateEntrySize(hashes_.at<2>(), 2u);
+  index()->UpdateEntrySize(hashes_.at<2>(), 2U * kSizeResolution);
   index()->Insert(hashes_.at<3>());
-  index()->UpdateEntrySize(hashes_.at<3>(), 3u);
+  index()->UpdateEntrySize(hashes_.at<3>(), 3U * kSizeResolution);
   index()->Insert(hashes_.at<4>());
-  index()->UpdateEntrySize(hashes_.at<4>(), 4u);
-  EXPECT_EQ(9U, index()->cache_size_);
+  index()->UpdateEntrySize(hashes_.at<4>(), 4U * kSizeResolution);
+  EXPECT_EQ(9U * kSizeResolution, index()->cache_size_);
   {
     std::unique_ptr<SimpleIndexLoadResult> result(new SimpleIndexLoadResult());
     result->did_load = true;
     index()->MergeInitializingSet(std::move(result));
   }
-  EXPECT_EQ(9U, index()->cache_size_);
+  EXPECT_EQ(9U * kSizeResolution, index()->cache_size_);
   {
     std::unique_ptr<SimpleIndexLoadResult> result(new SimpleIndexLoadResult());
     result->did_load = true;
     const uint64_t new_hash_key = hashes_.at<11>();
-    result->entries.insert(
-        std::make_pair(new_hash_key, EntryMetadata(base::Time::Now(), 11u)));
-    const uint64_t redundant_hash_key = hashes_.at<4>();
     result->entries.insert(std::make_pair(
-        redundant_hash_key, EntryMetadata(base::Time::Now(), 4u)));
+        new_hash_key, EntryMetadata(base::Time::Now(), 11U * kSizeResolution)));
+    const uint64_t redundant_hash_key = hashes_.at<4>();
+    result->entries.insert(
+        std::make_pair(redundant_hash_key,
+                       EntryMetadata(base::Time::Now(), 4U * kSizeResolution)));
     index()->MergeInitializingSet(std::move(result));
   }
-  EXPECT_EQ(2U + 3U + 4U + 11U, index()->cache_size_);
+  EXPECT_EQ((2U + 3U + 4U + 11U) * kSizeResolution, index()->cache_size_);
 }
 
 // State of index changes as expected with an insert and a remove.
@@ -350,11 +372,11 @@ TEST_F(SimpleIndexTest, UpdateEntrySize) {
   EXPECT_GT(
       now - base::TimeDelta::FromDays(2) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
-  EXPECT_EQ(475U, metadata.GetEntrySize());
+  EXPECT_EQ(RoundSize(475U), metadata.GetEntrySize());
 
   index()->UpdateEntrySize(kHash1, 600u);
   EXPECT_TRUE(GetEntryForTesting(kHash1, &metadata));
-  EXPECT_EQ(600U, metadata.GetEntrySize());
+  EXPECT_EQ(RoundSize(600U), metadata.GetEntrySize());
   EXPECT_EQ(1, index()->GetEntryCount());
 }
 
@@ -389,9 +411,8 @@ TEST_F(SimpleIndexTest, BasicInit) {
   InsertIntoIndexFileReturn(hashes_.at<1>(),
                             now - base::TimeDelta::FromDays(2),
                             10u);
-  InsertIntoIndexFileReturn(hashes_.at<2>(),
-                            now - base::TimeDelta::FromDays(3),
-                            100u);
+  InsertIntoIndexFileReturn(hashes_.at<2>(), now - base::TimeDelta::FromDays(3),
+                            1000u);
 
   ReturnIndexFile();
 
@@ -403,7 +424,7 @@ TEST_F(SimpleIndexTest, BasicInit) {
   EXPECT_GT(
       now - base::TimeDelta::FromDays(2) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
-  EXPECT_EQ(10U, metadata.GetEntrySize());
+  EXPECT_EQ(RoundSize(10U), metadata.GetEntrySize());
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<2>(), &metadata));
   EXPECT_LT(
       now - base::TimeDelta::FromDays(3) - base::TimeDelta::FromSeconds(1),
@@ -411,7 +432,7 @@ TEST_F(SimpleIndexTest, BasicInit) {
   EXPECT_GT(
       now - base::TimeDelta::FromDays(3) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
-  EXPECT_EQ(100U, metadata.GetEntrySize());
+  EXPECT_EQ(RoundSize(1000U), metadata.GetEntrySize());

[gavinp, 2017/08/04 18:42:54]

I'm unhappy about mixing U and u in this code. I prefer u; it stands out more.
No need to change here but I might do a cleanup CL if the mood reaches me. I'll
definitely LGTM one.

[Maks Orlovich, 2017/08/23 19:29:06]

Made the stuff I touched use 'u', at least.

 }
 
 // Remove something that's going to come in from the loaded index.
@@ -532,7 +553,7 @@ TEST_F(SimpleIndexTest, AllInitConflicts) {
       now - base::TimeDelta::FromDays(6) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
 
-  EXPECT_EQ(100000U, metadata.GetEntrySize());
+  EXPECT_EQ(RoundSize(100000U), metadata.GetEntrySize());
 }
 
 TEST_F(SimpleIndexTest, BasicEviction) {
@@ -621,7 +642,7 @@ TEST_F(SimpleIndexTest, DiskWriteExecuted) {
   const EntryMetadata& entry1(entry_set.begin()->second);
   EXPECT_LT(now - base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
   EXPECT_GT(now + base::TimeDelta::FromMinutes(1), entry1.GetLastUsedTime());
-  EXPECT_EQ(20U, entry1.GetEntrySize());
+  EXPECT_EQ(RoundSize(20U), entry1.GetEntrySize());
 }
 
 TEST_F(SimpleIndexTest, DiskWritePostponed) {