Add Keys() function to ServiceWorkerCache.

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"
 #include "base/message_loop/message_loop_proxy.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "webkit/browser/blob/blob_data_handle.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/blob/blob_url_request_job_factory.h"
 
 namespace content {
 
 namespace {
+struct EntriesDeleter;
 
 typedef scoped_ptr<disk_cache::Backend> ScopedBackendPtr;
 typedef base::Callback<void(bool)> BoolCallback;
 typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
     EntryBoolCallback;
+typedef base::Callback<void(scoped_ptr<ServiceWorkerRequestResponseHeaders>)>
+    HeadersCallback;
+typedef std::vector<disk_cache::Entry*> Entries;
+
+// Automatically closes all of the entries in the vector when it goes out of
+// scope.
+typedef scoped_ptr<Entries, EntriesDeleter> ScopedEntriesPtr;
+
 enum EntryIndex { INDEX_HEADERS = 0, INDEX_RESPONSE_BODY };
 
 // The maximum size of an individual cache. Ultimately cache size is controlled
 // per-origin.
 const int kMaxCacheBytes = 512 * 1024 * 1024;
 
 // Buffer size for cache and blob reading/writing.
 const int kBufferSize = 1024 * 512;
 
+struct EntriesDeleter {
+  void operator()(Entries* entries) {
+    for (size_t i = 0, max = entries->size(); i < max; ++i)
+      entries->at(i)->Close();

[michaeln, 2014/08/27 23:45:20]

delete entries too?

[jkarlin, 2014/08/28 15:16:11]

Done.

+  }
+};
+
 struct ResponseReadContext {
   ResponseReadContext(scoped_refptr<net::IOBufferWithSize> buff,
                       scoped_refptr<storage::BlobData> blob)
       : buffer(buff), blob_data(blob), total_bytes_read(0) {}
 
   scoped_refptr<net::IOBufferWithSize> buffer;
   scoped_refptr<storage::BlobData> blob_data;
   int total_bytes_read;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseReadContext);
@@ skipping 133 matching lines @@
 void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv);
 void MatchDidReadHeaderData(
     ServiceWorkerFetchRequest* request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
-    const scoped_refptr<net::IOBufferWithSize>& buffer,
-    int rv);
+    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
 void MatchDidReadResponseBodyData(
     ServiceWorkerFetchRequest* request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv);
 void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context);
 
 // Delete callbacks
 void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv);
 
