Make SimpleEntryImpl ref counted.

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 <string>
 
 #include "base/files/file_path.h"
+#include "base/memory/ref_counted.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_disk_format.h"
 #include "net/disk_cache/simple/simple_index.h"
 
 
 namespace net {
 class IOBuffer;
 }
 
 namespace disk_cache {
 
 class SimpleSynchronousEntry;
 
 // SimpleEntryImpl is the IO thread interface to an entry in the very simple
 // disk cache. It proxies for the SimpleSynchronousEntry, which performs IO
 // on the worker thread.
-class SimpleEntryImpl : public Entry {
+class SimpleEntryImpl : public Entry, public base::RefCounted<SimpleEntryImpl> {
+  friend class base::RefCounted<SimpleEntryImpl>;
  public:
   static int OpenEntry(base::WeakPtr<SimpleIndex> index,
                        const base::FilePath& path,
                        const std::string& key,
                        Entry** entry,
                        const CompletionCallback& callback);
 
   static int CreateEntry(base::WeakPtr<SimpleIndex> index,
                          const base::FilePath& path,
                          const std::string& key,
@@ skipping 33 matching lines @@
                               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);
+  SimpleEntryImpl(base::WeakPtr<SimpleIndex> index,
+                  const base::FilePath& path,
+                  const std::string& key);
+
 
   virtual ~SimpleEntryImpl();
 
   // 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,
+  void CreationOperationComplete(
       const CompletionCallback& completion_callback,
-      const std::string& key,
-      Entry** out_entry,
       SimpleSynchronousEntry* sync_entry);
 
   // Called after a SimpleSynchronousEntry has completed an asynchronous IO
   // operation, such as ReadData() or WriteData(). Calls |completion_callback|.
-  // If |entry| no longer exists, then it ensures |sync_entry| is closed.
-  static void EntryOperationComplete(
-      base::WeakPtr<SimpleIndex> index,
+  void EntryOperationComplete(
       const CompletionCallback& completion_callback,
-      base::WeakPtr<SimpleEntryImpl> entry,
-      SimpleSynchronousEntry* sync_entry,
       int result);
 
+  // Called after a SimpleSynchronousEntry has been successfully created for
+  // this entry. After this call, the SimpleEntryImpl claims |sync_entry| and
+  // is responsible for closing it.
+  void Initialize(SimpleSynchronousEntry* sync_entry);
+
   // Called on construction and also after the completion of asynchronous IO to
   // initialize the IO thread copies of data returned by synchronous accessor
   // functions. Copies data from |synchronous_entry_| into |this|, so that
   // values can be returned during our next IO operation.
   void SetSynchronousData();
 
+  // The disk_cache::Entry API requires a self delete on Close(). At the same
+  // time, we use ref counting to keep the SimpleEntryImpl alive while IO
+  // operations are pending. This |self_| reference is set to |this| at
+  // initialization and holds the implicit reference built in to the API. On
+  // Close(), we call |self_.reset()| so the Entry will self release after

[felipeg, 2013/04/12 15:52:19]

in the actual code you do
self_ = NULL;
change one or the other

[gavinp, 2013/04/13 08:54:35]

Done.

+  // the last pending IO operation completes.
+  scoped_refptr<SimpleEntryImpl> self_;
+
   // All nonstatic SimpleEntryImpl methods should always be called on the IO
   // thread, in all cases. |io_thread_checker_| documents and enforces this.
   base::ThreadChecker io_thread_checker_;
 
-  base::WeakPtrFactory<SimpleEntryImpl> weak_ptr_factory_;
-
-  // |path_| and |key_| are copied from the synchronous entry on construction,
-  // and never updated as they are const.
+  const base::WeakPtr<SimpleIndex> index_;
   const base::FilePath path_;
   const std::string key_;
 
   // |last_used_|, |last_modified_| and |data_size_| are copied from the
   // synchronous entry at the completion of each item of asynchronous IO.
   base::Time last_used_;
   base::Time last_modified_;
   int32 data_size_[kSimpleEntryFileCount];
 
   // The |synchronous_entry_| is the worker thread object that performs IO on
   // entries. It's owned by this SimpleEntryImpl whenever
   // |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_;
-
-  base::WeakPtr<SimpleIndex> index_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_