Implement in-memory byte hints in SimpleCache

net/disk_cache/simple/simple_index_file_unittest.cc

 // Copyright (c) 2011 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_file.h"
 
 #include <memory>
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
@@ skipping 28 matching lines @@
 using disk_cache::SimpleIndexFile;
 using disk_cache::SimpleIndex;
 
 namespace disk_cache {
 
 // The Simple Cache backend requires a few guarantees from the filesystem like
 // atomic renaming of recently open files. Those guarantees are not provided in
 // general on Windows.
 #if defined(OS_POSIX)
 
+namespace {
+
+uint32_t RoundSize(uint32_t in) {
+  return (in + 0xFFu) & 0xFFFFFF00u;
+}
+
+}  // namespace
+
 TEST(IndexMetadataTest, Basics) {
   SimpleIndexFile::IndexMetadata index_metadata;
 
   EXPECT_EQ(disk_cache::kSimpleIndexMagicNumber, index_metadata.magic_number_);
   EXPECT_EQ(disk_cache::kSimpleVersion, index_metadata.version_);
   EXPECT_EQ(0U, index_metadata.entry_count());
   EXPECT_EQ(0U, index_metadata.cache_size_);
 
   // Without setting a |reason_|, the index metadata isn't valid.
   index_metadata.reason_ = SimpleIndex::INDEX_WRITE_REASON_SHUTDOWN;
@@ skipping 55 matching lines @@
   EXPECT_EQ(new_index_metadata.magic_number_, v6_index_metadata.magic_number_);
   EXPECT_EQ(new_index_metadata.version_, v6_index_metadata.version_);
 
   EXPECT_EQ(new_index_metadata.reason_, SimpleIndex::INDEX_WRITE_REASON_MAX);
   EXPECT_EQ(new_index_metadata.entry_count(), v6_index_metadata.entry_count());
   EXPECT_EQ(new_index_metadata.cache_size_, v6_index_metadata.cache_size_);
 
   EXPECT_TRUE(new_index_metadata.CheckIndexMetadata());
 }
 
+// This derived index metadata class allows us to serialize the older V7 format
+// of the index metadata, thus allowing us to test deserializing the old format.
+class V7IndexMetadataForTest : public SimpleIndexFile::IndexMetadata {
+ public:
+  V7IndexMetadataForTest(uint64_t entry_count, uint64_t cache_size)
+      : SimpleIndexFile::IndexMetadata(SimpleIndex::INDEX_WRITE_REASON_SHUTDOWN,
+                                       entry_count,
+                                       cache_size) {
+    version_ = 7;
+  }
+};
+
 // This friend derived class is able to reexport its ancestors private methods
 // as public, for use in tests.
 class WrappedSimpleIndexFile : public SimpleIndexFile {
  public:
   using SimpleIndexFile::Deserialize;
   using SimpleIndexFile::LegacyIsIndexFileStale;
   using SimpleIndexFile::Serialize;
   using SimpleIndexFile::SerializeFinalData;
 
   explicit WrappedSimpleIndexFile(const base::FilePath& index_file_directory)
@@ skipping 12 matching lines @@
   }
 
   bool CreateIndexFileDirectory() const {
     return base::CreateDirectory(index_file_.DirName());
   }
 };
 
 class SimpleIndexFileTest : public testing::Test {
  public:
   bool CompareTwoEntryMetadata(const EntryMetadata& a, const EntryMetadata& b) {
-    return
-        a.last_used_time_seconds_since_epoch_ ==
-            b.last_used_time_seconds_since_epoch_ &&
-        a.entry_size_ == b.entry_size_;
+    return a.last_used_time_seconds_since_epoch_ ==
+               b.last_used_time_seconds_since_epoch_ &&
+           a.entry_size_256b_chunks_ == b.entry_size_256b_chunks_ &&
+           a.in_memory_data_ == b.in_memory_data_;
   }
 };
 
 TEST_F(SimpleIndexFileTest, Serialize) {
   SimpleIndex::EntrySet entries;
   static const uint64_t kHashes[] = {11, 22, 33};
   static const size_t kNumHashes = arraysize(kHashes);
   EntryMetadata metadata_entries[kNumHashes];
 
   SimpleIndexFile::IndexMetadata index_metadata(
       SimpleIndex::INDEX_WRITE_REASON_SHUTDOWN,
       static_cast<uint64_t>(kNumHashes), 456);
   for (size_t i = 0; i < kNumHashes; ++i) {
     uint64_t hash = kHashes[i];
     // TODO(eroman): Should restructure the test so no casting here (and same
     //               elsewhere where a hash is cast to an entry size).
     metadata_entries[i] = EntryMetadata(Time(), static_cast<uint32_t>(hash));
+    metadata_entries[i].SetInMemoryData(static_cast<uint8_t>(i));
     SimpleIndex::InsertInEntrySet(hash, metadata_entries[i], &entries);
   }
 
   std::unique_ptr<base::Pickle> pickle =
       WrappedSimpleIndexFile::Serialize(index_metadata, entries);
   EXPECT_TRUE(pickle.get() != NULL);
   base::Time now = base::Time::Now();
   EXPECT_TRUE(WrappedSimpleIndexFile::SerializeFinalData(now, pickle.get()));
   base::Time when_index_last_saw_cache;
   SimpleIndexLoadResult deserialize_result;
   WrappedSimpleIndexFile::Deserialize(static_cast<const char*>(pickle->data()),
                                       pickle->size(),
                                       &when_index_last_saw_cache,
                                       &deserialize_result);
   EXPECT_TRUE(deserialize_result.did_load);
   EXPECT_EQ(now, when_index_last_saw_cache);
   const SimpleIndex::EntrySet& new_entries = deserialize_result.entries;
   EXPECT_EQ(entries.size(), new_entries.size());
 
   for (size_t i = 0; i < kNumHashes; ++i) {
     SimpleIndex::EntrySet::const_iterator it = new_entries.find(kHashes[i]);
     EXPECT_TRUE(new_entries.end() != it);
     EXPECT_TRUE(CompareTwoEntryMetadata(it->second, metadata_entries[i]));
   }
 }
 
