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

net/disk_cache/simple/simple_entry_impl.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_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 
 #include <queue>
 #include <string>
 
@@ skipping 159 matching lines @@
                         int buf_len,
                         const CompletionCallback& callback);
 
   void WriteDataInternal(int index,
                          int offset,
                          net::IOBuffer* buf,
                          int buf_len,
                          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
   // |completion_callback|.
   void CreationOperationComplete(
       const CompletionCallback& completion_callback,
       const base::TimeTicks& start_time,
       scoped_ptr<SimpleEntryCreationResults> in_results,
       Entry** out_entry,
       net::NetLog::EventType end_event_type);
@@ skipping 17 matching lines @@
                              scoped_ptr<uint32> read_crc32,
                              scoped_ptr<base::Time> last_used,
                              scoped_ptr<int> result);
 
   // Called after an asynchronous write completes.
   void WriteOperationComplete(int stream_index,
                               const CompletionCallback& completion_callback,
                               scoped_ptr<SimpleEntryStat> entry_stat,
                               scoped_ptr<int> result);
 
+  // Called after an asynchronous doom completes. |state_to_restore| was the
+  // state of the entry instance before it transitioned to IO_PENDING.
+  void DoomOperationComplete(State state_to_restore,
+                             const CompletionCallback& callback,
+                             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.
   void ChecksumOperationComplete(
       int stream_index,
       int orig_result,
       const CompletionCallback& completion_callback,
       scoped_ptr<int> result);
 
   // Called after completion of asynchronous IO and receiving file metadata for
@@ skipping 40 matching lines @@
   uint32 crc32s_[kSimpleEntryFileCount];
 
   // If |have_written_[index]| is true, we have written to the stream |index|.
   bool have_written_[kSimpleEntryFileCount];
 
   // Reflects how much CRC checking has been done with the entry. This state is
   // reported on closing each entry stream.
   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_|
-  // is false (i.e. when an operation is not pending on the worker pool).

[Randy Smith (Not in Mondays), 2013/08/27 19:16:39]

I'd really like to keep a comment here describing the ownership of the
SimpleSynchronousEntry.   The ownership model isn't simple; SEI owns it, but
commits to not deleting it, and the only way it will be deleted is by post to
SSE::Close.  I'd like to have that sketched out here.  (I'd even more like to
have it self-documented by passing scoped_ptrs around, but that might require
some more complex re-working of the code.)

+  // entries.
   SimpleSynchronousEntry* synchronous_entry_;
 
   std::queue<SimpleEntryOperation> pending_operations_;
 
   net::BoundNetLog net_log_;
 
   scoped_ptr<SimpleEntryOperation> executing_operation_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_