Attachment 291357 Details for Bug 163332 – Patch

[patch] Patch

bug-163332-20161012171435.patch (text/plain), 35.47 KB, created by youenn fablet on 2016-10-12 08:18:01 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2016-10-12 08:18:01 PDT

Size: 35.47 KB

patch

obsolete

>Subversion Revision: 207193
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 9d305236507c06e9e1dfc84ed36565ff0357184b..8645062fe8318b8109aae6d9c28593fdb76dc5d2 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,5 +1,21 @@
> 2016-10-12  Youenn Fablet  <youenn@apple.com>
> 
>+        Make NetworkCache aware of fetch cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=163332
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Covered by rebased test, except for the change in determineRevalidationPolicy which needs further testing.
>+        Maybe using fetch+preloads may allow testing this.
>+
>+        * loader/ResourceLoader.h:
>+        (WebCore::ResourceLoader::cacheMode):
>+        * loader/cache/CachedResourceLoader.cpp:
>+        (WebCore::CachedResourceLoader::determineRevalidationPolicy): In case of no-cache, the strategy should be to
>+        always create a conditional request if there is an entry, therefore policy should be to set to Reload.
>+
>+2016-10-12  Youenn Fablet  <youenn@apple.com>
>+
>         Attribute setter binding generated code should use more references
>         https://bugs.webkit.org/show_bug.cgi?id=163275
> 
>diff --git a/Source/WebKit2/ChangeLog b/Source/WebKit2/ChangeLog
>index 17d9f4d4b7d2ae2773c89b576c552e0f7f6bb0fa..25a7b1f573ddf866e40a1499de78217a090b68cd 100644
>--- a/Source/WebKit2/ChangeLog
>+++ b/Source/WebKit2/ChangeLog
>@@ -1,3 +1,35 @@
>+2016-10-12  Youenn Fablet  <youenn@apple.com>
>+
>+        Make NetworkCache aware of fetch cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=163332
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Passing FetchOptions::Cache to network process so that the network cache can adapt to it.
>+        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/NetworkLoadParameters.h:
>+        * NetworkProcess/NetworkResourceLoadParameters.cpp:
>+        (WebKit::NetworkResourceLoadParameters::encode):
>+        (WebKit::NetworkResourceLoadParameters::decode):
>+        * NetworkProcess/NetworkResourceLoader.cpp:
>+        (WebKit::NetworkResourceLoader::canUseCache):
>+        (WebKit::NetworkResourceLoader::retrieveCacheEntry):
>+        (WebKit::NetworkResourceLoader::continueWillSendRequest):
>+        (WebKit::NetworkResourceLoader::tryStoreAsCacheEntry):
>+        (WebKit::NetworkResourceLoader::canUseCachedRedirect):K
>+        * NetworkProcess/cache/NetworkCache.cpp:
>+        (WebKit::NetworkCache::makeRetrieveDecision):
>+        (WebKit::NetworkCache::Cache::retrieve):
>+        * NetworkProcess/cache/NetworkCache.h:
>+        * WebProcess/Network/WebLoaderStrategy.cpp:
>+        (WebKit::WebLoaderStrategy::scheduleLoad):
>+
> 2016-10-11  Gyuyoung Kim  <gyuyoung.kim@navercorp.com>
> 
>         [EFL] Update API tests which are passed or failed
>diff --git a/Source/WebCore/loader/ResourceLoader.h b/Source/WebCore/loader/ResourceLoader.h
>index 5591bdddac4896519c489f95bb280436552089fe..5d07d0fd1d7f9075ff7ed8eff24f84e5bd003f5a 100644
>--- a/Source/WebCore/loader/ResourceLoader.h
>+++ b/Source/WebCore/loader/ResourceLoader.h
>@@ -131,7 +131,7 @@ public:
>     bool shouldSniffContent() const { return m_options.sniffContent == SniffContent; }
>     WEBCORE_EXPORT bool isAllowedToAskUserForCredentials() const;
>     bool shouldIncludeCertificateInfo() const { return m_options.certificateInfoPolicy == IncludeCertificateInfo; }
>-
>+    FetchOptions::Cache cacheMode() const { return m_options.cache; }
>     bool reachedTerminalState() const { return m_reachedTerminalState; }
> 
> 
>diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>index 52c6d401815e5990882a494b2e7111ee7f27ae6b..975859bc1c8800897f727b29358bca4df399e11c 100644
>--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>@@ -949,10 +949,10 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
>     if (!existingResource)
>         return Load;
> 
>-    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore)
>+    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore || cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
>         return Load;
> 
>-    if (cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
>+    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoCache)
>         return Reload;
> 
>     // We already have a preload going for this URL.
>diff --git a/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h b/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h
>index 4d2d455217be9d6c62ce8a1b2572a5004f944205..0720721b5155df2226c40ae6c2784e720598eabf 100644
>--- a/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h
>+++ b/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h
>@@ -41,6 +41,7 @@ public:
>     WebCore::ContentSniffingPolicy contentSniffingPolicy { WebCore::SniffContent };
>     WebCore::StoredCredentials allowStoredCredentials { WebCore::DoNotAllowStoredCredentials };
>     WebCore::ClientCredentialPolicy clientCredentialPolicy { WebCore::ClientCredentialPolicy::CannotAskClientForCredentials };
>+    WebCore::FetchOptions::Cache cacheMode { WebCore::FetchOptions::Cache::Default };
>     bool shouldFollowRedirects { true };
>     bool shouldClearReferrerOnHTTPSToHTTPRedirect { true };
>     bool defersLoading { false };
>diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp b/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp
>index 49ec4a0dd9f6b3ab2acb46123ed90ee7f7be8cfb..89772c24cdd2652a5e91a91714e4446c2ce0908b 100644
>--- a/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp
>+++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp
>@@ -80,6 +80,7 @@ void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const
>     encoder << defersLoading;
>     encoder << needsCertificateInfo;
>     encoder << maximumBufferingTime;
>+    encoder.encodeEnum(cacheMode);
> }
> 
> bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)
>@@ -141,8 +142,10 @@ bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourc
>         return false;
>     if (!decoder.decode(result.maximumBufferingTime))
>         return false;
>+    if (!decoder.decodeEnum(result.cacheMode))
>+        return false;
> 
>     return true;
> }
>-    
>+
> } // namespace WebKit
>diff --git a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
>index 2cbef9e5b33a0545936ffd127823e31e5277e387..af2e2fc918ecb0bf147b3f4cef520b67f3f690ed 100644
>--- a/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
>+++ b/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp
>@@ -122,7 +122,8 @@ bool NetworkResourceLoader::canUseCache(const ResourceRequest& request) const
>         return false;
>     if (!request.url().protocolIsInHTTPFamily())
>         return false;
>-
>+    if (m_parameters.cacheMode == WebCore::FetchOptions::Cache::NoStore)
>+        return false;
>     return true;
> }
> 
>@@ -138,6 +139,7 @@ bool NetworkResourceLoader::canUseCachedRedirect(const ResourceRequest& request)
> 
>     return true;
> }
>+
> #endif
> 
> bool NetworkResourceLoader::isSynchronous() const
>@@ -171,7 +173,7 @@ void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request)
>     ASSERT(canUseCache(request));
> 
>     RefPtr<NetworkResourceLoader> loader(this);
>-    NetworkCache::singleton().retrieve(request, { m_parameters.webPageID, m_parameters.webFrameID }, [loader, request](auto entry) {
>+    NetworkCache::singleton().retrieve(request, m_parameters.cacheMode, { m_parameters.webPageID, m_parameters.webFrameID }, [loader, request](auto entry) {
>         if (loader->hasOneRef()) {
>             // The loader has been aborted and is only held alive by this lambda.
>             return;
>@@ -188,7 +190,7 @@ void NetworkResourceLoader::retrieveCacheEntry(const ResourceRequest& request)
>             loader->startNetworkLoad(request);
>             return;
>         }
>-        if (entry->needsValidation()) {
>+        if (entry->needsValidation() || loader->m_parameters.cacheMode == WebCore::FetchOptions::Cache::NoCache) {
>             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");
>@@ -544,6 +549,8 @@ void NetworkResourceLoader::tryStoreAsCacheEntry()
>         return;
>     if (!m_bufferedDataForCache)
>         return;
>+    if (m_parameters.cacheMode == WebCore::FetchOptions::Cache::NoStore)
>+        return;
> 
>     NetworkCache::singleton().store(m_networkLoad->currentRequest(), m_response, WTFMove(m_bufferedDataForCache), [loader = makeRef(*this)](auto& mappedBody) mutable {
> #if ENABLE(SHAREABLE_RESOURCE)
>diff --git a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp b/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp
>index 240380f798a71bd12aef9fbfafcb01212d973ef9..4f0480a2ff561f706e9b86d14672c51d30c6a4a0 100644
>--- a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp
>+++ b/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp
>@@ -196,8 +196,10 @@ static UseDecision makeUseDecision(const Entry& entry, const WebCore::ResourceRe
>     return entry.redirectRequest() ? UseDecision::NoDueToExpiredRedirect : UseDecision::Validate;
> }
> 
>-static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request)
>+static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request, WebCore::FetchOptions::Cache cacheMode)
> {
>+    ASSERT(cacheMode != WebCore::FetchOptions::Cache::NoStore);
>+
>     // FIXME: Support HEAD requests.
>     if (request.httpMethod() != "GET")
>         return RetrieveDecision::NoDueToHTTPMethod;
>@@ -206,6 +208,9 @@ static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& req
>     if (request.cachePolicy() == WebCore::ReloadIgnoringCacheData && !request.isConditional())
>         return RetrieveDecision::NoDueToReloadIgnoringCache;
> 
>+    if (cacheMode == WebCore::FetchOptions::Cache::Reload)
>+        return RetrieveDecision::NoDueToReloadIgnoringCache;
>+
>     return RetrieveDecision::Yes;
> }
> 
>@@ -304,7 +309,7 @@ static StoreDecision makeStoreDecision(const WebCore::ResourceRequest& originalR
>     return StoreDecision::Yes;
> }
> 
>-void Cache::retrieve(const WebCore::ResourceRequest& request, const GlobalFrameID& frameID, std::function<void (std::unique_ptr<Entry>)>&& completionHandler)
>+void Cache::retrieve(const WebCore::ResourceRequest& request, WebCore::FetchOptions::Cache cacheMode, const GlobalFrameID& frameID, std::function<void (std::unique_ptr<Entry>)>&& completionHandler)
> {
>     ASSERT(isEnabled());
>     ASSERT(request.url().protocolIsInHTTPFamily());
>@@ -322,7 +327,7 @@ void Cache::retrieve(const WebCore::ResourceRequest& request, const GlobalFrameI
>         m_speculativeLoadManager->registerLoad(frameID, request, storageKey);
> #endif
> 
>-    auto retrieveDecision = makeRetrieveDecision(request);
>+    auto retrieveDecision = makeRetrieveDecision(request, cacheMode);
>     if (retrieveDecision != RetrieveDecision::Yes) {
>         if (m_statistics)
>             m_statistics->recordNotUsingCacheForRequest(frameID.first, storageKey, request, retrieveDecision);
>diff --git a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h b/Source/WebKit2/NetworkProcess/cache/NetworkCache.h
>index 39d7608971c5991f7facde4cd14d4b1503813758..505d70b14efc94dc224baf48007e084897b5ca4c 100644
>--- a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h
>+++ b/Source/WebKit2/NetworkProcess/cache/NetworkCache.h
>@@ -31,6 +31,7 @@
> #include "NetworkCacheEntry.h"
> #include "NetworkCacheStorage.h"
> #include "ShareableResource.h"
>+#include <WebCore/FetchOptions.h>
> #include <WebCore/ResourceResponse.h>
> #include <wtf/Function.h>
> #include <wtf/text/WTFString.h>
>@@ -105,7 +106,7 @@ public:
>     bool isEnabled() const { return !!m_storage; }
> 
>     // Completion handler may get called back synchronously on failure.
>-    void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, std::function<void (std::unique_ptr<Entry>)>&&);
>+    void retrieve(const WebCore::ResourceRequest&, WebCore::FetchOptions::Cache, const GlobalFrameID&, std::function<void (std::unique_ptr<Entry>)>&&);
>     std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void (MappedBody&)>&&);
>     std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
>     std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);
>diff --git a/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp b/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp
>index 53ed536e0da121dfa34bca54a502f1e7e6e29d0f..d37d0bb5c276edf055070d02a38b279a2c424d1d 100644
>--- a/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp
>+++ b/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp
>@@ -210,6 +210,7 @@ void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResou
>     loadParameters.defersLoading = resourceLoader.defersLoading();
>     loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();
>     loadParameters.maximumBufferingTime = maximumBufferingTime(resource);
>+    loadParameters.cacheMode = resourceLoader.cacheMode();
> 
>     ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);
> 
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index d82b3e07af1044c190c0bd3f9ef164d3207f138c..42793177945d4201430ec30bdf056479e27c4597 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,3 +1,12 @@
>+2016-10-12  Youenn Fablet  <youenn@apple.com>
>+
>+        Make NetworkCache aware of fetch cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=163332
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * web-platform-tests/fetch/api/request/request-cache-expected.txt:
>+
> 2016-10-11  Chris Dumez  <cdumez@apple.com>
> 
>         select.options may return too many option elements
>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
>index 5529cb0e0e27b55b53e255fa49204532fdd1861d..0cc2454a701ccfc2c2a8d5f0230d0c717f78a8f2 100644
>--- 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
>@@ -1,3 +1,11 @@
>+CONSOLE MESSAGE: Unsafe attempt to load URL http://127.0.0.1:8800/fetch/api/request/resources/cache.py?token=dead036c-3c49-4190-8018-bc30046dafed&content=0.03273021580735058&tag=0.14361419643569517&expires=Mon,%2002%20Oct%202017%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache.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=9ec76b75-d024-4734-94d1-f41017535b9b&content=0.17638640414627604&date=Wed,%2012%20Oct%202016%2015:11:25%20GMT&expires=Mon,%2002%20Oct%202017%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache.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=32994c10-37a1-44fc-b397-eee256f15dbe&content=0.7676388957529434&tag=0.4518398561716842&expires=Fri,%2002%20Oct%202015%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache.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=714e1dd5-6c4b-4d4b-9858-8095b9a268fc&content=0.8778856314528631&date=Wed,%2012%20Oct%202016%2015:11:25%20GMT&expires=Fri,%2002%20Oct%202015%2022:00:00%20GMT from frame with URL http://localhost:8800/fetch/api/request/request-cache.html. Domains, protocols and ports must match.
>+
> 
> 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 
>@@ -29,10 +37,10 @@ PASS RequestCache "only-if-cached" mode checks the cache for previously cached c
> 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") 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 
>@@ -95,8 +103,8 @@ PASS RequestCache "reload" mode does not check the cache for previously cached c
> 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 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 
>diff --git a/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt b/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt
>new file mode 100644
>index 0000000000000000000000000000000000000000..5529cb0e0e27b55b53e255fa49204532fdd1861d
>--- /dev/null
>+++ b/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt
>@@ -0,0 +1,104 @@
>+
>+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 
>+

Actions: View | Formatted Diff | Diff

Attachments on bug 163332: 291357 | 291469 | 291472 | 291473 | 291475 | 291583 | 291586