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 45 matching lines @@
   }
   return net::ERR_FAILED;
 }
 
 // static
 int SimpleEntryImpl::CreateEntry(SimpleIndex* index,
                                  const FilePath& path,
                                  const std::string& key,
                                  Entry** entry,
                                  const CompletionCallback& callback) {
+  // 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

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

nit: one space after .

[felipeg, 2013/04/19 12:20:29]

Done.

+  // from the index if the creation fails.
+  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