Attachment #291357 for bug #163332

View Details Raw Unified Return to Bug 163332

| Differences between



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




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

Lines 131-137 public: a/Source/WebCore/loader/ResourceLoader.h_sec1
- a/Source/WebCore/loader/ResourceLoader.h -1 / +1 lines
131	bool shouldSniffContent() const { return m_options.sniffContent == SniffContent; }	131	bool shouldSniffContent() const { return m_options.sniffContent == SniffContent; }
132	WEBCORE_EXPORT bool isAllowedToAskUserForCredentials() const;	132	WEBCORE_EXPORT bool isAllowedToAskUserForCredentials() const;
133	bool shouldIncludeCertificateInfo() const { return m_options.certificateInfoPolicy == IncludeCertificateInfo; }	133	bool shouldIncludeCertificateInfo() const { return m_options.certificateInfoPolicy == IncludeCertificateInfo; }
134		134	FetchOptions::Cache cacheMode() const { return m_options.cache; }
135	bool reachedTerminalState() const { return m_reachedTerminalState; }	135	bool reachedTerminalState() const { return m_reachedTerminalState; }
136		136
137		137



    if (!existingResource)
        return Load;

    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore || cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
        return Load;

    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoCache)
        return Reload;

    // We already have a preload going for this URL.

Lines 41-46 public: a/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h_sec1
- a/Source/WebKit2/NetworkProcess/NetworkLoadParameters.h +1 lines
41	WebCore::ContentSniffingPolicy contentSniffingPolicy { WebCore::SniffContent };	41	WebCore::ContentSniffingPolicy contentSniffingPolicy { WebCore::SniffContent };
42	WebCore::StoredCredentials allowStoredCredentials { WebCore::DoNotAllowStoredCredentials };	42	WebCore::StoredCredentials allowStoredCredentials { WebCore::DoNotAllowStoredCredentials };
43	WebCore::ClientCredentialPolicy clientCredentialPolicy { WebCore::ClientCredentialPolicy::CannotAskClientForCredentials };	43	WebCore::ClientCredentialPolicy clientCredentialPolicy { WebCore::ClientCredentialPolicy::CannotAskClientForCredentials };
		44	WebCore::FetchOptions::Cache cacheMode { WebCore::FetchOptions::Cache::Default };
44	bool shouldFollowRedirects { true };	45	bool shouldFollowRedirects { true };
45	bool shouldClearReferrerOnHTTPSToHTTPRedirect { true };	46	bool shouldClearReferrerOnHTTPSToHTTPRedirect { true };
46	bool defersLoading { false };	47	bool defersLoading { false };

Lines 80-85 void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const a/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp_sec1
- a/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp -1 / +4 lines
80	encoder << defersLoading;	80	encoder << defersLoading;
81	encoder << needsCertificateInfo;	81	encoder << needsCertificateInfo;
82	encoder << maximumBufferingTime;	82	encoder << maximumBufferingTime;
		83	encoder.encodeEnum(cacheMode);
83	}	84	}
84		85
85	bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)	86	bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)
Lines 141-148 bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourc a/Source/WebKit2/NetworkProcess/NetworkResourceLoadParameters.cpp_sec2
141	return false;	142	return false;
142	if (!decoder.decode(result.maximumBufferingTime))	143	if (!decoder.decode(result.maximumBufferingTime))
143	return false;	144	return false;
		145	if (!decoder.decodeEnum(result.cacheMode))
		146	return false;
144		147
145	return true;	148	return true;
146	}	149	}
147		150
148	} // namespace WebKit	151	} // namespace WebKit



        return false;
    if (!request.url().protocolIsInHTTPFamily())
        return false;
    if (m_parameters.cacheMode == WebCore::FetchOptions::Cache::NoStore)
        return false;
    return true;
}



    return true;
}

#endif

