[CacheStorage] Use QueryCache everywhere

content/browser/cache_storage/cache_storage_manager_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_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 187 matching lines @@
     cache_manager_->EnumerateCaches(
         origin, base::Bind(&CacheStorageManagerTest::StringsAndErrorCallback,
                            base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool StorageMatch(const GURL& origin,
                     const std::string& cache_name,
-                    const GURL& url) {
-    std::unique_ptr<ServiceWorkerFetchRequest> request(
-        new ServiceWorkerFetchRequest());
-    request->url = url;
+                    const GURL& url,
+                    const CacheStorageCacheQueryParams& match_params =
+                        CacheStorageCacheQueryParams()) {
+    ServiceWorkerFetchRequest request;
+    request.url = url;
+    return StorageMatchWithRequest(origin, cache_name, request, match_params);
+  }
+
+  bool StorageMatchWithRequest(
+      const GURL& origin,
+      const std::string& cache_name,
+      const ServiceWorkerFetchRequest& request,
+      const CacheStorageCacheQueryParams& match_params =
+          CacheStorageCacheQueryParams()) {
+    std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
+        base::MakeUnique<ServiceWorkerFetchRequest>(request);
+
     base::RunLoop loop;
     cache_manager_->MatchCache(
-        origin, cache_name, std::move(request),
+        origin, cache_name, std::move(unique_request), match_params,
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
-  bool StorageMatchAll(const GURL& origin, const GURL& url) {
-    std::unique_ptr<ServiceWorkerFetchRequest> request(
-        new ServiceWorkerFetchRequest());
-    request->url = url;
+  bool StorageMatchAll(const GURL& origin,
+                       const GURL& url,
+                       const CacheStorageCacheQueryParams& match_params =
+                           CacheStorageCacheQueryParams()) {
+    ServiceWorkerFetchRequest request;
+    request.url = url;
+    return StorageMatchAllWithRequest(origin, request, match_params);
+  }
+
+  bool StorageMatchAllWithRequest(
+      const GURL& origin,
+      const ServiceWorkerFetchRequest& request,
+      const CacheStorageCacheQueryParams& match_params =
+          CacheStorageCacheQueryParams()) {
+    std::unique_ptr<ServiceWorkerFetchRequest> unique_request =
+        base::MakeUnique<ServiceWorkerFetchRequest>(request);
     base::RunLoop loop;
     cache_manager_->MatchAllCaches(
-        origin, std::move(request),
+        origin, std::move(unique_request), match_params,
         base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
+

[nhiroki, 2016/08/18 00:05:43]

blank line

[jkarlin, 2016/08/18 14:08:23]

Done.

   }
 
   bool CachePut(CacheStorageCache* cache, const GURL& url) {
-    return CachePutWithStatusCode(cache, url, 200);
+    ServiceWorkerFetchRequest request;
+    request.url = url;
+
+    return CachePutWithStatusCode(cache, request, 200);
+  }
+
+  bool CachePutWithRequestAndHeaders(
+      CacheStorageCache* cache,
+      const ServiceWorkerFetchRequest& request,
+      const ServiceWorkerHeaderMap& response_headers) {
+    return CachePutWithStatusCode(cache, request, 200, response_headers);
   }
 
   bool CachePutWithStatusCode(CacheStorageCache* cache,
-                              const GURL& url,
-                              int status_code) {
-    ServiceWorkerFetchRequest request;
-    request.url = url;
-
+                              const ServiceWorkerFetchRequest& request,
+                              int status_code,
+                              const ServiceWorkerHeaderMap& response_headers =
+                                  ServiceWorkerHeaderMap()) {
     std::unique_ptr<storage::BlobDataBuilder> blob_data(
         new storage::BlobDataBuilder(base::GenerateGUID()));
-    blob_data->AppendData(url.spec());
+    blob_data->AppendData(request.url.spec());
 
     std::unique_ptr<storage::BlobDataHandle> blob_handle =
         blob_storage_context_->AddFinishedBlob(blob_data.get());
     ServiceWorkerResponse response(
-        url, status_code, "OK", blink::WebServiceWorkerResponseTypeDefault,
-        ServiceWorkerHeaderMap(), blob_handle->uuid(), url.spec().size(),
-        GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+        request.url, status_code, "OK",
+        blink::WebServiceWorkerResponseTypeDefault, response_headers,
+        blob_handle->uuid(), request.url.spec().size(), GURL(),
+        blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
         false /* is_in_cache_storage */,
         std::string() /* cache_storage_cache_name */,
         ServiceWorkerHeaderList() /* cors_exposed_header_names */);
 
     CacheStorageBatchOperation operation;
     operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
     operation.request = request;
     operation.response = response;
 
     base::RunLoop loop;
     cache->BatchOperation(
         std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageManagerTest::CachePutCallback,
                    base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   bool CacheMatch(CacheStorageCache* cache, const GURL& url) {
     std::unique_ptr<ServiceWorkerFetchRequest> request(
         new ServiceWorkerFetchRequest());
     request->url = url;
     base::RunLoop loop;
-    cache->Match(std::move(request),
+    cache->Match(std::move(request), CacheStorageCacheQueryParams(),
                  base::Bind(&CacheStorageManagerTest::CacheMatchCallback,
                             base::Unretained(this), base::Unretained(&loop)));
     loop.Run();
 
     return callback_error_ == CACHE_STORAGE_OK;
   }
 
   CacheStorage* CacheStorageForOrigin(const GURL& origin) {
     return cache_manager_->FindOrCreateCacheStorage(origin);
   }
@@ skipping 301 matching lines @@
 
   // Do some busy work on a different cache to move the cache pool threads
   // along and trigger the bug.
   EXPECT_TRUE(Open(origin1_, "bar"));
   EXPECT_TRUE(CachePut(callback_cache_handle_->value(), kTestURL));
   EXPECT_TRUE(CacheMatch(callback_cache_handle_->value(), kTestURL));
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchAllEntryExistsTwice) {
   EXPECT_TRUE(Open(origin1_, "foo"));
-  EXPECT_TRUE(CachePutWithStatusCode(callback_cache_handle_->value(),
-                                     GURL("http://example.com/foo"), 200));
+  ServiceWorkerFetchRequest request;
+  request.url = GURL("http://example.com/foo");
+  EXPECT_TRUE(
+      CachePutWithStatusCode(callback_cache_handle_->value(), request, 200));
   EXPECT_TRUE(Open(origin1_, "bar"));
-  EXPECT_TRUE(CachePutWithStatusCode(callback_cache_handle_->value(),
-                                     GURL("http://example.com/foo"), 201));
+  EXPECT_TRUE(
+      CachePutWithStatusCode(callback_cache_handle_->value(), request, 201));
 
   EXPECT_TRUE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
 
   // The caches need to be searched in order of creation, so verify that the
   // response came from the first cache.
   EXPECT_EQ(200, callback_cache_handle_response_->status_code);
 }
 
 TEST_P(CacheStorageManagerTestP, StorageMatchInOneOfMany) {
   EXPECT_TRUE(Open(origin1_, "foo"));
@@ skipping 305 matching lines @@
   EXPECT_EQ(0, quota_manager_proxy_->notify_storage_accessed_count());
 }
 
 TEST_P(CacheStorageManagerTestP, SizeThenCloseStorageAccessed) {
   EXPECT_EQ(0, GetSizeThenCloseAllCaches(origin1_));
   // GetSizeThenCloseAllCaches is not part of the web API and should not notify
   // the quota manager of an access.
   EXPECT_EQ(0, quota_manager_proxy_->notify_storage_accessed_count());
 }
 
+TEST_P(CacheStorageManagerTestP, StorageMatch_IgnoreSearch) {
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_handle_->value(),
+                       GURL("http://example.com/foo?bar")));
+
+  EXPECT_FALSE(StorageMatch(origin1_, "foo", GURL("http://example.com/foo")));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_search = true;
+  EXPECT_TRUE(StorageMatch(origin1_, "foo", GURL("http://example.com/foo"),
+                           match_params));
+}
+
+TEST_P(CacheStorageManagerTestP, StorageMatch_IgnoreMethod) {
+  GURL url = GURL("http://example.com/foo");
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_handle_->value(), url));
+
+  ServiceWorkerFetchRequest post_request;
+  post_request.url = url;
+  post_request.method = "POST";
+  EXPECT_FALSE(StorageMatchWithRequest(origin1_, "foo", post_request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_method = true;
+  EXPECT_TRUE(
+      StorageMatchWithRequest(origin1_, "foo", post_request, match_params));
+}
+
+TEST_P(CacheStorageManagerTestP, StorageMatch_IgnoreVary) {
+  GURL url = GURL("http://example.com/foo");
+  EXPECT_TRUE(Open(origin1_, "foo"));
+
+  ServiceWorkerFetchRequest request;
+  request.url = url;
+  request.headers["vary_foo"] = "foo";
+
+  ServiceWorkerHeaderMap response_headers;
+  response_headers["vary"] = "vary_foo";
+
+  EXPECT_TRUE(CachePutWithRequestAndHeaders(callback_cache_handle_->value(),
+                                            request, response_headers));
+  EXPECT_TRUE(StorageMatchWithRequest(origin1_, "foo", request));
+
+  request.headers["vary_foo"] = "bar";
+  EXPECT_FALSE(StorageMatchWithRequest(origin1_, "foo", request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(StorageMatchWithRequest(origin1_, "foo", request, match_params));
+}
+
+TEST_P(CacheStorageManagerTestP, StorageMatchAll_IgnoreSearch) {
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_handle_->value(),
+                       GURL("http://example.com/foo?bar")));
+
+  EXPECT_FALSE(StorageMatchAll(origin1_, GURL("http://example.com/foo")));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_search = true;
+  EXPECT_TRUE(
+      StorageMatchAll(origin1_, GURL("http://example.com/foo"), match_params));
+}
+
+TEST_P(CacheStorageManagerTestP, StorageMatchAll_IgnoreMethod) {
+  GURL url = GURL("http://example.com/foo");
+  EXPECT_TRUE(Open(origin1_, "foo"));
+  EXPECT_TRUE(CachePut(callback_cache_handle_->value(), url));
+
+  ServiceWorkerFetchRequest post_request;
+  post_request.url = url;
+  post_request.method = "POST";
+  EXPECT_FALSE(StorageMatchAllWithRequest(origin1_, post_request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_method = true;
+  EXPECT_TRUE(StorageMatchAllWithRequest(origin1_, post_request, match_params));
+}
+
+TEST_P(CacheStorageManagerTestP, StorageMatchAll_IgnoreVary) {
+  GURL url = GURL("http://example.com/foo");
+  EXPECT_TRUE(Open(origin1_, "foo"));
+
+  ServiceWorkerFetchRequest request;
+  request.url = url;
+  request.headers["vary_foo"] = "foo";
+
+  ServiceWorkerHeaderMap response_headers;
+  response_headers["vary"] = "vary_foo";
+
+  EXPECT_TRUE(CachePutWithRequestAndHeaders(callback_cache_handle_->value(),
+                                            request, response_headers));
+  EXPECT_TRUE(StorageMatchAllWithRequest(origin1_, request));
+
+  request.headers["vary_foo"] = "bar";
+  EXPECT_FALSE(StorageMatchAllWithRequest(origin1_, request));
+
+  CacheStorageCacheQueryParams match_params;
+  match_params.ignore_vary = true;
+  EXPECT_TRUE(StorageMatchAllWithRequest(origin1_, request, match_params));
+}
+
 class CacheStorageMigrationTest : public CacheStorageManagerTest {
  protected:
   CacheStorageMigrationTest() : cache1_("foo"), cache2_("bar") {}
 
   void SetUp() override {
     CacheStorageManagerTest::SetUp();
 
     // Populate a cache, then move it to the "legacy" location
     // so that tests can verify the results of migration.
     legacy_path_ = CacheStorageManager::ConstructLegacyOriginPath(
@@ skipping 357 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(CacheStorageManagerTests,
                         CacheStorageManagerTestP,
                         ::testing::Values(false, true));
 
 INSTANTIATE_TEST_CASE_P(CacheStorageQuotaClientTests,
                         CacheStorageQuotaClientTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content