Implement in-memory byte hints in SimpleCache

net/disk_cache/simple/simple_index_unittest.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_index.h"
 
 #include <algorithm>
 #include <functional>
 #include <memory>
 #include <utility>
@@ skipping 13 matching lines @@
 #include "net/disk_cache/simple/simple_test_util.h"
 #include "net/disk_cache/simple/simple_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace disk_cache {
 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) {
     EXPECT_LT(kTestLastUsedTime - base::TimeDelta::FromSeconds(2),
               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());
   }
 };
 
 class MockSimpleIndexFile : public SimpleIndexFile,
                             public base::SupportsWeakPtr<MockSimpleIndexFile> {
  public:
   MockSimpleIndexFile()
       : SimpleIndexFile(NULL, NULL, net::DISK_CACHE, base::FilePath()),
         load_result_(NULL),
         load_index_entries_calls_(0),
@@ skipping 107 matching lines @@
   base::WeakPtr<MockSimpleIndexFile> index_file_;
 
   std::vector<uint64_t> last_doom_entry_hashes_;
   int doom_entries_calls_;
 };
 
 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);
 
   const base::Time new_time = base::Time::Now();
   entry_metadata.SetLastUsedTime(new_time);
 
   EXPECT_LT(new_time - base::TimeDelta::FromSeconds(2),
             entry_metadata.GetLastUsedTime());
   EXPECT_GT(new_time + base::TimeDelta::FromSeconds(2),
@@ skipping 20 matching lines @@
 }
 
 TEST_F(EntryMetadataTest, Serialize) {
   EntryMetadata entry_metadata = NewEntryMetadataWithValues();
 
   base::Pickle pickle;
   entry_metadata.Serialize(&pickle);
 
   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 * kSizeResolution)));
+    const uint64_t redundant_hash_key = hashes_.at<4>();
     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)));
+        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.
 TEST_F(SimpleIndexTest, BasicInsertRemove) {
   // Confirm blank state.
   EntryMetadata metadata;
   EXPECT_EQ(base::Time(), metadata.GetLastUsedTime());
   EXPECT_EQ(0U, metadata.GetEntrySize());
 
   // Confirm state after insert.
@@ skipping 86 matching lines @@
   ReturnIndexFile();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(kHash1, &metadata));
   EXPECT_LT(
       now - base::TimeDelta::FromDays(2) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   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());
 }
 
 TEST_F(SimpleIndexTest, GetEntryCount) {
   EXPECT_EQ(0, index()->GetEntryCount());
   index()->Insert(hashes_.at<1>());
   EXPECT_EQ(1, index()->GetEntryCount());
   index()->Insert(hashes_.at<2>());
   EXPECT_EQ(2, index()->GetEntryCount());
   index()->Insert(hashes_.at<3>());
@@ skipping 14 matching lines @@
   EXPECT_EQ(0, index()->GetEntryCount());
 }
 
 // Confirm that we get the results we expect from a simple init.
 TEST_F(SimpleIndexTest, BasicInit) {
   base::Time now(base::Time::Now());
 
   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();
 
   EntryMetadata metadata;
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<1>(), &metadata));
   EXPECT_LT(
       now - base::TimeDelta::FromDays(2) - base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   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),
       metadata.GetLastUsedTime());
   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.
 TEST_F(SimpleIndexTest, RemoveBeforeInit) {
   const uint64_t kHash1 = hashes_.at<1>();
   index()->Remove(kHash1);
 
   InsertIntoIndexFileReturn(kHash1,
                             base::Time::Now() - base::TimeDelta::FromDays(2),
                             10u);
@@ skipping 100 matching lines @@
 
   EXPECT_TRUE(GetEntryForTesting(hashes_.at<5>(), &metadata));
 
   EXPECT_GT(
       now - base::TimeDelta::FromDays(6) + base::TimeDelta::FromSeconds(1),
       metadata.GetLastUsedTime());
   EXPECT_LT(
       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) {
   base::Time now(base::Time::Now());
   index()->SetMaxSize(1000);
   InsertIntoIndexFileReturn(hashes_.at<1>(),
                             now - base::TimeDelta::FromDays(2),
                             475u);
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 475u);
@@ skipping 68 matching lines @@
   SimpleIndex::EntrySet entry_set;
   index_file_->GetAndResetDiskWriteEntrySet(&entry_set);
 
   uint64_t hash_key = kHash1;
   base::Time now(base::Time::Now());
   ASSERT_EQ(1u, entry_set.size());
   EXPECT_EQ(hash_key, entry_set.begin()->first);
   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) {
   index()->SetMaxSize(1000);
   ReturnIndexFile();
 
   EXPECT_FALSE(index()->write_to_disk_timer_.IsRunning());
 
   index()->Insert(hashes_.at<1>());
   index()->UpdateEntrySize(hashes_.at<1>(), 20u);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   base::TimeTicks expected_trigger(
       index()->write_to_disk_timer_.desired_run_time());
 
   WaitForTimeChange();
   EXPECT_EQ(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->Insert(hashes_.at<2>());
   index()->UpdateEntrySize(hashes_.at<2>(), 40u);
   EXPECT_TRUE(index()->write_to_disk_timer_.IsRunning());
   EXPECT_LT(expected_trigger, index()->write_to_disk_timer_.desired_run_time());
   index()->write_to_disk_timer_.Stop();
 }
 
 }  // namespace disk_cache