Fix race condition for non-open/create operations happening after a doom.

net/disk_cache/simple/simple_synchronous_entry.h

 // 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_
 
 #include <algorithm>
 #include <string>
 #include <utility>
@@ skipping 66 matching lines @@
                         SimpleEntryCreationResults* out_results);
 
   static void CreateEntry(const base::FilePath& path,
                           const std::string& key,
                           uint64 entry_hash,
                           bool had_index,
                           SimpleEntryCreationResults* out_results);
 
   // Deletes an entry without first Opening it. Does not check if there is
   // already an Entry object in memory holding the open files. Be careful! This
-  // is meant to be used by the Backend::DoomEntry() call. |callback| will be
-  // run by |callback_runner|.
-  static void DoomEntry(const base::FilePath& path,
-                        const std::string& key,
-                        uint64 entry_hash,
-                        int* out_result);
+  // is meant to be used by the Backend::DoomEntry() call. Returns a net error
+  // code.

[Randy Smith (Not in Mondays), 2013/09/03 18:48:19]

Suggestion: Now that dooms on active entries are done via the SEI operations
queue, it seems weird for this to be a static.  I presume it's a static because
a) it doesn't need the information in the SSE, b) if the SEI hasn't created an
SSE, there's no point in creating one for Doom, and c) we want to keep the SSE
info (file descriptors & etc.) around if it's there.  I'd value having a comment
calling some portion of this out, either here or in the .cc file.  That
reasonable?

[Philippe, 2013/09/04 09:35:23]

Thanks Randy. I find that the current comment wasn't providing much value. For
instance it said 'Be careful! This is meant to be used by the
Backend::DoomEntry()'. Not very useful to me if it doesn't say why I should be
careful :) I replaced it with a simple sentence that should cover/imlpy a few
points.

[Randy Smith (Not in Mondays), 2013/09/04 15:44:16]

Awesome; thank you.  Just because I'm a (maybe too :-}) explicit person, willing
to add " ... if any (allowing operations to continue to be executed through that
instance)."?  Just a suggestion; feel free not to if you feel it's too
verbose/doesn't add value.

[Philippe, 2013/09/04 15:50:32]

Done.

+  static int DoomEntry(const base::FilePath& path,
+                       const std::string& key,
+                       uint64 entry_hash);
 
   // Like |DoomEntry()| above. Deletes all entries corresponding to the
   // |key_hashes|. Succeeds only when all entries are deleted. Returns a net
   // error code.
   static int DoomEntrySet(scoped_ptr<std::vector<uint64> > key_hashes,
                           const base::FilePath& path);
 
   // N.B. ReadData(), WriteData(), CheckEOFRecord() and Close() may block on IO.
   void ReadData(const EntryOperationData& in_entry_op,
                 net::IOBuffer* out_buf,
@@ skipping 54 matching lines @@
 
   bool have_open_files_;
   bool initialized_;
 
   base::PlatformFile files_[kSimpleEntryFileCount];
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_SYNCHRONOUS_ENTRY_H_