Make NetworkCache aware of fetch cache mode
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 14 Oct 2016 08:47:16 +0000 (08:47 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 14 Oct 2016 08:47:16 +0000 (08:47 +0000)
https://bugs.webkit.org/show_bug.cgi?id=163332

Patch by Youenn Fablet <youenn@apple.com> on 2016-10-14
Reviewed by Antti Koivisto.

LayoutTests/imported/w3c:

Splitting web-platform-tests/fetch/api/request/request-cache.html in several files so that running the individual test files
is more manageable.

* web-platform-tests/fetch/api/request/request-cache-default-conditional-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-default-conditional.html: Added.
* web-platform-tests/fetch/api/request/request-cache-default-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-default.html: Added.
* web-platform-tests/fetch/api/request/request-cache-expected.txt: Removed.
* web-platform-tests/fetch/api/request/request-cache-force-cache-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-force-cache.html: Added.
* web-platform-tests/fetch/api/request/request-cache-no-cache-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-no-cache.html: Added.
* web-platform-tests/fetch/api/request/request-cache-no-store-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-no-store.html: Added.
* web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-only-if-cached.html: Added.
* web-platform-tests/fetch/api/request/request-cache-reload-expected.txt: Added.
* web-platform-tests/fetch/api/request/request-cache-reload.html: Added.
* web-platform-tests/fetch/api/request/request-cache.html: Removed.
* web-platform-tests/fetch/api/request/request-cache.js: Added.
(base_path):
(make_url):
(expected_status):
(expected_response_text):
(server_state):
(run_next_step):
(make_test):

Source/WebCore:

Tests: imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-default.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html
       imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html

* loader/cache/CachedResourceLoader.cpp:
(WebCore::updateRequestAccordingCacheMode): Setting request cache policy according cache mode.
Basically, these two are about the same.
(WebCore::CachedResourceLoader::determineRevalidationPolicy): Making use of cache policy instead of cache mode.
* platform/network/ResourceRequestBase.h: Adding new cache policies, aligned with fetch cache modes.
* platform/network/cf/ResourceRequestCFNet.cpp:
(WebCore::toPlatformRequestCachePolicy): If policy is not supported by CFNetwork, fallback to ReloadIgnoringCacheData.
This is the best approximate we might find.
(WebCore::ResourceRequest::doUpdatePlatformHTTPBody):
(WebCore::ResourceRequest::doUpdateResourceRequest): Only updating cache policy, if cache policy is the default.
* platform/network/cf/ResourceRequestCFNet.h:
* platform/network/cocoa/ResourceRequestCocoa.mm: Doing the same modifications as for ResourceRequestCFNet.
(WebCore::ResourceRequest::doUpdateResourceRequest):
(WebCore::toPlatformRequestCachePolicy):
(WebCore::ResourceRequest::doUpdatePlatformRequest):

Source/WebKit2:

Adding explicit serialization of ResourceRequest cachePolicy since it does no longer map to platform request cache policy.

Added support for:
- Bypassing entirely the network cache in case cache mode is NoStore.
- requiring revalidation in case of cache hit and cache mode is NoCache.
- Not using any entry if cache mode is Reload (but cache can still be updated)

Also made sure that the ResourceRequest::cachePolicy remains the same throughout redirections.

* NetworkProcess/NetworkResourceLoader.cpp:
(WebKit::NetworkResourceLoader::canUseCache):
(WebKit::NetworkResourceLoader::retrieveCacheEntry):
(WebKit::NetworkResourceLoader::continueWillSendRequest):
* NetworkProcess/cache/NetworkCache.cpp:
(WebKit::NetworkCache::cachePolicyAllowsExpired):
(WebKit::NetworkCache::makeRetrieveDecision):
* Shared/mac/WebCoreArgumentCodersMac.mm:
(IPC::ArgumentCoder<ResourceRequest>::encodePlatformData):
(IPC::ArgumentCoder<ResourceRequest>::decodePlatformData):

LayoutTests:

* platform/ios-simulator/TestExpectations:
* platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt: Added.
* platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt: Added.
* platform/win/TestExpectations:
* platform/wk2/TestExpectations:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@207330 268f45cc-cd09-0410-ab3c-d52691b4dbfc

35 files changed:
LayoutTests/ChangeLog
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt [deleted file]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html [new file with mode: 0644]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [deleted file]
LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.js [new file with mode: 0644]
LayoutTests/platform/ios-simulator/TestExpectations
LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt [new file with mode: 0644]
LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt [new file with mode: 0644]
LayoutTests/platform/win/TestExpectations
LayoutTests/platform/wk2/TestExpectations
Source/WebCore/ChangeLog
Source/WebCore/loader/cache/CachedResourceLoader.cpp
Source/WebCore/loader/cache/CachedResourceRequest.cpp
Source/WebCore/platform/network/ResourceRequestBase.h
Source/WebCore/platform/network/cf/ResourceRequestCFNet.cpp
Source/WebCore/platform/network/cf/ResourceRequestCFNet.h
Source/WebCore/platform/network/cocoa/ResourceRequestCocoa.mm
Source/WebKit2/ChangeLog
Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp
Source/WebKit2/Shared/mac/WebCoreArgumentCodersMac.mm

index 8b06dd5..152c55b 100644 (file)
@@ -1,3 +1,16 @@
+2016-10-14  Youenn Fablet  <youenn@apple.com>
+
+        Make NetworkCache aware of fetch cache mode
+        https://bugs.webkit.org/show_bug.cgi?id=163332
+
+        Reviewed by Antti Koivisto.
+
+        * platform/ios-simulator/TestExpectations:
+        * platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt: Added.
+        * platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt: Added.
+        * platform/win/TestExpectations:
+        * platform/wk2/TestExpectations:
+
 2016-10-13  Joseph Pecoraro  <pecoraro@apple.com>
 
         Exception message for expressions with multiple bracket accesses is inconsistent / incorrect
index d97d780..fa2fa78 100644 (file)
@@ -1,3 +1,38 @@
+2016-10-14  Youenn Fablet  <youenn@apple.com>
+
+        Make NetworkCache aware of fetch cache mode
+        https://bugs.webkit.org/show_bug.cgi?id=163332
+
+        Reviewed by Antti Koivisto.
+
+        Splitting web-platform-tests/fetch/api/request/request-cache.html in several files so that running the individual test files
+        is more manageable.
+
+        * web-platform-tests/fetch/api/request/request-cache-default-conditional-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-default-conditional.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-default-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-default.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-expected.txt: Removed.
+        * web-platform-tests/fetch/api/request/request-cache-force-cache-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-force-cache.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-no-cache-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-no-cache.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-no-store-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-no-store.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-only-if-cached.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache-reload-expected.txt: Added.
+        * web-platform-tests/fetch/api/request/request-cache-reload.html: Added.
+        * web-platform-tests/fetch/api/request/request-cache.html: Removed.
+        * web-platform-tests/fetch/api/request/request-cache.js: Added.
+        (base_path):
+        (make_url):
+        (expected_status):
+        (expected_response_text):
+        (server_state):
+        (run_next_step):
+        (make_test):
+
 2016-10-13  Joseph Pecoraro  <pecoraro@apple.com>
 
         Exception message for expressions with multiple bracket accesses is inconsistent / incorrect
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional-expected.txt
new file mode 100644 (file)
index 0000000..55809df
--- /dev/null
@@ -0,0 +1,42 @@
+
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response 
+PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional.html
new file mode 100644 (file)
index 0000000..7b2a7bd
--- /dev/null
@@ -0,0 +1,180 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - default with conditional requests</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Modified-Since": now.toGMTString()}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Modified-Since": now.toGMTString()}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Modified-Since": now.toGMTString()}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Modified-Since": now.toGMTString()}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-None-Match": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-None-Match": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-None-Match": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-None-Match": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Unmodified-Since": now.toGMTString()}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Unmodified-Since": now.toGMTString()}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Unmodified-Since": now.toGMTString()}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Unmodified-Since": now.toGMTString()}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Match": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Match": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Match": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Match": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Range": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{}, {"If-Range": '"foo"'}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
+        state: "stale",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Range": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        request_headers: [{"If-Range": '"foo"'}, {}],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-expected.txt
new file mode 100644 (file)
index 0000000..e7044ec
--- /dev/null
@@ -0,0 +1,10 @@
+
+PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with Etag and stale response 
+PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with date and stale response 
+PASS RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with Etag and fresh response 
+PASS RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with date and fresh response 
+PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and stale response 
+PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and stale response 
+PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and fresh response 
+PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-default.html
new file mode 100644 (file)
index 0000000..c0e37b2
--- /dev/null
@@ -0,0 +1,50 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - default</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses',
+        state: "stale",
+        request_cache: ["default", "default"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists',
+        state: "fresh",
+        request_cache: ["default", "default"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+      {
+        name: 'Responses with the "Cache-Control: no-store" header are not stored in the cache',
+        state: "stale",
+        cache_control: "no-store",
+        request_cache: ["default", "default"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'Responses with the "Cache-Control: no-store" header are not stored in the cache',
+        state: "fresh",
+        cache_control: "no-store",
+        request_cache: ["default", "default"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt
deleted file mode 100644 (file)
index 5529cb0..0000000
+++ /dev/null
@@ -1,104 +0,0 @@
-
-PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with Etag and stale response 
-PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with date and stale response 
-PASS RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with Etag and fresh response 
-PASS RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists with date and fresh response 
-PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with Etag and stale response 
-PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with date and stale response 
-PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with Etag and fresh response 
-PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with date and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Etag and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with date and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with Etag and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with date and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with Etag and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with date and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with Etag and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with date and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with Etag and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with date and stale response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with Etag and fresh response 
-PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with date and fresh response 
-PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and stale response 
-PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and stale response 
-PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and fresh response 
-PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and fresh response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with Etag and fresh response 
-PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with date and fresh response 
-FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
-FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
-FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
-FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
-PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response 
-PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response 
-PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response 
-PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and stale response 
-PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
-PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
-PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
-PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
-PASS RequestCache "no-store" mode does not store the response in the cache with Etag and stale response 
-PASS RequestCache "no-store" mode does not store the response in the cache with date and stale response 
-PASS RequestCache "no-store" mode does not store the response in the cache with Etag and fresh response 
-PASS RequestCache "no-store" mode does not store the response in the cache with date and fresh response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response 
-PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response 
-PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and stale response 
-PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and stale response 
-PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and fresh response 
-PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and fresh response 
-PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
-PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
-PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
-PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
-PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response 
-PASS RequestCache "reload" mode does store the response in the cache with date and stale response 
-FAIL RequestCache "reload" mode does store the response in the cache with Etag and fresh response assert_equals: expected 1 but got 2
-FAIL RequestCache "reload" mode does store the response in the cache with date and fresh response assert_equals: expected 1 but got 2
-PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response 
-PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response 
-PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response 
-PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response 
-
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache-expected.txt
new file mode 100644 (file)
index 0000000..6b15812
--- /dev/null
@@ -0,0 +1,18 @@
+
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Etag and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with date and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with Etag and fresh response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with date and fresh response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with Etag and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with date and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with Etag and fresh response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found with date and fresh response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with Etag and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with date and stale response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with Etag and fresh response 
+PASS RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary with date and fresh response 
+PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and stale response 
+PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and stale response 
+PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and fresh response 
+PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache.html
new file mode 100644 (file)
index 0000000..ed45726
--- /dev/null
@@ -0,0 +1,78 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - force-cache</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses',
+        state: "stale",
+        request_cache: ["default", "force-cache"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses',
+        state: "fresh",
+        request_cache: ["default", "force-cache"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found',
+        state: "stale",
+        request_cache: ["force-cache"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found',
+        state: "fresh",
+        request_cache: ["force-cache"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary',
+        state: "stale",
+        vary: "*",
+        request_cache: ["default", "force-cache"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary',
+        state: "fresh",
+        vary: "*",
+        request_cache: ["default", "force-cache"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "force-cache" stores the response in the cache if it goes to the network',
+        state: "stale",
+        request_cache: ["force-cache", "default"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "force-cache" stores the response in the cache if it goes to the network',
+        state: "fresh",
+        request_cache: ["force-cache", "default"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache-expected.txt
new file mode 100644 (file)
index 0000000..551c455
--- /dev/null
@@ -0,0 +1,6 @@
+
+PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with Etag and stale response 
+PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with date and stale response 
+PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with Etag and fresh response 
+PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache.html
new file mode 100644 (file)
index 0000000..d30ed16
--- /dev/null
@@ -0,0 +1,36 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache : no-cache</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "no-cache" mode revalidates stale responses found in the cache',
+        state: "stale",
+        request_cache: ["default", "no-cache"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+        expected_max_age_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "no-cache" mode revalidates fresh responses found in the cache',
+        state: "fresh",
+        request_cache: ["default", "no-cache"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [false, false],
+        expected_max_age_headers: [false, true],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store-expected.txt
new file mode 100644 (file)
index 0000000..96eb722
--- /dev/null
@@ -0,0 +1,10 @@
+
+PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
+PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
+PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
+PASS RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
+PASS RequestCache "no-store" mode does not store the response in the cache with Etag and stale response 
+PASS RequestCache "no-store" mode does not store the response in the cache with date and stale response 
+PASS RequestCache "no-store" mode does not store the response in the cache with Etag and fresh response 
+PASS RequestCache "no-store" mode does not store the response in the cache with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store.html
new file mode 100644 (file)
index 0000000..396b6a6
--- /dev/null
@@ -0,0 +1,48 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - no store</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless',
+        state: "stale",
+        request_cache: ["default", "no-store"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless',
+        state: "fresh",
+        request_cache: ["default", "no-store"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "no-store" mode does not store the response in the cache',
+        state: "stale",
+        request_cache: ["no-store", "default"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "no-store" mode does not store the response in the cache',
+        state: "fresh",
+        request_cache: ["no-store", "default"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [true, false],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt
new file mode 100644 (file)
index 0000000..379b457
--- /dev/null
@@ -0,0 +1,24 @@
+CONSOLE MESSAGE: Unsafe attempt to load URL http://127.0.0.1:8800/fetch/api/request/resources/cache.py?token=2ea4f431-f8b9-4e0e-b2ab-5c8c14d9fddd&content=0.38709557547171725&tag=0.479555361588907&expires=Tue,%2003%20Oct%202017%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache-only-if-cached.html. Domains, protocols and ports must match.
+
+CONSOLE MESSAGE: Unsafe attempt to load URL http://127.0.0.1:8800/fetch/api/request/resources/cache.py?token=d8c7da3d-d121-44ce-9de7-cfee3b6a3737&content=0.797971561144814&date=Thu,%2013%20Oct%202016%2009:15:42%20GMT&expires=Tue,%2003%20Oct%202017%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache-only-if-cached.html. Domains, protocols and ports must match.
+
+CONSOLE MESSAGE: Unsafe attempt to load URL http://127.0.0.1:8800/fetch/api/request/resources/cache.py?token=40ec0908-6ae7-44cf-b2ed-9eb5620a6f7c&content=0.4833112948629348&tag=0.9322512369284536&expires=Sat,%2003%20Oct%202015%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache-only-if-cached.html. Domains, protocols and ports must match.
+
+CONSOLE MESSAGE: Unsafe attempt to load URL http://127.0.0.1:8800/fetch/api/request/resources/cache.py?token=90f850f5-f936-4654-abdc-4568f11f59a3&content=0.030517910813487314&date=Thu,%2013%20Oct%202016%2009:15:42%20GMT&expires=Sat,%2003%20Oct%202015%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache-only-if-cached.html. Domains, protocols and ports must match.
+
+
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with Etag and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with date and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and stale response 
+PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and stale response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and stale response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html
new file mode 100644 (file)
index 0000000..adb31a3
--- /dev/null
@@ -0,0 +1,76 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - only-if-cached</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses',
+        state: "stale",
+        request_cache: ["default", "only-if-cached"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false]
+      },
+      {
+        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses',
+        state: "fresh",
+        request_cache: ["default", "only-if-cached"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [false]
+      },
+      {
+        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found',
+        state: "fresh",
+        request_cache: ["only-if-cached"],
+        response: ["error"],
+        expected_validation_headers: [],
+        expected_no_cache_headers: []
+      },
+      {
+        name: 'RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content',
+        state: "fresh",
+        request_cache: ["default", "only-if-cached"],
+        redirect: "same-origin",
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content',
+        state: "stale",
+        request_cache: ["default", "only-if-cached"],
+        redirect: "same-origin",
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects',
+        state: "fresh",
+        request_cache: ["default", "only-if-cached"],
+        redirect: "cross-origin",
+        response: [null, "error"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+      {
+        name: 'RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects',
+        state: "stale",
+        request_cache: ["default", "only-if-cached"],
+        redirect: "cross-origin",
+        response: [null, "error"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, false],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt
new file mode 100644 (file)
index 0000000..1d02257
--- /dev/null
@@ -0,0 +1,14 @@
+
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response 
+PASS RequestCache "reload" mode does store the response in the cache with date and stale response 
+PASS RequestCache "reload" mode does store the response in the cache with Etag and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache with date and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response 
+
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html
new file mode 100644 (file)
index 0000000..45ff583
--- /dev/null
@@ -0,0 +1,62 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Request cache - reload</title>
+    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
+    <script src="/resources/testharness.js"></script>
+    <script src="/resources/testharnessreport.js"></script>
+    <script src="/common/utils.js"></script>
+    <script src="/common/get-host-info.sub.js"></script>
+    <script src="request-cache.js"></script>
+  </head>
+  <body>
+    <script>
+    var tests = [
+      {
+        name: 'RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless',
+        state: "stale",
+        request_cache: ["default", "reload"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless',
+        state: "fresh",
+        request_cache: ["default", "reload"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+      {
+        name: 'RequestCache "reload" mode does store the response in the cache',
+        state: "stale",
+        request_cache: ["reload", "default"],
+        expected_validation_headers: [false, true],
+        expected_no_cache_headers: [true, false],
+      },
+      {
+        name: 'RequestCache "reload" mode does store the response in the cache',
+        state: "fresh",
+        request_cache: ["reload", "default"],
+        expected_validation_headers: [false],
+        expected_no_cache_headers: [true],
+      },
+      {
+        name: 'RequestCache "reload" mode does store the response in the cache even if a previous response is already stored',
+        state: "stale",
+        request_cache: ["default", "reload", "default"],
+        expected_validation_headers: [false, false, true],
+        expected_no_cache_headers: [false, true, false],
+      },
+      {
+        name: 'RequestCache "reload" mode does store the response in the cache even if a previous response is already stored',
+        state: "fresh",
+        request_cache: ["default", "reload", "default"],
+        expected_validation_headers: [false, false],
+        expected_no_cache_headers: [false, true],
+      },
+    ];
+    run_tests(tests);
+    </script>
+  </body>
+</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.html
deleted file mode 100644 (file)
index f2c442a..0000000
+++ /dev/null
@@ -1,626 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>Request cache</title>
-    <meta name="help" href="https://fetch.spec.whatwg.org/#request">
-    <meta name="timeout" content="long">
-    <script src="/resources/testharness.js"></script>
-    <script src="/resources/testharnessreport.js"></script>
-    <script src="/common/utils.js"></script>
-    <script src="/common/get-host-info.sub.js"></script>
-  </head>
-  <body>
-    <script>
-    var now = new Date();
-    /**
-     * Each test is run twice: once using etag/If-None-Match and once with
-     * date/If-Modified-Since.  Each test run gets its own URL and randomized
-     * content and operates independently.
-     *
-     * The test steps are run with request_cache.length fetch requests issued
-     * and their immediate results sanity-checked.  The cache.py server script
-     * stashes an entry containing any If-None-Match, If-Modified-Since, Pragma,
-     * and Cache-Control observed headers for each request it receives.  When
-     * the test fetches have run, this state is retrieved from cache.py and the
-     * expected_* lists are checked, including their length.
-     *
-     * This means that if a request_* fetch is expected to hit the cache and not
-     * touch the network, then there will be no entry for it in the expect_*
-     * lists.  AKA (request_cache.length - expected_validation_headers.length)
-     * should equal the number of cache hits that didn't touch the network.
-     *
-     * Test dictionary keys:
-     * - state: required string that determines whether the Expires response for
-     *   the fetched document should be set in the future ("fresh") or past
-     *   ("stale").
-     * - vary: optional string to be passed to the server for it to quote back
-     *   in a Vary header on the response to us.
-     * - cache_control: optional string to be passed to the server for it to
-     *   quote back in a Cache-Control header on the response to us.
-     * - redirect: optional string "same-origin" or "cross-origin".  If
-     *   provided, the server will issue an absolute redirect to the script on
-     *   the same or a different origin, as appropriate.  The redirected
-     *   location is the script with the redirect parameter removed, so the
-     *   content/state/etc. will be as if you hadn't specified a redirect.
-     * - request_cache: required array of cache modes to use (via `cache`).
-     * - request_headers: optional array of explicit fetch `headers` arguments.
-     *   If provided, the server will log an empty dictionary for each request
-     *   instead of the request headers it would normally log.
-     * - response: optional array of specialized response handling.  Right now,
-     *   "error" array entries indicate a network error response is expected
-     *   which will reject with a TypeError.
-     * - expected_validation_headers: required boolean array indicating whether
-     *   the server should have seen an If-None-Match/If-Modified-Since header
-     *   in the request.
-     * - expected_no_cache_headers: required boolean array indicating whether
-     *   the server should have seen Pragma/Cache-control:no-cache headers in
-     *   the request.
-     * - expected_max_age_headers: optional boolean array indicating whether
-     *   the server should have seen a Cache-Control:max-age=0 header in the
-     *   request.
-     */
-    var tests = [
-      {
-        name: 'RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses',
-        state: "stale",
-        request_cache: ["default", "default"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "default" mode checks the cache for previously cached content and avoids going to the network if a fresh response exists',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "no-cache" mode revalidates stale responses found in the cache',
-        state: "stale",
-        request_cache: ["default", "no-cache"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-        expected_max_age_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "no-cache" mode revalidates fresh responses found in the cache',
-        state: "fresh",
-        request_cache: ["default", "no-cache"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-        expected_max_age_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses',
-        state: "stale",
-        request_cache: ["default", "force-cache"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses',
-        state: "fresh",
-        request_cache: ["default", "force-cache"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found',
-        state: "stale",
-        request_cache: ["force-cache"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response is not found',
-        state: "fresh",
-        request_cache: ["force-cache"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary',
-        state: "stale",
-        vary: "*",
-        request_cache: ["default", "force-cache"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "force-cache" mode checks the cache for previously cached content and goes to the network if a cached response would vary',
-        state: "fresh",
-        vary: "*",
-        request_cache: ["default", "force-cache"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "force-cache" stores the response in the cache if it goes to the network',
-        state: "stale",
-        request_cache: ["force-cache", "default"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "force-cache" stores the response in the cache if it goes to the network',
-        state: "fresh",
-        request_cache: ["force-cache", "default"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false],
-      },
-      {
-        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses',
-        state: "stale",
-        request_cache: ["default", "only-if-cached"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false]
-      },
-      {
-        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses',
-        state: "fresh",
-        request_cache: ["default", "only-if-cached"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [false]
-      },
-      {
-        name: 'RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found',
-        state: "fresh",
-        request_cache: ["only-if-cached"],
-        response: ["error"],
-        expected_validation_headers: [],
-        expected_no_cache_headers: []
-      },
-      {
-        name: 'RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content',
-        state: "fresh",
-        request_cache: ["default", "only-if-cached"],
-        redirect: "same-origin",
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content',
-        state: "stale",
-        request_cache: ["default", "only-if-cached"],
-        redirect: "same-origin",
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects',
-        state: "fresh",
-        request_cache: ["default", "only-if-cached"],
-        redirect: "cross-origin",
-        response: [null, "error"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects',
-        state: "stale",
-        request_cache: ["default", "only-if-cached"],
-        redirect: "cross-origin",
-        response: [null, "error"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless',
-        state: "stale",
-        request_cache: ["default", "no-store"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless',
-        state: "fresh",
-        request_cache: ["default", "no-store"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "no-store" mode does not store the response in the cache',
-        state: "stale",
-        request_cache: ["no-store", "default"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "no-store" mode does not store the response in the cache',
-        state: "fresh",
-        request_cache: ["no-store", "default"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Modified-Since": now.toGMTString()}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Modified-Since": now.toGMTString()}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Modified-Since": now.toGMTString()}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Modified-Since": now.toGMTString()}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-None-Match": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-None-Match": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-None-Match": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-None-Match": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Unmodified-Since": now.toGMTString()}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Unmodified-Since": now.toGMTString()}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Unmodified-Since": now.toGMTString()}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Unmodified-Since": now.toGMTString()}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Match": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Match": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Match": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Match header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Match": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Range": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{}, {"If-Range": '"foo"'}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
-        state: "stale",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Range": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "default" mode with an If-Range header is treated similarly to "no-store"',
-        state: "fresh",
-        request_cache: ["default", "default"],
-        request_headers: [{"If-Range": '"foo"'}, {}],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'Responses with the "Cache-Control: no-store" header are not stored in the cache',
-        state: "stale",
-        cache_control: "no-store",
-        request_cache: ["default", "default"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'Responses with the "Cache-Control: no-store" header are not stored in the cache',
-        state: "fresh",
-        cache_control: "no-store",
-        request_cache: ["default", "default"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, false],
-      },
-      {
-        name: 'RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless',
-        state: "stale",
-        request_cache: ["default", "reload"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless',
-        state: "fresh",
-        request_cache: ["default", "reload"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-      {
-        name: 'RequestCache "reload" mode does store the response in the cache',
-        state: "stale",
-        request_cache: ["reload", "default"],
-        expected_validation_headers: [false, true],
-        expected_no_cache_headers: [true, false],
-      },
-      {
-        name: 'RequestCache "reload" mode does store the response in the cache',
-        state: "fresh",
-        request_cache: ["reload", "default"],
-        expected_validation_headers: [false],
-        expected_no_cache_headers: [true],
-      },
-      {
-        name: 'RequestCache "reload" mode does store the response in the cache even if a previous response is already stored',
-        state: "stale",
-        request_cache: ["default", "reload", "default"],
-        expected_validation_headers: [false, false, true],
-        expected_no_cache_headers: [false, true, false],
-      },
-      {
-        name: 'RequestCache "reload" mode does store the response in the cache even if a previous response is already stored',
-        state: "fresh",
-        request_cache: ["default", "reload", "default"],
-        expected_validation_headers: [false, false],
-        expected_no_cache_headers: [false, true],
-      },
-    ];
-    function base_path() {
-      return location.pathname.replace(/\/[^\/]*$/, '/');
-    }
-    function make_url(uuid, id, value, content, info) {
-      var dates = {
-        fresh: new Date(now.getFullYear() + 1, now.getMonth(), now.getDay()).toGMTString(),
-        stale: new Date(now.getFullYear() - 1, now.getMonth(), now.getDay()).toGMTString(),
-      };
-      var vary = "";
-      if ("vary" in info) {
-        vary = "&vary=" + info.vary;
-      }
-      var cache_control = "";
-      if ("cache_control" in info) {
-        cache_control = "&cache_control=" + info.cache_control;
-      }
-      var redirect = "";
-
-      var ignore_request_headers = "";
-      if ("request_headers" in info) {
-        // Ignore the request headers that we send since they may be synthesized by the test.
-        ignore_request_headers = "&ignore";
-      }
-      var url_sans_redirect = "resources/cache.py?token=" + uuid +
-        "&content=" + content +
-        "&" + id + "=" + value +
-        "&expires=" + dates[info.state] +
-        vary + cache_control + ignore_request_headers;
-      // If there's a redirect, the target is the script without any redirect at
-      // either the same domain or a different domain.
-      if ("redirect" in info) {
-        var host_info = get_host_info();
-        var origin;
-        switch (info.redirect) {
-          case "same-origin":
-            origin = host_info['HTTP_ORIGIN'];
-            break;
-          case "cross-origin":
-            origin = host_info['HTTP_REMOTE_ORIGIN'];
-            break;
-        }
-        var redirected_url = origin + base_path() + url_sans_redirect;
-        return url_sans_redirect + "&redirect=" + encodeURIComponent(redirected_url);
-      } else {
-        return url_sans_redirect;
-      }
-    }
-    function expected_status(type, identifier, init) {
-      if (type == "date" &&
-          init.headers &&
-          init.headers["If-Modified-Since"] == identifier) {
-        // The server will respond with a 304 in this case.
-        return [304, "Not Modified"];
-      }
-      return [200, "OK"];
-    }
-    function expected_response_text(type, identifier, init, content) {
-      if (type == "date" &&
-          init.headers &&
-          init.headers["If-Modified-Since"] == identifier) {
-        // The server will respond with a 304 in this case.
-        return "";
-      }
-      return content;
-    }
-    function server_state(uuid) {
-      return fetch("resources/cache.py?querystate&token=" + uuid)
-        .then(function(response) {
-          return response.text();
-        }).then(function(text) {
-          // null will be returned if the server never received any requests
-          // for the given uuid.  Normalize that to an empty list consistent
-          // with our representation.
-          return JSON.parse(text) || [];
-        });
-    }
-    function make_test(type, info) {
-      return function(test) {
-        var uuid = token();
-        var identifier = (type == "tag" ? Math.random() : now.toGMTString());
-        var content = Math.random().toString();
-        var url = make_url(uuid, type, identifier, content, info);
-        var fetch_functions = [];
-        for (var i = 0; i < info.request_cache.length; ++i) {
-          fetch_functions.push(function(idx) {
-            var init = {cache: info.request_cache[idx]};
-            if ("request_headers" in info) {
-              init.headers = info.request_headers[idx];
-            }
-            if (init.cache === "only-if-cached") {
-              // only-if-cached requires we use same-origin mode.
-              init.mode = "same-origin";
-            }
-            return fetch(url, init)
-              .then(function(response) {
-                if ("response" in info && info.response[idx] === "error") {
-                  assert_true(false, "fetch should have been an error");
-                  return;
-                }
-                assert_array_equals([response.status, response.statusText],
-                                    expected_status(type, identifier, init));
-                return response.text();
-              }).then(function(text) {
-                assert_equals(text, expected_response_text(type, identifier, init, content));
-              }, function(reason) {
-                if ("response" in info && info.response[idx] === "error") {
-                  assert_throws(new TypeError(), function() { throw reason; });
-                } else {
-                  throw reason;
-                }
-              });
-          });
-        }
-        var i = 0;
-        function run_next_step() {
-          if (fetch_functions.length) {
-            return fetch_functions.shift()(i++)
-              .then(run_next_step);
-          } else {
-            return Promise.resolve();
-          }
-        }
-        return run_next_step()
-          .then(function() {
-            // Now, query the server state
-            return server_state(uuid);
-          }).then(function(state) {
-            var expectedState = [];
-            info.expected_validation_headers.forEach(function (validate) {
-              if (validate) {
-                if (type == "tag") {
-                  expectedState.push({"If-None-Match": '"' + identifier + '"'});
-                } else {
-                  expectedState.push({"If-Modified-Since": identifier});
-                }
-              } else {
-                expectedState.push({});
-              }
-            });
-            for (var i = 0; i < info.expected_no_cache_headers.length; ++i) {
-              if (info.expected_no_cache_headers[i]) {
-                expectedState[i]["Pragma"] = "no-cache";
-                expectedState[i]["Cache-Control"] = "no-cache";
-              }
-            }
-            if ("expected_max_age_headers" in info) {
-              for (var i = 0; i < info.expected_max_age_headers.length; ++i) {
-                if (info.expected_max_age_headers[i]) {
-                  expectedState[i]["Cache-Control"] = "max-age=0";
-                }
-              }
-            }
-            assert_equals(state.length, expectedState.length);
-            for (var i = 0; i < state.length; ++i) {
-              for (var header in state[i]) {
-                assert_equals(state[i][header], expectedState[i][header]);
-                delete expectedState[i][header];
-              }
-              for (var header in expectedState[i]) {
-                assert_false(header in state[i]);
-              }
-            }
-          });
-      };
-    }
-    tests.forEach(function(info) {
-      promise_test(make_test("tag", info), info.name + " with Etag and " + info.state + " response");
-      promise_test(make_test("date", info), info.name + " with date and " + info.state + " response");
-    });
-    </script>
-  </body>
-</html>
diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.js b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache.js
new file mode 100644 (file)
index 0000000..deeb17d
--- /dev/null
@@ -0,0 +1,223 @@
+/**
+ * Each test is run twice: once using etag/If-None-Match and once with
+ * date/If-Modified-Since.  Each test run gets its own URL and randomized
+ * content and operates independently.
+ *
+ * The test steps are run with request_cache.length fetch requests issued
+ * and their immediate results sanity-checked.  The cache.py server script
+ * stashes an entry containing any If-None-Match, If-Modified-Since, Pragma,
+ * and Cache-Control observed headers for each request it receives.  When
+ * the test fetches have run, this state is retrieved from cache.py and the
+ * expected_* lists are checked, including their length.
+ *
+ * This means that if a request_* fetch is expected to hit the cache and not
+ * touch the network, then there will be no entry for it in the expect_*
+ * lists.  AKA (request_cache.length - expected_validation_headers.length)
+ * should equal the number of cache hits that didn't touch the network.
+ *
+ * Test dictionary keys:
+ * - state: required string that determines whether the Expires response for
+ *   the fetched document should be set in the future ("fresh") or past
+ *   ("stale").
+ * - vary: optional string to be passed to the server for it to quote back
+ *   in a Vary header on the response to us.
+ * - cache_control: optional string to be passed to the server for it to
+ *   quote back in a Cache-Control header on the response to us.
+ * - redirect: optional string "same-origin" or "cross-origin".  If
+ *   provided, the server will issue an absolute redirect to the script on
+ *   the same or a different origin, as appropriate.  The redirected
+ *   location is the script with the redirect parameter removed, so the
+ *   content/state/etc. will be as if you hadn't specified a redirect.
+ * - request_cache: required array of cache modes to use (via `cache`).
+ * - request_headers: optional array of explicit fetch `headers` arguments.
+ *   If provided, the server will log an empty dictionary for each request
+ *   instead of the request headers it would normally log.
+ * - response: optional array of specialized response handling.  Right now,
+ *   "error" array entries indicate a network error response is expected
+ *   which will reject with a TypeError.
+ * - expected_validation_headers: required boolean array indicating whether
+ *   the server should have seen an If-None-Match/If-Modified-Since header
+ *   in the request.
+ * - expected_no_cache_headers: required boolean array indicating whether
+ *   the server should have seen Pragma/Cache-control:no-cache headers in
+ *   the request.
+ * - expected_max_age_headers: optional boolean array indicating whether
+ *   the server should have seen a Cache-Control:max-age=0 header in the
+ *   request.
+ */
+
+var now = new Date();
+
+function base_path() {
+  return location.pathname.replace(/\/[^\/]*$/, '/');
+}
+function make_url(uuid, id, value, content, info) {
+  var dates = {
+    fresh: new Date(now.getFullYear() + 1, now.getMonth(), now.getDay()).toGMTString(),
+    stale: new Date(now.getFullYear() - 1, now.getMonth(), now.getDay()).toGMTString(),
+  };
+  var vary = "";
+  if ("vary" in info) {
+    vary = "&vary=" + info.vary;
+  }
+  var cache_control = "";
+  if ("cache_control" in info) {
+    cache_control = "&cache_control=" + info.cache_control;
+  }
+  var redirect = "";
+
+  var ignore_request_headers = "";
+  if ("request_headers" in info) {
+    // Ignore the request headers that we send since they may be synthesized by the test.
+    ignore_request_headers = "&ignore";
+  }
+  var url_sans_redirect = "resources/cache.py?token=" + uuid +
+    "&content=" + content +
+    "&" + id + "=" + value +
+    "&expires=" + dates[info.state] +
+    vary + cache_control + ignore_request_headers;
+  // If there's a redirect, the target is the script without any redirect at
+  // either the same domain or a different domain.
+  if ("redirect" in info) {
+    var host_info = get_host_info();
+    var origin;
+    switch (info.redirect) {
+      case "same-origin":
+        origin = host_info['HTTP_ORIGIN'];
+        break;
+      case "cross-origin":
+        origin = host_info['HTTP_REMOTE_ORIGIN'];
+        break;
+    }
+    var redirected_url = origin + base_path() + url_sans_redirect;
+    return url_sans_redirect + "&redirect=" + encodeURIComponent(redirected_url);
+  } else {
+    return url_sans_redirect;
+  }
+}
+function expected_status(type, identifier, init) {
+  if (type == "date" &&
+      init.headers &&
+      init.headers["If-Modified-Since"] == identifier) {
+    // The server will respond with a 304 in this case.
+    return [304, "Not Modified"];
+  }
+  return [200, "OK"];
+}
+function expected_response_text(type, identifier, init, content) {
+  if (type == "date" &&
+      init.headers &&
+      init.headers["If-Modified-Since"] == identifier) {
+    // The server will respond with a 304 in this case.
+    return "";
+  }
+  return content;
+}
+function server_state(uuid) {
+  return fetch("resources/cache.py?querystate&token=" + uuid)
+    .then(function(response) {
+      return response.text();
+    }).then(function(text) {
+      // null will be returned if the server never received any requests
+      // for the given uuid.  Normalize that to an empty list consistent
+      // with our representation.
+      return JSON.parse(text) || [];
+    });
+}
+function make_test(type, info) {
+  return function(test) {
+    var uuid = token();
+    var identifier = (type == "tag" ? Math.random() : now.toGMTString());
+    var content = Math.random().toString();
+    var url = make_url(uuid, type, identifier, content, info);
+    var fetch_functions = [];
+    for (var i = 0; i < info.request_cache.length; ++i) {
+      fetch_functions.push(function(idx) {
+        var init = {cache: info.request_cache[idx]};
+        if ("request_headers" in info) {
+          init.headers = info.request_headers[idx];
+        }
+        if (init.cache === "only-if-cached") {
+          // only-if-cached requires we use same-origin mode.
+          init.mode = "same-origin";
+        }
+        return fetch(url, init)
+          .then(function(response) {
+            if ("response" in info && info.response[idx] === "error") {
+              assert_true(false, "fetch should have been an error");
+              return;
+            }
+            assert_array_equals([response.status, response.statusText],
+                                expected_status(type, identifier, init));
+            return response.text();
+          }).then(function(text) {
+            assert_equals(text, expected_response_text(type, identifier, init, content));
+          }, function(reason) {
+            if ("response" in info && info.response[idx] === "error") {
+              assert_throws(new TypeError(), function() { throw reason; });
+            } else {
+              throw reason;
+            }
+          });
+      });
+    }
+    var i = 0;
+    function run_next_step() {
+      if (fetch_functions.length) {
+        return fetch_functions.shift()(i++)
+          .then(run_next_step);
+      } else {
+        return Promise.resolve();
+      }
+    }
+    return run_next_step()
+      .then(function() {
+        // Now, query the server state
+        return server_state(uuid);
+      }).then(function(state) {
+        var expectedState = [];
+        info.expected_validation_headers.forEach(function (validate) {
+          if (validate) {
+            if (type == "tag") {
+              expectedState.push({"If-None-Match": '"' + identifier + '"'});
+            } else {
+              expectedState.push({"If-Modified-Since": identifier});
+            }
+          } else {
+            expectedState.push({});
+          }
+        });
+        for (var i = 0; i < info.expected_no_cache_headers.length; ++i) {
+          if (info.expected_no_cache_headers[i]) {
+            expectedState[i]["Pragma"] = "no-cache";
+            expectedState[i]["Cache-Control"] = "no-cache";
+          }
+        }
+        if ("expected_max_age_headers" in info) {
+          for (var i = 0; i < info.expected_max_age_headers.length; ++i) {
+            if (info.expected_max_age_headers[i]) {
+              expectedState[i]["Cache-Control"] = "max-age=0";
+            }
+          }
+        }
+        assert_equals(state.length, expectedState.length);
+        for (var i = 0; i < state.length; ++i) {
+          for (var header in state[i]) {
+            assert_equals(state[i][header], expectedState[i][header]);
+            delete expectedState[i][header];
+          }
+          for (var header in expectedState[i]) {
+            assert_false(header in state[i]);
+          }
+        }
+      });
+  };
+}
+
+function run_tests(tests)
+{
+  tests.forEach(function(info) {
+    promise_test(make_test("tag", info), info.name + " with Etag and " + info.state + " response");
+    promise_test(make_test("date", info), info.name + " with date and " + info.state + " response");
+  });
+}
index cd1f262..b4368cf 100644 (file)
@@ -2520,7 +2520,8 @@ webkit.org/b/157592 fast/images/composited-animated-gif-outside-viewport.html [
 
 webkit.org/b/156561 perf/rel-list-remove.html [ Pass Timeout Failure ]
 
-webkit.org/b/159683 imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Pass Failure ]
+webkit.org/b/163332 imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html [ Pass Failure ]
+webkit.org/b/163332 imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html [ Pass Failure ]
 
 webkit.org/b/158640 imported/blink/storage/indexeddb/blob-valid-after-deletion.html [ Pass Failure ]
 
diff --git a/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt b/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached-expected.txt
new file mode 100644 (file)
index 0000000..9e47886
--- /dev/null
@@ -0,0 +1,16 @@
+
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with Etag and fresh response 
+PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and does not go to the network if a cached response is not found with date and fresh response 
+FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
+FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
+FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
+FAIL RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response 
+PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and stale response 
+
diff --git a/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt b/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload-expected.txt
new file mode 100644 (file)
index 0000000..6451995
--- /dev/null
@@ -0,0 +1,14 @@
+
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response 
+PASS RequestCache "reload" mode does store the response in the cache with date and stale response 
+FAIL RequestCache "reload" mode does store the response in the cache with Etag and fresh response assert_equals: expected 1 but got 2
+FAIL RequestCache "reload" mode does store the response in the cache with date and fresh response assert_equals: expected 1 but got 2
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response 
+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response 
+
index 8b75b7d..11e1b30 100644 (file)
@@ -3494,7 +3494,8 @@ imported/w3c/web-platform-tests/fetch/api/credentials/cookies.html [ Failure ]
 imported/w3c/web-platform-tests/fetch/api/credentials/cookies-worker.html [ Failure ]
 imported/w3c/web-platform-tests/fetch/api/redirect/redirect-method.html [ Failure ]
 imported/w3c/web-platform-tests/fetch/api/redirect/redirect-method-worker.html [ Failure ]
-imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Failure ]
+imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html [ Failure ]
+imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html [ Failure ]
 imported/w3c/web-platform-tests/html/browsers/browsing-the-web/unloading-documents/unload/007.html [ Failure ]
 imported/w3c/web-platform-tests/html/browsers/history/the-history-interface/history_forward_1.html [ Failure ]
 imported/w3c/web-platform-tests/html/browsers/history/the-history-interface/history_go_no_argument.html [ Failure ]
index 17569dd..9480583 100644 (file)
@@ -685,7 +685,7 @@ fast/images/gif-loop-count.html [ Pass ]
 http/tests/misc/will-send-request-with-client-provided-http-body.html [ Pass ]
 
 # bug 162281
-imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Skip ]
+imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html [ Failure ]
 
 ### END OF (5) Progressions, expected successes that are expected failures in WebKit1.
 ########################################
index 927b054..688b6fe 100644 (file)
@@ -1,3 +1,34 @@
+2016-10-14  Youenn Fablet  <youenn@apple.com>
+
+        Make NetworkCache aware of fetch cache mode
+        https://bugs.webkit.org/show_bug.cgi?id=163332
+
+        Reviewed by Antti Koivisto.
+
+        Tests: imported/w3c/web-platform-tests/fetch/api/request/request-cache-default-conditional.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-default.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-force-cache.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-cache.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-no-store.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-only-if-cached.html
+               imported/w3c/web-platform-tests/fetch/api/request/request-cache-reload.html
+
+        * loader/cache/CachedResourceLoader.cpp:
+        (WebCore::updateRequestAccordingCacheMode): Setting request cache policy according cache mode.
+        Basically, these two are about the same.
+        (WebCore::CachedResourceLoader::determineRevalidationPolicy): Making use of cache policy instead of cache mode.
+        * platform/network/ResourceRequestBase.h: Adding new cache policies, aligned with fetch cache modes.
+        * platform/network/cf/ResourceRequestCFNet.cpp:
+        (WebCore::toPlatformRequestCachePolicy): If policy is not supported by CFNetwork, fallback to ReloadIgnoringCacheData.
+        This is the best approximate we might find.
+        (WebCore::ResourceRequest::doUpdatePlatformHTTPBody):
+        (WebCore::ResourceRequest::doUpdateResourceRequest): Only updating cache policy, if cache policy is the default.
+        * platform/network/cf/ResourceRequestCFNet.h:
+        * platform/network/cocoa/ResourceRequestCocoa.mm: Doing the same modifications as for ResourceRequestCFNet.
+        (WebCore::ResourceRequest::doUpdateResourceRequest):
+        (WebCore::toPlatformRequestCachePolicy):
+        (WebCore::ResourceRequest::doUpdatePlatformRequest):
+
 2016-10-13  Youenn Fablet  <youenn@apple.com>
 
         Binding generated code for private operations should assert for casted-this checks
index eb45002..2d673dd 100644 (file)
@@ -835,7 +835,7 @@ CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedRe
 {
     auto& memoryCache = MemoryCache::singleton();
     ASSERT(!request.allowsCaching() || !memoryCache.resourceForRequest(request.resourceRequest(), sessionID())
-        || request.options().cache == FetchOptions::Cache::NoCache || request.options().cache == FetchOptions::Cache::NoStore || request.options().cache == FetchOptions::Cache::Reload);
+        || request.resourceRequest().cachePolicy() == DoNotUseAnyCache || request.resourceRequest().cachePolicy() == ReloadIgnoringCacheData || request.resourceRequest().cachePolicy() == RefreshAnyCacheData);
 
     LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
 
@@ -888,10 +888,10 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
     if (!existingResource)
         return Load;
 
-    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore)
+    if (request.cachePolicy() == DoNotUseAnyCache || request.cachePolicy() == ReloadIgnoringCacheData)
         return Load;
 
-    if (cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
+    if (request.cachePolicy() == RefreshAnyCacheData)
         return Reload;
 
     // We already have a preload going for this URL.
index 0c3406f..1dc2257 100644 (file)
@@ -153,12 +153,12 @@ void CachedResourceRequest::updateAccordingCacheMode()
 
     switch (m_options.cache) {
     case FetchOptions::Cache::NoCache:
-        m_resourceRequest.setCachePolicy(ReloadIgnoringCacheData);
+        m_resourceRequest.setCachePolicy(RefreshAnyCacheData);
         m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::maxAge0());
         break;
     case FetchOptions::Cache::NoStore:
         m_options.cachingPolicy = CachingPolicy::DisallowCaching;
-        m_resourceRequest.setCachePolicy(ReloadIgnoringCacheData);
+        m_resourceRequest.setCachePolicy(DoNotUseAnyCache);
         m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, HTTPHeaderValues::noCache());
         m_resourceRequest.addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, HTTPHeaderValues::noCache());
         break;
index 49fb67f..96c5fbd 100644 (file)
 namespace WebCore {
 
 enum ResourceRequestCachePolicy {
-    UseProtocolCachePolicy, // normal load
-    ReloadIgnoringCacheData, // reload
-    ReturnCacheDataElseLoad, // back/forward or encoding change - allow stale data
-    ReturnCacheDataDontLoad  // results of a post - allow stale data and only use cache
+    UseProtocolCachePolicy, // normal load, equivalent to fetch "default" cache mode.
+    ReloadIgnoringCacheData, // reload, equivalent to fetch "reload"cache mode.
+    ReturnCacheDataElseLoad, // back/forward or encoding change - allow stale data, equivalent to fetch "force-cache" cache mode.
+    ReturnCacheDataDontLoad, // results of a post - allow stale data and only use cache, equivalent to fetch "only-if-cached" cache mode.
+    DoNotUseAnyCache, // Bypass the cache entirely, equivalent to fetch "no-store" cache mode.
+    RefreshAnyCacheData, // Serve cache data only if revalidated, equivalent to fetch "no-cache" mode.
 };
 
 enum HTTPBodyUpdatePolicy {
index abc1d72..35e5e27 100644 (file)
@@ -170,6 +170,20 @@ void ResourceRequest::doUpdatePlatformRequest()
     m_cfRequest = adoptCF(cfRequest);
 }
 
+static inline CFURLRequestCachePolicy toPlatformRequestCachePolicy(ResourceRequestCachePolicy policy)
+{
+    switch (policy) {
+    case UseProtocolCachePolicy:
+        return CFURLRequestUseProtocolCachePolicy;
+    case ReturnCacheDataElseLoad:
+        return CFURLRequestReturnCacheDataElseLoad;
+    case ReturnCacheDataDontLoad:
+        return CFURLRequestReturnCacheDataDontLoad;
+    default:
+        return CFURLRequestReloadIgnoringLocalCacheData;
+    }
+}
+
 void ResourceRequest::doUpdatePlatformHTTPBody()
 {
     CFMutableURLRequestRef cfRequest;
@@ -180,7 +194,7 @@ void ResourceRequest::doUpdatePlatformHTTPBody()
         cfRequest = CFURLRequestCreateMutableCopy(0, m_cfRequest.get());
         CFURLRequestSetURL(cfRequest, url.get());
         CFURLRequestSetMainDocumentURL(cfRequest, firstPartyForCookies.get());
-        CFURLRequestSetCachePolicy(cfRequest, (CFURLRequestCachePolicy)cachePolicy());
+        CFURLRequestSetCachePolicy(cfRequest, toPlatformRequestCachePolicy(cachePolicy()));
         CFURLRequestSetTimeoutInterval(cfRequest, timeoutInterval());
     } else
         cfRequest = CFURLRequestCreateMutable(0, url.get(), (CFURLRequestCachePolicy)cachePolicy(), timeoutInterval(), firstPartyForCookies.get());
@@ -211,7 +225,8 @@ void ResourceRequest::doUpdateResourceRequest()
 
     m_url = CFURLRequestGetURL(m_cfRequest.get());
 
-    m_cachePolicy = (ResourceRequestCachePolicy)CFURLRequestGetCachePolicy(m_cfRequest.get());
+    if (!m_cachePolicy)
+        m_cachePolicy = (ResourceRequestCachePolicy)CFURLRequestGetCachePolicy(m_cfRequest.get());
     m_timeoutInterval = CFURLRequestGetTimeoutInterval(m_cfRequest.get());
     m_firstPartyForCookies = CFURLRequestGetMainDocumentURL(m_cfRequest.get());
     if (CFStringRef method = CFURLRequestCopyHTTPRequestMethod(m_cfRequest.get())) {
index cdd674b..c288466 100644 (file)
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #pragma once
 
 #include "CFNetworkSPI.h"
 #include "ResourceLoadPriority.h"
+#include "ResourceRequestBase.h"
 
 namespace WebCore {
 
index 7593ab3..e71cc1f 100644 (file)
@@ -61,10 +61,40 @@ CFURLRequestRef ResourceRequest::cfURLRequest(HTTPBodyUpdatePolicy bodyPolicy) c
     return [nsURLRequest(bodyPolicy) _CFURLRequest];
 }
 
+static inline ResourceRequestCachePolicy fromPlatformRequestCachePolicy(NSURLRequestCachePolicy policy)
+{
+    switch (policy) {
+    case NSURLRequestUseProtocolCachePolicy:
+        return UseProtocolCachePolicy;
+    case NSURLRequestReturnCacheDataElseLoad:
+        return ReturnCacheDataElseLoad;
+    case NSURLRequestReturnCacheDataDontLoad:
+        return ReturnCacheDataDontLoad;
+    default:
+        return ReloadIgnoringCacheData;
+    }
+}
+
+static inline NSURLRequestCachePolicy toPlatformRequestCachePolicy(ResourceRequestCachePolicy policy)
+{
+    switch (policy) {
+    case UseProtocolCachePolicy:
+        return NSURLRequestUseProtocolCachePolicy;
+    case ReturnCacheDataElseLoad:
+        return NSURLRequestReturnCacheDataElseLoad;
+    case ReturnCacheDataDontLoad:
+        return NSURLRequestReturnCacheDataDontLoad;
+    default:
+        return NSURLRequestReloadIgnoringLocalCacheData;
+    }
+}
+
 void ResourceRequest::doUpdateResourceRequest()
 {
     m_url = [m_nsRequest.get() URL];
-    m_cachePolicy = (ResourceRequestCachePolicy)[m_nsRequest.get() cachePolicy];
+
+    if (!m_cachePolicy)
+        m_cachePolicy = fromPlatformRequestCachePolicy([m_nsRequest.get() cachePolicy]);
     m_timeoutInterval = [m_nsRequest.get() timeoutInterval];
     m_firstPartyForCookies = [m_nsRequest.get() mainDocumentURL];
 
@@ -132,7 +162,7 @@ void ResourceRequest::doUpdatePlatformRequest()
     if (ResourceRequest::resourcePrioritiesEnabled())
         CFURLRequestSetRequestPriority([nsRequest _CFURLRequest], toPlatformRequestPriority(priority()));
 
-    [nsRequest setCachePolicy:(NSURLRequestCachePolicy)cachePolicy()];
+    [nsRequest setCachePolicy:toPlatformRequestCachePolicy(cachePolicy())];
     _CFURLRequestSetProtocolProperty([nsRequest _CFURLRequest], kCFURLRequestAllowAllPOSTCaching, kCFBooleanTrue);
 
     double timeoutInterval = ResourceRequestBase::timeoutInterval();
index 95bde9e..7d12238 100644 (file)
@@ -1,3 +1,30 @@
+2016-10-14  Youenn Fablet  <youenn@apple.com>
+
+        Make NetworkCache aware of fetch cache mode
+        https://bugs.webkit.org/show_bug.cgi?id=163332
+
+        Reviewed by Antti Koivisto.
+
+        Adding explicit serialization of ResourceRequest cachePolicy since it does no longer map to platform request cache policy.
+
+        Added support for:
+        - Bypassing entirely the network cache in case cache mode is NoStore.
+        - requiring revalidation in case of cache hit and cache mode is NoCache.
+        - Not using any entry if cache mode is Reload (but cache can still be updated)
+
+        Also made sure that the ResourceRequest::cachePolicy remains the same throughout redirections.
+
+        * NetworkProcess/NetworkResourceLoader.cpp:
+        (WebKit::NetworkResourceLoader::canUseCache):
+        (WebKit::NetworkResourceLoader::retrieveCacheEntry):
+        (WebKit::NetworkResourceLoader::continueWillSendRequest):
+        * NetworkProcess/cache/NetworkCache.cpp:
+        (WebKit::NetworkCache::cachePolicyAllowsExpired):
+        (WebKit::NetworkCache::makeRetrieveDecision):
+        * Shared/mac/WebCoreArgumentCodersMac.mm:
+        (IPC::ArgumentCoder<ResourceRequest>::encodePlatformData):
+        (IPC::ArgumentCoder<ResourceRequest>::decodePlatformData):
+
 2016-10-13  Tim Horton  <timothy_horton@apple.com>
 
         Rename the SPI added in r207292 due to post-landing review comments
index 2cbef9e..952184f 100644 (file)
@@ -122,6 +122,8 @@ bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const
         return false;
     if (!request.url().protocolIsInHTTPFamily())
         return false;
+    if (originalRequest().cachePolicy() == WebCore::DoNotUseAnyCache)
+        return false;
 
     return true;
 }
@@ -188,7 +190,7 @@ void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request)
             loader->startNetworkLoad(request);
             return;
         }
-        if (entry->needsValidation()) {
+        if (entry->needsValidation() || request.cachePolicy() == WebCore::RefreshAnyCacheData) {
             loader->validateCacheEntry(WTFMove(entry));
             return;
         }
@@ -471,6 +473,9 @@ void NetworkResourceLoader::continueWillSendRequest(ResourceRequest&& newRequest
 {
     RELEASE_LOG_IF_ALLOWED("continueWillSendRequest: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier);
 
+    // If there is a match in the network cache, we need to reuse the original cache policy.
+    newRequest.setCachePolicy(originalRequest().cachePolicy());
+
 #if ENABLE(NETWORK_CACHE)
     if (m_isWaitingContinueWillSendRequestForCachedRedirect) {
         LOG(NetworkCache, "(NetworkProcess) Retrieving cached redirect");
index 240380f..dfe5c46 100644 (file)
@@ -136,9 +136,12 @@ static bool cachePolicyAllowsExpired(WebCore::ResourceRequestCachePolicy policy)
         return true;
     case WebCore::UseProtocolCachePolicy:
     case WebCore::ReloadIgnoringCacheData:
+    case WebCore::RefreshAnyCacheData:
+        return false;
+    case WebCore::DoNotUseAnyCache:
+        ASSERT_NOT_REACHED();
         return false;
     }
-    ASSERT_NOT_REACHED();
     return false;
 }
 
@@ -198,6 +201,8 @@ static UseDecision makeUseDecision(const Entry& entry, const WebCore::ResourceRe
 
 static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request)
 {
+    ASSERT(request.cachePolicy() != WebCore::DoNotUseAnyCache);
+
     // FIXME: Support HEAD requests.
     if (request.httpMethod() != "GET")
         return RetrieveDecision::NoDueToHTTPMethod;
index 69e7a6f..9cedce8 100644 (file)
@@ -77,6 +77,7 @@ void ArgumentCoder<ResourceRequest>::encodePlatformData(Encoder& encoder, const
     // The fallback array is part of NSURLRequest, but it is not encoded by WKNSURLRequestCreateSerializableRepresentation.
     encoder << resourceRequest.responseContentDispositionEncodingFallbackArray();
     encoder.encodeEnum(resourceRequest.requester());
+    encoder.encodeEnum(resourceRequest.cachePolicy());
 }
 
 bool ArgumentCoder<ResourceRequest>::decodePlatformData(Decoder& decoder, ResourceRequest& resourceRequest)
@@ -115,6 +116,11 @@ bool ArgumentCoder<ResourceRequest>::decodePlatformData(Decoder& decoder, Resour
         return false;
     resourceRequest.setRequester(requester);
 
+    ResourceRequestCachePolicy cachePolicy;
+    if (!decoder.decodeEnum(cachePolicy))
+        return false;
+    resourceRequest.setCachePolicy(cachePolicy);
+
     return true;
 }