[CacheStorage] Use QueryCache everywhere

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 230 matching lines @@
       : request(std::move(request)),
         options(options),
         callback(callback),
         out_requests(new Requests),
         out_responses(new Responses),
         out_blob_data_handles(new BlobDataHandles) {}
 
   std::unique_ptr<ServiceWorkerFetchRequest> request;
   CacheStorageCacheQueryParams options;
   QueryCacheResultsCallback callback;
+  QueryCacheType query_type;
 
   std::unique_ptr<Requests> out_requests;
   std::unique_ptr<Responses> out_responses;
   std::unique_ptr<BlobDataHandles> out_blob_data_handles;
+  std::vector<disk_cache::ScopedEntryPtr> out_entries;
 
   std::unique_ptr<OpenAllEntriesContext> entries_context;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QueryCacheResults);
 };
 
 // static
 std::unique_ptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     const GURL& origin,
@@ skipping 26 matching lines @@
   cache->InitBackend();
   return base::WrapUnique(cache);
 }
 
 base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void CacheStorageCache::Match(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
+    const CacheStorageCacheQueryParams& match_params,
     const ResponseCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(std::move(request)),
+                 base::Passed(std::move(request)), match_params,
                  scheduler_->WrapCallbackToRunNext(callback)));
 }
 
 void CacheStorageCache::MatchAll(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
     const ResponsesCallback& callback) {
   if (backend_state_ == BACKEND_CLOSED) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
                  std::unique_ptr<BlobDataHandles>());
@@ skipping 259 matching lines @@
 
   rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void CacheStorageCache::QueryCache(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
+    QueryCacheType query_type,
     const QueryCacheResultsCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  std::unique_ptr<QueryCacheResults>());
     return;
   }
 
   if (!options.ignore_method && request && !request->method.empty() &&
       request->method != "GET") {
     callback.Run(CACHE_STORAGE_OK, base::MakeUnique<QueryCacheResults>(
                                        std::move(request), options, callback));
     return;
   }
 
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
   std::unique_ptr<QueryCacheResults> query_cache_results(
       new QueryCacheResults(std::move(request), options, callback));
+  query_cache_results->query_type = query_type;
+
+  if (query_cache_results->request &&
+      !query_cache_results->request->url.is_empty() && !options.ignore_search) {
+    // There is no need to scan the entire backend, just search for the exact
+    // URL.
+    std::unique_ptr<disk_cache::Entry*> entry =
+        base::MakeUnique<disk_cache::Entry*>();
+    disk_cache::Entry** entry_ptr = entry.get();
+
+    net::CompletionCallback open_entry_callback =
+        base::Bind(&CacheStorageCache::QueryCacheDidOpenEntry,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Passed(std::move(query_cache_results)),
+                   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);
+    return;
+  }
+
   OpenAllEntries(base::Bind(&CacheStorageCache::QueryCacheDidOpenAllEntries,
                             weak_ptr_factory_.GetWeakPtr(),
                             base::Passed(std::move(query_cache_results))));
 }
 
+void CacheStorageCache::QueryCacheDidOpenEntry(
+    std::unique_ptr<QueryCacheResults> query_cache_results,
+    std::unique_ptr<disk_cache::Entry*> entry,
+    int rv) {
+  if (rv != net::OK) {
+    QueryCacheResults* results = query_cache_results.get();
+    results->callback.Run(CACHE_STORAGE_OK, std::move(query_cache_results));
+    return;
+  }
+
+  std::unique_ptr<OpenAllEntriesContext> entries_context =
+      base::MakeUnique<OpenAllEntriesContext>();
+  entries_context->entries.push_back(*entry.get());
+  QueryCacheDidOpenAllEntries(std::move(query_cache_results),
+                              std::move(entries_context), CACHE_STORAGE_OK);
+}
+
 void CacheStorageCache::QueryCacheDidOpenAllEntries(
     std::unique_ptr<QueryCacheResults> query_cache_results,
     std::unique_ptr<OpenAllEntriesContext> entries_context,
     CacheStorageError error) {
   if (error != CACHE_STORAGE_OK) {
     query_cache_results->callback.Run(error,
                                       std::unique_ptr<QueryCacheResults>());
     return;
   }
 
@@ skipping 43 matching lines @@
   *iter = nullptr;
 
   if (!metadata) {
     entry->Doom();
     QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
     return;
   }
 
   ServiceWorkerFetchRequest request;
   PopulateRequestFromMetadata(*metadata, GURL(entry->GetKey()), &request);
-  query_cache_results->out_requests->push_back(request);
 
   ServiceWorkerResponse response;
   PopulateResponseMetadata(*metadata, &response);
 
+  if (query_cache_results->request &&
+      !query_cache_results->options.ignore_vary &&
+      !VaryMatches(query_cache_results->request->headers, request.headers,
+                   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;
+  }
+  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;
   }
 
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
       PopulateResponseBody(std::move(entry), &response);
 
   query_cache_results->out_responses->push_back(response);
   query_cache_results->out_blob_data_handles->push_back(*blob_data_handle);
   QueryCacheProcessNextEntry(std::move(query_cache_results), iter + 1);
 }
 
 void CacheStorageCache::MatchImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