+// Keys callback
+void KeysDidOpenNextEntry(const ServiceWorkerCache::RequestsCallback& callback,
+                          base::WeakPtr<ServiceWorkerCache> cache,
+                          scoped_ptr<void*> iter,
+                          scoped_ptr<disk_cache::Entry*> entryptr,
+                          ScopedEntriesPtr entries,
+                          int rv);
+void KeysProcessNextEntry(const ServiceWorkerCache::RequestsCallback& callback,
+                          scoped_ptr<ServiceWorkerCache::Requests> requests,
+                          ScopedEntriesPtr entries,
+                          const Entries::iterator& iter);
+void KeysDidReadHeaders(
+    const ServiceWorkerCache::RequestsCallback& callback,
+    scoped_ptr<ServiceWorkerCache::Requests> out_requests,
+    ScopedEntriesPtr entries,
+    const Entries::iterator& iter,
+    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
+
+// Copy headers out of a cache entry and into a protobuf. The callback is
+// guaranteed to be run.
+void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback);
+void ReadHeadersDidReadHeaderData(
+    disk_cache::Entry* entry,
+    const HeadersCallback& callback,
+    const scoped_refptr<net::IOBufferWithSize>& buffer,
+    int rv);
+
 // CreateBackend callbacks
 void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
                             scoped_ptr<ScopedBackendPtr> backend_ptr,
                             base::WeakPtr<ServiceWorkerCache> cache,
                             int rv);
 
 void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
                        ServiceWorkerResponse* response,
                        const ServiceWorkerCache::ErrorCallback& callback,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        scoped_ptr<storage::BlobDataHandle> blob_data_handle,
                        net::URLRequestContext* request_context,
                        int rv) {
-  if (rv != net::OK) {
-    callback.Run(ServiceWorkerCache::ErrorTypeExists);
-    return;
-  }
+  if (rv != net::OK)
+    return callback.Run(ServiceWorkerCache::ErrorTypeExists);
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
   ServiceWorkerRequestResponseHeaders headers;
   headers.set_method(request->method);
 
   headers.set_status_code(response->status_code);
   headers.set_status_text(response->status_text);
   for (std::map<std::string, std::string>::const_iterator it =
@@ skipping 10 matching lines @@
            response->headers.begin();
        it != response->headers.end();
        ++it) {
     ServiceWorkerRequestResponseHeaders::HeaderMap* header_map =
         headers.add_response_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
-  if (!headers.SerializeToString(serialized.get())) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
-    return;
-  }
+  if (!headers.SerializeToString(serialized.get()))
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage);
 
   scoped_refptr<net::StringIOBuffer> buffer(
       new net::StringIOBuffer(serialized.Pass()));
 
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   net::CompletionCallback write_headers_callback =
       base::Bind(PutDidWriteHeaders,
                  response,
@@ skipping 16 matching lines @@
 
 void PutDidWriteHeaders(ServiceWorkerResponse* response,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         disk_cache::ScopedEntryPtr entry,
                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
                         net::URLRequestContext* request_context,
                         int expected_bytes,
                         int rv) {
   if (rv != expected_bytes) {
     entry->Doom();
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage);
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
-  if (response->blob_uuid.empty()) {
-    callback.Run(ServiceWorkerCache::ErrorTypeOK);
-    return;
-  }
+  if (response->blob_uuid.empty())
+    return callback.Run(ServiceWorkerCache::ErrorTypeOK);
 
   DCHECK(blob_data_handle);
 
   scoped_ptr<BlobReader> reader(new BlobReader(entry.Pass()));
   BlobReader* reader_ptr = reader.get();
 
   reader_ptr->StreamBlobToCache(
       request_context,
       blob_data_handle.Pass(),
       base::Bind(
           PutDidWriteBlobToCache, callback, base::Passed(reader.Pass())));
 }
 
 void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
                             scoped_ptr<BlobReader> blob_reader,
                             disk_cache::ScopedEntryPtr entry,
                             bool success) {
   if (!success) {
     entry->Doom();
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage);
   }
 
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
 void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv) {
   if (rv != net::OK) {
-    callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
+                        scoped_ptr<ServiceWorkerResponse>(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
-  scoped_refptr<net::IOBufferWithSize> buffer(
-      new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
-
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
-  net::CompletionCallback read_header_callback =
-      base::Bind(MatchDidReadHeaderData,
-                 request,
-                 callback,
-                 blob_storage,
-                 base::Passed(entry.Pass()),
-                 buffer);
+  HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
+                                                request,
+                                                callback,
+                                                blob_storage,
+                                                base::Passed(entry.Pass()));
 
-  int read_rv = tmp_entry_ptr->ReadData(
-      INDEX_HEADERS, 0, buffer.get(), buffer->size(), read_header_callback);
-
-  if (read_rv != net::ERR_IO_PENDING)
-    read_header_callback.Run(read_rv);
+  ReadHeaders(tmp_entry_ptr, headers_callback);
 }
 
 void MatchDidReadHeaderData(
     ServiceWorkerFetchRequest* request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
-    const scoped_refptr<net::IOBufferWithSize>& buffer,
-    int rv) {
-  if (rv != buffer->size()) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-
-    return;
-  }
-
-  ServiceWorkerRequestResponseHeaders headers;
-
-  if (!headers.ParseFromArray(buffer->data(), buffer->size())) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-
-    return;
+    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
+  if (!headers) {
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        scoped_ptr<ServiceWorkerResponse>(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   scoped_ptr<ServiceWorkerResponse> response(
       new ServiceWorkerResponse(request->url,
-                                headers.status_code(),
-                                headers.status_text(),
+                                headers->status_code(),
+                                headers->status_text(),
                                 std::map<std::string, std::string>(),
                                 ""));
 
-  for (int i = 0; i < headers.response_headers_size(); ++i) {
+  for (int i = 0; i < headers->response_headers_size(); ++i) {
     const ServiceWorkerRequestResponseHeaders::HeaderMap header =
-        headers.response_headers(i);
+        headers->response_headers(i);
     response->headers.insert(std::make_pair(header.name(), header.value()));
   }
 
   // TODO(jkarlin): Insert vary validation here.
 
   if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    callback.Run(ServiceWorkerCache::ErrorTypeOK,
-                 response.Pass(),
-                 scoped_ptr<storage::BlobDataHandle>());
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeOK,
+                        response.Pass(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   // Stream the response body into a blob.
   if (!blob_storage) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        scoped_ptr<ServiceWorkerResponse>(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   response->blob_uuid = base::GenerateGUID();
 
   scoped_refptr<storage::BlobData> blob_data =
       new storage::BlobData(response->blob_uuid);
   scoped_refptr<net::IOBufferWithSize> response_body_buffer(
       new net::IOBufferWithSize(kBufferSize));
 
   scoped_ptr<ResponseReadContext> read_context(
@@ skipping 23 matching lines @@
 
 void MatchDidReadResponseBodyData(
     ServiceWorkerFetchRequest* request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv) {
   if (rv < 0) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        scoped_ptr<ServiceWorkerResponse>(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   if (rv == 0) {
     MatchDoneWithBody(request,
                       callback,
                       blob_storage,
                       response.Pass(),
                       response_context.Pass());
     return;
   }
@@ skipping 27 matching lines @@
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context) {
   if (!blob_storage) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                 scoped_ptr<ServiceWorkerResponse>(),
-                 scoped_ptr<storage::BlobDataHandle>());
-    return;
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        scoped_ptr<ServiceWorkerResponse>(),
+                        scoped_ptr<storage::BlobDataHandle>());
   }
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       blob_storage->AddFinishedBlob(response_context->blob_data.get()));
 
   callback.Run(ServiceWorkerCache::ErrorTypeOK,
                response.Pass(),
                blob_data_handle.Pass());
 }
 
 void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv) {
-  if (rv != net::OK) {
-    callback.Run(ServiceWorkerCache::ErrorTypeNotFound);
-    return;
-  }
+  if (rv != net::OK)
+    return callback.Run(ServiceWorkerCache::ErrorTypeNotFound);
 
   DCHECK(entryptr);
   disk_cache::ScopedEntryPtr entry(*entryptr);
 
   entry->Doom();
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
+void KeysDidOpenNextEntry(const ServiceWorkerCache::RequestsCallback& callback,
+                          base::WeakPtr<ServiceWorkerCache> cache,
+                          scoped_ptr<void*> iter,

[michaeln, 2014/08/27 23:45:20]

might be nice to distinguish the void* iter from the Entries::iterator iter via
naming thruout

[jkarlin, 2014/08/28 15:16:11]

Done.

+                          scoped_ptr<disk_cache::Entry*> entryptr,
+                          ScopedEntriesPtr entries,
+                          int rv) {
+  if (rv == net::ERR_FAILED) {
+    // Enumeration is complete, extract the requests from the entries.
+    Entries::iterator iter = entries->begin();
+    scoped_ptr<ServiceWorkerCache::Requests> out_requests(
+        new ServiceWorkerCache::Requests());

[michaeln, 2014/08/27 23:45:20]

ah ha, here's where the collection to hold the result of the keys method is
cons'd up! you might want to refer to this as out_keys to make that connection
more clear? 

[jkarlin, 2014/08/28 15:16:10]

Done.

+    return KeysProcessNextEntry(

[michaeln, 2014/08/27 23:45:20]

its odd to see return <something> in a function with a void return value? i'd
vote to have return; on the next line instead

[jkarlin, 2014/08/28 15:16:10]

Done for the whole file.

+        callback, out_requests.Pass(), entries.Pass(), iter);
+  }
+
+  if (rv < 0 || !cache) {
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        scoped_ptr<ServiceWorkerCache::Requests>());
+  }
+
+  entries->push_back(*entryptr);
+
+  void** iter_ptr = iter.get();
+  disk_cache::Entry** entry_ptr = entryptr.get();
+
+  net::CompletionCallback open_entry_callback =
+      base::Bind(KeysDidOpenNextEntry,
+                 callback,
+                 cache,
+                 base::Passed(iter.Pass()),
+                 base::Passed(entryptr.Pass()),
+                 base::Passed(entries.Pass()));
+
+  // Enumerate the next entry.
+  int rvv =

[michaeln, 2014/08/27 23:45:20]

looks like you could just use the existing parameter/variable 'rv' here, i was
wondering if rvv was a typo

[jkarlin, 2014/08/28 15:16:11]

Done.

+      cache->backend()->OpenNextEntry(iter_ptr, entry_ptr, open_entry_callback);

[michaeln, 2014/08/27 23:45:20]

i was wondering what caused backend() to be added to the public interface. seems
like this class should more thouroughly encapsulate the backend. if these anon
function where all static instance methods, backend* would not have to be
exposed.

[jkarlin, 2014/08/28 15:16:10]

You're right, better to hide backend.  I'm not gaining any encapsulation with
unnamed functions if I have to expose private variables to do it.  I need to do
the same for a couple other functions later.

+
+  if (rvv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rvv);
+}
+
+void KeysProcessNextEntry(const ServiceWorkerCache::RequestsCallback& callback,
+                          scoped_ptr<ServiceWorkerCache::Requests> requests,
+                          ScopedEntriesPtr entries,
+                          const Entries::iterator& iter) {
+  if (iter == entries->end())
+    return callback.Run(ServiceWorkerCache::ErrorTypeOK, requests.Pass());

[michaeln, 2014/08/27 23:45:20]

This is the end of the line in the expected case, is that right?

nit: its impressive that the bind mechanism can express ownership and be used to
xfer ownership down the line, but it doesn't always make for the most grokkable
code.

In Keys(), these ptrs to ptrs are created and kept alive thru a very long series
of completion callbacks. 
 830   scoped_ptr<void*> iter(new void*(NULL));
 831   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 839   ScopedEntriesPtr entries(new Entries());
Additional values are added to the long lived 'state' thats kept alive at key
points in the processing.
 564     Entries::iterator iter = entries->begin();  // not to be confused with
scoped_ptr<void*> iter
 565     scoped_ptr<ServiceWorkerCache::Requests> out_requests(

All the ptr-to-ptr indirection obscures whats going on,
ServiceWorkerCache::Requests is really just a std::vector<T>, and understanding
where objects are created and finally deleted is like hunting for a ghost.
Personal opinion but i think this would be easier to follow and maintain if
there was one struct to bundle up the state needed to process a Keys() method
call and that one thing was new'd at the beginning and Passed down the line.

[jkarlin, 2014/08/28 15:16:11]

Done.

+
+  ReadHeaders(*iter,
+              base::Bind(KeysDidReadHeaders,
+                         callback,
+                         base::Passed(requests.Pass()),
+                         base::Passed(entries.Pass()),
+                         iter));
+}
+
+void KeysDidReadHeaders(
+    const ServiceWorkerCache::RequestsCallback& callback,
+    scoped_ptr<ServiceWorkerCache::Requests> out_requests,
+    ScopedEntriesPtr entries,
+    const Entries::iterator& iter,
+    scoped_ptr<ServiceWorkerRequestResponseHeaders> headers) {
+  disk_cache::Entry* entry = *iter;
+
+  if (!headers) {
+    entry->Doom();

[michaeln, 2014/08/27 23:45:20]

Interesting, a subsequent call to Keys() will yeild a different result since the
iteration will continue at this point to the next item. Would it make sense to
Doom the botched entry here, but to also continue the iteration so subsequent
calls would be expected to get the same results.

[jkarlin, 2014/08/28 15:16:10]

Done.

+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage,
+                        out_requests.Pass());
+  }
+
+  out_requests->push_back(
+      ServiceWorkerFetchRequest(GURL(entry->GetKey()),
+                                headers->method(),
+                                std::map<std::string, std::string>(),
+                                GURL(),
+                                false));
+
+  std::map<std::string, std::string>& req_headers =
+      out_requests->back().headers;
+
+  for (int i = 0; i < headers->request_headers_size(); ++i) {
+    const ServiceWorkerRequestResponseHeaders::HeaderMap header =
+        headers->request_headers(i);
+    req_headers.insert(std::make_pair(header.name(), header.value()));
+  }
+
+  KeysProcessNextEntry(callback, out_requests.Pass(), entries.Pass(), iter + 1);
+}
+
+void ReadHeaders(disk_cache::Entry* entry, const HeadersCallback& callback) {
+  DCHECK(entry);
+
+  scoped_refptr<net::IOBufferWithSize> buffer(
+      new net::IOBufferWithSize(entry->GetDataSize(INDEX_HEADERS)));
+
+  net::CompletionCallback read_header_callback =
+      base::Bind(ReadHeadersDidReadHeaderData, entry, callback, buffer);
+
+  int read_rv = entry->ReadData(
+      INDEX_HEADERS, 0, buffer.get(), buffer->size(), read_header_callback);
+
+  if (read_rv != net::ERR_IO_PENDING)
+    read_header_callback.Run(read_rv);
+}
+
+void ReadHeadersDidReadHeaderData(
+    disk_cache::Entry* entry,
+    const HeadersCallback& callback,
+    const scoped_refptr<net::IOBufferWithSize>& buffer,
+    int rv) {
+  if (rv != buffer->size())
+    return callback.Run(scoped_ptr<ServiceWorkerRequestResponseHeaders>());
+
+  scoped_ptr<ServiceWorkerRequestResponseHeaders> headers(
+      new ServiceWorkerRequestResponseHeaders());
+
+  if (!headers->ParseFromArray(buffer->data(), buffer->size()))
+    return callback.Run(scoped_ptr<ServiceWorkerRequestResponseHeaders>());
+
+  callback.Run(headers.Pass());
+}
+
 void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
                             scoped_ptr<ScopedBackendPtr> backend_ptr,
                             base::WeakPtr<ServiceWorkerCache> cache,
                             int rv) {
-  if (rv != net::OK || !cache) {
-    callback.Run(ServiceWorkerCache::ErrorTypeStorage);
-    return;
-  }
+  if (rv != net::OK || !cache)
+    return callback.Run(ServiceWorkerCache::ErrorTypeStorage);
+
   cache->set_backend(backend_ptr->Pass());
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
 }  // namespace
 
 // static
 scoped_ptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
@@ skipping 59 matching lines @@
   DCHECK(backend_);
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
 
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
-      callback.Run(ErrorTypeStorage);
-      return;
+      return callback.Run(ErrorTypeStorage);

[michaeln, 2014/08/27 23:45:20]

why?

[jkarlin, 2014/08/28 15:16:10]

Done.

     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
-      callback.Run(ErrorTypeStorage);
-      return;
+      return callback.Run(ErrorTypeStorage);
     }
   }
 
   net::CompletionCallback create_entry_callback =
       base::Bind(PutDidCreateEntry,
                  request,
                  response,
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
@@ skipping 37 matching lines @@
 
   net::CompletionCallback open_entry_callback = base::Bind(
       DeleteDidOpenEntry, request, callback, base::Passed(entry.Pass()));
 
   int rv =
       backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
+void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
+  DCHECK(backend_);
+
+  scoped_ptr<void*> iter(new void*(NULL));
+  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
+
+  void** iter_ptr = iter.get();
+  disk_cache::Entry** entry_ptr = entry.get();
+
+  // Load up all of the entries into a vector and then read the request data

[michaeln, 2014/08/27 23:45:20]

It might help to expand on this comment to better explain the sequence of
events, its not so straightforward from a reading of the code.

[jkarlin, 2014/08/28 15:16:10]

Done.

+  // from them. This has to be done in two steps because enumeration breaks if
+  // entries are altered (such as reading header data) while enumerating.

[michaeln, 2014/08/27 23:45:20]

how does reading header data alter it?

[jkarlin, 2014/08/28 15:16:10]

It changes the "last_used" field which seems buggy but the comments clearly warn
that this might happen.  I've clarified the comment.

+  ScopedEntriesPtr entries(new Entries());
+
+  net::CompletionCallback open_entry_callback =
+      base::Bind(KeysDidOpenNextEntry,
+                 callback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(iter.Pass()),
+                 base::Passed(entry.Pass()),
+                 base::Passed(entries.Pass()));
+
+  int rv = backend_->OpenNextEntry(iter_ptr, entry_ptr, open_entry_callback);
+
+  if (rv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rv);
+}
+
 bool ServiceWorkerCache::HasCreatedBackend() const {
   return backend_;
 }
 
 ServiceWorkerCache::ServiceWorkerCache(
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : path_(path),
       request_context_(request_context),
       blob_storage_context_(blob_context),
       weak_ptr_factory_(this) {
 }
 
 }  // namespace content