Reland of "Remove void** from disk_cache interface" w/ blockfile iter fix.

net/disk_cache/blockfile/in_flight_backend_io.h

 // Copyright (c) 2012 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_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_
 #define NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_
 
 #include <list>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/disk_cache/blockfile/in_flight_io.h"
+#include "net/disk_cache/blockfile/rankings.h"
 
 namespace disk_cache {
 
 class BackendImpl;
 class Entry;
 class EntryImpl;
 
 // This class represents a single asynchronous disk cache IO operation while it
 // is being bounced between threads.
 class BackendIO : public BackgroundIO {
@@ skipping 21 matching lines @@
 
   // The operations we proxy:
   void Init();
   void OpenEntry(const std::string& key, Entry** entry);
   void CreateEntry(const std::string& key, Entry** entry);
   void DoomEntry(const std::string& key);
   void DoomAllEntries();
   void DoomEntriesBetween(const base::Time initial_time,
                           const base::Time end_time);
   void DoomEntriesSince(const base::Time initial_time);
-  void OpenNextEntry(void** iter, Entry** next_entry);
-  void EndEnumeration(void* iterator);
+  void OpenNextEntry(Rankings::Iterator* iterator, Entry** next_entry);
+  void EndEnumeration(scoped_ptr<Rankings::Iterator> iterator);
   void OnExternalCacheHit(const std::string& key);
   void CloseEntryImpl(EntryImpl* entry);
   void DoomEntryImpl(EntryImpl* entry);
   void FlushQueue();  // Dummy operation.
   void RunTask(const base::Closure& task);
   void ReadData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                 int buf_len);
   void WriteData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                  int buf_len, bool truncate);
   void ReadSparseData(EntryImpl* entry, int64 offset, net::IOBuffer* buf,
@@ skipping 49 matching lines @@
 
   BackendImpl* backend_;
   net::CompletionCallback callback_;
   Operation operation_;
 
   // The arguments of all the operations we proxy:
   std::string key_;
   Entry** entry_ptr_;
   base::Time initial_time_;
   base::Time end_time_;
-  void** iter_ptr_;
-  void* iter_;
+  Rankings::Iterator* iterator_;
+  scoped_ptr<Rankings::Iterator> scoped_iterator_;
   EntryImpl* entry_;
   int index_;
   int offset_;
   scoped_refptr<net::IOBuffer> buf_;
   int buf_len_;
   bool truncate_;
   int64 offset64_;
   int64* start_;
   base::TimeTicks start_time_;
   base::Closure task_;
@@ skipping 16 matching lines @@
   void CreateEntry(const std::string& key, Entry** entry,
                    const net::CompletionCallback& callback);
   void DoomEntry(const std::string& key,
                  const net::CompletionCallback& callback);
   void DoomAllEntries(const net::CompletionCallback& callback);
   void DoomEntriesBetween(const base::Time initial_time,
                           const base::Time end_time,
                           const net::CompletionCallback& callback);
   void DoomEntriesSince(const base::Time initial_time,
                         const net::CompletionCallback& callback);
-  void OpenNextEntry(void** iter, Entry** next_entry,
+  void OpenNextEntry(Rankings::Iterator* iterator, Entry** next_entry,
                      const net::CompletionCallback& callback);
-  void EndEnumeration(void* iterator);
+  void EndEnumeration(scoped_ptr<Rankings::Iterator> iterator);
   void OnExternalCacheHit(const std::string& key);
   void CloseEntryImpl(EntryImpl* entry);
   void DoomEntryImpl(EntryImpl* entry);
   void FlushQueue(const net::CompletionCallback& callback);
   void RunTask(const base::Closure& task,
                const net::CompletionCallback& callback);
   void ReadData(EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
                 int buf_len, const net::CompletionCallback& callback);
   void WriteData(
       EntryImpl* entry, int index, int offset, net::IOBuffer* buf,
@@ skipping 32 matching lines @@
   BackendImpl* backend_;
   scoped_refptr<base::SingleThreadTaskRunner> background_thread_;
   base::WeakPtrFactory<InFlightBackendIO> ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InFlightBackendIO);
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_BLOCKFILE_IN_FLIGHT_BACKEND_IO_H_