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 433 matching lines @@
   barrier_closure.Run();
 }
 
 void CacheStorageCache::BatchDidAllOperations(
     std::unique_ptr<ErrorCallback> callback) {
   if (callback->is_null())
     return;
   callback->Run(CACHE_STORAGE_OK);
 }
 
-void CacheStorageCache::Keys(const RequestsCallback& callback) {
+void CacheStorageCache::Keys(std::unique_ptr<ServiceWorkerFetchRequest> request,
+                             const CacheStorageCacheQueryParams& options,
+                             const RequestsCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
     return;
   }
 
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::KeysImpl, weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(std::move(request)), options,
                  scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::Close(const base::Closure& callback) {
   DCHECK_NE(BACKEND_CLOSED, backend_state_)
       << "Was CacheStorageCache::Close() called twice?";
 
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::CloseImpl, weak_ptr_factory_.GetWeakPtr(),
                  scheduler_->WrapCallbackToRunNext(callback)));
@@ skipping 146 matching lines @@
 
 void CacheStorageCache::QueryCacheProcessNextEntry(
     std::unique_ptr<QueryCacheResults> query_cache_results,
     const Entries::iterator& iter) {
   if (iter == query_cache_results->entries_context->entries.end()) {
     QueryCacheResultsCallback success_callback = query_cache_results->callback;
     success_callback.Run(CACHE_STORAGE_OK, std::move(query_cache_results));
     return;
   }
 
-  if (query_cache_results->options.ignore_search) {
-    DCHECK(query_cache_results->request);
+  if (query_cache_results->request &&
+      !query_cache_results->request->url.is_empty()) {
     disk_cache::Entry* entry(*iter);
-    if (RemoveQueryParam(query_cache_results->request->url) !=
-        RemoveQueryParam(GURL(entry->GetKey()))) {
+    GURL requestURL = query_cache_results->request->url;
+    GURL cachedURL = GURL(entry->GetKey());
+
+    if (query_cache_results->options.ignore_search) {
+      requestURL = RemoveQueryParam(requestURL);
+      cachedURL = RemoveQueryParam(cachedURL);
+    }
+
+    if (cachedURL != requestURL) {
       QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
       return;
     }
   }
 
   ReadMetadata(*iter,
                base::Bind(&CacheStorageCache::QueryCacheDidReadMetadata,
                           weak_ptr_factory_.GetWeakPtr(),
                           base::Passed(std::move(query_cache_results)), iter));
 }
@@ skipping 616 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(
+    std::unique_ptr<ServiceWorkerFetchRequest> request,
+    const CacheStorageCacheQueryParams& options,
+    const RequestsCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Requests>());
     return;
   }
 
-  std::unique_ptr<ServiceWorkerFetchRequest> request(
-      new ServiceWorkerFetchRequest);
-  QueryCache(std::move(request), CacheStorageCacheQueryParams(),
+  QueryCache(std::move(request), options,
              base::Bind(&CacheStorageCache::KeysDidQueryCache,
                         weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorageCache::KeysDidQueryCache(
     const RequestsCallback& callback,
     CacheStorageError error,
     std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
     callback.Run(error, std::unique_ptr<Requests>());
@@ skipping 165 matching lines @@
       temp_entry, INDEX_RESPONSE_BODY, INDEX_SIDE_DATA);
   return blob_storage_context_->AddFinishedBlob(&blob_data);
 }
 
 std::unique_ptr<CacheStorageCacheHandle>
 CacheStorageCache::CreateCacheHandle() {
   return cache_storage_->CreateCacheHandle(this);
 }
 
 }  // namespace content