+    const CacheStorageCacheQueryParams& match_params,
     const ResponseCallback& callback) {
-  DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
-  if (backend_state_ != BACKEND_OPEN) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::unique_ptr<ServiceWorkerResponse>(),
+  MatchAllImpl(std::move(request), match_params,
+               base::Bind(&CacheStorageCache::MatchDidMatchAll,
+                          weak_ptr_factory_.GetWeakPtr(), callback));
+}
+
+void CacheStorageCache::MatchDidMatchAll(
+    const ResponseCallback& callback,
+    CacheStorageError match_all_error,
+    std::unique_ptr<Responses> match_all_responses,
+    std::unique_ptr<BlobDataHandles> match_all_handles) {
+  if (match_all_error != CACHE_STORAGE_OK) {
+    callback.Run(match_all_error, std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  if (!request->method.empty() && request->method != "GET") {
+  if (match_all_responses->empty()) {
     callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
-  std::unique_ptr<disk_cache::Entry*> scoped_entry_ptr(
-      new disk_cache::Entry*());
-  disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
-  ServiceWorkerFetchRequest* request_ptr = request.get();
+  std::unique_ptr<ServiceWorkerResponse> response =
+      base::MakeUnique<ServiceWorkerResponse>(match_all_responses->at(0));
 
-  net::CompletionCallback open_entry_callback = base::Bind(
-      &CacheStorageCache::MatchDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(request)), callback,
-      base::Passed(std::move(scoped_entry_ptr)));
-
-  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::MatchDidOpenEntry(
-    std::unique_ptr<ServiceWorkerFetchRequest> request,
-    const ResponseCallback& callback,
-    std::unique_ptr<disk_cache::Entry*> entry_ptr,
-    int rv) {
-  if (rv != net::OK) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
-    return;
-  }
-  disk_cache::ScopedEntryPtr entry(*entry_ptr);
-
-  MetadataCallback headers_callback = base::Bind(
-      &CacheStorageCache::MatchDidReadMetadata, weak_ptr_factory_.GetWeakPtr(),
-      base::Passed(std::move(request)), callback,
-      base::Passed(std::move(entry)));
-
-  ReadMetadata(*entry_ptr, headers_callback);
-}
-
-void CacheStorageCache::MatchDidReadMetadata(
-    std::unique_ptr<ServiceWorkerFetchRequest> request,
-    const ResponseCallback& callback,
-    disk_cache::ScopedEntryPtr entry,
-    std::unique_ptr<CacheMetadata> metadata) {
-  if (!metadata) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
-    return;
+  std::unique_ptr<storage::BlobDataHandle> data_handle;
+  if (response->blob_size > 0) {
+    // NOTE: This assumes that MatchAll returns the handles in the same order
+    // as the responses.
+    data_handle =
+        base::MakeUnique<storage::BlobDataHandle>(match_all_handles->at(0));
   }
 
-  std::unique_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse);
-  PopulateResponseMetadata(*metadata, response.get());
-
-  ServiceWorkerHeaderMap cached_request_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'));
-    cached_request_headers[header.name()] = header.value();
-  }
-
-  if (!VaryMatches(request->headers, cached_request_headers,
-                   response->headers)) {
-    callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
-    return;
-  }
-
-  if (entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    callback.Run(CACHE_STORAGE_OK, std::move(response),
-                 std::unique_ptr<storage::BlobDataHandle>());
-    return;
-  }
-
-  if (!blob_storage_context_) {
-    callback.Run(CACHE_STORAGE_ERROR_STORAGE,
-                 std::unique_ptr<ServiceWorkerResponse>(),
-                 std::unique_ptr<storage::BlobDataHandle>());
-    return;
-  }
-
-  std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
-      PopulateResponseBody(std::move(entry), response.get());
-  callback.Run(CACHE_STORAGE_OK, std::move(response),
-               std::move(blob_data_handle));
+  callback.Run(CACHE_STORAGE_OK, std::move(response), std::move(data_handle));
 }
 
 void CacheStorageCache::MatchAllImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
     const ResponsesCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE, std::unique_ptr<Responses>(),
                  std::unique_ptr<BlobDataHandles>());
     return;
   }
 
   QueryCache(std::move(request), options,
+             QueryCacheType::REQUESTS_AND_RESPONSES,
              base::Bind(&CacheStorageCache::MatchAllDidQueryCache,
                         weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
 void CacheStorageCache::MatchAllDidQueryCache(
     const ResponsesCallback& callback,
     CacheStorageError error,
     std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
     callback.Run(error, std::unique_ptr<Responses>(),
@@ skipping 170 matching lines @@
                  base::Passed(std::move(put_context))));
 }
 
 void CacheStorageCache::PutImpl(std::unique_ptr<PutContext> put_context) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  std::unique_ptr<ServiceWorkerFetchRequest> request_copy(
-      new ServiceWorkerFetchRequest(*put_context->request));
+  std::string key = put_context->request->url.spec();
 
-  DeleteImpl(std::move(request_copy), CacheStorageCacheQueryParams(),
-             base::Bind(&CacheStorageCache::PutDidDelete,
-                        weak_ptr_factory_.GetWeakPtr(),
-                        base::Passed(std::move(put_context))));
+  net::CompletionCallback callback = base::Bind(
+      &CacheStorageCache::PutDidDoomEntry, weak_ptr_factory_.GetWeakPtr(),
+      base::Passed(std::move(put_context)));
+
+  int rv = backend_->DoomEntry(key, callback);
+  if (rv != net::ERR_IO_PENDING)
+    callback.Run(rv);
 }
 
