CacheStorage: Expand cache.keys() method.

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_cache.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 
@@ skipping 225 matching lines @@
 
   // The context holding open entries.
   scoped_ptr<OpenAllEntriesContext> entries_context;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MatchAllContext);
 };
 
 // The state needed to pass between CacheStorageCache::Keys callbacks.
 struct CacheStorageCache::KeysContext {
-  explicit KeysContext(const CacheStorageCache::RequestsCallback& callback)
-      : original_callback(callback), out_keys(new Requests()) {}
+  explicit KeysContext(scoped_ptr<ServiceWorkerFetchRequest> request,

[jkarlin, 2016/03/04 14:39:09]

Remove explicit

+                       const CacheStorageCacheQueryParams& match_params,
+                       const CacheStorageCache::RequestsCallback& callback)
+      : request(std::move(request)),
+        options(match_params),
+        original_callback(callback),
+        out_keys(new Requests()) {}
   ~KeysContext() {}
 
+  scoped_ptr<ServiceWorkerFetchRequest> request;
+
+  CacheStorageCacheQueryParams options;
+
   // The callback passed to the Keys() function.
   RequestsCallback original_callback;
 
   // The output of the Keys function.
   scoped_ptr<Requests> out_keys;
 
   // The context holding open entries.
   scoped_ptr<OpenAllEntriesContext> entries_context;
 
  private:
@@ skipping 141 matching lines @@
   barrier_closure.Run();
 }
 
 void CacheStorageCache::BatchDidAllOperations(
     scoped_ptr<ErrorCallback> callback) {
   if (callback->is_null())
     return;
   callback->Run(CACHE_STORAGE_OK);
 }
 
-void CacheStorageCache::Keys(const RequestsCallback& callback) {
+void CacheStorageCache::Keys(scoped_ptr<ServiceWorkerFetchRequest> request,
+                             const CacheStorageCacheQueryParams& match_params,
+                             const RequestsCallback& callback) {
   if (!LazyInitialize()) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Requests>());
     return;
   }
 
   RequestsCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::KeysImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           pending_callback));
+  scheduler_->ScheduleOperation(base::Bind(
+      &CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), match_params, pending_callback));
 }
 
 void CacheStorageCache::Close(const base::Closure& callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
   base::Closure pending_callback =
       base::Bind(&CacheStorageCache::PendingClosure,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
@@ skipping 680 matching lines @@
   DCHECK(entry_ptr);
   disk_cache::ScopedEntryPtr entry(*entry_ptr);
 
   entry->Doom();
   entry.reset();
 
   UpdateCacheSize();
   callback.Run(CACHE_STORAGE_OK);
 }
 
-void CacheStorageCache::KeysImpl(const RequestsCallback& callback) {
+void CacheStorageCache::KeysImpl(
+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const CacheStorageCacheQueryParams& match_params,
+    const RequestsCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, scoped_ptr<Requests>());
     return;
   }
 
-  // 1. Iterate through all of the entries, open them, and add them to a vector.
-  // 2. For each open entry:
-  //  2.1. Read the headers into a protobuf.
-  //  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).
+  if (request->url.is_empty() || match_params.ignore_search) {
+    scoped_ptr<KeysContext> keys_context(
+        new KeysContext(std::move(request), match_params, callback));
 
-  // The entries have to be loaded into a vector first because enumeration loops
-  // forever if you read data from a cache entry while enumerating.
+    // 1. Iterate through all of the entries, open them, and add them to a
+    // vector.
+    // 2. For each open entry:
+    //  2.1. Read the headers into a protobuf.
+    //  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).
 
-  OpenAllEntries(base::Bind(&CacheStorageCache::KeysDidOpenAllEntries,
-                            weak_ptr_factory_.GetWeakPtr(), callback));
+    // The entries have to be loaded into a vector first because enumeration
+    // loops

[jkarlin, 2016/03/04 14:39:09]

comment formatting, you have an extra newline here

+    // forever if you read data from a cache entry while enumerating.
+
+    OpenAllEntries(base::Bind(&CacheStorageCache::KeysDidOpenAllEntries,
+                              weak_ptr_factory_.GetWeakPtr(),
+                              base::Passed(std::move(keys_context))));
+    return;
+  }
+
+  scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
+  disk_cache::Entry** entry_ptr = entry.get();
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
+  net::CompletionCallback open_entry_callback = base::Bind(
+      &CacheStorageCache::KeyDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(request)), callback,
+      base::Passed(std::move(entry)));
+
+  int rv = backend_->OpenEntry(request_ptr->url.spec(), entry_ptr,
+                               open_entry_callback);
+  if (rv != net::ERR_IO_PENDING)
+    open_entry_callback.Run(rv);
+}
+
+void CacheStorageCache::KeyDidOpenEntry(

[jkarlin, 2016/03/04 14:39:09]

Should be KeysDidOpenEntry to show that it's a continuation of the keys
function.

+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const RequestsCallback& callback,
+    scoped_ptr<disk_cache::Entry*> entry_ptr,
+    int rv) {
+  if (rv != net::OK) {
+    // If there is no matched request, then return empty array.
+    scoped_ptr<Requests> requests(new Requests());
+    callback.Run(CACHE_STORAGE_OK, std::move(requests));
+    return;
+  }
+
+  disk_cache::ScopedEntryPtr entry(*entry_ptr);
+
+  ReadMetadata(*entry_ptr,
+               base::Bind(&CacheStorageCache::KeyDidReadMetadata,
+                          weak_ptr_factory_.GetWeakPtr(),
+                          base::Passed(std::move(request)), callback,
+                          base::Passed(std::move(entry))));
+}
+
+void CacheStorageCache::KeyDidReadMetadata(

[jkarlin, 2016/03/04 14:39:09]

Should be KeysDidReadMetadata

+    scoped_ptr<ServiceWorkerFetchRequest> request,
+    const RequestsCallback& callback,
+    disk_cache::ScopedEntryPtr entry,
+    scoped_ptr<CacheMetadata> metadata) {
+  scoped_ptr<Requests> requests(new Requests());
+
+  if (metadata) {

[jkarlin, 2016/03/04 14:39:09]

Start with the failed case and return early:

e.g.,

if (!metadata) {
  entry->Doom();
  callback.Run(CACHE_STORAGE_OK, std::move(requests));
  return;
}
...

+    requests->push_back(ServiceWorkerFetchRequest(
+        GURL(entry->GetKey()), metadata->request().method(),
+        ServiceWorkerHeaderMap(), Referrer(), false));
+
+    ServiceWorkerHeaderMap& req_headers = requests->back().headers;
+
+    for (int i = 0; i < metadata->request().headers_size(); ++i) {
+      const CacheHeaderMap header = metadata->request().headers(i);
+      DCHECK_EQ(std::string::npos, header.name().find('\0'));
+      DCHECK_EQ(std::string::npos, header.value().find('\0'));
+      req_headers.insert(std::make_pair(header.name(), header.value()));
+    }

[jkarlin, 2016/03/04 14:39:09]

Lines 1210-1221 could be put in a new 
PopulateFetchRequestFromMetadata function akin to PopulateResponseMetadata (this
should be moved to anonymous namespace and renamed to
PopulateResponseFromMetadata).

namespace {

void PopulateFetchRequestFromMetadata(const CacheMetadata& metadata,
ServiceWorkerFetchRequest* request) { 
...
}

}  // namespace

+  } else {
+    entry->Doom();
+  }
+
+  callback.Run(CACHE_STORAGE_OK, std::move(requests));
 }
 
 void CacheStorageCache::KeysDidOpenAllEntries(
-    const RequestsCallback& callback,
+    scoped_ptr<KeysContext> keys_context,
     scoped_ptr<OpenAllEntriesContext> entries_context,
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
-    callback.Run(error, scoped_ptr<Requests>());
+    keys_context->original_callback.Run(error, scoped_ptr<Requests>());
     return;
   }
 