bool NetworkResourceLoader::isSynchronous() const

    ASSERT(canUseCache(request));

    RefPtr<NetworkResourceLoader> loader(this);
    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;

            loader->startNetworkLoad(request);
            return;
        }
        if (entry->needsValidation() || loader->m_parameters.cacheMode == WebCore::FetchOptions::Cache::NoCache) {
            loader->validateCacheEntry(WTFMove(entry));
            return;
        }

{
    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");

        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)

Lines 196-203 static UseDecision makeUseDecision(const Entry& entry, const WebCore::ResourceRe a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp_sec1
- a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp -3 / +8 lines
196	return entry.redirectRequest() ? UseDecision::NoDueToExpiredRedirect : UseDecision::Validate;	196	return entry.redirectRequest() ? UseDecision::NoDueToExpiredRedirect : UseDecision::Validate;
197	}	197	}
198		198
199	static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request)	199	static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& request, WebCore::FetchOptions::Cache cacheMode)
200	{	200	{
		201	ASSERT(cacheMode != WebCore::FetchOptions::Cache::NoStore);
		202
201	// FIXME: Support HEAD requests.	203	// FIXME: Support HEAD requests.
202	if (request.httpMethod() != "GET")	204	if (request.httpMethod() != "GET")
203	return RetrieveDecision::NoDueToHTTPMethod;	205	return RetrieveDecision::NoDueToHTTPMethod;
Lines 206-211 static RetrieveDecision makeRetrieveDecision(const WebCore::ResourceRequest& req a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp_sec2
206	if (request.cachePolicy() == WebCore::ReloadIgnoringCacheData && !request.isConditional())	208	if (request.cachePolicy() == WebCore::ReloadIgnoringCacheData && !request.isConditional())
207	return RetrieveDecision::NoDueToReloadIgnoringCache;	209	return RetrieveDecision::NoDueToReloadIgnoringCache;
208		210
		211	if (cacheMode == WebCore::FetchOptions::Cache::Reload)
		212	return RetrieveDecision::NoDueToReloadIgnoringCache;
		213
209	return RetrieveDecision::Yes;	214	return RetrieveDecision::Yes;
210	}	215	}
211		216
Lines 304-310 static StoreDecision makeStoreDecision(const WebCore::ResourceRequest& originalR a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp_sec3
304	return StoreDecision::Yes;	309	return StoreDecision::Yes;
305	}	310	}
306		311
307	void Cache::retrieve(const WebCore::ResourceRequest& request, const GlobalFrameID& frameID, std::function<void (std::unique_ptr<Entry>)>&& completionHandler)	312	void Cache::retrieve(const WebCore::ResourceRequest& request, WebCore::FetchOptions::Cache cacheMode, const GlobalFrameID& frameID, std::function<void (std::unique_ptr<Entry>)>&& completionHandler)
308	{	313	{
309	ASSERT(isEnabled());	314	ASSERT(isEnabled());
310	ASSERT(request.url().protocolIsInHTTPFamily());	315	ASSERT(request.url().protocolIsInHTTPFamily());
Lines 322-328 void Cache::retrieve(const WebCore::ResourceRequest& request, const GlobalFrameI a/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp_sec4
322	m_speculativeLoadManager->registerLoad(frameID, request, storageKey);	327	m_speculativeLoadManager->registerLoad(frameID, request, storageKey);
323	#endif	328	#endif
324		329
325	auto retrieveDecision = makeRetrieveDecision(request);	330	auto retrieveDecision = makeRetrieveDecision(request, cacheMode);
326	if (retrieveDecision != RetrieveDecision::Yes) {	331	if (retrieveDecision != RetrieveDecision::Yes) {
327	if (m_statistics)	332	if (m_statistics)
328	m_statistics->recordNotUsingCacheForRequest(frameID.first, storageKey, request, retrieveDecision);	333	m_statistics->recordNotUsingCacheForRequest(frameID.first, storageKey, request, retrieveDecision);



#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>

    bool isEnabled() const { return !!m_storage; }

    // Completion handler may get called back synchronously on failure.
    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);

Lines 210-215 void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResou a/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp_sec1
- a/Source/WebKit2/WebProcess/Network/WebLoaderStrategy.cpp +1 lines
210	loadParameters.defersLoading = resourceLoader.defersLoading();	210	loadParameters.defersLoading = resourceLoader.defersLoading();
211	loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();	211	loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();
212	loadParameters.maximumBufferingTime = maximumBufferingTime(resource);	212	loadParameters.maximumBufferingTime = maximumBufferingTime(resource);
		213	loadParameters.cacheMode = resourceLoader.cacheMode();
213		214
214	ASSERT((loadParameters.webPageID && loadParameters.webFrameID) \|\| loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);	215	ASSERT((loadParameters.webPageID && loadParameters.webFrameID) \|\| loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);
215		216



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



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 

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 "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 "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 


Return to Bug 163332

Lines 949-958 CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida a/Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec1
- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp -2 / +2 lines
949	if (!existingResource)	949	if (!existingResource)
950	return Load;	950	return Load;
951		951
952	if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore)	952	if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore \|\| cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
953	return Load;	953	return Load;
954		954
955	if (cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)	955	if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoCache)
956	return Reload;	956	return Reload;
957		957
958	// We already have a preload going for this URL.	958	// We already have a preload going for this URL.

Lines 1-5 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +16 lines
1	2016-10-12 Youenn Fablet <youenn@apple.com>	1	2016-10-12 Youenn Fablet <youenn@apple.com>
2		2
		3	Make NetworkCache aware of fetch cache mode
		4	https://bugs.webkit.org/show_bug.cgi?id=163332
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Covered by rebased test, except for the change in determineRevalidationPolicy which needs further testing.
		9	Maybe using fetch+preloads may allow testing this.
		10
		11	* loader/ResourceLoader.h:
		12	(WebCore::ResourceLoader::cacheMode):
		13	* loader/cache/CachedResourceLoader.cpp:
		14	(WebCore::CachedResourceLoader::determineRevalidationPolicy): In case of no-cache, the strategy should be to
		15	always create a conditional request if there is an entry, therefore policy should be to set to Reload.
		16
		17	2016-10-12 Youenn Fablet <youenn@apple.com>
		18
3	Attribute setter binding generated code should use more references	19	Attribute setter binding generated code should use more references
4	https://bugs.webkit.org/show_bug.cgi?id=163275	20	https://bugs.webkit.org/show_bug.cgi?id=163275
5		21

Lines 1-3 a/Source/WebKit2/ChangeLog_sec1
- a/Source/WebKit2/ChangeLog +32 lines
		1	2016-10-12 Youenn Fablet <youenn@apple.com>
		2
		3	Make NetworkCache aware of fetch cache mode
		4	https://bugs.webkit.org/show_bug.cgi?id=163332
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Passing FetchOptions::Cache to network process so that the network cache can adapt to it.
		9	Added support for:
		10	- Bypassing entirely the network cache in case cache mode is NoStore.
		11	- requiring revalidation in case of cache hit and cache mode is NoCache.
		12	- Not using any entry if cache mode is Reload (but cache can still be updated)
		13
		14	Also made sure that the ResourceRequest::cachePolicy remains the same throughout redirections.
		15
		16	* NetworkProcess/NetworkLoadParameters.h:
		17	* NetworkProcess/NetworkResourceLoadParameters.cpp:
		18	(WebKit::NetworkResourceLoadParameters::encode):
		19	(WebKit::NetworkResourceLoadParameters::decode):
		20	* NetworkProcess/NetworkResourceLoader.cpp:
		21	(WebKit::NetworkResourceLoader::canUseCache):
		22	(WebKit::NetworkResourceLoader::retrieveCacheEntry):
		23	(WebKit::NetworkResourceLoader::continueWillSendRequest):
		24	(WebKit::NetworkResourceLoader::tryStoreAsCacheEntry):
		25	(WebKit::NetworkResourceLoader::canUseCachedRedirect):K
		26	* NetworkProcess/cache/NetworkCache.cpp:
		27	(WebKit::NetworkCache::makeRetrieveDecision):
		28	(WebKit::NetworkCache::Cache::retrieve):
		29	* NetworkProcess/cache/NetworkCache.h:
		30	* WebProcess/Network/WebLoaderStrategy.cpp:
		31	(WebKit::WebLoaderStrategy::scheduleLoad):
		32
1	2016-10-11 Gyuyoung Kim <gyuyoung.kim@navercorp.com>	33	2016-10-11 Gyuyoung Kim <gyuyoung.kim@navercorp.com>
2		34
3	[EFL] Update API tests which are passed or failed	35	[EFL] Update API tests which are passed or failed

Lines 31-36 a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h_sec1
- a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h -1 / +2 lines
31	#include "NetworkCacheEntry.h"	31	#include "NetworkCacheEntry.h"
32	#include "NetworkCacheStorage.h"	32	#include "NetworkCacheStorage.h"
33	#include "ShareableResource.h"	33	#include "ShareableResource.h"
		34	#include <WebCore/FetchOptions.h>
34	#include <WebCore/ResourceResponse.h>	35	#include <WebCore/ResourceResponse.h>
35	#include <wtf/Function.h>	36	#include <wtf/Function.h>
36	#include <wtf/text/WTFString.h>	37	#include <wtf/text/WTFString.h>
Lines 105-111 public: a/Source/WebKit2/NetworkProcess/cache/NetworkCache.h_sec2
105	bool isEnabled() const { return !!m_storage; }	106	bool isEnabled() const { return !!m_storage; }
106		107
107	// Completion handler may get called back synchronously on failure.	108	// Completion handler may get called back synchronously on failure.
108	void retrieve(const WebCore::ResourceRequest&, const GlobalFrameID&, std::function<void (std::unique_ptr<Entry>)>&&);	109	void retrieve(const WebCore::ResourceRequest&, WebCore::FetchOptions::Cache, const GlobalFrameID&, std::function<void (std::unique_ptr<Entry>)>&&);
109	std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void (MappedBody&)>&&);	110	std::unique_ptr<Entry> store(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&, Function<void (MappedBody&)>&&);
110	std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);	111	std::unique_ptr<Entry> storeRedirect(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
111	std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);	112	std::unique_ptr<Entry> update(const WebCore::ResourceRequest&, const GlobalFrameID&, const Entry&, const WebCore::ResourceResponse& validatingResponse);