-void CacheStorageCache::PutDidDelete(std::unique_ptr<PutContext> put_context,
-                                     CacheStorageError delete_error) {
+void CacheStorageCache::PutDidDoomEntry(std::unique_ptr<PutContext> put_context,
+                                        int rv) {
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
+  // |rv| is ignored as doom entry can fail if the entry doesn't exist.
+
   std::unique_ptr<disk_cache::Entry*> scoped_entry_ptr(
       new disk_cache::Entry*());
   disk_cache::Entry** entry_ptr = scoped_entry_ptr.get();
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = backend_.get();
 
   net::CompletionCallback create_entry_callback = base::Bind(
       &CacheStorageCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(std::move(scoped_entry_ptr)),
       base::Passed(std::move(put_context)));
@@ skipping 180 matching lines @@
 void CacheStorageCache::DeleteImpl(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& match_params,
     const ErrorCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
 
-  if (match_params.ignore_search) {
-    OpenAllEntries(base::Bind(&CacheStorageCache::DeleteDidOpenAllEntries,
-                              weak_ptr_factory_.GetWeakPtr(),
-                              base::Passed(std::move(request)), callback));
-    return;
-  }
-
-  std::unique_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::DeleteDidOpenEntry, weak_ptr_factory_.GetWeakPtr(),
-      origin_, 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);
+  QueryCache(std::move(request), match_params, QueryCacheType::CACHE_ENTRIES,
+             base::Bind(&CacheStorageCache::DeleteDidQueryCache,
+                        weak_ptr_factory_.GetWeakPtr(), callback));
 }
 
-void CacheStorageCache::DeleteDidOpenAllEntries(
-    std::unique_ptr<ServiceWorkerFetchRequest> request,
+void CacheStorageCache::DeleteDidQueryCache(
     const ErrorCallback& callback,
-    std::unique_ptr<OpenAllEntriesContext> entries_context,
-    CacheStorageError error) {
+    CacheStorageError error,
+    std::unique_ptr<QueryCacheResults> query_cache_results) {
   if (error != CACHE_STORAGE_OK) {
     callback.Run(error);
     return;
   }
 
-  GURL request_url_without_query = RemoveQueryParam(request->url);
-  for (Entries::iterator iter = entries_context->entries.begin();
-       iter != entries_context->entries.end(); iter++) {
-    disk_cache::Entry* entry(*iter);
-    if (request_url_without_query == RemoveQueryParam(GURL(entry->GetKey())))
-      entry->Doom();
-  }
-
-  entries_context.reset();
-
-  UpdateCacheSize();
-  callback.Run(CACHE_STORAGE_OK);
-}
-
-void CacheStorageCache::DeleteDidOpenEntry(
-    const GURL& origin,
-    std::unique_ptr<ServiceWorkerFetchRequest> request,
-    const CacheStorageCache::ErrorCallback& callback,
-    std::unique_ptr<disk_cache::Entry*> entry_ptr,
-    int rv) {
-  if (rv != net::OK) {
+  if (query_cache_results->out_entries.empty()) {
     callback.Run(CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
-  DCHECK(entry_ptr);
-  disk_cache::ScopedEntryPtr entry(*entry_ptr);
-
-  entry->Doom();
-  entry.reset();
+  for (auto& entry : query_cache_results->out_entries) {
+    entry->Doom();
+    entry.reset();
+  }
 
   UpdateCacheSize();
   callback.Run(CACHE_STORAGE_OK);
 }
 
 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,
              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