c75ba58eb42feb9e81559c4e3ea3bd17e1d4d1d8
[WebKit-https.git] / Source / WebKit / WebProcess / Network / WebLoaderStrategy.cpp
1 /*
2  * Copyright (C) 2012, 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "WebLoaderStrategy.h"
28
29 #include "DataReference.h"
30 #include "HangDetectionDisabler.h"
31 #include "Logging.h"
32 #include "NetworkConnectionToWebProcessMessages.h"
33 #include "NetworkProcessConnection.h"
34 #include "NetworkResourceLoadParameters.h"
35 #include "SessionTracker.h"
36 #include "WebCompiledContentRuleList.h"
37 #include "WebCoreArgumentCoders.h"
38 #include "WebErrors.h"
39 #include "WebFrame.h"
40 #include "WebFrameLoaderClient.h"
41 #include "WebFrameNetworkingContext.h"
42 #include "WebPage.h"
43 #include "WebPageProxyMessages.h"
44 #include "WebProcess.h"
45 #include "WebResourceLoader.h"
46 #include "WebServiceWorkerProvider.h"
47 #include "WebURLSchemeHandlerProxy.h"
48 #include "WebURLSchemeTaskProxy.h"
49 #include <WebCore/ApplicationCacheHost.h>
50 #include <WebCore/CachedResource.h>
51 #include <WebCore/ContentSecurityPolicy.h>
52 #include <WebCore/DiagnosticLoggingClient.h>
53 #include <WebCore/DiagnosticLoggingKeys.h>
54 #include <WebCore/Document.h>
55 #include <WebCore/DocumentLoader.h>
56 #include <WebCore/FetchOptions.h>
57 #include <WebCore/Frame.h>
58 #include <WebCore/FrameLoader.h>
59 #include <WebCore/NetscapePlugInStreamLoader.h>
60 #include <WebCore/PlatformStrategies.h>
61 #include <WebCore/ReferrerPolicy.h>
62 #include <WebCore/ResourceLoader.h>
63 #include <WebCore/SecurityOrigin.h>
64 #include <WebCore/Settings.h>
65 #include <WebCore/SubresourceLoader.h>
66 #include <WebCore/UserContentProvider.h>
67 #include <pal/SessionID.h>
68 #include <wtf/text/CString.h>
69
70 #if USE(QUICK_LOOK)
71 #include <WebCore/QuickLook.h>
72 #endif
73
74 using namespace WebCore;
75
76 #define RELEASE_LOG_IF_ALLOWED(permissionChecker, fmt, ...) RELEASE_LOG_IF(permissionChecker.isAlwaysOnLoggingAllowed(), Network, "%p - WebLoaderStrategy::" fmt, this, ##__VA_ARGS__)
77 #define RELEASE_LOG_ERROR_IF_ALLOWED(permissionChecker, fmt, ...) RELEASE_LOG_ERROR_IF(permissionChecker.isAlwaysOnLoggingAllowed(), Network, "%p - WebLoaderStrategy::" fmt, this, ##__VA_ARGS__)
78
79 namespace WebKit {
80
81 WebLoaderStrategy::WebLoaderStrategy()
82     : m_internallyFailedLoadTimer(RunLoop::main(), this, &WebLoaderStrategy::internallyFailedLoadTimerFired)
83 {
84 }
85
86 WebLoaderStrategy::~WebLoaderStrategy()
87 {
88 }
89
90 RefPtr<SubresourceLoader> WebLoaderStrategy::loadResource(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
91 {
92     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
93     if (loader)
94         scheduleLoad(*loader, &resource, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
95     else
96         RELEASE_LOG_IF_ALLOWED(frame, "loadResource: Unable to create SubresourceLoader (frame = %p", &frame);
97     return loader;
98 }
99
100 RefPtr<NetscapePlugInStreamLoader> WebLoaderStrategy::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, const ResourceRequest& request)
101 {
102     RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
103     if (loader)
104         scheduleLoad(*loader, 0, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
105     return loader;
106 }
107
108 static Seconds maximumBufferingTime(CachedResource* resource)
109 {
110     if (!resource)
111         return 0_s;
112
113     switch (resource->type()) {
114     case CachedResource::Beacon:
115     case CachedResource::CSSStyleSheet:
116     case CachedResource::Script:
117 #if ENABLE(SVG_FONTS)
118     case CachedResource::SVGFontResource:
119 #endif
120     case CachedResource::FontResource:
121         return Seconds::infinity();
122     case CachedResource::ImageResource:
123         return 500_ms;
124     case CachedResource::MediaResource:
125         return 50_ms;
126     case CachedResource::MainResource:
127     case CachedResource::Icon:
128     case CachedResource::RawResource:
129     case CachedResource::SVGDocumentResource:
130 #if ENABLE(LINK_PREFETCH)
131     case CachedResource::LinkPrefetch:
132     case CachedResource::LinkSubresource:
133 #endif
134 #if ENABLE(VIDEO_TRACK)
135     case CachedResource::TextTrackResource:
136 #endif
137 #if ENABLE(XSLT)
138     case CachedResource::XSLStyleSheet:
139 #endif
140         return 0_s;
141     }
142
143     ASSERT_NOT_REACHED();
144     return 0_s;
145 }
146
147 void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResource* resource, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
148 {
149     ResourceLoadIdentifier identifier = resourceLoader.identifier();
150     ASSERT(identifier);
151
152     auto& frameLoaderClient = resourceLoader.frameLoader()->client();
153
154     WebResourceLoader::TrackingParameters trackingParameters;
155     trackingParameters.pageID = frameLoaderClient.pageID();
156     trackingParameters.frameID = frameLoaderClient.frameID();
157     trackingParameters.resourceID = identifier;
158     auto sessionID = frameLoaderClient.sessionID();
159
160 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
161     // If the DocumentLoader schedules this as an archive resource load,
162     // then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess.
163     if (resourceLoader.documentLoader()->scheduleArchiveLoad(resourceLoader, resourceLoader.request())) {
164         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as an archive resource.", resourceLoader.url().string().utf8().data());
165         RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as an archive resource (frame = %p, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), trackingParameters.pageID, trackingParameters.frameID, identifier);
166         m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
167         return;
168     }
169 #endif
170
171     if (resourceLoader.documentLoader()->applicationCacheHost().maybeLoadResource(resourceLoader, resourceLoader.request(), resourceLoader.request().url())) {
172         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded from application cache.", resourceLoader.url().string().utf8().data());
173         RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be loaded from application cache (frame = %p, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), trackingParameters.pageID, trackingParameters.frameID, identifier);
174         m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
175         return;
176     }
177
178     if (resourceLoader.request().url().protocolIsData()) {
179         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded as data.", resourceLoader.url().string().utf8().data());
180         RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be loaded as data (frame = %p, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), trackingParameters.pageID, trackingParameters.frameID, identifier);
181         startLocalLoad(resourceLoader);
182         return;
183     }
184
185 #if USE(QUICK_LOOK)
186     if (isQuickLookPreviewURL(resourceLoader.request().url())) {
187         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a QuickLook resource.", resourceLoader.url().string().utf8().data());
188         RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as a QuickLook resource (frame = %p, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), trackingParameters.pageID, trackingParameters.frameID, identifier);
189         startLocalLoad(resourceLoader);
190         return;
191     }
192 #endif
193
194 #if USE(SOUP)
195     // For apps that call g_resource_load in a web extension.
196     // https://blogs.gnome.org/alexl/2012/01/26/resources-in-glib/
197     if (resourceLoader.request().url().protocolIs("resource")) {
198         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a GResource.", resourceLoader.url().string().utf8().data());
199         RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled as a GResource (frame = %p, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), trackingParameters.pageID, trackingParameters.frameID, identifier);
200         startLocalLoad(resourceLoader);
201         return;
202     }
203 #endif
204
205     auto* webFrameLoaderClient = toWebFrameLoaderClient(resourceLoader.frameLoader()->client());
206     auto* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
207     auto* webPage = webFrame ? webFrame->page() : nullptr;
208     if (webPage) {
209         if (auto* handler = webPage->urlSchemeHandlerForScheme(resourceLoader.request().url().protocol().toStringWithoutCopying())) {
210             LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, URL '%s' will be handled by a UIProcess URL scheme handler.", resourceLoader.url().string().utf8().data());
211             RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled by a UIProcess URL scheme handler (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier);
212
213             handler->startNewTask(resourceLoader);
214             return;
215         }
216     }
217
218 #if ENABLE(SERVICE_WORKER)
219     WebServiceWorkerProvider::singleton().handleFetch(resourceLoader, resource, sessionID, [trackingParameters, sessionID, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime = maximumBufferingTime(resource), resourceLoader = makeRef(resourceLoader)] (ServiceWorkerClientFetch::Result result) mutable {
220         if (result != ServiceWorkerClientFetch::Result::Unhandled)
221             return;
222         if (resourceLoader->options().serviceWorkersMode == ServiceWorkersMode::Only) {
223             callOnMainThread([resourceLoader = WTFMove(resourceLoader)] {
224                 auto error = internalError(resourceLoader->request().url());
225                 error.setType(ResourceError::Type::AccessControl);
226                 resourceLoader->didFail(error);
227             });
228             return;
229         }
230
231         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be scheduled through ServiceWorker handle fetch algorithm", resourceLoader->url().string().latin1().data());
232         WebProcess::singleton().webLoaderStrategy().scheduleLoadFromNetworkProcess(resourceLoader.get(), resourceLoader->originalRequest(), trackingParameters, sessionID, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime);
233     });
234 #else
235     LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be scheduled through ServiceWorker handle fetch algorithm", resourceLoader.url().string().latin1().data());
236     scheduleLoadFromNetworkProcess(resourceLoader, resourceLoader.request(), trackingParameters, sessionID, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));
237 #endif
238 }
239
240 void WebLoaderStrategy::scheduleLoadFromNetworkProcess(ResourceLoader& resourceLoader, const ResourceRequest& request, const WebResourceLoader::TrackingParameters& trackingParameters, PAL::SessionID sessionID, bool shouldClearReferrerOnHTTPSToHTTPRedirect, Seconds maximumBufferingTime)
241 {
242     ResourceLoadIdentifier identifier = resourceLoader.identifier();
243     ASSERT(identifier);
244
245     LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be scheduled with the NetworkProcess with priority %d", resourceLoader.url().string().latin1().data(), static_cast<int>(resourceLoader.request().priority()));
246
247     ContentSniffingPolicy contentSniffingPolicy = resourceLoader.shouldSniffContent() ? SniffContent : DoNotSniffContent;
248     ContentEncodingSniffingPolicy contentEncodingSniffingPolicy = resourceLoader.shouldSniffContentEncoding() ? ContentEncodingSniffingPolicy::Sniff : ContentEncodingSniffingPolicy::DoNotSniff;
249     StoredCredentialsPolicy storedCredentialsPolicy = resourceLoader.shouldUseCredentialStorage() ? StoredCredentialsPolicy::Use : StoredCredentialsPolicy::DoNotUse;
250
251     NetworkResourceLoadParameters loadParameters;
252     loadParameters.identifier = identifier;
253     loadParameters.webPageID = trackingParameters.pageID;
254     loadParameters.webFrameID = trackingParameters.frameID;
255     loadParameters.sessionID = sessionID;
256     loadParameters.request = request;
257     loadParameters.contentSniffingPolicy = contentSniffingPolicy;
258     loadParameters.contentEncodingSniffingPolicy = contentEncodingSniffingPolicy;
259     loadParameters.storedCredentialsPolicy = storedCredentialsPolicy;
260     // If there is no WebFrame then this resource cannot be authenticated with the client.
261     loadParameters.clientCredentialPolicy = (loadParameters.webFrameID && loadParameters.webPageID && resourceLoader.isAllowedToAskUserForCredentials()) ? ClientCredentialPolicy::MayAskClientForCredentials : ClientCredentialPolicy::CannotAskClientForCredentials;
262     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
263     loadParameters.defersLoading = resourceLoader.defersLoading();
264     loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();
265     loadParameters.maximumBufferingTime = maximumBufferingTime;
266     loadParameters.derivedCachedDataTypesToRetrieve = resourceLoader.options().derivedCachedDataTypesToRetrieve;
267
268     ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);
269
270     RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: Resource is being scheduled with the NetworkProcess (frame = %p, priority = %d, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), static_cast<int>(resourceLoader.request().priority()), loadParameters.webPageID, loadParameters.webFrameID, loadParameters.identifier);
271     if (!WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
272         RELEASE_LOG_ERROR_IF_ALLOWED(resourceLoader, "scheduleLoad: Unable to schedule resource with the NetworkProcess (frame = %p, priority = %d, pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", resourceLoader.frame(), static_cast<int>(resourceLoader.request().priority()), loadParameters.webPageID, loadParameters.webFrameID, loadParameters.identifier);
273         // We probably failed to schedule this load with the NetworkProcess because it had crashed.
274         // This load will never succeed so we will schedule it to fail asynchronously.
275         scheduleInternallyFailedLoad(resourceLoader);
276         return;
277     }
278
279     m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
280 }
281
282 void WebLoaderStrategy::scheduleInternallyFailedLoad(WebCore::ResourceLoader& resourceLoader)
283 {
284     m_internallyFailedResourceLoaders.add(&resourceLoader);
285     m_internallyFailedLoadTimer.startOneShot(0_s);
286 }
287
288 void WebLoaderStrategy::internallyFailedLoadTimerFired()
289 {
290     for (auto& resourceLoader : copyToVector(m_internallyFailedResourceLoaders))
291         resourceLoader->didFail(internalError(resourceLoader->url()));
292 }
293
294 void WebLoaderStrategy::startLocalLoad(WebCore::ResourceLoader& resourceLoader)
295 {
296     resourceLoader.start();
297     m_webResourceLoaders.set(resourceLoader.identifier(), WebResourceLoader::create(resourceLoader, { }));
298 }
299
300 void WebLoaderStrategy::addURLSchemeTaskProxy(WebURLSchemeTaskProxy& task)
301 {
302     auto result = m_urlSchemeTasks.add(task.identifier(), &task);
303     ASSERT_UNUSED(result, result.isNewEntry);
304 }
305
306 void WebLoaderStrategy::removeURLSchemeTaskProxy(WebURLSchemeTaskProxy& task)
307 {
308     m_urlSchemeTasks.remove(task.identifier());
309 }
310
311 void WebLoaderStrategy::remove(ResourceLoader* resourceLoader)
312 {
313     ASSERT(resourceLoader);
314     LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader->url().string().utf8().data());
315
316     if (auto task = m_urlSchemeTasks.take(resourceLoader->identifier())) {
317         ASSERT(!m_internallyFailedResourceLoaders.contains(resourceLoader));
318         task->stopLoading();
319         return;
320     }
321
322     if (m_internallyFailedResourceLoaders.contains(resourceLoader)) {
323         m_internallyFailedResourceLoaders.remove(resourceLoader);
324         return;
325     }
326     
327     ResourceLoadIdentifier identifier = resourceLoader->identifier();
328     if (!identifier) {
329         LOG_ERROR("WebLoaderStrategy removing a ResourceLoader that has no identifier.");
330         return;
331     }
332
333 #if ENABLE(SERVICE_WORKER)
334     if (WebServiceWorkerProvider::singleton().cancelFetch(identifier))
335         return;
336 #endif
337
338     RefPtr<WebResourceLoader> loader = m_webResourceLoaders.take(identifier);
339     // Loader may not be registered if we created it, but haven't scheduled yet (a bundle client can decide to cancel such request via willSendRequest).
340     if (!loader)
341         return;
342
343     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::RemoveLoadIdentifier(identifier), 0);
344
345     // It's possible that this WebResourceLoader might be just about to message back to the NetworkProcess (e.g. ContinueWillSendRequest)
346     // but there's no point in doing so anymore.
347     loader->detachFromCoreLoader();
348 }
349
350 void WebLoaderStrategy::setDefersLoading(ResourceLoader* resourceLoader, bool defers)
351 {
352     ResourceLoadIdentifier identifier = resourceLoader->identifier();
353     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetDefersLoading(identifier, defers), 0);
354 }
355
356 void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader*, const URL&)
357 {
358     // We handle cross origin redirects entirely within the NetworkProcess.
359     // We override this call in the WebProcess to make it a no-op.
360 }
361
362 void WebLoaderStrategy::servePendingRequests(ResourceLoadPriority)
363 {
364     // This overrides the base class version.
365     // We don't need to do anything as this is handled by the network process.
366 }
367
368 void WebLoaderStrategy::suspendPendingRequests()
369 {
370     // Network process does keep requests in pending state.
371 }
372
373 void WebLoaderStrategy::resumePendingRequests()
374 {
375     // Network process does keep requests in pending state.
376 }
377
378 void WebLoaderStrategy::networkProcessCrashed()
379 {
380     RELEASE_LOG_ERROR(Network, "WebLoaderStrategy::networkProcessCrashed: failing all pending resource loaders");
381
382     for (auto& loader : m_webResourceLoaders)
383         scheduleInternallyFailedLoad(*loader.value->resourceLoader());
384
385     m_webResourceLoaders.clear();
386
387     auto pingLoadCompletionHandlers = WTFMove(m_pingLoadCompletionHandlers);
388     for (auto& pingLoadCompletionHandler : pingLoadCompletionHandlers.values())
389         pingLoadCompletionHandler(internalError(URL()), { });
390
391     auto preconnectCompletionHandlers = WTFMove(m_preconnectCompletionHandlers);
392     for (auto& preconnectCompletionHandler : preconnectCompletionHandlers.values())
393         preconnectCompletionHandler(internalError(URL()));
394 }
395
396 void WebLoaderStrategy::loadResourceSynchronously(NetworkingContext* context, unsigned long resourceLoadIdentifier, const ResourceRequest& request, StoredCredentialsPolicy storedCredentialsPolicy, ClientCredentialPolicy clientCredentialPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
397 {
398     WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(context);
399     // FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
400     // EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
401     // but in the meantime we have to make sure not to mis-cast.
402     WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
403     WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
404     WebPage* webPage = webFrame ? webFrame->page() : 0;
405
406     NetworkResourceLoadParameters loadParameters;
407     loadParameters.identifier = resourceLoadIdentifier;
408     loadParameters.webPageID = webPage ? webPage->pageID() : 0;
409     loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
410     loadParameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
411     loadParameters.request = request;
412     loadParameters.contentSniffingPolicy = SniffContent;
413     loadParameters.contentEncodingSniffingPolicy = ContentEncodingSniffingPolicy::Sniff;
414     loadParameters.storedCredentialsPolicy = storedCredentialsPolicy;
415     loadParameters.clientCredentialPolicy = clientCredentialPolicy;
416     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = context->shouldClearReferrerOnHTTPSToHTTPRedirect();
417
418     data.shrink(0);
419
420     HangDetectionDisabler hangDetectionDisabler;
421
422     if (!WebProcess::singleton().networkConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, data), 0)) {
423         RELEASE_LOG_ERROR_IF_ALLOWED(loadParameters.sessionID, "loadResourceSynchronously: failed sending synchronous network process message (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ")", loadParameters.webPageID, loadParameters.webFrameID, loadParameters.identifier);
424         if (auto* page = webPage->corePage())
425             page->diagnosticLoggingClient().logDiagnosticMessage(WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::synchronousMessageFailedKey(), WebCore::ShouldSample::No);
426         response = ResourceResponse();
427         error = internalError(request.url());
428     }
429 }
430
431 static uint64_t generateLoadIdentifier()
432 {
433     static uint64_t identifier = 0;
434     return ++identifier;
435 }
436
437 void WebLoaderStrategy::startPingLoad(Frame& frame, ResourceRequest& request, const HTTPHeaderMap& originalRequestHeaders, const FetchOptions& options, PingLoadCompletionHandler&& completionHandler)
438 {
439     // It's possible that call to createPingHandle might be made during initial empty Document creation before a NetworkingContext exists.
440     // It is not clear that we should send ping loads during that process anyways.
441     auto* networkingContext = frame.loader().networkingContext();
442     if (!networkingContext) {
443         if (completionHandler)
444             completionHandler(internalError(request.url()), { });
445         return;
446     }
447
448     WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(networkingContext);
449     WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
450
451     auto* document = frame.document();
452     if (!document) {
453         if (completionHandler)
454             completionHandler(internalError(request.url()), { });
455         return;
456     }
457     
458     NetworkResourceLoadParameters loadParameters;
459     loadParameters.identifier = generateLoadIdentifier();
460     loadParameters.request = request;
461     loadParameters.sourceOrigin = &document->securityOrigin();
462     loadParameters.sessionID = webFrameLoaderClient ? webFrameLoaderClient->sessionID() : PAL::SessionID::defaultSessionID();
463     loadParameters.storedCredentialsPolicy = options.credentials == FetchOptions::Credentials::Omit ? StoredCredentialsPolicy::DoNotUse : StoredCredentialsPolicy::Use;
464     loadParameters.mode = options.mode;
465     loadParameters.shouldFollowRedirects = options.redirect == FetchOptions::Redirect::Follow;
466     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = networkingContext->shouldClearReferrerOnHTTPSToHTTPRedirect();
467     if (!document->shouldBypassMainWorldContentSecurityPolicy()) {
468         if (auto * contentSecurityPolicy = document->contentSecurityPolicy())
469             loadParameters.cspResponseHeaders = contentSecurityPolicy->responseHeaders();
470     }
471
472 #if ENABLE(CONTENT_EXTENSIONS)
473     loadParameters.mainDocumentURL = document->topDocument().url();
474
475     if (auto* documentLoader = frame.loader().documentLoader()) {
476         if (auto* page = frame.page()) {
477             page->userContentProvider().forEachContentExtension([&loadParameters](const String& identifier, ContentExtensions::ContentExtension& contentExtension) {
478                 loadParameters.contentRuleLists.append(std::make_pair(identifier, static_cast<const WebCompiledContentRuleList&>(contentExtension.compiledExtension()).data()));
479             }, *documentLoader);
480         }
481     }
482 #endif
483
484     if (completionHandler)
485         m_pingLoadCompletionHandlers.add(loadParameters.identifier, WTFMove(completionHandler));
486
487     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing(WTFMove(loadParameters), originalRequestHeaders), 0);
488 }
489
490 void WebLoaderStrategy::didFinishPingLoad(uint64_t pingLoadIdentifier, ResourceError&& error, ResourceResponse&& response)
491 {
492     if (auto completionHandler = m_pingLoadCompletionHandlers.take(pingLoadIdentifier))
493         completionHandler(WTFMove(error), WTFMove(response));
494 }
495
496 void WebLoaderStrategy::preconnectTo(NetworkingContext& context, const WebCore::URL& url, StoredCredentialsPolicy storedCredentialsPolicy, PreconnectCompletionHandler&& completionHandler)
497 {
498     uint64_t preconnectionIdentifier = generateLoadIdentifier();
499     auto addResult = m_preconnectCompletionHandlers.add(preconnectionIdentifier, WTFMove(completionHandler));
500     ASSERT_UNUSED(addResult, addResult.isNewEntry);
501
502     auto& webContext = static_cast<WebFrameNetworkingContext&>(context);
503     auto* webFrameLoaderClient = webContext.webFrameLoaderClient();
504     if (!webFrameLoaderClient) {
505         completionHandler(internalError(url));
506         return;
507     }
508     auto* webFrame = webFrameLoaderClient->webFrame();
509     if (!webFrame) {
510         completionHandler(internalError(url));
511         return;
512     }
513     auto* webPage = webFrame->page();
514     if (!webPage) {
515         completionHandler(internalError(url));
516         return;
517     }
518
519     NetworkResourceLoadParameters parameters;
520     parameters.request = ResourceRequest { url };
521     parameters.webPageID = webPage ? webPage->pageID() : 0;
522     parameters.webFrameID = webFrame ? webFrame->frameID() : 0;
523     parameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
524     parameters.storedCredentialsPolicy = storedCredentialsPolicy;
525     parameters.shouldPreconnectOnly = PreconnectOnly::Yes;
526
527     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::PreconnectTo(preconnectionIdentifier, WTFMove(parameters)), 0);
528 }
529
530 void WebLoaderStrategy::didFinishPreconnection(uint64_t preconnectionIdentifier, ResourceError&& error)
531 {
532     if (auto completionHandler = m_preconnectCompletionHandlers.take(preconnectionIdentifier))
533         completionHandler(WTFMove(error));
534 }
535
536 void WebLoaderStrategy::storeDerivedDataToCache(const SHA1::Digest& bodyHash, const String& type, const String& partition, WebCore::SharedBuffer& data)
537 {
538     NetworkCache::DataKey key { partition, type, bodyHash };
539     IPC::SharedBufferDataReference dataReference { &data };
540     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::StoreDerivedDataToCache(key, dataReference), 0);
541 }
542
543 void WebLoaderStrategy::setCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
544 {
545     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCaptureExtraNetworkLoadMetricsEnabled(enabled), 0);
546 }
547
548 } // namespace WebKit