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

net/disk_cache/blockfile/backend_impl.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/backend_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 363 matching lines @@
   DCHECK_NE(net::APP_CACHE, cache_type_);
   if (end_time.is_null())
     return SyncDoomEntriesSince(initial_time);
 
   DCHECK(end_time >= initial_time);
 
   if (disabled_)
     return net::ERR_FAILED;
 
   EntryImpl* node;
-  void* iter = NULL;
-  EntryImpl* next = OpenNextEntryImpl(&iter);
+  scoped_ptr<Rankings::Iterator> iterator(new Rankings::Iterator());
+  EntryImpl* next = OpenNextEntryImpl(iterator.get());
   if (!next)
     return net::OK;
 
   while (next) {
     node = next;
-    next = OpenNextEntryImpl(&iter);
+    next = OpenNextEntryImpl(iterator.get());
 
     if (node->GetLastUsed() >= initial_time &&
         node->GetLastUsed() < end_time) {
       node->DoomImpl();
     } else if (node->GetLastUsed() < initial_time) {
       if (next)
         next->Release();
       next = NULL;
-      SyncEndEnumeration(iter);
+      SyncEndEnumeration(iterator.Pass());
     }
 
     node->Release();
   }
 
   return net::OK;
 }
 
 // We use OpenNextEntryImpl to retrieve elements from the cache, until we get
 // entries that are too old.
 int BackendImpl::SyncDoomEntriesSince(const base::Time initial_time) {
   DCHECK_NE(net::APP_CACHE, cache_type_);
   if (disabled_)
     return net::ERR_FAILED;
 
   stats_.OnEvent(Stats::DOOM_RECENT);
   for (;;) {
-    void* iter = NULL;
-    EntryImpl* entry = OpenNextEntryImpl(&iter);
+    scoped_ptr<Rankings::Iterator> iterator(new Rankings::Iterator());
+    EntryImpl* entry = OpenNextEntryImpl(iterator.get());
     if (!entry)
       return net::OK;
 
     if (initial_time > entry->GetLastUsed()) {
       entry->Release();
-      SyncEndEnumeration(iter);
+      SyncEndEnumeration(iterator.Pass());
       return net::OK;
     }
 
     entry->DoomImpl();
     entry->Release();
-    SyncEndEnumeration(iter);  // Dooming the entry invalidates the iterator.
+    SyncEndEnumeration(iterator.Pass());  // The doom invalidated the iterator.
   }
 }
 
