Add SimpleCache index file heuristics

net/disk_cache/simple/simple_entry_impl.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_entry_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
 
 // static
 int SimpleEntryImpl::OpenEntry(SimpleIndex* index,
                                const FilePath& path,
                                const std::string& key,
                                Entry** entry,
                                const CompletionCallback& callback) {
   // TODO(gavinp): More closely unify the last_used_ in the
   // SimpleSynchronousEntry  and the SimpleIndex.
   if (!index || index->UseIfExists(key)) {
+    // We insert the entry in the index before creating the entry files in the
+    // SimpleSynchronousEntry, because this way the worse scenario is when we
+    // have the entry in the index but we don't have the created files yet, this
+    // way we never leak files.  CreationOperationComplete will remove the entry
+    // from the index if the creation fails.
+    // Same is true for the CreateEntry() bellow.
+    if (index)
+      index->Insert(key);

[gavinp, 2013/04/19 09:30:17]

This is dead code. Either index is null, or index->UseIfExists() returned true.

[felipeg, 2013/04/19 10:14:05]

Done.

     scoped_refptr<SimpleEntryImpl> new_entry =
         new SimpleEntryImpl(index, path, key);
     SynchronousCreationCallback sync_creation_callback =
         base::Bind(&SimpleEntryImpl::CreationOperationComplete,
                    new_entry, entry, callback);
     WorkerPool::PostTask(FROM_HERE,
                          base::Bind(&SimpleSynchronousEntry::OpenEntry, path,
                                     key, MessageLoopProxy::current(),
                                     sync_creation_callback),
                          true);
     return net::ERR_IO_PENDING;
   }
   return net::ERR_FAILED;
 }
 
 // static
 int SimpleEntryImpl::CreateEntry(SimpleIndex* index,
                                  const FilePath& path,
                                  const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
+  // See comment on OpenEntry regarding inserting the entry in the index.
+  if (index)
+    index->Insert(key);
   scoped_refptr<SimpleEntryImpl> new_entry =
       new SimpleEntryImpl(index, path, key);
   SynchronousCreationCallback sync_creation_callback =
       base::Bind(&SimpleEntryImpl::CreationOperationComplete,
                  new_entry, entry, callback);
   WorkerPool::PostTask(FROM_HERE,
                        base::Bind(&SimpleSynchronousEntry::CreateEntry, path,
                                   key, MessageLoopProxy::current(),
                                   sync_creation_callback),
                        true);
@@ skipping 251 matching lines @@
     // The reference held by the Callback calling us will go out of scope and
     // delete |this| on leaving this scope.
     return;
   }
   // The Backend interface requires us to return |this|, and keep the Entry
   // alive until Entry::Close(). Adding a reference to self will keep |this|
   // alive after the scope of the Callback calling us is destroyed.
   AddRef();  // Balanced in CloseInternal().
   synchronous_entry_ = sync_entry;
   SetSynchronousData();
-  if (index_)
-    index_->Insert(key_);
   *out_entry = this;
   completion_callback.Run(net::OK);
 }
 
 void SimpleEntryImpl::EntryOperationComplete(
     const CompletionCallback& completion_callback,
     int result) {
   DCHECK(io_thread_checker_.CalledOnValidThread());
   DCHECK(synchronous_entry_);
   DCHECK(operation_running_);
@@ skipping 19 matching lines @@
   // adding an IO thread index (for fast misses etc...), we can store this data
   // in that structure. This also solves problems with last_used() on ext4
   // filesystems not being accurate.
   last_used_ = synchronous_entry_->last_used();
   last_modified_ = synchronous_entry_->last_modified();
   for (int i = 0; i < kSimpleEntryFileCount; ++i)
     data_size_[i] = synchronous_entry_->data_size(i);
 }
 
 }  // namespace disk_cache