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 161 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.
+  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.
   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 41 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).
+  // entries. It's owned by this SimpleEntryImpl whenever |executing_operation_|
+  // is false (i.e. when an operation is not pending on the worker pool). When
+  // an operation is being executed no one owns the synchronous entry. Therefore
+  // SimpleEntryImpl should not be deleted while an operation is running as that
+  // would leak the SimpleSynchronousEntry.
   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_