[CacheStorage] Keys only needs requests, not responses from QueryCache

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 717 matching lines @@
                    response.headers)) {
     QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
     return;
   }
 
   if (query_cache_results->query_type == QueryCacheType::CACHE_ENTRIES) {
     query_cache_results->out_entries.push_back(std::move(entry));
     QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
     return;
   }
+
+  query_cache_results->out_requests->push_back(request);
+  if (query_cache_results->query_type == QueryCacheType::REQUESTS) {
+    QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
+    return;
+  }
+
   DCHECK_EQ(QueryCacheType::REQUESTS_AND_RESPONSES,
             query_cache_results->query_type);
 
-  query_cache_results->out_requests->push_back(request);
-
   if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
     query_cache_results->out_responses->push_back(response);
     QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
     return;
   }
 
   if (!blob_storage_context_) {
     query_cache_results->callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                                       std::unique_ptr<QueryCacheResults>());
     return;
@@ skipping 502 matching lines @@
 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;
   }
 
-  QueryCache(std::move(request), options,
-             QueryCacheType::REQUESTS_AND_RESPONSES,
+  QueryCache(std::move(request), options, QueryCacheType::REQUESTS,
              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