Unlink corrupt SimpleCache index files immediately after load.

net/disk_cache/simple/simple_index_file.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_file.h"
 
 #include <vector>
 
+#include <base/bind_helpers.h>
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/hash.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/pickle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_restrictions.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_index.h"
@@ skipping 149 matching lines @@
   // Index file last_modified must be equal to the directory last_modified since
   // the last operation we do is ReplaceFile in the
   // SimpleIndexFile::WriteToDisk().
   // If not true, we need to restore the index.
   return index_mtime < dir_mtime;
 }
 
 // static
 scoped_ptr<SimpleIndex::EntrySet> SimpleIndexFile::LoadFromDisk(
     const base::FilePath& index_filename) {
+  base::ScopedClosureRunner
+      scoped_index_deleter(base::Bind(base::IgnoreResult(&file_util::Delete),
+                                      index_filename, false));
+
   std::string contents;
   if (!file_util::ReadFileToString(index_filename, &contents)) {
     LOG(WARNING) << "Could not read Simple Index file.";
     return scoped_ptr<SimpleIndex::EntrySet>();
   }
 
-  return SimpleIndexFile::Deserialize(contents.data(), contents.size());
+  scoped_ptr<SimpleIndex::EntrySet> entries =
+      SimpleIndexFile::Deserialize(contents.data(), contents.size());
+  if (!entries)
+    return scoped_ptr<SimpleIndex::EntrySet>();
+
+  scoped_index_deleter.Release();

[pasko, 2013/06/20 13:52:22]

I don't like using automatic closure runner in this simple function. It
complicates the matter because of wtf-always-deleting-the-index until the very
end of the function where there is a Release(). Also it runs base::Bind and
other memory allocation heavy lifting only to throw everything away in .9999% of
cases.

I know, lisp-ish code looks beautiful, but could you just call
file_util::Delete(index_filename, false) on the two return paths? It will be
less lines of code and less metaprogramming.

[gavinp, 2013/06/20 20:18:18]

Done. I was only trying to show off that I knew about base::IgnoreResult anyway,
and now that's done!

+  return entries.Pass();
 }
 
 // static
 scoped_ptr<SimpleIndex::EntrySet> SimpleIndexFile::Deserialize(const char* data,
                                                                int data_len) {
   DCHECK(data);
   Pickle pickle(data, data_len);
   if (!pickle.data()) {
     LOG(WARNING) << "Corrupt Simple Index File.";
     return scoped_ptr<SimpleIndex::EntrySet>();
@@ skipping 177 matching lines @@
           index_file_entries.get());
     } else {
       // Summing up the total size of the entry through all the *_[0-2] files
       it->second.SetEntrySize(it->second.GetEntrySize() + file_size);
     }
   }
   return index_file_entries.Pass();
 }
 
 }  // namespace disk_cache