[CacheStorage] Use QueryCache everywhere

content/browser/cache_storage/cache_storage_cache_unittest.cc

Index: content/browser/cache_storage/cache_storage_cache_unittest.cc
diff --git a/content/browser/cache_storage/cache_storage_cache_unittest.cc b/content/browser/cache_storage/cache_storage_cache_unittest.cc
index 1de9c9eeecac1116cabdd1e2ee760e190db83f89..544be9379b43412d03e69c3937ef75225af17e87 100644
--- a/content/browser/cache_storage/cache_storage_cache_unittest.cc
+++ b/content/browser/cache_storage/cache_storage_cache_unittest.cc
@@ -63,7 +63,7 @@ std::unique_ptr<storage::BlobProtocolHandler> CreateMockBlobProtocolHandler(
 class DelayableBackend : public disk_cache::Backend {
  public:
   DelayableBackend(std::unique_ptr<disk_cache::Backend> backend)
-      : backend_(std::move(backend)), delay_open_(false) {}
+      : backend_(std::move(backend)), delay_doom_(false) {}
 
   // disk_cache::Backend overrides
   net::CacheType GetCacheType() const override {
@@ -73,15 +73,9 @@ class DelayableBackend : public disk_cache::Backend {
   int OpenEntry(const std::string& key,
                 disk_cache::Entry** entry,
                 const CompletionCallback& callback) override {
-    if (delay_open_) {
-      open_entry_callback_ =
-          base::Bind(&DelayableBackend::OpenEntryDelayedImpl,
-                     base::Unretained(this), key, entry, callback);
-      return net::ERR_IO_PENDING;
-    }
-
     return backend_->OpenEntry(key, entry, callback);
   }
+
   int CreateEntry(const std::string& key,
                   disk_cache::Entry** entry,
                   const CompletionCallback& callback) override {
@@ -89,6 +83,12 @@ class DelayableBackend : public disk_cache::Backend {
   }
   int DoomEntry(const std::string& key,
                 const CompletionCallback& callback) override {
+    if (delay_doom_) {
+      doom_entry_callback_ = base::Bind(&DelayableBackend::DoomEntryDelayedImpl,
+                                        base::Unretained(this), key, callback);
+      return net::ERR_IO_PENDING;
+    }
+
     return backend_->DoomEntry(key, callback);
   }
   int DoomAllEntries(const CompletionCallback& callback) override {
@@ -117,26 +117,25 @@ class DelayableBackend : public disk_cache::Backend {
     return backend_->OnExternalCacheHit(key);
   }
 
-  // Call to continue a delayed open.
-  void OpenEntryContinue() {
-    EXPECT_FALSE(open_entry_callback_.is_null());
-    open_entry_callback_.Run();
+  // Call to continue a delayed doom.
+  void DoomEntryContinue() {
+    EXPECT_FALSE(doom_entry_callback_.is_null());
+    doom_entry_callback_.Run();
   }
 
-  void set_delay_open(bool value) { delay_open_ = value; }
+  void set_delay_doom(bool value) { delay_doom_ = value; }
 
  private:
-  void OpenEntryDelayedImpl(const std::string& key,
-                            disk_cache::Entry** entry,
+  void DoomEntryDelayedImpl(const std::string& key,
                             const CompletionCallback& callback) {
-    int rv = backend_->OpenEntry(key, entry, callback);
+    int rv = backend_->DoomEntry(key, callback);
     if (rv != net::ERR_IO_PENDING)
       callback.Run(rv);
   }
 
   std::unique_ptr<disk_cache::Backend> backend_;
-  bool delay_open_;
-  base::Closure open_entry_callback_;
+  bool delay_doom_;
+  base::Closure doom_entry_callback_;
 };
 
 void CopyBody(const storage::BlobDataHandle& blob_handle, std::string* output) {
@@ -460,11 +459,13 @@ class CacheStorageCacheTest : public testing::Test {
     return error == CACHE_STORAGE_OK;
   }
 
-  bool Match(const ServiceWorkerFetchRequest& request) {
+  bool Match(const ServiceWorkerFetchRequest& request,
+             const CacheStorageCacheQueryParams& match_params =
+                 CacheStorageCacheQueryParams()) {
     std::unique_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Match(
-        CopyFetchRequest(request),
+        CopyFetchRequest(request), match_params,
         base::Bind(&CacheStorageCacheTest::ResponseAndErrorCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
@@ -927,6 +928,155 @@ TEST_P(CacheStorageCacheTestP, MatchAll_TwoResponsesThenOne) {
   EXPECT_TRUE(body_handles->empty());
 }
 
+TEST_P(CacheStorageCacheTestP, Match_IgnoreSearch) {
+  EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
+
+  EXPECT_FALSE(Match(body_request_));
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_search = true;
+  EXPECT_TRUE(Match(body_request_, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, Match_IgnoreMethod) {
+  EXPECT_TRUE(Put(body_request_, body_response_));
+
+  ServiceWorkerFetchRequest post_request = body_request_;
+  post_request.method = "POST";
+  EXPECT_FALSE(Match(post_request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_method = true;
+  EXPECT_TRUE(Match(post_request, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, Match_IgnoreVary) {
+  body_request_.headers["vary_foo"] = "foo";
+  body_response_.headers["vary"] = "vary_foo";
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(Match(body_request_));
+
+  body_request_.headers["vary_foo"] = "bar";
+  EXPECT_FALSE(Match(body_request_));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(Match(body_request_, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, Keys_IgnoreSearch) {
+  EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
+
+  EXPECT_TRUE(Keys(body_request_));
+  EXPECT_EQ(0u, callback_strings_.size());
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_search = true;
+  EXPECT_TRUE(Keys(body_request_, match_params));
+  EXPECT_EQ(1u, callback_strings_.size());
+}
+
+TEST_P(CacheStorageCacheTestP, Keys_IgnoreMethod) {
+  EXPECT_TRUE(Put(body_request_, body_response_));
+
+  ServiceWorkerFetchRequest post_request = body_request_;
+  post_request.method = "POST";
+  EXPECT_TRUE(Keys(post_request));
+  EXPECT_EQ(0u, callback_strings_.size());
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_method = true;
+  EXPECT_TRUE(Keys(post_request, match_params));
+  EXPECT_EQ(1u, callback_strings_.size());
+}
+
+TEST_P(CacheStorageCacheTestP, Keys_IgnoreVary) {
+  body_request_.headers["vary_foo"] = "foo";
+  body_response_.headers["vary"] = "vary_foo";
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(Keys(body_request_));
+  EXPECT_EQ(1u, callback_strings_.size());
+
+  body_request_.headers["vary_foo"] = "bar";
+  EXPECT_TRUE(Keys(body_request_));
+  EXPECT_EQ(0u, callback_strings_.size());
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(Keys(body_request_, match_params));
+  EXPECT_EQ(1u, callback_strings_.size());
+}
+
+TEST_P(CacheStorageCacheTestP, Delete_IgnoreSearch) {
+  EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
+
+  EXPECT_FALSE(Delete(body_request_));
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_search = true;
+  EXPECT_TRUE(Delete(body_request_, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, Delete_IgnoreMethod) {
+  EXPECT_TRUE(Put(body_request_, body_response_));
+
+  ServiceWorkerFetchRequest post_request = body_request_;
+  post_request.method = "POST";
+  EXPECT_FALSE(Delete(post_request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_method = true;
+  EXPECT_TRUE(Delete(post_request, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, Delete_IgnoreVary) {
+  body_request_.headers["vary_foo"] = "foo";
+  body_response_.headers["vary"] = "vary_foo";
+  EXPECT_TRUE(Put(body_request_, body_response_));
+
+  body_request_.headers["vary_foo"] = "bar";
+  EXPECT_FALSE(Delete(body_request_));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(Delete(body_request_, match_params));
+}
+
+TEST_P(CacheStorageCacheTestP, MatchAll_IgnoreMethod) {
+  EXPECT_TRUE(Put(body_request_, body_response_));
+
+  ServiceWorkerFetchRequest post_request = body_request_;
+  post_request.method = "POST";
+  std::unique_ptr<CacheStorageCache::Responses> responses;
+  std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
+  CacheStorageCacheQueryParams match_params;
+
+  EXPECT_TRUE(MatchAll(post_request, match_params, &responses, &body_handles));
+  EXPECT_EQ(0u, responses->size());
+
+  match_params.ignore_method = true;
+  EXPECT_TRUE(MatchAll(post_request, match_params, &responses, &body_handles));
+  EXPECT_EQ(1u, responses->size());
+}
+
+TEST_P(CacheStorageCacheTestP, MatchAll_IgnoreVary) {
+  body_request_.headers["vary_foo"] = "foo";
+  body_response_.headers["vary"] = "vary_foo";
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  std::unique_ptr<CacheStorageCache::Responses> responses;
+  std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
+  CacheStorageCacheQueryParams match_params;
+
+  EXPECT_TRUE(MatchAll(body_request_, match_params, &responses, &body_handles));
+  EXPECT_EQ(1u, responses->size());
+  body_request_.headers["vary_foo"] = "bar";
+
+  EXPECT_TRUE(MatchAll(body_request_, match_params, &responses, &body_handles));
+  EXPECT_EQ(0u, responses->size());
+
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(MatchAll(body_request_, match_params, &responses, &body_handles));
+  EXPECT_EQ(1u, responses->size());
+}
+
 TEST_P(CacheStorageCacheTestP, MatchAll_IgnoreSearch) {
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Put(body_request_with_query_, body_response_with_query_));
@@ -1404,7 +1554,7 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   // second should wait for the first.
   EXPECT_TRUE(Keys());  // Opens the backend.
   DelayableBackend* delayable_backend = cache_->UseDelayableBackend();
-  delayable_backend->set_delay_open(true);
+  delayable_backend->set_delay_doom(true);
 
   int sequence_out = -1;
 
@@ -1419,7 +1569,7 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
       base::Bind(&CacheStorageCacheTest::SequenceCallback,
                  base::Unretained(this), 1, &sequence_out, close_loop1.get()));
 
-  // Blocks on opening the cache entry.
+  // Blocks on creating the cache entry.
   base::RunLoop().RunUntilIdle();
 
   CacheStorageBatchOperation operation2;
@@ -1427,7 +1577,7 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   operation2.request = body_request_;
   operation2.response = body_response_;
 
-  delayable_backend->set_delay_open(false);
+  delayable_backend->set_delay_doom(false);
   std::unique_ptr<base::RunLoop> close_loop2(new base::RunLoop());
   cache_->BatchOperation(
       std::vector<CacheStorageBatchOperation>(1, operation2),
@@ -1438,7 +1588,7 @@ TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_response_);
 
-  delayable_backend->OpenEntryContinue();
+  delayable_backend->DoomEntryContinue();
   close_loop1->Run();
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();