-  scoped_ptr<KeysContext> keys_context(new KeysContext(callback));
   keys_context->entries_context.swap(entries_context);
   Entries::iterator iter = keys_context->entries_context->entries.begin();
   KeysProcessNextEntry(std::move(keys_context), iter);
 }
 
 void CacheStorageCache::KeysProcessNextEntry(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter) {
   if (iter == keys_context->entries_context->entries.end()) {
     // All done. Return all of the keys.
     keys_context->original_callback.Run(CACHE_STORAGE_OK,
                                         std::move(keys_context->out_keys));
     return;
   }
 
+  if (keys_context->options.ignore_search) {

[jkarlin, 2016/03/04 14:39:09]

This CL adds what is essentially a third implementation of the Query Cache
algorithm. It's time to consolidate.

In a separate CL, please create something like the following and update Match
and Delete to use it:

struct RequestAndResponse {
  scoped_ptr<ServiceWorkerFetchRequest> request;
  scoped_ptr<ServiceWorkerResponse> response;
  BlobDataHandle response_body_handle;
};

using CacheQueryResults = std::vector<RequestAndResponse>;
using CacheQueryResultsCallback = base::Callback<void(CacheQueryResults)>;

void CacheStorageCache::QueryCache(scoped_ptr<ServiceWorkerFetchRequest>
request, const CacheStorageCacheQueryParams& match_params, const
CacheQueryResultsCallback& callback) {

// Perform
http://slightlyoff.github.io/ServiceWorker/spec/service_worker/#query-cache-a...
here

}

Then in this CL use your new method for Keys as well.

+    DCHECK(keys_context->request);
+    disk_cache::Entry* entry(*iter);
+    if (RemoveQueryParam(keys_context->request->url) !=
+        RemoveQueryParam(GURL(entry->GetKey()))) {
+      KeysProcessNextEntry(std::move(keys_context), iter + 1);
+      return;
+    }
+  }
+
   ReadMetadata(*iter, base::Bind(&CacheStorageCache::KeysDidReadMetadata,
                                  weak_ptr_factory_.GetWeakPtr(),
                                  base::Passed(std::move(keys_context)), iter));
 }
 
 void CacheStorageCache::KeysDidReadMetadata(
     scoped_ptr<KeysContext> keys_context,
     const Entries::iterator& iter,
     scoped_ptr<CacheMetadata> metadata) {
   disk_cache::Entry* entry = *iter;
@@ skipping 216 matching lines @@
   storage::BlobDataBuilder blob_data(response->blob_uuid);
 
   disk_cache::Entry* temp_entry = entry.get();
   blob_data.AppendDiskCacheEntry(
       new CacheStorageCacheDataHandle(this, std::move(entry)), temp_entry,
       INDEX_RESPONSE_BODY);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 }  // namespace content