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

net/disk_cache/blockfile/in_flight_backend_io.cc

 // 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.
 
 #include "net/disk_cache/blockfile/in_flight_backend_io.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/blockfile/entry_impl.h"
 #include "net/disk_cache/blockfile/histogram_macros.h"
 
 // Provide a BackendImpl object to macros from histogram_macros.h.
 #define CACHE_UMA_BACKEND_IMPL_OBJ backend_
 
 namespace disk_cache {
 
 BackendIO::BackendIO(InFlightIO* controller, BackendImpl* backend,
                      const net::CompletionCallback& callback)
     : BackgroundIO(controller),
       backend_(backend),
       callback_(callback),
       operation_(OP_NONE),
       entry_ptr_(NULL),
-      iter_ptr_(NULL),
-      iter_(NULL),
+      iterator_(NULL),
       entry_(NULL),
       index_(0),
       offset_(0),
       buf_len_(0),
       truncate_(false),
       offset64_(0),
       start_(NULL) {
   start_time_ = base::TimeTicks::Now();
 }
 
@@ skipping 68 matching lines @@
   operation_ = OP_DOOM_BETWEEN;
   initial_time_ = initial_time;
   end_time_ = end_time;
 }
 
 void BackendIO::DoomEntriesSince(const base::Time initial_time) {
   operation_ = OP_DOOM_SINCE;
   initial_time_ = initial_time;
 }
 
-void BackendIO::OpenNextEntry(void** iter, Entry** next_entry) {
+void BackendIO::OpenNextEntry(Rankings::Iterator* iterator,
+                              Entry** next_entry) {
   operation_ = OP_OPEN_NEXT;
-  iter_ptr_ = iter;
+  iterator_ = iterator;
   entry_ptr_ = next_entry;
 }
 
-void BackendIO::EndEnumeration(void* iterator) {
+void BackendIO::EndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
   operation_ = OP_END_ENUMERATION;
-  iter_ = iterator;
+  scoped_iterator_ = iterator.Pass();
 }
 
 void BackendIO::OnExternalCacheHit(const std::string& key) {
   operation_ = OP_ON_EXTERNAL_CACHE_HIT;
   key_ = key;
 }
 
 void BackendIO::CloseEntryImpl(EntryImpl* entry) {
   operation_ = OP_CLOSE_ENTRY;
   entry_ = entry;
@@ skipping 100 matching lines @@
     case OP_DOOM_ALL:
       result_ = backend_->SyncDoomAllEntries();
       break;
     case OP_DOOM_BETWEEN:
       result_ = backend_->SyncDoomEntriesBetween(initial_time_, end_time_);
       break;
     case OP_DOOM_SINCE:
       result_ = backend_->SyncDoomEntriesSince(initial_time_);
       break;
     case OP_OPEN_NEXT:
-      result_ = backend_->SyncOpenNextEntry(iter_ptr_, entry_ptr_);
+      result_ = backend_->SyncOpenNextEntry(iterator_, entry_ptr_);
       break;
     case OP_END_ENUMERATION:
-      backend_->SyncEndEnumeration(iter_);
+      backend_->SyncEndEnumeration(scoped_iterator_.Pass());
       result_ = net::OK;
       break;
     case OP_ON_EXTERNAL_CACHE_HIT:
       backend_->SyncOnExternalCacheHit(key_);
       result_ = net::OK;
       break;
     case OP_CLOSE_ENTRY:
       entry_->Release();
       result_ = net::OK;
       break;
@@ skipping 113 matching lines @@
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::DoomEntriesSince(
     const base::Time initial_time, const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
   operation->DoomEntriesSince(initial_time);
   PostOperation(operation.get());
 }
 
-void InFlightBackendIO::OpenNextEntry(void** iter, Entry** next_entry,
+void InFlightBackendIO::OpenNextEntry(Rankings::Iterator* iterator,
+                                      Entry** next_entry,
                                       const net::CompletionCallback& callback) {
   scoped_refptr<BackendIO> operation(new BackendIO(this, backend_, callback));
-  operation->OpenNextEntry(iter, next_entry);
+  operation->OpenNextEntry(iterator, next_entry);
   PostOperation(operation.get());
 }
 
-void InFlightBackendIO::EndEnumeration(void* iterator) {
+void InFlightBackendIO::EndEnumeration(
+    scoped_ptr<Rankings::Iterator> iterator) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
-  operation->EndEnumeration(iterator);
+  operation->EndEnumeration(iterator.Pass());
   PostOperation(operation.get());
 }
 
 void InFlightBackendIO::OnExternalCacheHit(const std::string& key) {
   scoped_refptr<BackendIO> operation(
       new BackendIO(this, backend_, net::CompletionCallback()));
   operation->OnExternalCacheHit(key);
   PostOperation(operation.get());
 }
 
@@ skipping 96 matching lines @@
   background_thread_->PostTask(
       FROM_HERE, base::Bind(&BackendIO::ExecuteOperation, operation));
   OnOperationPosted(operation);
 }
 
 base::WeakPtr<InFlightBackendIO> InFlightBackendIO::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 }  // namespace