+TEST_F(SimpleIndexFileTest, ReadV7Format) {
+  static const uint64_t kHashes[] = {11, 22, 33};
+  static const uint32_t kSizes[] = {394, 594, 495940};
+  static_assert(arraysize(kHashes) == arraysize(kSizes),
+                "Need same number of hashes and sizes");
+  static const size_t kNumHashes = arraysize(kHashes);
+
+  V7IndexMetadataForTest v7_metadata(kNumHashes, 100 * 1024 * 1024);
+
+  // We don't have a convenient way of serializing the actual entries in the
+  // V7 format, but we can cheat a bit by using the implementation details: if
+  // we set the 8 lower bits of size as the memory data, and upper bits
+  // as the size, the new serialization will produce what we want.
+  SimpleIndex::EntrySet entries;
+  for (size_t i = 0; i < kNumHashes; ++i) {
+    EntryMetadata entry(Time(), kSizes[i] & 0xFFFFFF00u);
+    entry.SetInMemoryData(static_cast<uint8_t>(kSizes[i] & 0xFFu));
+    SimpleIndex::InsertInEntrySet(kHashes[i], entry, &entries);
+  }
+  std::unique_ptr<base::Pickle> pickle =
+      WrappedSimpleIndexFile::Serialize(v7_metadata, entries);
+  ASSERT_TRUE(pickle.get() != NULL);
+  base::Time now = base::Time::Now();
+  ASSERT_TRUE(WrappedSimpleIndexFile::SerializeFinalData(now, pickle.get()));
+
+  // Now read it back. We should get the sizes rounded, and 0 for mem entries.
+  base::Time when_index_last_saw_cache;
+  SimpleIndexLoadResult deserialize_result;
+  WrappedSimpleIndexFile::Deserialize(
+      static_cast<const char*>(pickle->data()), pickle->size(),
+      &when_index_last_saw_cache, &deserialize_result);
+  EXPECT_TRUE(deserialize_result.did_load);
+  EXPECT_EQ(now, when_index_last_saw_cache);
+  const SimpleIndex::EntrySet& new_entries = deserialize_result.entries;
+  ASSERT_EQ(entries.size(), new_entries.size());
+  for (size_t i = 0; i < kNumHashes; ++i) {
+    SimpleIndex::EntrySet::const_iterator it = new_entries.find(kHashes[i]);
+    ASSERT_TRUE(new_entries.end() != it);
+    EXPECT_EQ(RoundSize(kSizes[i]), it->second.GetEntrySize());
+    EXPECT_EQ(0u, it->second.GetInMemoryData());
+  }
+}
+
 TEST_F(SimpleIndexFileTest, LegacyIsIndexFileStale) {
   base::ScopedTempDir cache_dir;
   ASSERT_TRUE(cache_dir.CreateUniqueTempDir());
   base::Time cache_mtime;
   const base::FilePath cache_path = cache_dir.GetPath();
 
   ASSERT_TRUE(simple_util::GetMTime(cache_path, &cache_mtime));
   WrappedSimpleIndexFile simple_index_file(cache_path);
   ASSERT_TRUE(simple_index_file.CreateIndexFileDirectory());
   const base::FilePath& index_path = simple_index_file.GetIndexFilePath();
@@ skipping 189 matching lines @@
   closure.WaitForResult();
 
   // Check that the temporary file was deleted and the index file was created.
   EXPECT_FALSE(base::PathExists(simple_index_file.GetTempIndexFilePath()));
   EXPECT_TRUE(base::PathExists(simple_index_file.GetIndexFilePath()));
 }
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace disk_cache