Add Cache size to the Simple Index.

net/disk_cache/simple/simple_index.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/task_runner.h"
@@ skipping 94 matching lines @@
         &entries_buffer.get()[entries_buffer_offset], &entry_metadata);
     InsertInternal(entry_metadata);
     entries_buffer_offset += SimpleIndexFile::kEntryMetadataSize;
   }
   DCHECK_EQ(header.number_of_entries, entries_set_.size());
   CloseIndexFile();
   return true;
 }
 
 void SimpleIndex::Insert(const std::string& key) {
+  // Upon insert we don't know yet the size of the entry.
+  // It will be updated later when the SynchronousEntryImpl finish and the

[gavinp, 2013/04/10 10:33:23]

Wording suggestion: It will be updated later when the SimpleEntryImpl finishes
opening or creating the new entry, and then UpdateEntrySize will be called.

Since the call comes from SimpleEntryImpl which is supposed to proxy for
SynchronousEntryImpl, this is conceptually easier for me. Also it avoids
mentioning threads.

[felipeg, 2013/04/10 11:45:35]

Done.

+  // UpdateEntrySize will be called.
   InsertInternal(SimpleIndexFile::EntryMetadata(GetEntryHashForKey(key),
-                                                base::Time::Now()));
+                                                base::Time::Now(), 0));
 }
 
 void SimpleIndex::Remove(const std::string& key) {
+  UpdateEntrySize(key, 0);
   entries_set_.erase(GetEntryHashForKey(key));
 }
 
 bool SimpleIndex::Has(const std::string& key) const {
   return entries_set_.count(GetEntryHashForKey(key)) != 0;
 }
 
 bool SimpleIndex::UseIfExists(const std::string& key) {
   EntrySet::iterator it = entries_set_.find(GetEntryHashForKey(key));
   if (it == entries_set_.end())
     return false;
   it->second.SetLastUsedTime(base::Time::Now());
   return true;
 }
 
+bool SimpleIndex::UpdateEntrySize(const std::string& key, uint64 entry_size) {
+  EntrySet::iterator it = entries_set_.find(GetEntryHashForKey(key));
+  if (it == entries_set_.end())
+    return false;
+
+  // Update the total cache size with the new entry size.
+  cache_size_ -= it->second.entry_size;
+  cache_size_ += entry_size;
+  it->second.entry_size = entry_size;
+
+  return true;
+}
+
 void SimpleIndex::InsertInternal(
     const SimpleIndexFile::EntryMetadata& entry_metadata) {
   entries_set_.insert(make_pair(entry_metadata.GetHashKey(), entry_metadata));
 }
 
 bool SimpleIndex::RestoreFromDisk() {
   using file_util::FileEnumerator;
   LOG(INFO) << "Simple Cache Index is being restored from disk.";
   CloseIndexFile();
   file_util::Delete(index_filename_, /* recursive = */ false);
   entries_set_.clear();
-  const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_0");
+  // TODO(felipeg,gavinp): Fix this once we have a one-file per entry format.

[gavinp, 2013/04/10 10:33:23]

COMPILE_ASSERT(kSimpleEntryFileCount == 3, file_pattern_must_match_file_count);

[felipeg, 2013/04/10 11:45:35]

Done.

+  const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_[0-2]");

[gavinp, 2013/04/10 10:33:23]

Would: ??????????_[0-2]

Be a good idea?

[felipeg, 2013/04/10 11:45:35]

It doesn't matter, we will change it anyway

   FileEnumerator enumerator(path_,
                             false /* recursive */,
                             FileEnumerator::FILES,
                             file_pattern);
+
   for (base::FilePath file_path = enumerator.Next(); !file_path.empty();
        file_path = enumerator.Next()) {
     const base::FilePath::StringType base_name = file_path.BaseName().value();
     // Converting to std::string is OK since we never use UTF8 wide chars in our
     // file names.
     const std::string hash_name(base_name.begin(), base_name.end());
     const std::string hash_key = hash_name.substr(0, kEntryHashKeySize);
 
     FileEnumerator::FindInfo find_info = {};
     enumerator.GetFindInfo(&find_info);
     base::Time last_used_time;
 #if defined(OS_POSIX)
     // For POSIX systems, a last access time is available. However, it's not
     // guaranteed to be more accurate than mtime. It is no worse though.
     last_used_time = base::Time::FromTimeT(find_info.stat.st_atime);
 #endif
     if (last_used_time.is_null())
       last_used_time = FileEnumerator::GetLastModifiedTime(find_info);
-    InsertInternal(SimpleIndexFile::EntryMetadata(hash_key, last_used_time));
+
+    int64 file_size = FileEnumerator::GetFilesize(find_info);
+    EntrySet::iterator it = entries_set_.find(hash_key);

[gavinp, 2013/04/10 10:33:23]

Note that in the not found case (33% of enumerations) you're doing two searches
in the index. The truly cycle-counting coder writes:

std::pair<EntrySet::iterator, bool> insert_result =
entries_set_.insert(hash_key);
if (insert_result.second) {  // entry was inserted.
...
} else {  // entry was found.
...
}

Since nobody can ever read that style of code, and since InsertInternal does its
own insert, I think it's best to leave this as it is.

[felipeg, 2013/04/10 11:45:35]

it is a hash map
two searches doesn't matter compared to the increased cost in code maintenance
of having two different ways of inserting in the index

[gavinp, 2013/04/10 14:49:29]

Good point on the hash.

Note also that every time I've written the "single-search" insert, I've had to
remove it in review. So sharing it in reviews like this is the only time I ever
get to talk about it.

+    if (it == entries_set_.end()) {
+      InsertInternal(SimpleIndexFile::EntryMetadata(
+          hash_key, last_used_time, file_size));
+    } else {
+      // Summing up the total size of the entry through all the *_[0-2] files
+      it->second.entry_size += file_size;
+    }
   }
+
   // TODO(felipeg): Detect unrecoverable problems and return false here.
   return true;
 }
 
 void SimpleIndex::Serialize(std::string* out_buffer) {
   DCHECK(out_buffer);
   SimpleIndexFile::Header header;
   SimpleIndexFile::Footer footer;
 
   header.initial_magic_number = kSimpleIndexInitialMagicNumber;
@@ skipping 68 matching lines @@
                << temp_filename.value();
     file_util::Delete(temp_filename, /* recursive = */ false);
     return;
   }
   // Swap temp and index_file.
   bool result = file_util::ReplaceFile(temp_filename, index_filename);
   DCHECK(result);
 }
 
 }  // namespace disk_cache