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 too.
+    STATE_FAILURE,
   };
 
   virtual ~SimpleEntryImpl();
 
   // Sets entry o 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 79 matching lines @@
 
   // If |have_written_[index]| is true, we have written to the stream |index|.
   bool have_written_[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).
   SimpleSynchronousEntry* synchronous_entry_;
 
   std::queue<base::Closure> pending_operations_;
+
+  // Flag to turn On or Off Create and Write optimistic operations.
+  bool optimistic_;

[gavinp, 2013/05/01 13:11:22]

I think we should either test with this flag (since i expect other cache users,
like APP_CACHE might want it off), or we should remove this flag. WDYT?

[felipeg, 2013/05/02 09:49:27]

I will remove it and we add it later if we need it.

 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_