Connect SimpleCache Backend active_entries_ more closely to Entry lifetime.

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/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/base/net_log.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_operation.h"
 
 namespace base {
 class TaskRunner;
 }
 
 namespace net {
 class GrowableIOBuffer;
 class IOBuffer;
 }
 
 namespace disk_cache {
 
 class SimpleBackendImpl;
 class SimpleSynchronousEntry;
 class SimpleEntryStat;
 struct SimpleEntryCreationResults;
 
 // 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 NET_EXPORT_PRIVATE SimpleEntryImpl : public Entry,
-    public base::RefCounted<SimpleEntryImpl>,
-    public base::SupportsWeakPtr<SimpleEntryImpl> {
+    public base::RefCounted<SimpleEntryImpl> {
   friend class base::RefCounted<SimpleEntryImpl>;
  public:
   enum OperationsMode {
     NON_OPTIMISTIC_OPERATIONS,
     OPTIMISTIC_OPERATIONS,
   };
 
+  // The Backend provides an |ActiveEntryProxy| instance to this entry when it
+  // is active, meaning it's the canonical entry for this |entry_hash_|. The
+  // entry can make itself inactive by deleting its proxy.
+  class ActiveEntryProxy {
+   public:
+    virtual ~ActiveEntryProxy() = 0;
+  };
+
   SimpleEntryImpl(net::CacheType cache_type,
                   const base::FilePath& path,
                   uint64 entry_hash,
                   OperationsMode operations_mode,
                   SimpleBackendImpl* backend,
                   net::NetLog* net_log);
 
+  void SetActiveEntryProxy(
+      scoped_ptr<ActiveEntryProxy> active_entry_proxy);
+
   // Adds another reader/writer to this entry, if possible, returning |this| to
   // |entry|.
   int OpenEntry(Entry** entry, const CompletionCallback& callback);
 
   // Creates this entry, if possible. Returns |this| to |entry|.
   int CreateEntry(Entry** entry, const CompletionCallback& callback);
 
   // Identical to Backend::Doom() except that it accepts a CompletionCallback.
   int DoomEntry(const CompletionCallback& callback);
 
@@ skipping 74 matching lines @@
   // expect).
   void PostClientCallback(const CompletionCallback& callback, int result);
 
   // 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();
@@ skipping 123 matching lines @@
                      int offset, int buf_len,
                      bool truncate);
 
   // Updates |crc32s_| and |crc32s_end_offset_| for a write of the data in
   // |buffer| on |stream_index|, starting at |offset| and of length |length|.
   void AdvanceCrc(net::IOBuffer* buffer,
                   int offset,
                   int length,
                   int stream_index);
 
+  scoped_ptr<ActiveEntryProxy> active_entry_proxy_;
+
   // 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_;
 
   const base::WeakPtr<SimpleBackendImpl> backend_;
   const net::CacheType cache_type_;
   const scoped_refptr<base::TaskRunner> worker_pool_;
   const base::FilePath path_;
   const uint64 entry_hash_;
   const bool use_optimistic_operations_;
@@ skipping 53 matching lines @@
   // 1 on disk, to reduce the number of file descriptors and save disk space.
   // This strategy allows stream 1 to change size easily. Since stream 0 is only
   // used to write HTTP headers, the memory consumption of keeping it in memory
   // is acceptable.
   scoped_refptr<net::GrowableIOBuffer> stream_0_data_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_