Support overlapping operations on the SimpleEntryImpl.

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>
 
 #include "base/files/file_path.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_index.h"
 
 
@@ skipping 20 matching lines @@
                          const base::FilePath& path,
                          const std::string& key,
                          Entry** entry,
                          const CompletionCallback& callback);
 
   static int DoomEntry(base::WeakPtr<SimpleIndex> index,
                        const base::FilePath& path,
                        const std::string& key,
                        const CompletionCallback& callback);
 
+  std::string key() const { return key_; }
+  void RunNextOperationIfNeeded();
+
   // From Entry:
   virtual void Doom() OVERRIDE;
   virtual void Close() OVERRIDE;
   virtual std::string GetKey() const OVERRIDE;
   virtual base::Time GetLastUsed() const OVERRIDE;
   virtual base::Time GetLastModified() const OVERRIDE;
   virtual int32 GetDataSize(int index) const OVERRIDE;
   virtual int ReadData(int index,
                        int offset,
                        net::IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) OVERRIDE;
+
   virtual int WriteData(int index,
                         int offset,
                         net::IOBuffer* buf,
                         int buf_len,
                         const CompletionCallback& callback,
                         bool truncate) OVERRIDE;
   virtual int ReadSparseData(int64 offset,
                              net::IOBuffer* buf,
                              int buf_len,
                              const CompletionCallback& callback) OVERRIDE;
   virtual int WriteSparseData(int64 offset,
                               net::IOBuffer* buf,
                               int buf_len,
                               const CompletionCallback& callback) OVERRIDE;
   virtual int GetAvailableRange(int64 offset,
                                 int len,
                                 int64* start,
                                 const CompletionCallback& callback) OVERRIDE;
   virtual bool CouldBeSparse() const OVERRIDE;
   virtual void CancelSparseIO() OVERRIDE;
   virtual int ReadyForSparseIO(const CompletionCallback& callback) OVERRIDE;
 
  private:
   SimpleEntryImpl(SimpleSynchronousEntry* synchronous_entry,
                   base::WeakPtr<SimpleIndex> index);
 
   virtual ~SimpleEntryImpl();
 
+  void DoomInternal();
+
+  void ReadDataInternal(int index,
+                        int offset,
+                        scoped_refptr<net::IOBuffer> buf,
+                        int buf_len,
+                        const CompletionCallback& callback);
+  void WriteDataInternal(int index,
+                         int offset,
+                         scoped_refptr<net::IOBuffer> buf,
+                         int buf_len,
+                         const CompletionCallback& callback,
+                         bool truncate);
+
+
+
   // Called after a SimpleSynchronousEntry has completed CreateEntry() or
   // OpenEntry(). Constructs the new SimpleEntryImpl (if |result| is net::OK)
   // and passes it back to the caller via |out_entry|. Also runs
   // |completion_callback|.
   static void CreationOperationComplete(
       base::WeakPtr<SimpleIndex> index,
       const CompletionCallback& completion_callback,
       const std::string& key,
       Entry** out_entry,
       SimpleSynchronousEntry* sync_entry);
@@ skipping 36 matching lines @@
   // |synchronous_entry_in_use_by_worker_| is false (i.e. when an operation
   // is not pending on the worker pool). When an operation is pending on the
   // worker pool, the |synchronous_entry_| is owned by itself.
   SimpleSynchronousEntry* synchronous_entry_;
 
   // Set to true when a worker operation is posted on the |synchronous_entry_|,
   // and false after. Used to ensure thread safety by not allowing multiple
   // threads to access the |synchronous_entry_| simultaneously.
   bool synchronous_entry_in_use_by_worker_;
 
+  bool read_only_operation_;
+  std::queue<base::Closure> operations_;
+
+
   base::WeakPtr<SimpleIndex> index_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_