Attachment 289456 Details for Bug 162281 – Removing WK2 changes

[patch] Removing WK2 changes

bug-162281-20160921180414.patch (text/plain), 47.46 KB, created by youenn fablet on 2016-09-21 09:07:04 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2016-09-21 09:07:04 PDT

Size: 47.46 KB

patch

obsolete

>Subversion Revision: 206206
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 34e066a884167c78fb04b96ba5dae0fbcbe54e62..e8e180b4e9e2ea2f3b64c1c3a9b2255bde9dd5e0 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,5 +1,50 @@
> 2016-09-21  Youenn Fablet  <youenn@apple.com>
> 
>+        [Fetch API] Support Request cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=162281
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Covered by updated test.
>+
>+        Added support for only-if-cached mode at Request level.
>+
>+        Added support for cache mode at CachedResourceLoader, by setting HTTP headers and ResourceRequest cache policy
>+        based on https://fetch.spec.whatwg.org/#concept-request-cache-mode and https://fetch.spec.whatwg.org/#http-network-or-cache-fetch.
>+
>+        Disabled default cache policy computation (done in FrameLoader) when cache mode is different from the default.
>+        Activated no-store cache mode for EventSource as per https://html.spec.whatwg.org/#the-eventsource-interface.
>+
>+        * Modules/fetch/FetchRequest.cpp:
>+        (WebCore::setCache): Adding support for only-if-cached.
>+        (WebCore::buildOptions): Throw if only-if-cached and fetch mode is not same-origin.
>+        * loader/FetchOptions.h: Adding support for only-if-cached.
>+        * loader/FrameLoader.cpp:
>+        (WebCore::FrameLoader::defaultRequestCachingPolicy): Introduced to ease readability.
>+        (WebCore::FrameLoader::addExtraFieldsToRequest): Updating cache policy only if request has the default cache policy.
>+        This allows bypassing the default behavior for fetch cache mode different from "default".
>+        * loader/FrameLoader.h:
>+        * loader/cache/CachedResourceLoader.cpp:
>+        (WebCore::updateRequestAccordingCacheMode): Introduced to set headers and request cache policy according fetch cache mode.
>+        (WebCore::CachedResourceLoader::requestResource):
>+        (WebCore::CachedResourceLoader::loadResource):
>+        (WebCore::CachedResourceLoader::determineRevalidationPolicy): Ensure bypassing the memory cache in no-store and reload cases.
>+        We reload in case of cache mode=reload to refresh the meory cache entry.
>+        * loader/cache/CachedResourceRequest.h:
>+        (WebCore::CachedResourceRequest::setCacheModeToNoStore):
>+        * page/EventSource.cpp:
>+        (WebCore::EventSource::connect): Use no-store cache mode as per https://html.spec.whatwg.org/#the-eventsource-interface.
>+        * platform/network/HTTPHeaderMap.cpp:
>+        (WebCore::HTTPHeaderMap::addIfNotPresent): Helper routine.
>+        * platform/network/HTTPHeaderMap.h:
>+        * platform/network/ResourceRequestBase.cpp:
>+        (WebCore::ResourceRequestBase::addHTTPHeaderFieldIfNotPresent):
>+        (WebCore::ResourceRequestBase::addHTTPHeaderField):
>+        (WebCore::ResourceRequestBase::hasHTTPHeaderField):
>+        * platform/network/ResourceRequestBase.h:
>+
>+2016-09-21  Youenn Fablet  <youenn@apple.com>
>+
>         [Fetch] Align Accept header default values with fetch spec
>         https://bugs.webkit.org/show_bug.cgi?id=162260
> 
>diff --git a/Source/WebCore/Modules/fetch/FetchRequest.cpp b/Source/WebCore/Modules/fetch/FetchRequest.cpp
>index 9ed25911ac1c972bdcd6f18217ef46257b245c01..6e75dd105a3fdf6e6a9727622d61cc10acab3f7d 100644
>--- a/Source/WebCore/Modules/fetch/FetchRequest.cpp
>+++ b/Source/WebCore/Modules/fetch/FetchRequest.cpp
>@@ -98,6 +98,8 @@ static bool setCache(FetchOptions& options, const String& cache)
>         options.cache = FetchOptions::Cache::NoCache;
>     else if (cache == "force-cache")
>         options.cache = FetchOptions::Cache::ForceCache;
>+    else if (cache == "only-if-cached")
>+        options.cache = FetchOptions::Cache::OnlyIfCached;
>     else
>         return false;
>     return true;
>@@ -182,6 +184,9 @@ static bool buildOptions(FetchRequest::InternalRequest& request, ScriptExecution
>     if (init.get("cache", value) && !setCache(request.options, value))
>         return false;
> 
>+    if (request.options.cache == FetchOptions::Cache::OnlyIfCached && request.options.mode != FetchOptions::Mode::SameOrigin)
>+        return false;
>+
>     if (init.get("redirect", value) && !setRedirect(request.options, value))
>         return false;
> 
>diff --git a/Source/WebCore/loader/FetchOptions.h b/Source/WebCore/loader/FetchOptions.h
>index 499c81b5a442c5550c2d84d460015b644ebe7e77..b733461c64bcb79d5e216f9ca54aa9c38db14468 100644
>--- a/Source/WebCore/loader/FetchOptions.h
>+++ b/Source/WebCore/loader/FetchOptions.h
>@@ -43,7 +43,7 @@ struct FetchOptions {
>     enum class Credentials { Omit, SameOrigin, Include };
>     Credentials credentials { Credentials::Omit };
> 
>-    enum class Cache { Default, NoStore, Reload, NoCache, ForceCache };
>+    enum class Cache { Default, NoStore, Reload, NoCache, ForceCache, OnlyIfCached };
>     Cache cache { Cache::Default };
> 
>     enum class Redirect { Follow, Error, Manual };
>diff --git a/Source/WebCore/loader/FrameLoader.cpp b/Source/WebCore/loader/FrameLoader.cpp
>index 0cdb4b0c43fbb7d7bb0077b2063f82527b87bd6a..4c74c7e82684fa6f806a251f97fe89983d05da76 100644
>--- a/Source/WebCore/loader/FrameLoader.cpp
>+++ b/Source/WebCore/loader/FrameLoader.cpp
>@@ -2561,36 +2561,14 @@ void FrameLoader::addExtraFieldsToMainResourceRequest(ResourceRequest& request)
>     addHTTPUpgradeInsecureRequestsIfNeeded(request);
> }
> 
>-void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadType loadType, bool mainResource)
>+ResourceRequestCachePolicy FrameLoader::defaultRequestCachingPolicy(const ResourceRequest& request, FrameLoadType loadType, bool isMainResource)
> {
>-    Page* page = frame().page();
>-    bool cachingDisabled = page && page->isResourceCachingDisabled();
>-
>-    if (cachingDisabled)
>-        request.setCachePolicy(ReloadIgnoringCacheData);
>-
>-    // Don't set the cookie policy URL if it's already been set.
>-    // But make sure to set it on all requests regardless of protocol, as it has significance beyond the cookie policy (<rdar://problem/6616664>).
>-    if (request.firstPartyForCookies().isEmpty()) {
>-        if (mainResource && m_frame.isMainFrame())
>-            request.setFirstPartyForCookies(request.url());
>-        else if (Document* document = m_frame.document())
>-            request.setFirstPartyForCookies(document->firstPartyForCookies());
>-    }
>-
>-    // The remaining modifications are only necessary for HTTP and HTTPS.
>-    if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
>-        return;
>-
>-    applyUserAgent(request);
>-
>-    if (cachingDisabled) {
>-        // Cache policy was already set above in the non-HTTP-specific code.
>-        loadType = FrameLoadType::ReloadFromOrigin;
>-    } else if (!mainResource) {
>+    if (m_overrideCachePolicyForTesting)
>+        return m_overrideCachePolicyForTesting.value();
>+    if (!isMainResource) {
>         if (request.isConditional())
>-            request.setCachePolicy(ReloadIgnoringCacheData);
>-        else if (documentLoader()->isLoadingInAPISense()) {
>+            return ReloadIgnoringCacheData;
>+        if (documentLoader()->isLoadingInAPISense()) {
>             // If we inherit cache policy from a main resource, we use the DocumentLoader's
>             // original request cache policy for two reasons:
>             // 1. For POST requests, we mutate the cache policy for the main resource,
>@@ -2601,22 +2579,41 @@ void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadTyp
>             ResourceRequestCachePolicy mainDocumentOriginalCachePolicy = documentLoader()->originalRequest().cachePolicy();
>             // Back-forward navigations try to load main resource from cache only to avoid re-submitting form data, and start over (with a warning dialog) if that fails.
>             // This policy is set on initial request too, but should not be inherited.
>-            ResourceRequestCachePolicy subresourceCachePolicy = (mainDocumentOriginalCachePolicy == ReturnCacheDataDontLoad) ? ReturnCacheDataElseLoad : mainDocumentOriginalCachePolicy;
>-            request.setCachePolicy(subresourceCachePolicy);
>-        } else
>-            request.setCachePolicy(UseProtocolCachePolicy);
>-
>+            return (mainDocumentOriginalCachePolicy == ReturnCacheDataDontLoad) ? ReturnCacheDataElseLoad : mainDocumentOriginalCachePolicy;
>+        }
>     // FIXME: Other FrameLoader functions have duplicated code for setting cache policy of main request when reloading.
>     // It seems better to manage it explicitly than to hide the logic inside addExtraFieldsToRequest().
>     } else if (loadType == FrameLoadType::Reload || loadType == FrameLoadType::ReloadFromOrigin || request.isConditional())
>+        return ReloadIgnoringCacheData;
>+
>+    return UseProtocolCachePolicy;
>+}
>+
>+void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadType loadType, bool isMainResource)
>+{
>+    // Don't set the cookie policy URL if it's already been set.
>+    // But make sure to set it on all requests regardless of protocol, as it has significance beyond the cookie policy (<rdar://problem/6616664>).
>+    if (request.firstPartyForCookies().isEmpty()) {
>+        if (isMainResource && m_frame.isMainFrame())
>+            request.setFirstPartyForCookies(request.url());
>+        else if (Document* document = m_frame.document())
>+            request.setFirstPartyForCookies(document->firstPartyForCookies());
>+    }
>+
>+    Page* page = frame().page();
>+    bool hasSpecificCachePolicy = request.cachePolicy() != UseProtocolCachePolicy;
>+
>+    if (page && page->isResourceCachingDisabled()) {
>         request.setCachePolicy(ReloadIgnoringCacheData);
>+        loadType = FrameLoadType::ReloadFromOrigin;
>+    } else if (!hasSpecificCachePolicy)
>+        request.setCachePolicy(defaultRequestCachingPolicy(request, loadType, isMainResource));
> 
>-    if (m_overrideCachePolicyForTesting)
>-        request.setCachePolicy(m_overrideCachePolicyForTesting.value());
>-    if (m_overrideResourceLoadPriorityForTesting)
>-        request.setPriority(m_overrideResourceLoadPriorityForTesting.value());
>+    // The remaining modifications are only necessary for HTTP and HTTPS.
>+    if (!request.url().isEmpty() && !request.url().protocolIsInHTTPFamily())
>+        return;
> 
>-    if (request.cachePolicy() == ReloadIgnoringCacheData) {
>+    if (!hasSpecificCachePolicy && request.cachePolicy() == ReloadIgnoringCacheData) {
>         if (loadType == FrameLoadType::Reload)
>             request.setHTTPHeaderField(HTTPHeaderName::CacheControl, "max-age=0");
>         else if (loadType == FrameLoadType::ReloadFromOrigin) {
>@@ -2625,7 +2622,12 @@ void FrameLoader::addExtraFieldsToRequest(ResourceRequest& request, FrameLoadTyp
>         }
>     }
> 
>-    if (mainResource)
>+    if (m_overrideResourceLoadPriorityForTesting)
>+        request.setPriority(m_overrideResourceLoadPriorityForTesting.value());
>+
>+    applyUserAgent(request);
>+
>+    if (isMainResource)
>         request.setHTTPAccept(defaultAcceptHeader);
> 
>     // Make sure we send the Origin header.
>diff --git a/Source/WebCore/loader/FrameLoader.h b/Source/WebCore/loader/FrameLoader.h
>index 601478c164f4e6e6443ab154f86af4f422506f52..614e526c90f2aa9cb9985ec97cec4b493de8c88d 100644
>--- a/Source/WebCore/loader/FrameLoader.h
>+++ b/Source/WebCore/loader/FrameLoader.h
>@@ -311,16 +311,17 @@ private:
>     bool allChildrenAreComplete() const; // immediate children, not all descendants
> 
>     void checkTimerFired();
>-    
>+
>     void loadSameDocumentItem(HistoryItem&);
>     void loadDifferentDocumentItem(HistoryItem&, FrameLoadType, FormSubmissionCacheLoadPolicy);
>-    
>+
>     void loadProvisionalItemFromCachedPage();
> 
>     void updateFirstPartyForCookies();
>     void setFirstPartyForCookies(const URL&);
>-    
>+
>     void addExtraFieldsToRequest(ResourceRequest&, FrameLoadType, bool isMainResource);
>+    ResourceRequestCachePolicy defaultRequestCachingPolicy(const ResourceRequest&, FrameLoadType, bool isMainResource);
> 
>     void clearProvisionalLoad();
>     void transitionToCommitted(CachedPage*);
>diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>index 017a618497c01e99478060283bee5458d1e4b226..e5f4358ac9e9079f56d4506d9da7bc255f1b44d4 100644
>--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
>@@ -602,6 +602,43 @@ void CachedResourceLoader::prepareFetch(CachedResource::Type type, CachedResourc
>     // FIXME: Decide whether to support client hints
> }
> 
>+static inline void updateRequestAccordingCacheMode(CachedResourceRequest& request)
>+{
>+    if (request.options().cache == FetchOptions::Cache::Default
>+        && (request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfModifiedSince)
>+            || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfNoneMatch)
>+            || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfUnmodifiedSince)
>+            || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfMatch)
>+            || request.resourceRequest().hasHTTPHeaderField(HTTPHeaderName::IfRange)))
>+        request.setCacheModeToNoStore();
>+
>+    switch (request.options().cache) {
>+    case FetchOptions::Cache::NoCache:
>+        request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
>+        request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, ASCIILiteral("max-age=0"));
>+        break;
>+    case FetchOptions::Cache::NoStore:
>+        request.setCachingPolicy(CachingPolicy::DisallowCaching);
>+        request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
>+        request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, ASCIILiteral("no-cache"));
>+        request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, ASCIILiteral("no-cache"));
>+        break;
>+    case FetchOptions::Cache::Reload:
>+        request.mutableResourceRequest().setCachePolicy(ReloadIgnoringCacheData);
>+        request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::Pragma, ASCIILiteral("no-cache"));
>+        request.mutableResourceRequest().addHTTPHeaderFieldIfNotPresent(HTTPHeaderName::CacheControl, ASCIILiteral("no-cache"));
>+        break;
>+    case FetchOptions::Cache::Default:
>+        break;
>+    case FetchOptions::Cache::ForceCache:
>+        request.mutableResourceRequest().setCachePolicy(ReturnCacheDataElseLoad);
>+        break;
>+    case FetchOptions::Cache::OnlyIfCached:
>+        request.mutableResourceRequest().setCachePolicy(ReturnCacheDataDontLoad);
>+        break;
>+    }
>+}
>+
> CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest&& request)
> {
>     if (Document* document = this->document())
>@@ -658,6 +695,9 @@ CachedResourceHandle<CachedResource> CachedResourceLoader::requestResource(Cache
>     loadTiming.markStartTimeAndFetchStart();
> #endif
> 
>+    if (request.resourceRequest().url().protocolIsInHTTPFamily())
>+        updateRequestAccordingCacheMode(request);
>+
>     auto& memoryCache = MemoryCache::singleton();
>     if (request.allowsCaching() && memoryCache.disabled()) {
>         DocumentResourceMap::iterator it = m_documentResources.find(url.string());
>@@ -789,7 +829,8 @@ CachedResourceHandle<CachedResource> CachedResourceLoader::revalidateResource(Ca
> CachedResourceHandle<CachedResource> CachedResourceLoader::loadResource(CachedResource::Type type, CachedResourceRequest&& request)
> {
>     auto& memoryCache = MemoryCache::singleton();
>-    ASSERT(!request.allowsCaching() || !memoryCache.resourceForRequest(request.resourceRequest(), sessionID()));
>+    ASSERT(!request.allowsCaching() || !memoryCache.resourceForRequest(request.resourceRequest(), sessionID())
>+        || request.options().cache == FetchOptions::Cache::NoCache || request.options().cache == FetchOptions::Cache::NoStore || request.options().cache == FetchOptions::Cache::Reload);
> 
>     LOG(ResourceLoading, "Loading CachedResource for '%s'.", request.resourceRequest().url().stringCenterEllipsizedToLength().latin1().data());
> 
>@@ -842,6 +883,12 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
>     if (!existingResource)
>         return Load;
> 
>+    if (cachedResourceRequest.options().cache == FetchOptions::Cache::NoStore)
>+        return Load;
>+
>+    if (cachedResourceRequest.options().cache == FetchOptions::Cache::Reload)
>+        return Reload;
>+
>     // We already have a preload going for this URL.
>     if (cachedResourceRequest.forPreload() && existingResource->isPreloaded())
>         return Use;
>@@ -877,10 +924,12 @@ CachedResourceLoader::RevalidationPolicy CachedResourceLoader::determineRevalida
>     if (cachedResourceRequest.defer() == CachedResourceRequest::DeferredByClient)
>         return Reload;
> 
>-    // Don't reload resources while pasting.
>-    if (m_allowStaleResources)
>+    // Don't reload resources while pasting or if cache mode allows stale resources.
>+    if (m_allowStaleResources || cachedResourceRequest.options().cache == FetchOptions::Cache::ForceCache || cachedResourceRequest.options().cache == FetchOptions::Cache::OnlyIfCached)
>         return Use;
> 
>+    ASSERT(cachedResourceRequest.options().cache == FetchOptions::Cache::Default || cachedResourceRequest.options().cache == FetchOptions::Cache::NoCache);
>+
>     // Always use preloads.
>     if (existingResource->isPreloaded())
>         return Use;
>diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.h b/Source/WebCore/loader/cache/CachedResourceRequest.h
>index a1d80eea577dcf9be2e22d16480a0267b5726adc..ffb2633d110b79190163d5856a87c232ce6c40b6 100644
>--- a/Source/WebCore/loader/cache/CachedResourceRequest.h
>+++ b/Source/WebCore/loader/cache/CachedResourceRequest.h
>@@ -63,6 +63,8 @@ public:
> 
>     void setAsPotentiallyCrossOrigin(const String&, Document&);
> 
>+    void setCacheModeToNoStore() { m_options.cache = FetchOptions::Cache::NoStore; }
>+
> private:
>     ResourceRequest m_resourceRequest;
>     String m_charset;
>diff --git a/Source/WebCore/page/EventSource.cpp b/Source/WebCore/page/EventSource.cpp
>index d138205c27209606b5ffc7068ba852ee53ac6217..4c5cbc073b8263f39294014ce664b682b301f445 100644
>--- a/Source/WebCore/page/EventSource.cpp
>+++ b/Source/WebCore/page/EventSource.cpp
>@@ -108,6 +108,7 @@ void EventSource::connect()
>     options.credentials = m_withCredentials ? FetchOptions::Credentials::Include : FetchOptions::Credentials::SameOrigin;
>     options.preflightPolicy = PreventPreflight;
>     options.mode = FetchOptions::Mode::Cors;
>+    options.cache = FetchOptions::Cache::NoStore;
>     options.dataBufferingPolicy = DoNotBufferData;
>     options.contentSecurityPolicyEnforcement = scriptExecutionContext()->shouldBypassMainWorldContentSecurityPolicy() ? ContentSecurityPolicyEnforcement::DoNotEnforce : ContentSecurityPolicyEnforcement::EnforceConnectSrcDirective;
> 
>diff --git a/Source/WebCore/platform/network/HTTPHeaderMap.cpp b/Source/WebCore/platform/network/HTTPHeaderMap.cpp
>index bb20f7080ff24dd0e0d7f3ca15545c23c1c427b9..4fc814849c886a34bdbf0d32211faf8b0538b65c 100644
>--- a/Source/WebCore/platform/network/HTTPHeaderMap.cpp
>+++ b/Source/WebCore/platform/network/HTTPHeaderMap.cpp
>@@ -103,6 +103,11 @@ void HTTPHeaderMap::add(const String& name, const String& value)
>     add(headerName, value);
> }
> 
>+bool HTTPHeaderMap::addIfNotPresent(HTTPHeaderName headerName, const String& value)
>+{
>+    return m_commonHeaders.add(headerName, value).isNewEntry;
>+}
>+
> bool HTTPHeaderMap::contains(const String& name) const
> {
>     HTTPHeaderName headerName;
>diff --git a/Source/WebCore/platform/network/HTTPHeaderMap.h b/Source/WebCore/platform/network/HTTPHeaderMap.h
>index 3709f2573f207d0b797eee9e63b67f08a3f5dc26..1495a6c924eb31e04ddfdc5eceddbcd5c996830d 100644
>--- a/Source/WebCore/platform/network/HTTPHeaderMap.h
>+++ b/Source/WebCore/platform/network/HTTPHeaderMap.h
>@@ -141,6 +141,7 @@ public:
>     WEBCORE_EXPORT String get(HTTPHeaderName) const;
>     void set(HTTPHeaderName, const String& value);
>     void add(HTTPHeaderName, const String& value);
>+    bool addIfNotPresent(HTTPHeaderName, const String&);
>     bool contains(HTTPHeaderName) const;
>     WEBCORE_EXPORT bool remove(HTTPHeaderName);
> 
>diff --git a/Source/WebCore/platform/network/ResourceRequestBase.cpp b/Source/WebCore/platform/network/ResourceRequestBase.cpp
>index a6b5356dea4242d93e95b1d3c4d0e9e0798bc6d5..f223bfe0b4bb76ceba262bca2815bd1e0b31f7c8 100644
>--- a/Source/WebCore/platform/network/ResourceRequestBase.cpp
>+++ b/Source/WebCore/platform/network/ResourceRequestBase.cpp
>@@ -464,6 +464,17 @@ void ResourceRequestBase::setPriority(ResourceLoadPriority priority)
>         m_platformRequestUpdated = false;
> }
> 
>+void ResourceRequestBase::addHTTPHeaderFieldIfNotPresent(HTTPHeaderName name, const String& value)
>+{
>+    updateResourceRequest();
>+
>+    if (!m_httpHeaderFields.addIfNotPresent(name, value))
>+        return;
>+
>+    if (url().protocolIsInHTTPFamily())
>+        m_platformRequestUpdated = false;
>+}
>+
> void ResourceRequestBase::addHTTPHeaderField(HTTPHeaderName name, const String& value)
> {
>     updateResourceRequest();
>@@ -477,13 +488,18 @@ void ResourceRequestBase::addHTTPHeaderField(HTTPHeaderName name, const String&
> void ResourceRequestBase::addHTTPHeaderField(const String& name, const String& value)
> {
>     updateResourceRequest();
>-    
>+
>     m_httpHeaderFields.add(name, value);
>-    
>+
>     if (url().protocolIsInHTTPFamily())
>         m_platformRequestUpdated = false;
> }
>-    
>+
>+bool ResourceRequestBase::hasHTTPHeaderField(HTTPHeaderName headerName) const
>+{
>+    return m_httpHeaderFields.contains(headerName);
>+}
>+
> void ResourceRequestBase::setHTTPHeaderFields(HTTPHeaderMap headerFields)
> {
>     updateResourceRequest();
>diff --git a/Source/WebCore/platform/network/ResourceRequestBase.h b/Source/WebCore/platform/network/ResourceRequestBase.h
>index 010acc53fc3cecae7493a17668611e0dcac9bfe7..49fb67f745262c9c49bcd0387972f99895dbce8b 100644
>--- a/Source/WebCore/platform/network/ResourceRequestBase.h
>+++ b/Source/WebCore/platform/network/ResourceRequestBase.h
>@@ -85,6 +85,9 @@ public:
>     WEBCORE_EXPORT void setHTTPHeaderField(HTTPHeaderName, const String& value);
>     void addHTTPHeaderField(HTTPHeaderName, const String& value);
>     void addHTTPHeaderField(const String& name, const String& value);
>+    void addHTTPHeaderFieldIfNotPresent(HTTPHeaderName, const String&);
>+
>+    bool hasHTTPHeaderField(HTTPHeaderName) const;
> 
>     // Instead of passing a string literal to any of these functions, just use a HTTPHeaderName instead.
>     template<size_t length> String httpHeaderField(const char (&)[length]) const = delete;
>diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog
>index 38346a7255cf9cd1007fb03d1f9c6b768bc17712..148d7be48ac9dfca0446372996c9d915fe57f56c 100644
>--- a/LayoutTests/ChangeLog
>+++ b/LayoutTests/ChangeLog
>@@ -1,5 +1,18 @@
> 2016-09-21  Youenn Fablet  <youenn@apple.com>
> 
>+        [Fetch API] Support Request cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=162281
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Activating request-cache.html tests for WK1, but not yet for WK2.
>+
>+        * TestExpectations:
>+        * platform/mac/TestExpectations:
>+        * platform/wk2/TestExpectations:
>+
>+2016-09-21  Youenn Fablet  <youenn@apple.com>
>+
>         [Fetch] Align Accept header default values with fetch spec
>         https://bugs.webkit.org/show_bug.cgi?id=162260
> 
>diff --git a/LayoutTests/imported/w3c/ChangeLog b/LayoutTests/imported/w3c/ChangeLog
>index cf0557be5dc1d9ba608d4fdd0c0c02a90203c214..a6013cd8e053b646b7abb8c5555cee32c1333cde 100644
>--- a/LayoutTests/imported/w3c/ChangeLog
>+++ b/LayoutTests/imported/w3c/ChangeLog
>@@ -1,5 +1,16 @@
> 2016-09-21  Youenn Fablet  <youenn@apple.com>
> 
>+        [Fetch API] Support Request cache mode
>+        https://bugs.webkit.org/show_bug.cgi?id=162281
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * web-platform-tests/fetch/api/request/request-cache-expected.txt: Rebasing test now that more tests are passing.
>+        * web-platform-tests/fetch/api/request/request-error-expected.txt:
>+        * web-platform-tests/fetch/api/request/request-error.html: Adding test to ensure only-if-cached is used with same-origin fetch mode.
>+
>+2016-09-21  Youenn Fablet  <youenn@apple.com>
>+
>         [Fetch] Align Accept header default values with fetch spec
>         https://bugs.webkit.org/show_bug.cgi?id=162260
> 
>diff --git a/LayoutTests/TestExpectations b/LayoutTests/TestExpectations
>index e7925c64a404bef8ad3fe18ad22f1432585567e8..d7fd93a8a1ecf93e8652306a833e298cbe1a5ec1 100644
>--- a/LayoutTests/TestExpectations
>+++ b/LayoutTests/TestExpectations
>@@ -273,8 +273,6 @@ imported/w3c/web-platform-tests/XMLHttpRequest/send-redirect-to-non-cors.htm [ S
> # Failing assertion with dynamic message
> imported/w3c/web-platform-tests/XMLHttpRequest/responsexml-document-properties.htm [ Failure ]
> 
>-imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Skip ]
>-
> webkit.org/b/161176 [ Debug ] imported/w3c/web-platform-tests/url/url-setters.html [ Skip ]
> 
> webkit.org/b/157068 imported/w3c/web-platform-tests/fetch/nosniff/importscripts.html [ Skip ]
>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 ec1501adc2ea7a97f27dc062327bf39c0b54d13a..5529cb0e0e27b55b53e255fa49204532fdd1861d 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
>@@ -5,10 +5,10 @@ PASS RequestCache "default" mode checks the cache for previously cached content
> 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 
>-FAIL RequestCache "no-cache" mode revalidates fresh responses found in the cache with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "no-cache" mode revalidates fresh responses found in the cache with date and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with Etag and stale response assert_equals: expected 1 but got 2
>-FAIL RequestCache "force-cache" mode checks the cache for previously cached content and avoid revalidation for stale responses with date and stale response assert_equals: expected 1 but got 2
>+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 
>@@ -23,10 +23,10 @@ PASS RequestCache "force-cache" stores the response in the cache if it goes to t
> 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 
>-FAIL RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with Etag and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
>-FAIL RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for stale responses with date and stale response promise_test: Unhandled rejection with value: object "TypeError: Type error"
>-FAIL RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with Etag and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
>-FAIL RequestCache "only-if-cached" mode checks the cache for previously cached content and avoids revalidation for fresh responses with date and fresh response promise_test: Unhandled rejection with value: object "TypeError: Type error"
>+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"
>@@ -37,21 +37,21 @@ PASS RequestCache "only-if-cached" (with "same-origin") does not follow redirect
> 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 
>-FAIL RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response assert_equals: expected (undefined) undefined but got (string) "\"0.04196530864700354\""
>-FAIL RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response assert_equals: expected (undefined) undefined but got (string) "Fri, 09 Sep 2016 08:49:10 GMT"
>-FAIL RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "no-store" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "no-store" mode does not store the response in the cache with Etag and stale response assert_equals: expected (undefined) undefined but got (string) "\"0.12846053184726147\""
>-FAIL RequestCache "no-store" mode does not store the response in the cache with date and stale response assert_equals: expected (undefined) undefined but got (string) "Fri, 09 Sep 2016 08:49:10 GMT"
>-FAIL RequestCache "no-store" mode does not store the response in the cache with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "no-store" mode does not store the response in the cache with date and fresh response assert_equals: expected 2 but got 1
>+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 
>-FAIL RequestCache "default" mode with an If-Modified-Since header is treated similarly to "no-store" with Etag and fresh response assert_equals: expected 2 but got 1
>+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 
>@@ -59,46 +59,46 @@ PASS RequestCache "default" mode with an If-None-Match header is treated similar
> 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 
>-FAIL RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "default" mode with an If-None-Match header is treated similarly to "no-store" with date and fresh response assert_equals: expected 2 but got 1
>+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 
>-FAIL RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "default" mode with an If-Unmodified-Since header is treated similarly to "no-store" with date and fresh response assert_equals: expected 2 but got 1
>+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 
>-FAIL RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "default" mode with an If-Match header is treated similarly to "no-store" with date and fresh response assert_equals: expected 2 but got 1
>+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 
>-FAIL RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "default" mode with an If-Range header is treated similarly to "no-store" with date and fresh response assert_equals: expected 2 but got 1
>+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 
>-FAIL RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response assert_equals: expected (undefined) undefined but got (string) "\"0.7894894845056666\""
>-FAIL RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response assert_equals: expected (undefined) undefined but got (string) "Fri, 09 Sep 2016 08:49:10 GMT"
>-FAIL RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response assert_equals: expected 2 but got 1
>+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and stale response 
>+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and stale response 
>+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with Etag and fresh response 
>+PASS RequestCache "reload" mode does not check the cache for previously cached content and goes to the network regardless with date and fresh response 
> PASS RequestCache "reload" mode does store the response in the cache with Etag and stale response 
> PASS RequestCache "reload" mode does store the response in the cache with date and stale response 
>-PASS RequestCache "reload" mode does store the response in the cache with Etag and fresh response 
>-PASS RequestCache "reload" mode does store the response in the cache with date and fresh response 
>-FAIL RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response assert_equals: expected (undefined) undefined but got (string) "\"0.49509960167414313\""
>-FAIL RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response assert_equals: expected (undefined) undefined but got (string) "Fri, 09 Sep 2016 08:49:10 GMT"
>-FAIL RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response assert_equals: expected 2 but got 1
>-FAIL RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response assert_equals: expected 2 but got 1
>+FAIL RequestCache "reload" mode does store the response in the cache with Etag and fresh response assert_equals: expected 1 but got 2
>+FAIL RequestCache "reload" mode does store the response in the cache with date and fresh response assert_equals: expected 1 but got 2
>+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and stale response 
>+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and stale response 
>+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with Etag and fresh response 
>+PASS RequestCache "reload" mode does store the response in the cache even if a previous response is already stored with date and fresh response 
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error-expected.txt b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error-expected.txt
>index a9e8e372de6e61f8a5615cde906884d17d455cd2..e80fba8724db8aa30b3d9ae88fbd5623f3cfa9d1 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error-expected.txt
>+++ b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error-expected.txt
>@@ -19,4 +19,8 @@ PASS Bad mode init parameter value
> PASS Bad credentials init parameter value 
> PASS Bad cache init parameter value 
> PASS Bad redirect init parameter value 
>+PASS Request with cache mode: only-if-cached and fetch mode: same-origin 
>+PASS Request with cache mode: only-if-cached and fetch mode: cors 
>+PASS Request with cache mode: only-if-cached and fetch mode: no-cors 
>+PASS Request should not get its content-type from the init request if init headers are provided 
> 
>diff --git a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error.html b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error.html
>index c87429e76372608a7ba8763c255a6a30e04e2ae8..279aeda573e3c6f8d4de4c790eb6e883b8368b68 100644
>--- a/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error.html
>+++ b/LayoutTests/imported/w3c/web-platform-tests/fetch/api/request/request-error.html
>@@ -105,6 +105,28 @@
>           assert_throws(new TypeError(), function() { new Request("", options); });
>         },"Bad " + parameter +" init parameter value");
>       });
>+
>+      function testOnlyIfCachedMode(fetchMode, ok) {
>+        test(function() {
>+          var options = {"cache": "only-if-cached", "mode": fetchMode};
>+          if (ok)
>+            new Request("test", options);
>+          else
>+            assert_throws(new TypeError(), function() { new Request("test", options); });
>+        }, "Request with cache mode: only-if-cached and fetch mode: " + fetchMode);
>+      }
>+      testOnlyIfCachedMode("same-origin", true);
>+      testOnlyIfCachedMode("cors", false);
>+      testOnlyIfCachedMode("no-cors", false);
>+
>+      test(function() {
>+        var initialHeaders = new Headers([["Content-Type", "potato"]]);
>+        var initialRequest = new Request("", {"headers" : initialHeaders});
>+        var headers = new Headers([]);
>+        var request = new Request(initialRequest, {"headers" : headers});
>+        assert_false(request.headers.has("Content-Type"));
>+      }, "Request should not get its content-type from the init request if init headers are provided");
>+
>     </script>
>   </body>
> </html>
>diff --git a/LayoutTests/platform/mac/TestExpectations b/LayoutTests/platform/mac/TestExpectations
>index 520f7246349ecd803100145dead994d0fec81aa4..7495c471c6205e733edf0866af9127e6b1549b02 100644
>--- a/LayoutTests/platform/mac/TestExpectations
>+++ b/LayoutTests/platform/mac/TestExpectations
>@@ -1406,8 +1406,6 @@ webkit.org/b/158747 [ ElCapitan ] media/restore-from-page-cache.html [ Pass Fail
> 
> webkit.org/b/151287 [ ElCapitan ] media/controls/inline-elements-dropoff-order.html [ Failure ]
> 
>-webkit.org/b/159683 imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Pass Failure ]
>-
> webkit.org/b/158500 storage/indexeddb/database-close-private.html [ Pass Failure ]
> 
> webkit.org/b/158640 imported/blink/storage/indexeddb/blob-valid-after-deletion.html [ Pass Failure ]
>diff --git a/LayoutTests/platform/wk2/TestExpectations b/LayoutTests/platform/wk2/TestExpectations
>index 86dc1e14ebd6633db0524e1532426871e4765939..639a744b6ee61ac6b9ccb133673e3bbdcab396dd 100644
>--- a/LayoutTests/platform/wk2/TestExpectations
>+++ b/LayoutTests/platform/wk2/TestExpectations
>@@ -690,6 +690,9 @@ fast/images/gif-loop-count.html [ Pass ]
> # DumpRenderTree does not implement setWillSendRequestHTTPBody
> http/tests/misc/will-send-request-with-client-provided-http-body.html [ Pass ]
> 
>+# bug 162281
>+imported/w3c/web-platform-tests/fetch/api/request/request-cache.html [ Skip ]
>+
> ### END OF (5) Progressions, expected successes that are expected failures in WebKit1.
> ########################################
>

Actions: View | Formatted Diff | Diff

Attachments on bug 162281: 289358 | 289373 | 289374 | 289376 | 289378 | 289448 | 289456 | 291246