https://bugs.webkit.org/show_bug.cgi?id=175679
Reviewed by Youenn Fablet.
Source/WebCore:
For performance reason, we should only copy the original request headers for Ping loads
(Beacon at the moment), not for all CachedResourceRequests.
* loader/LoaderStrategy.h:
* loader/cache/CachedResource.cpp:
(WebCore::CachedResource::CachedResource):
(WebCore::CachedResource::load):
* loader/cache/CachedResource.h:
(WebCore::CachedResource::shouldUsePingLoad):
(WebCore::CachedResource::setOriginalRequestHeaders):
* loader/cache/CachedResourceLoader.cpp:
(WebCore::CachedResourceLoader::requestResource):
* loader/cache/CachedResourceRequest.cpp:
(WebCore::CachedResourceRequest::CachedResourceRequest):
* loader/cache/CachedResourceRequest.h:
(WebCore::CachedResourceRequest::releaseResourceRequest):
(WebCore::CachedResourceRequest::releaseOriginalRequestHeaders): Deleted.
Source/WebKit:
For performance reason, we should only copy the original request headers for Ping loads
(Beacon at the moment), not for all CachedResourceRequests.
* NetworkProcess/NetworkConnectionToWebProcess.cpp:
(WebKit::NetworkConnectionToWebProcess::loadPing):
* NetworkProcess/NetworkConnectionToWebProcess.h:
* NetworkProcess/NetworkConnectionToWebProcess.messages.in:
* NetworkProcess/NetworkResourceLoadParameters.cpp:
(WebKit::NetworkResourceLoadParameters::encode const):
(WebKit::NetworkResourceLoadParameters::decode):
* NetworkProcess/NetworkResourceLoadParameters.h:
* NetworkProcess/PingLoad.cpp:
(WebKit::PingLoad::PingLoad):
(WebKit::PingLoad::willPerformHTTPRedirection):
(WebKit::PingLoad::makeCrossOriginAccessRequest):
(WebKit::PingLoad::makeSimpleCrossOriginAccessRequest):
(WebKit::PingLoad::originalRequestHeaders const): Deleted.
* NetworkProcess/PingLoad.h:
* WebProcess/Network/WebLoaderStrategy.cpp:
(WebKit::WebLoaderStrategy::createPingHandle):
* WebProcess/Network/WebLoaderStrategy.h:
Source/WebKitLegacy:
* WebCoreSupport/WebResourceLoadScheduler.cpp:
(WebResourceLoadScheduler::createPingHandle):
* WebCoreSupport/WebResourceLoadScheduler.h:
git-svn-id: https://svn.webkit.org/repository/webkit/trunk@220888
268f45cc-cd09-0410-ab3c-
d52691b4dbfc
+2017-08-17 Chris Dumez <cdumez@apple.com>
+
+ Regression(r220817): We should only copy the original request headers for Ping loads
+ https://bugs.webkit.org/show_bug.cgi?id=175679
+
+ Reviewed by Youenn Fablet.
+
+ For performance reason, we should only copy the original request headers for Ping loads
+ (Beacon at the moment), not for all CachedResourceRequests.
+
+ * loader/LoaderStrategy.h:
+ * loader/cache/CachedResource.cpp:
+ (WebCore::CachedResource::CachedResource):
+ (WebCore::CachedResource::load):
+ * loader/cache/CachedResource.h:
+ (WebCore::CachedResource::shouldUsePingLoad):
+ (WebCore::CachedResource::setOriginalRequestHeaders):
+ * loader/cache/CachedResourceLoader.cpp:
+ (WebCore::CachedResourceLoader::requestResource):
+ * loader/cache/CachedResourceRequest.cpp:
+ (WebCore::CachedResourceRequest::CachedResourceRequest):
+ * loader/cache/CachedResourceRequest.h:
+ (WebCore::CachedResourceRequest::releaseResourceRequest):
+ (WebCore::CachedResourceRequest::releaseOriginalRequestHeaders): Deleted.
+
2017-08-17 Don Olmstead <don.olmstead@sony.com>
[PAL] Relocate SessionID to root
virtual void suspendPendingRequests() = 0;
virtual void resumePendingRequests() = 0;
- virtual void createPingHandle(NetworkingContext*, ResourceRequest&, HTTPHeaderMap&& originalRequestHeaders, Ref<SecurityOrigin>&& sourceOrigin, ContentSecurityPolicy*, const FetchOptions&) = 0;
+ virtual void createPingHandle(NetworkingContext*, ResourceRequest&, const HTTPHeaderMap& originalRequestHeaders, Ref<SecurityOrigin>&& sourceOrigin, ContentSecurityPolicy*, const FetchOptions&) = 0;
virtual void storeDerivedDataToCache(const SHA1::Digest& bodyKey, const String& type, const String& partition, WebCore::SharedBuffer&) = 0;
CachedResource::CachedResource(CachedResourceRequest&& request, Type type, PAL::SessionID sessionID)
: m_resourceRequest(request.releaseResourceRequest())
- , m_originalRequestHeaders(request.releaseOriginalRequestHeaders())
, m_options(request.options())
, m_decodedDataDeletionTimer(*this, &CachedResource::destroyDecodedData, deadDecodedDataDeletionIntervalForResourceType(type))
, m_sessionID(sessionID)
return;
}
// FIXME: We should not special-case Beacon here.
- if (type() == CachedResource::Beacon) {
+ if (shouldUsePingLoad(type())) {
ASSERT(m_origin);
// Beacon is not exposed to workers so it is safe to rely on the document here.
auto* document = cachedResourceLoader.document();
auto* contentSecurityPolicy = document && !document->shouldBypassMainWorldContentSecurityPolicy() ? document->contentSecurityPolicy() : nullptr;
- platformStrategies()->loaderStrategy()->createPingHandle(frame.loader().networkingContext(), request, HTTPHeaderMap(m_originalRequestHeaders), *m_origin, contentSecurityPolicy, m_options);
+ ASSERT(m_originalRequestHeaders);
+ platformStrategies()->loaderStrategy()->createPingHandle(frame.loader().networkingContext(), request, *m_originalRequestHeaders, *m_origin, contentSecurityPolicy, m_options);
// FIXME: We currently do not get notified when ping loads finish so we treat them as finishing right away.
finishLoading(nullptr);
return;
PAL::SessionID sessionID() const { return m_sessionID; }
Type type() const { return m_type; }
+ static bool shouldUsePingLoad(Type type) { return type == Type::Beacon; }
+
ResourceLoadPriority loadPriority() const { return m_loadPriority; }
void setLoadPriority(const std::optional<ResourceLoadPriority>&);
unsigned long identifierForLoadWithoutResourceLoader() const { return m_identifierForLoadWithoutResourceLoader; }
static ResourceLoadPriority defaultPriorityForResourceType(Type);
+ void setOriginalRequestHeaders(std::optional<HTTPHeaderMap>&& originalRequestHeaders) { m_originalRequestHeaders = WTFMove(originalRequestHeaders); }
+
protected:
// CachedResource constructor that may be used when the CachedResource can already be filled with response data.
CachedResource(const URL&, Type, PAL::SessionID);
// FIXME: Make the rest of these data members private and use functions in derived classes instead.
HashCountedSet<CachedResourceClient*> m_clients;
ResourceRequest m_resourceRequest;
- HTTPHeaderMap m_originalRequestHeaders;
+ std::optional<HTTPHeaderMap> m_originalRequestHeaders; // Needed by Ping loads.
RefPtr<SubresourceLoader> m_loader;
ResourceLoaderOptions m_options;
ResourceResponse m_response;
ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::requestResource(CachedResource::Type type, CachedResourceRequest&& request, ForPreload forPreload, DeferOption defer)
{
+ std::optional<HTTPHeaderMap> originalRequestHeaders;
+ if (CachedResource::shouldUsePingLoad(type))
+ originalRequestHeaders = request.resourceRequest().httpHeaderFields();
+
if (Document* document = this->document())
request.upgradeInsecureRequestIfNeeded(*document);
break;
}
ASSERT(resource);
+ resource->setOriginalRequestHeaders(WTFMove(originalRequestHeaders));
if (forPreload == ForPreload::No && resource->loader() && resource->ignoreForRequestCount()) {
resource->setIgnoreForRequestCount(false);
CachedResourceRequest::CachedResourceRequest(ResourceRequest&& resourceRequest, const ResourceLoaderOptions& options, std::optional<ResourceLoadPriority> priority, String&& charset)
: m_resourceRequest(WTFMove(resourceRequest))
- , m_originalRequestHeaders(m_resourceRequest.httpHeaderFields())
, m_charset(WTFMove(charset))
, m_options(options)
, m_priority(priority)
CachedResourceRequest(ResourceRequest&&, const ResourceLoaderOptions&, std::optional<ResourceLoadPriority> = std::nullopt, String&& charset = String());
ResourceRequest&& releaseResourceRequest() { return WTFMove(m_resourceRequest); }
- HTTPHeaderMap&& releaseOriginalRequestHeaders() { return WTFMove(m_originalRequestHeaders); }
const ResourceRequest& resourceRequest() const { return m_resourceRequest; }
const String& charset() const { return m_charset; }
void setCharset(const String& charset) { m_charset = charset; }
private:
ResourceRequest m_resourceRequest;
- HTTPHeaderMap m_originalRequestHeaders;
String m_charset;
ResourceLoaderOptions m_options;
std::optional<ResourceLoadPriority> m_priority;
+2017-08-17 Chris Dumez <cdumez@apple.com>
+
+ Regression(r220817): We should only copy the original request headers for Ping loads
+ https://bugs.webkit.org/show_bug.cgi?id=175679
+
+ Reviewed by Youenn Fablet.
+
+ For performance reason, we should only copy the original request headers for Ping loads
+ (Beacon at the moment), not for all CachedResourceRequests.
+
+ * NetworkProcess/NetworkConnectionToWebProcess.cpp:
+ (WebKit::NetworkConnectionToWebProcess::loadPing):
+ * NetworkProcess/NetworkConnectionToWebProcess.h:
+ * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
+ * NetworkProcess/NetworkResourceLoadParameters.cpp:
+ (WebKit::NetworkResourceLoadParameters::encode const):
+ (WebKit::NetworkResourceLoadParameters::decode):
+ * NetworkProcess/NetworkResourceLoadParameters.h:
+ * NetworkProcess/PingLoad.cpp:
+ (WebKit::PingLoad::PingLoad):
+ (WebKit::PingLoad::willPerformHTTPRedirection):
+ (WebKit::PingLoad::makeCrossOriginAccessRequest):
+ (WebKit::PingLoad::makeSimpleCrossOriginAccessRequest):
+ (WebKit::PingLoad::originalRequestHeaders const): Deleted.
+ * NetworkProcess/PingLoad.h:
+ * WebProcess/Network/WebLoaderStrategy.cpp:
+ (WebKit::WebLoaderStrategy::createPingHandle):
+ * WebProcess/Network/WebLoaderStrategy.h:
+
2017-08-17 Don Olmstead <don.olmstead@sony.com>
[PAL] Relocate SessionID to root
loader->start();
}
-void NetworkConnectionToWebProcess::loadPing(NetworkResourceLoadParameters&& loadParameters)
+void NetworkConnectionToWebProcess::loadPing(NetworkResourceLoadParameters&& loadParameters, HTTPHeaderMap&& originalRequestHeaders)
{
#if USE(NETWORK_SESSION)
// PingLoad manages its own lifetime, deleting itself when its purpose has been fulfilled.
- new PingLoad(WTFMove(loadParameters));
+ new PingLoad(WTFMove(loadParameters), WTFMove(originalRequestHeaders));
#else
+ UNUSED_PARAM(originalRequestHeaders);
RefPtr<NetworkingContext> context = RemoteNetworkingContext::create(loadParameters.sessionID, loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect);
// PingHandle manages its own lifetime, deleting itself when its purpose has been fulfilled.
namespace WebCore {
class BlobDataFileReference;
+class HTTPHeaderMap;
class ResourceRequest;
}
void scheduleResourceLoad(const NetworkResourceLoadParameters&);
void performSynchronousLoad(const NetworkResourceLoadParameters&, Ref<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>&&);
- void loadPing(NetworkResourceLoadParameters&&);
+ void loadPing(NetworkResourceLoadParameters&&, WebCore::HTTPHeaderMap&& originalRequestHeaders);
void prefetchDNS(const String&);
void removeLoadIdentifier(ResourceLoadIdentifier);
ScheduleResourceLoad(WebKit::NetworkResourceLoadParameters resourceLoadParameters)
PerformSynchronousLoad(WebKit::NetworkResourceLoadParameters resourceLoadParameters) -> (WebCore::ResourceError error, WebCore::ResourceResponse response, Vector<char> data) Delayed
- LoadPing(WebKit::NetworkResourceLoadParameters resourceLoadParameters)
+ LoadPing(WebKit::NetworkResourceLoadParameters resourceLoadParameters, WebCore::HTTPHeaderMap originalRequestHeaders)
RemoveLoadIdentifier(uint64_t resourceLoadIdentifier)
SetDefersLoading(uint64_t resourceLoadIdentifier, bool defers)
PrefetchDNS(String hostname)
encoder << SecurityOriginData::fromSecurityOrigin(*sourceOrigin);
encoder.encodeEnum(mode);
encoder << cspResponseHeaders;
- encoder << originalRequestHeaders;
}
bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourceLoadParameters& result)
return false;
if (!decoder.decode(result.cspResponseHeaders))
return false;
- if (!decoder.decode(result.originalRequestHeaders))
- return false;
return true;
}
#include "SandboxExtension.h"
#include <WebCore/ContentSecurityPolicyResponseHeaders.h>
#include <WebCore/FetchOptions.h>
-#include <WebCore/HTTPHeaderMap.h>
#include <WebCore/ResourceHandle.h>
#include <WebCore/ResourceLoaderOptions.h>
#include <WebCore/ResourceRequest.h>
RefPtr<WebCore::SecurityOrigin> sourceOrigin;
WebCore::FetchOptions::Mode mode;
std::optional<WebCore::ContentSecurityPolicyResponseHeaders> cspResponseHeaders;
- std::optional<WebCore::HTTPHeaderMap> originalRequestHeaders;
};
} // namespace WebKit
using namespace WebCore;
-PingLoad::PingLoad(NetworkResourceLoadParameters&& parameters)
+PingLoad::PingLoad(NetworkResourceLoadParameters&& parameters, HTTPHeaderMap&& originalRequestHeaders)
: m_parameters(WTFMove(parameters))
+ , m_originalRequestHeaders(WTFMove(originalRequestHeaders))
, m_timeoutTimer(*this, &PingLoad::timeoutTimerFired)
, m_isSameOriginRequest(securityOrigin().canRequest(m_parameters.request.url()))
{
ASSERT(m_parameters.sourceOrigin);
- ASSERT(m_parameters.originalRequestHeaders);
// If the server never responds, this object will hang around forever.
// Set a very generous timeout, just in case.
return m_origin ? *m_origin : *m_parameters.sourceOrigin;
}
-const HTTPHeaderMap& PingLoad::originalRequestHeaders() const
-{
- return *m_parameters.originalRequestHeaders;
-}
-
void PingLoad::willPerformHTTPRedirection(ResourceResponse&& redirectResponse, ResourceRequest&& request, RedirectCompletionHandler&& completionHandler)
{
RELEASE_LOG_IF_ALLOWED("willPerformHTTPRedirection - shouldFollowRedirects? %d", m_parameters.shouldFollowRedirects);
}
// Except in case where preflight is needed, loading should be able to continue on its own.
- if (m_isSimpleRequest && isSimpleCrossOriginAccessRequest(request.httpMethod(), originalRequestHeaders())) {
+ if (m_isSimpleRequest && isSimpleCrossOriginAccessRequest(request.httpMethod(), m_originalRequestHeaders)) {
completionHandler(WTFMove(request));
return;
}
ASSERT(m_parameters.mode == FetchOptions::Mode::Cors);
RELEASE_LOG_IF_ALLOWED("makeCrossOriginAccessRequest");
- if (isSimpleCrossOriginAccessRequest(request.httpMethod(), originalRequestHeaders())) {
+ if (isSimpleCrossOriginAccessRequest(request.httpMethod(), m_originalRequestHeaders)) {
makeSimpleCrossOriginAccessRequest(WTFMove(request));
return;
}
m_isSimpleRequest = false;
- if (CrossOriginPreflightResultCache::singleton().canSkipPreflight(securityOrigin().toString(), request.url(), m_parameters.allowStoredCredentials, request.httpMethod(), originalRequestHeaders())) {
+ if (CrossOriginPreflightResultCache::singleton().canSkipPreflight(securityOrigin().toString(), request.url(), m_parameters.allowStoredCredentials, request.httpMethod(), m_originalRequestHeaders)) {
RELEASE_LOG_IF_ALLOWED("makeCrossOriginAccessRequest - preflight can be skipped thanks to cached result");
preflightSuccess(WTFMove(request));
} else
void PingLoad::makeSimpleCrossOriginAccessRequest(ResourceRequest&& request)
{
- ASSERT(isSimpleCrossOriginAccessRequest(request.httpMethod(), originalRequestHeaders()));
+ ASSERT(isSimpleCrossOriginAccessRequest(request.httpMethod(), m_originalRequestHeaders));
RELEASE_LOG_IF_ALLOWED("makeSimpleCrossOriginAccessRequest");
if (!request.url().protocolIsInHTTPFamily()) {
namespace WebCore {
class ContentSecurityPolicy;
+class HTTPHeaderMap;
class URL;
}
class PingLoad final : private NetworkDataTaskClient {
public:
- explicit PingLoad(NetworkResourceLoadParameters&&);
+ PingLoad(NetworkResourceLoadParameters&&, WebCore::HTTPHeaderMap&& originalRequestHeaders);
private:
~PingLoad();
void preflightSuccess(WebCore::ResourceRequest&&);
WebCore::SecurityOrigin& securityOrigin() const;
- const WebCore::HTTPHeaderMap& originalRequestHeaders() const; // Needed for CORS checks.
NetworkResourceLoadParameters m_parameters;
+ WebCore::HTTPHeaderMap m_originalRequestHeaders; // Needed for CORS checks.
RefPtr<NetworkDataTask> m_task;
WebCore::Timer m_timeoutTimer;
std::unique_ptr<NetworkCORSPreflightChecker> m_corsPreflightChecker;
}
}
-void WebLoaderStrategy::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, HTTPHeaderMap&& originalRequestHeaders, Ref<SecurityOrigin>&& sourceOrigin, ContentSecurityPolicy* contentSecurityPolicy, const FetchOptions& options)
+void WebLoaderStrategy::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, const HTTPHeaderMap& originalRequestHeaders, Ref<SecurityOrigin>&& sourceOrigin, ContentSecurityPolicy* contentSecurityPolicy, const FetchOptions& options)
{
// It's possible that call to createPingHandle might be made during initial empty Document creation before a NetworkingContext exists.
// It is not clear that we should send ping loads during that process anyways.
NetworkResourceLoadParameters loadParameters;
loadParameters.request = request;
- loadParameters.originalRequestHeaders = WTFMove(originalRequestHeaders);
loadParameters.sourceOrigin = WTFMove(sourceOrigin);
loadParameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
loadParameters.allowStoredCredentials = options.credentials == FetchOptions::Credentials::Omit ? DoNotAllowStoredCredentials : AllowStoredCredentials;
if (contentSecurityPolicy)
loadParameters.cspResponseHeaders = contentSecurityPolicy->responseHeaders();
- WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing(WTFMove(loadParameters)), 0);
+ WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing(WTFMove(loadParameters), originalRequestHeaders), 0);
}
void WebLoaderStrategy::storeDerivedDataToCache(const SHA1::Digest& bodyHash, const String& type, const String& partition, WebCore::SharedBuffer& data)
void suspendPendingRequests() final;
void resumePendingRequests() final;
- void createPingHandle(WebCore::NetworkingContext*, WebCore::ResourceRequest&, WebCore::HTTPHeaderMap&& originalRequestHeaders, Ref<WebCore::SecurityOrigin>&& sourceOrigin, WebCore::ContentSecurityPolicy*, const WebCore::FetchOptions&) final;
+ void createPingHandle(WebCore::NetworkingContext*, WebCore::ResourceRequest&, const WebCore::HTTPHeaderMap& originalRequestHeaders, Ref<WebCore::SecurityOrigin>&& sourceOrigin, WebCore::ContentSecurityPolicy*, const WebCore::FetchOptions&) final;
void storeDerivedDataToCache(const SHA1::Digest& bodyHash, const String& type, const String& partition, WebCore::SharedBuffer&) final;
+2017-08-17 Chris Dumez <cdumez@apple.com>
+
+ Regression(r220817): We should only copy the original request headers for Ping loads
+ https://bugs.webkit.org/show_bug.cgi?id=175679
+
+ Reviewed by Youenn Fablet.
+
+ * WebCoreSupport/WebResourceLoadScheduler.cpp:
+ (WebResourceLoadScheduler::createPingHandle):
+ * WebCoreSupport/WebResourceLoadScheduler.h:
+
2017-08-17 Don Olmstead <don.olmstead@sony.com>
[PAL] Relocate SessionID to root
return m_requestsLoading.size() >= (webResourceLoadScheduler().isSerialLoadingEnabled() ? 1 : m_maxRequestsInFlight);
}
-void WebResourceLoadScheduler::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, HTTPHeaderMap&&, Ref<SecurityOrigin>&&, WebCore::ContentSecurityPolicy*, const FetchOptions& options)
+void WebResourceLoadScheduler::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, const HTTPHeaderMap&, Ref<SecurityOrigin>&&, WebCore::ContentSecurityPolicy*, const FetchOptions& options)
{
// PingHandle manages its own lifetime, deleting itself when its purpose has been fulfilled.
new PingHandle(networkingContext, request, options.credentials != FetchOptions::Credentials::Omit, PingHandle::UsesAsyncCallbacks::No, options.redirect == FetchOptions::Redirect::Follow);
void suspendPendingRequests() override;
void resumePendingRequests() override;
- void createPingHandle(WebCore::NetworkingContext*, WebCore::ResourceRequest&, WebCore::HTTPHeaderMap&&, Ref<WebCore::SecurityOrigin>&& sourceOrigin, WebCore::ContentSecurityPolicy*, const WebCore::FetchOptions&) override;
+ void createPingHandle(WebCore::NetworkingContext*, WebCore::ResourceRequest&, const WebCore::HTTPHeaderMap&, Ref<WebCore::SecurityOrigin>&& sourceOrigin, WebCore::ContentSecurityPolicy*, const WebCore::FetchOptions&) override;
void storeDerivedDataToCache(const SHA1::Digest&, const String&, const String&, WebCore::SharedBuffer&) override { }