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 SimpleEntryImpl finishes opening or
+  // creating the new entry, and then 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.
+  COMPILE_ASSERT(kSimpleEntryFileCount == 3,
+                 file_pattern_must_match_file_count);
+  const base::FilePath::StringType file_pattern = FILE_PATH_LITERAL("*_[0-2]");
   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);
+    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