Connect SimpleCache Backend active_entries_ more closely to Entry lifetime.

net/disk_cache/simple/simple_backend_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_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 48 matching lines @@
   base::TaskRunner* worker_pool() { return worker_pool_.get(); }
 
   int Init(const CompletionCallback& completion_callback);
 
   // Sets the maximum size for the total amount of data stored by this instance.
   bool SetMaxSize(int max_bytes);
 
   // Returns the maximum file size permitted in this backend.
   int GetMaxFileSize() const;
 
-  // Removes |entry| from the |active_entries_| set, forcing future Open/Create
-  // operations to construct a new object.
-  void OnDeactivated(const SimpleEntryImpl* entry);
-
   // Flush our SequencedWorkerPool.
   static void FlushWorkerPoolForTesting();
 
   // The entry for |entry_hash| is being doomed; the backend will not attempt
   // run new operations for this |entry_hash| until the Doom is completed.
   void OnDoomStart(uint64 entry_hash);
 
   // The entry for |entry_hash| has been successfully doomed, we can now allow
   // operations on this entry, and we can run any operations enqueued while the
   // doom completed.
@@ skipping 19 matching lines @@
   virtual int DoomEntriesSince(base::Time initial_time,
                                const CompletionCallback& callback) OVERRIDE;
   virtual int OpenNextEntry(void** iter, Entry** next_entry,
                             const CompletionCallback& callback) OVERRIDE;
   virtual void EndEnumeration(void** iter) OVERRIDE;
   virtual void GetStats(
       std::vector<std::pair<std::string, std::string> >* stats) OVERRIDE;
   virtual void OnExternalCacheHit(const std::string& key) OVERRIDE;
 
  private:
-  typedef base::hash_map<uint64, base::WeakPtr<SimpleEntryImpl> > EntryMap;
+  typedef base::hash_map<uint64, SimpleEntryImpl*> EntryMap;
 
   typedef base::Callback<void(base::Time mtime, uint64 max_size, int result)>
       InitializeIndexCallback;
 
+  class ActiveEntryProxy;
+  friend class ActiveEntryProxy;
+
   // Return value of InitCacheStructureOnDisk().
   struct DiskStatResult {
     base::Time cache_dir_mtime;
     uint64 max_size;
     bool detected_magic_number_mismatch;
     int net_error;
   };
 
   void InitializeIndex(const CompletionCallback& callback,
                        const DiskStatResult& result);
@@ skipping 85 matching lines @@
   // is complete. The base::Closure map target is used to store deferred
   // operations to be run at the completion of the Doom.
   base::hash_map<uint64, std::vector<base::Closure> > entries_pending_doom_;
 
   net::NetLog* const net_log_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_