-int BackendImpl::SyncOpenNextEntry(void** iter, Entry** next_entry) {
-  *next_entry = OpenNextEntryImpl(iter);
+int BackendImpl::SyncOpenNextEntry(Rankings::Iterator* iterator,
+                                   Entry** next_entry) {
+  *next_entry = OpenNextEntryImpl(iterator);
   return (*next_entry) ? net::OK : net::ERR_FAILED;
 }
 
-void BackendImpl::SyncEndEnumeration(void* iter) {
-  scoped_ptr<Rankings::Iterator> iterator(
-      reinterpret_cast<Rankings::Iterator*>(iter));
+void BackendImpl::SyncEndEnumeration(scoped_ptr<Rankings::Iterator> iterator) {
+  iterator->Reset();
 }
 
 void BackendImpl::SyncOnExternalCacheHit(const std::string& key) {
   if (disabled_)
     return;
 
   uint32 hash = base::Hash(key);
   bool error;
   EntryImpl* cache_entry = MatchEntry(key, hash, false, Addr(), &error);
   if (cache_entry) {
@@ skipping 144 matching lines @@
 
   CACHE_UMA(AGE_MS, "CreateTime", 0, start);
   stats_.OnEvent(Stats::CREATE_HIT);
   SIMPLE_STATS_COUNTER("disk_cache.miss");
   Trace("create entry hit ");
   FlushIndex();
   cache_entry->AddRef();
   return cache_entry.get();
 }
 
-EntryImpl* BackendImpl::OpenNextEntryImpl(void** iter) {
+EntryImpl* BackendImpl::OpenNextEntryImpl(Rankings::Iterator* iterator) {
   if (disabled_)
     return NULL;
 
-  DCHECK(iter);
-
   const int kListsToSearch = 3;
   scoped_refptr<EntryImpl> entries[kListsToSearch];
-  scoped_ptr<Rankings::Iterator> iterator(
-      reinterpret_cast<Rankings::Iterator*>(*iter));
-  *iter = NULL;
-
-  if (!iterator.get()) {
-    iterator.reset(new Rankings::Iterator(&rankings_));
+  if (!iterator->my_rankings) {
+    iterator->my_rankings = &rankings_;
     bool ret = false;
 
     // Get an entry from each list.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       ret |= OpenFollowingEntryFromList(static_cast<Rankings::List>(i),
                                         &iterator->nodes[i], &temp);
       entries[i].swap(&temp);  // The entry was already addref'd.
     }
-    if (!ret)
+    if (!ret) {
+      iterator->Reset();
       return NULL;
+    }
   } else {
     // Get the next entry from the last list, and the actual entries for the
     // elements on the other lists.
     for (int i = 0; i < kListsToSearch; i++) {
       EntryImpl* temp = NULL;
       if (iterator->list == i) {
           OpenFollowingEntryFromList(
               iterator->list, &iterator->nodes[i], &temp);
       } else {
         temp = GetEnumeratedEntry(iterator->nodes[i],
@@ skipping 15 matching lines @@
         newest = oldest = i;
         continue;
       }
       if (access_times[i] > access_times[newest])
         newest = i;
       if (access_times[i] < access_times[oldest])
         oldest = i;
     }
   }
 
-  if (newest < 0 || oldest < 0)
+  if (newest < 0 || oldest < 0) {
+    iterator->Reset();
     return NULL;
+  }
 
   EntryImpl* next_entry;
   next_entry = entries[newest].get();
   iterator->list = static_cast<Rankings::List>(newest);
-  *iter = iterator.release();
   next_entry->AddRef();
   return next_entry;
 }
 
 bool BackendImpl::SetMaxSize(int max_bytes) {
   COMPILE_ASSERT(sizeof(max_bytes) == sizeof(max_size_), unsupported_int_model);
   if (max_bytes < 0)
     return false;
 
   // Zero size means use the default.
@@ skipping 559 matching lines @@
   return net::ERR_IO_PENDING;
 }
 
 int BackendImpl::DoomEntriesSince(const base::Time initial_time,
                                   const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   background_queue_.DoomEntriesSince(initial_time, callback);
   return net::ERR_IO_PENDING;
 }
 
-int BackendImpl::OpenNextEntry(void** iter, Entry** next_entry,
-                               const CompletionCallback& callback) {
-  DCHECK(!callback.is_null());
-  background_queue_.OpenNextEntry(iter, next_entry, callback);
-  return net::ERR_IO_PENDING;
-}
+class BackendImpl::IteratorImpl : public Backend::Iterator {
+ public:
+  explicit IteratorImpl(base::WeakPtr<InFlightBackendIO> background_queue)
+      : background_queue_(background_queue),
+        iterator_(new Rankings::Iterator()) {
+  }
 
-void BackendImpl::EndEnumeration(void** iter) {
-  background_queue_.EndEnumeration(*iter);
-  *iter = NULL;
+  virtual ~IteratorImpl() {
+    if (background_queue_)
+      background_queue_->EndEnumeration(iterator_.Pass());
+  }
+
+  virtual int OpenNextEntry(Entry** next_entry,
+                            const net::CompletionCallback& callback) OVERRIDE {
+    if (!background_queue_)
+      return net::ERR_FAILED;
+    background_queue_->OpenNextEntry(iterator_.get(), next_entry, callback);
+    return net::ERR_IO_PENDING;
+  }
+
+ private:
+  const base::WeakPtr<InFlightBackendIO> background_queue_;
+  scoped_ptr<Rankings::Iterator> iterator_;
+};
+
+scoped_ptr<Backend::Iterator> BackendImpl::CreateIterator() {
+  return scoped_ptr<Backend::Iterator>(new IteratorImpl(GetBackgroundQueue()));
 }
 
 void BackendImpl::GetStats(StatsItems* stats) {
   if (disabled_)
     return;
 
   std::pair<std::string, std::string> item;
 
   item.first = "Entries";
   item.second = base::StringPrintf("%d", data_->header.num_entries);
@@ skipping 793 matching lines @@
     if (total_memory > kMaxBuffersSize || total_memory <= 0)
       total_memory = kMaxBuffersSize;
 
     done = true;
   }
 
   return static_cast<int>(total_memory);
 }
 
 }  // namespace disk_cache