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

content/browser/service_worker/service_worker_cache.cc

 // Copyright 2014 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 "content/browser/service_worker/service_worker_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 579 matching lines @@
 
 }  // namespace
 
 // The state needed to pass between ServiceWorkerCache::Keys callbacks.
 struct ServiceWorkerCache::KeysContext {
   KeysContext(const ServiceWorkerCache::RequestsCallback& callback,
               base::WeakPtr<ServiceWorkerCache> cache)
       : original_callback(callback),
         cache(cache),
         out_keys(new ServiceWorkerCache::Requests()),
-        backend_iterator(NULL),
         enumerated_entry(NULL) {}
 
   ~KeysContext() {
     for (size_t i = 0, max = entries.size(); i < max; ++i)
       entries[i]->Close();
     if (enumerated_entry)
       enumerated_entry->Close();
-    if (cache && backend_iterator && cache->backend_)
-      cache->backend_->EndEnumeration(&backend_iterator);
   }
 
   // The callback passed to the Keys() function.
   ServiceWorkerCache::RequestsCallback original_callback;
 
   // The ServiceWorkerCache that Keys was called on.
   base::WeakPtr<ServiceWorkerCache> cache;
 
   // The vector of open entries in the backend.
   Entries entries;
 
   // The output of the Keys function.
   scoped_ptr<ServiceWorkerCache::Requests> out_keys;
 
   // Used for enumerating cache entries.
-  void* backend_iterator;
+  scoped_ptr<disk_cache::Backend::Iterator> backend_iterator;
   disk_cache::Entry* enumerated_entry;
 };
 
 // static
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
   return make_scoped_refptr(
       new ServiceWorkerCache(base::FilePath(), request_context, blob_context));
 }
@@ skipping 131 matching lines @@
   //  2.2. Copy the protobuf into a ServiceWorkerFetchRequest (a "key").
   //  2.3. Push the response into a vector of requests to be returned.
   // 3. Return the vector of requests (keys).
 
   // The entries have to be loaded into a vector first because enumeration loops
   // forever if you read data from a cache entry while enumerating.
 
   scoped_ptr<KeysContext> keys_context(
       new KeysContext(callback, weak_ptr_factory_.GetWeakPtr()));
 
-  void** backend_iterator = &keys_context->backend_iterator;
+  keys_context->backend_iterator = backend_->CreateIterator();
+  disk_cache::Backend::Iterator& iterator = *keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
 
-  int rv = backend_->OpenNextEntry(
-      backend_iterator, enumerated_entry, open_entry_callback);
+  int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Close() {
   backend_.reset();
 }
 
 ServiceWorkerCache::ServiceWorkerCache(
@@ skipping 62 matching lines @@
     keys_context->original_callback.Run(ErrorTypeNotFound,
                                         scoped_ptr<Requests>());
     return;
   }
 
   // Store the entry.
   keys_context->entries.push_back(keys_context->enumerated_entry);
   keys_context->enumerated_entry = NULL;
 
   // Enumerate the next entry.
-  void** backend_iterator = &keys_context->backend_iterator;
+  disk_cache::Backend::Iterator& iterator = *keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
-
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
 
-  rv = cache->backend_->OpenNextEntry(
-      backend_iterator, enumerated_entry, open_entry_callback);
+  rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 // static
 void ServiceWorkerCache::KeysProcessNextEntry(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter) {
   if (iter == keys_context->entries.end()) {
@@ skipping 88 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content