Cache API should not match() HEAD requests

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 578 matching lines @@
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCacheQueryParams& options,
     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;
+  }
+
   std::unique_ptr<QueryCacheResults> query_cache_results(
       new QueryCacheResults(std::move(request), options, callback));
   OpenAllEntries(base::Bind(&CacheStorageCache::QueryCacheDidOpenAllEntries,
                             weak_ptr_factory_.GetWeakPtr(),
                             base::Passed(std::move(query_cache_results))));
 }
 
 void CacheStorageCache::QueryCacheDidOpenAllEntries(
     std::unique_ptr<QueryCacheResults> query_cache_results,
     std::unique_ptr<OpenAllEntriesContext> entries_context,
@@ skipping 86 matching lines @@
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback) {
   DCHECK_NE(BACKEND_UNINITIALIZED, backend_state_);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(CACHE_STORAGE_ERROR_STORAGE,
                  std::unique_ptr<ServiceWorkerResponse>(),
                  std::unique_ptr<storage::BlobDataHandle>());
     return;
   }
 
+  if (!request->method.empty() && request->method != "GET") {
+    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();
 
   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)));
 
@@ skipping 750 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