Lines 1-3 a/LayoutTests/imported/w3c/ChangeLog_sec1
- a/LayoutTests/imported/w3c/ChangeLog +9 lines
		1	2016-10-12 Youenn Fablet <youenn@apple.com>
		2
		3	Make NetworkCache aware of fetch cache mode
		4	https://bugs.webkit.org/show_bug.cgi?id=163332
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* web-platform-tests/fetch/api/request/request-cache-expected.txt:
		9
1	2016-10-11 Chris Dumez <cdumez@apple.com>	10	2016-10-11 Chris Dumez <cdumez@apple.com>
2		11
3	select.options may return too many option elements	12	select.options may return too many option elements

Lines 1-3 a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt_sec1
- a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt -6 / +14 lines
		1	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.
		2
		3	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.
		4
		5	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.
		6
		7	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.
		8
1		9
2	PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with Etag and stale response	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
3	PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with date and stale response	11	PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with date and stale response
Lines 29-38 PASS RequestCache "only-if-cached" mode checks the cache for previously cached c a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt_sec2
29	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response	37	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response
30	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	38	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
31	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	39	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
32	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"	40	PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and fresh response
33	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"	41	PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and fresh response
34	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"	42	PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with Etag and stale response
35	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"	43	PASS RequestCache "only-if-cached" (with "same-origin") uses cached same-origin redirects to same-origin content with date and stale response
36	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response	44	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response
37	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response	45	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response
38	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response	46	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response
Lines 95-102 PASS RequestCache "reload" mode does not check the cache for previously cached c a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt_sec3
95	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response	103	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response
96	PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response	104	PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response
97	PASS RequestCache "reload" mode does store the response in the cache with date and stale response	105	PASS RequestCache "reload" mode does store the response in the cache with date and stale response
98	FAIL RequestCache "reload" mode does store the response in the cache with Etag and fresh response assert_equals: expected 1 but got 2	106	PASS RequestCache "reload" mode does store the response in the cache with Etag and fresh response
99	FAIL RequestCache "reload" mode does store the response in the cache with date and fresh response assert_equals: expected 1 but got 2	107	PASS RequestCache "reload" mode does store the response in the cache with date and fresh response
100	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response	108	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response
101	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response	109	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response
102	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response	110	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response

