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

net/disk_cache/simple/simple_entry_impl.h

Index: net/disk_cache/simple/simple_entry_impl.h
diff --git a/net/disk_cache/simple/simple_entry_impl.h b/net/disk_cache/simple/simple_entry_impl.h
index 7eb8914e8731ab73d1dca0ef0b394b678123db87..7daf381541a32fd07486f83c29bf60223c4c5520 100644
--- a/net/disk_cache/simple/simple_entry_impl.h
+++ b/net/disk_cache/simple/simple_entry_impl.h
@@ -177,6 +177,8 @@ class SimpleEntryImpl : public Entry, public base::RefCounted<SimpleEntryImpl>,
                          const CompletionCallback& callback,
                          bool truncate);
 
+  void DoomEntryInternal(const CompletionCallback& callback);
+
   // Called after a SimpleSynchronousEntry has completed CreateEntry() or
   // OpenEntry(). If |in_sync_entry| is non-NULL, creation is successful and we
   // can return |this| SimpleEntryImpl to |*out_entry|. Runs
@@ -214,6 +216,11 @@ class SimpleEntryImpl : public Entry, public base::RefCounted<SimpleEntryImpl>,
                               scoped_ptr<SimpleEntryStat> entry_stat,
                               scoped_ptr<int> result);
 
+  // Called after an asynchronous doom completes.
+  void DoomOperationComplete(const CompletionCallback& callback,
+                             State state_to_restore,
+                             int result);
+
   // Called after validating the checksums on an entry. Passes through the
   // original result if successful, propogates the error if the checksum does
   // not validate.
@@ -274,7 +281,7 @@ class SimpleEntryImpl : public Entry, public base::RefCounted<SimpleEntryImpl>,
   CheckCrcResult crc_check_state_[kSimpleEntryFileCount];
 
   // The |synchronous_entry_| is the worker thread object that performs IO on
-  // entries. It's owned by this SimpleEntryImpl whenever |operation_running_|
+  // entries. It's owned by this SimpleEntryImpl whenever |executing_operation_|
   // is false (i.e. when an operation is not pending on the worker pool).

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

Suggestion (doesn't have to be part of this CL, just "while we're here"): When I
read this, the immediate question that comes to my mind is "Who owns it when
executing_operation_ is true?" to which the answer is "no one owns (== can
delete) the operation while executing_operation_ is true" and "The
SimpleEntryImpl may not be deleted while executing_operation_ is true, as that
would leak the SimpleSynchronousEntry".  Worth adding those points to this
comment?

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

Thanks.

   SimpleSynchronousEntry* synchronous_entry_;