Support optimistic Create and Write operations on the SimpleCache.

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 86 matching lines @@
     // has been assigned. This is the state at construction, and is the only
     // legal state to destruct an entry in.
     STATE_UNINITIALIZED,
 
     // This entry is available for regular IO.
     STATE_READY,
 
     // IO is currently in flight, operations must wait for completion before
     // launching.
     STATE_IO_PENDING,
+
+    // A failure occurred in the current or previous operation. All operations
+    // after that must fail, until we receive a Close().
+    STATE_FAILURE,
   };
 
   virtual ~SimpleEntryImpl();
 
   // Sets entry to STATE_UNINITIALIZED.
   void MakeUninitialized();
 
   // Return this entry to a user of the API in |out_entry|. Increments the user
   // count.
   void ReturnEntryToCaller(Entry** out_entry);
 
   // Ensures that |this| is no longer referenced by our |backend_|, this
   // guarantees that this entry cannot have OpenEntry/CreateEntry called again.
   void RemoveSelfFromBackend();
 
   // An error occured, and the SimpleSynchronousEntry should have Doomed
   // us at this point. We need to remove |this| from the Backend and the
   // index.
   void MarkAsDoomed();
 
   // Runs the next operation in the queue, if any and if there is no other
   // operation running at the moment.
   // WARNING: May delete |this|, as an operation in the queue can contain
   // the last reference.
   void RunNextOperationIfNeeded();
 
-  void OpenEntryInternal(Entry** entry,
-                         const CompletionCallback& callback);
+  void OpenEntryInternal(const CompletionCallback& callback, Entry** out_entry);
 
-  void CreateEntryInternal(Entry** entry,
-                           const CompletionCallback& callback);
+  void CreateEntryInternal(const CompletionCallback& callback,
+                           Entry** out_entry);
 
   void CloseInternal();
 
   void ReadDataInternal(int index,
                         int offset,
                         net::IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback);
 
   void WriteDataInternal(int index,
@@ skipping 85 matching lines @@
   // entries. It's owned by this SimpleEntryImpl whenever |operation_running_|
   // is false (i.e. when an operation is not pending on the worker pool).
   SimpleSynchronousEntry* synchronous_entry_;
 
   std::queue<base::Closure> pending_operations_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_