Line 0 a/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt_sec1
- a/LayoutTests/platform/mac-wk1/imported/w3c/web-platform-tests/fetch/api/request/request-cache-expected.txt +104 lines
		1
		2	PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with Etag and stale response
		3	PASS RequestCache "default" mode checks the cache for previously cached content and goes to the network for stale responses with date and stale response
		4	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
		5	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
		6	PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with Etag and stale response
		7	PASS RequestCache "no-cache" mode revalidates stale responses found in the cache with date and stale response
		8	PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with Etag and fresh response
		9	PASS RequestCache "no-cache" mode revalidates fresh responses found in the cache with date and fresh response
		10	PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Etag and stale response
		11	PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with date and stale response
		12	PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with Etag and fresh response
		13	PASS RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for fresh responses with date and fresh response
		14	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
		15	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
		16	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
		17	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
		18	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
		19	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
		20	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
		21	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
		22	PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and stale response
		23	PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and stale response
		24	PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with Etag and fresh response
		25	PASS RequestCache "force-cache" stores the response in the cache if it goes to the network with date and fresh response
		26	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response
		27	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response
		28	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response
		29	PASS RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response
		30	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
		31	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
		32	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"
		33	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"
		34	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"
		35	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"
		36	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and fresh response
		37	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and fresh response
		38	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with Etag and stale response
		39	PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirects across origins and rejects with date and stale response
		40	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
		41	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
		42	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
		43	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
		44	PASS RequestCache "no-store" mode does not store the response in the cache with Etag and stale response
		45	PASS RequestCache "no-store" mode does not store the response in the cache with date and stale response
		46	PASS RequestCache "no-store" mode does not store the response in the cache with Etag and fresh response
		47	PASS RequestCache "no-store" mode does not store the response in the cache with date and fresh response
		48	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response
		49	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response
		50	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response
		51	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response
		52	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and stale response
		53	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and stale response
		54	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response
		55	PASS RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with date and fresh response
		56	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response
		57	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response
		58	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response
		59	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response
		60	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and stale response
		61	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and stale response
		62	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response
		63	PASS RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response
		64	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response
65	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response
66	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response
67	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response
68	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and stale response
69	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and stale response
70	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response
71	PASS RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response
72	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response
73	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response
74	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response
75	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response
76	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and stale response
77	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and stale response
78	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response
79	PASS RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response
80	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response
81	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response
82	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response
83	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response
84	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and stale response
85	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and stale response
86	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response
87	PASS RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response
88	PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and stale response
89	PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and stale response
90	PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with Etag and fresh response
91	PASS Responses with the "Cache-Control: no-store" header are not stored in the cache with date and fresh response
92	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response
93	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response
94	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response
95	PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response
96	PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response
97	PASS RequestCache "reload" mode does store the response in the cache with date and stale response
98	FAIL RequestCache "reload" mode does store the response in the cache with Etag and fresh response assert_equals: expected 1 but got 2
99	FAIL RequestCache "reload" mode does store the response in the cache with date and fresh response assert_equals: expected 1 but got 2
100	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response
101	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response
102	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response
103	PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response
104