[CacheStorage] Use QueryCache everywhere

content/browser/cache_storage/cache_storage_cache_unittest.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 <stdint.h>
 
 #include <memory>
@@ skipping 45 matching lines @@
   // The FileSystemContext and thread task runner are not actually used but a
   // task runner is needed to avoid a DCHECK in BlobURLRequestJob ctor.
   return base::WrapUnique(new storage::BlobProtocolHandler(
       blob_storage_context, NULL, base::ThreadTaskRunnerHandle::Get().get()));
 }
 
 // A disk_cache::Backend wrapper that can delay operations.
 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 {
     return backend_->GetCacheType();
   }
   int32_t GetEntryCount() const override { return backend_->GetEntryCount(); }
   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 {
     return backend_->CreateEntry(key, entry, callback);
   }
   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 {
     return backend_->DoomAllEntries(callback);
   }
   int DoomEntriesBetween(base::Time initial_time,
                          base::Time end_time,
                          const CompletionCallback& callback) override {
     return backend_->DoomEntriesBetween(initial_time, end_time, callback);
   }
   int DoomEntriesSince(base::Time initial_time,
                        const CompletionCallback& callback) override {
     return backend_->DoomEntriesSince(initial_time, callback);
   }
   int CalculateSizeOfAllEntries(
       const CompletionCallback& callback) override {
     return backend_->CalculateSizeOfAllEntries(callback);
   }
   std::unique_ptr<Iterator> CreateIterator() override {
     return backend_->CreateIterator();
   }
   void GetStats(base::StringPairs* stats) override {
     return backend_->GetStats(stats);
   }
   void OnExternalCacheHit(const std::string& key) override {
     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) {
   *output = std::string();
   std::unique_ptr<storage::BlobDataSnapshot> data =
       blob_handle.CreateSnapshot();
   const auto& items = data->items();
   for (const auto& item : items) {
     switch (item->type()) {
       case storage::DataElement::TYPE_BYTES: {
@@ skipping 303 matching lines @@
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     CacheStorageError error =
         BatchOperation(std::vector<CacheStorageBatchOperation>(1, operation));
     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();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool MatchAll(
       const ServiceWorkerFetchRequest& request,
       const CacheStorageCacheQueryParams& match_params,
@@ skipping 442 matching lines @@
 
   EXPECT_TRUE(Delete(body_request_));
   EXPECT_TRUE(MatchAll(&responses, &body_handles));
 
   ASSERT_EQ(1u, responses->size());
   EXPECT_TRUE(
       ResponseMetadataEqual(SetCacheName(no_body_response_), responses->at(0)));
   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_));
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
 
   std::unique_ptr<CacheStorageCache::Responses> responses;
   std::unique_ptr<CacheStorageCache::BlobDataHandles> body_handles;
   CacheStorageCacheQueryParams match_params;
   match_params.ignore_search = true;
   EXPECT_TRUE(MatchAll(body_request_, match_params, &responses, &body_handles));
@@ skipping 457 matching lines @@
   EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Close());
   VerifyAllOpsFail();
 }
 
 TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   // Start two operations, the first one is delayed but the second isn't. The
   // 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;
 
   CacheStorageBatchOperation operation1;
   operation1.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   operation1.request = body_request_;
   operation1.response = body_response_;
 
   std::unique_ptr<base::RunLoop> close_loop1(new base::RunLoop());
   cache_->BatchOperation(
       std::vector<CacheStorageBatchOperation>(1, operation1),
       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;
   operation2.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
   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),
       base::Bind(&CacheStorageCacheTest::SequenceCallback,
                  base::Unretained(this), 2, &sequence_out, close_loop2.get()));
 
   // The second put operation should wait for the first to complete.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_response_);
 
-  delayable_backend->OpenEntryContinue();
+  delayable_backend->DoomEntryContinue();
   close_loop1->Run();
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content