ac197f1578d5de3c5d92db47cfcf1a4309f1fb36
[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 "WebCoreArgumentCoders.h"
37 #include "WebErrors.h"
38 #include "WebFrame.h"
39 #include "WebFrameLoaderClient.h"
40 #include "WebFrameNetworkingContext.h"
41 #include "WebPage.h"
42 #include "WebPageProxyMessages.h"
43 #include "WebProcess.h"
44 #include "WebResourceLoader.h"
45 #include "WebURLSchemeHandlerProxy.h"
46 #include "WebURLSchemeTaskProxy.h"
47 #include <WebCore/ApplicationCacheHost.h>
48 #include <WebCore/CachedResource.h>
49 #include <WebCore/ContentSecurityPolicy.h>
50 #include <WebCore/DiagnosticLoggingClient.h>
51 #include <WebCore/DiagnosticLoggingKeys.h>
52 #include <WebCore/Document.h>
53 #include <WebCore/DocumentLoader.h>
54 #include <WebCore/FetchOptions.h>
55 #include <WebCore/Frame.h>
56 #include <WebCore/FrameLoader.h>
57 #include <WebCore/NetscapePlugInStreamLoader.h>
58 #include <WebCore/PlatformStrategies.h>
59 #include <WebCore/ReferrerPolicy.h>
60 #include <WebCore/ResourceLoader.h>
61 #include <WebCore/SecurityOrigin.h>
62 #include <WebCore/Settings.h>
63 #include <WebCore/SubresourceLoader.h>
64 #include <pal/SessionID.h>
65 #include <wtf/text/CString.h>
66
67 #if USE(QUICK_LOOK)
68 #include <WebCore/QuickLook.h>
69 #endif
70
71 using namespace WebCore;
72
73 #define RELEASE_LOG_IF_ALLOWED(permissionChecker, fmt, ...) RELEASE_LOG_IF(permissionChecker.isAlwaysOnLoggingAllowed(), Network, "%p - WebLoaderStrategy::" fmt, this, ##__VA_ARGS__)
74 #define RELEASE_LOG_ERROR_IF_ALLOWED(permissionChecker, fmt, ...) RELEASE_LOG_ERROR_IF(permissionChecker.isAlwaysOnLoggingAllowed(), Network, "%p - WebLoaderStrategy::" fmt, this, ##__VA_ARGS__)
75
76 namespace WebKit {
77
78 WebLoaderStrategy::WebLoaderStrategy()
79     : m_internallyFailedLoadTimer(RunLoop::main(), this, &WebLoaderStrategy::internallyFailedLoadTimerFired)
80 {
81 }
82
83 WebLoaderStrategy::~WebLoaderStrategy()
84 {
85 }
86
87 RefPtr<SubresourceLoader> WebLoaderStrategy::loadResource(Frame& frame, CachedResource& resource, const ResourceRequest& request, const ResourceLoaderOptions& options)
88 {
89     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
90     if (loader)
91         scheduleLoad(*loader, &resource, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
92     else
93         RELEASE_LOG_IF_ALLOWED(frame, "loadResource: Unable to create SubresourceLoader (frame = %p", &frame);
94     return loader;
95 }
96
97 RefPtr<NetscapePlugInStreamLoader> WebLoaderStrategy::schedulePluginStreamLoad(Frame& frame, NetscapePlugInStreamLoaderClient& client, const ResourceRequest& request)
98 {
99     RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
100     if (loader)
101         scheduleLoad(*loader, 0, frame.document()->referrerPolicy() == ReferrerPolicy::NoReferrerWhenDowngrade);
102     return loader;
103 }
104
105 static Seconds maximumBufferingTime(CachedResource* resource)
106 {
107     if (!resource)
108         return 0_s;
109
110     switch (resource->type()) {
111     case CachedResource::Beacon:
112     case CachedResource::CSSStyleSheet:
113     case CachedResource::Script:
114 #if ENABLE(SVG_FONTS)
115     case CachedResource::SVGFontResource:
116 #endif
117     case CachedResource::FontResource:
118         return Seconds::infinity();
119     case CachedResource::ImageResource:
120         return 500_ms;
121     case CachedResource::MediaResource:
122         return 50_ms;
123     case CachedResource::MainResource:
124     case CachedResource::Icon:
125     case CachedResource::RawResource:
126     case CachedResource::SVGDocumentResource:
127 #if ENABLE(LINK_PREFETCH)
128     case CachedResource::LinkPrefetch:
129     case CachedResource::LinkSubresource:
130 #endif
131 #if ENABLE(VIDEO_TRACK)
132     case CachedResource::TextTrackResource:
133 #endif
134 #if ENABLE(XSLT)
135     case CachedResource::XSLStyleSheet:
136 #endif
137         return 0_s;
138     }
139
140     ASSERT_NOT_REACHED();
141     return 0_s;
142 }
143
144 void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResource* resource, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
145 {
146     ResourceLoadIdentifier identifier = resourceLoader.identifier();
147     ASSERT(identifier);
148
149     // FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
150     // EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
151     // but in the meantime we have to make sure not to mis-cast.
152     WebFrameLoaderClient* webFrameLoaderClient = toWebFrameLoaderClient(resourceLoader.frameLoader()->client());
153     WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
154     WebPage* webPage = webFrame ? webFrame->page() : nullptr;
155
156     WebResourceLoader::TrackingParameters trackingParameters;
157     trackingParameters.pageID = webPage ? webPage->pageID() : 0;
158     trackingParameters.frameID = webFrame ? webFrame->frameID() : 0;
159     trackingParameters.resourceID = identifier;
160
161 #if ENABLE(WEB_ARCHIVE) || ENABLE(MHTML)
162     // If the DocumentLoader schedules this as an archive resource load,
163     // then we should remember the ResourceLoader in our records but not schedule it in the NetworkProcess.
164     if (resourceLoader.documentLoader()->scheduleArchiveLoad(resourceLoader, resourceLoader.request())) {
165         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as an archive resource.", resourceLoader.url().string().utf8().data());
166         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);
167         m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
168         return;
169     }
170 #endif
171
172     if (resourceLoader.documentLoader()->applicationCacheHost().maybeLoadResource(resourceLoader, resourceLoader.request(), resourceLoader.request().url())) {
173         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded from application cache.", resourceLoader.url().string().utf8().data());
174         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);
175         m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
176         return;
177     }
178
179     if (resourceLoader.request().url().protocolIsData()) {
180         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be loaded as data.", resourceLoader.url().string().utf8().data());
181         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);
182         startLocalLoad(resourceLoader);
183         return;
184     }
185
186 #if USE(QUICK_LOOK)
187     if (isQuickLookPreviewURL(resourceLoader.request().url())) {
188         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a QuickLook resource.", resourceLoader.url().string().utf8().data());
189         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);
190         startLocalLoad(resourceLoader);
191         return;
192     }
193 #endif
194
195 #if USE(SOUP)
196     // For apps that call g_resource_load in a web extension.
197     // https://blogs.gnome.org/alexl/2012/01/26/resources-in-glib/
198     if (resourceLoader.request().url().protocolIs("resource")) {
199         LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, url '%s' will be handled as a GResource.", resourceLoader.url().string().utf8().data());
200         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);
201         startLocalLoad(resourceLoader);
202         return;
203     }
204 #endif
205
206     if (webPage) {
207         if (auto* handler = webPage->urlSchemeHandlerForScheme(resourceLoader.request().url().protocol().toStringWithoutCopying())) {
208             LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::scheduleLoad, URL '%s' will be handled by a UIProcess URL scheme handler.", resourceLoader.url().string().utf8().data());
209             RELEASE_LOG_IF_ALLOWED(resourceLoader, "scheduleLoad: URL will be handled by a UIProcess URL scheme handler (frame = %p, resourceID = %" PRIu64 ")", resourceLoader.frame(), identifier);
210
211             handler->startNewTask(resourceLoader);
212             return;
213         }
214     }
215
216     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()));
217
218     ContentSniffingPolicy contentSniffingPolicy = resourceLoader.shouldSniffContent() ? SniffContent : DoNotSniffContent;
219     StoredCredentials allowStoredCredentials = resourceLoader.shouldUseCredentialStorage() ? AllowStoredCredentials : DoNotAllowStoredCredentials;
220
221     NetworkResourceLoadParameters loadParameters;
222     loadParameters.identifier = identifier;
223     loadParameters.webPageID = webPage ? webPage->pageID() : 0;
224     loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
225     loadParameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
226     loadParameters.request = resourceLoader.request();
227     loadParameters.contentSniffingPolicy = contentSniffingPolicy;
228     loadParameters.allowStoredCredentials = allowStoredCredentials;
229     // If there is no WebFrame then this resource cannot be authenticated with the client.
230     loadParameters.clientCredentialPolicy = (webFrame && webPage && resourceLoader.isAllowedToAskUserForCredentials()) ? ClientCredentialPolicy::MayAskClientForCredentials : ClientCredentialPolicy::CannotAskClientForCredentials;
231     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = shouldClearReferrerOnHTTPSToHTTPRedirect;
232     loadParameters.defersLoading = resourceLoader.defersLoading();
233     loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();
234     loadParameters.maximumBufferingTime = maximumBufferingTime(resource);
235     loadParameters.derivedCachedDataTypesToRetrieve = resourceLoader.options().derivedCachedDataTypesToRetrieve;
236
237     ASSERT((loadParameters.webPageID && loadParameters.webFrameID) || loadParameters.clientCredentialPolicy == ClientCredentialPolicy::CannotAskClientForCredentials);
238
239     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);
240     if (!WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
241         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);
242         // We probably failed to schedule this load with the NetworkProcess because it had crashed.
243         // This load will never succeed so we will schedule it to fail asynchronously.
244         scheduleInternallyFailedLoad(resourceLoader);
245         return;
246     }
247
248     m_webResourceLoaders.set(identifier, WebResourceLoader::create(resourceLoader, trackingParameters));
249 }
250
251 void WebLoaderStrategy::scheduleInternallyFailedLoad(WebCore::ResourceLoader& resourceLoader)
252 {
253     m_internallyFailedResourceLoaders.add(&resourceLoader);
254     m_internallyFailedLoadTimer.startOneShot(0_s);
255 }
256
257 void WebLoaderStrategy::internallyFailedLoadTimerFired()
258 {
259     Vector<RefPtr<ResourceLoader>> internallyFailedResourceLoaders;
260     copyToVector(m_internallyFailedResourceLoaders, internallyFailedResourceLoaders);
261     
262     for (size_t i = 0; i < internallyFailedResourceLoaders.size(); ++i)
263         internallyFailedResourceLoaders[i]->didFail(internalError(internallyFailedResourceLoaders[i]->url()));
264 }
265
266 void WebLoaderStrategy::startLocalLoad(WebCore::ResourceLoader& resourceLoader)
267 {
268     resourceLoader.start();
269     m_webResourceLoaders.set(resourceLoader.identifier(), WebResourceLoader::create(resourceLoader, { }));
270 }
271
272 void WebLoaderStrategy::addURLSchemeTaskProxy(WebURLSchemeTaskProxy& task)
273 {
274     auto result = m_urlSchemeTasks.add(task.identifier(), &task);
275     ASSERT_UNUSED(result, result.isNewEntry);
276 }
277
278 void WebLoaderStrategy::removeURLSchemeTaskProxy(WebURLSchemeTaskProxy& task)
279 {
280     m_urlSchemeTasks.remove(task.identifier());
281 }
282
283 void WebLoaderStrategy::remove(ResourceLoader* resourceLoader)
284 {
285     ASSERT(resourceLoader);
286     LOG(NetworkScheduling, "(WebProcess) WebLoaderStrategy::remove, url '%s'", resourceLoader->url().string().utf8().data());
287
288     if (auto task = m_urlSchemeTasks.take(resourceLoader->identifier())) {
289         ASSERT(!m_internallyFailedResourceLoaders.contains(resourceLoader));
290         task->stopLoading();
291         return;
292     }
293
294     if (m_internallyFailedResourceLoaders.contains(resourceLoader)) {
295         m_internallyFailedResourceLoaders.remove(resourceLoader);
296         return;
297     }
298     
299     ResourceLoadIdentifier identifier = resourceLoader->identifier();
300     if (!identifier) {
301         LOG_ERROR("WebLoaderStrategy removing a ResourceLoader that has no identifier.");
302         return;
303     }
304     
305     RefPtr<WebResourceLoader> loader = m_webResourceLoaders.take(identifier);
306     // 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).
307     if (!loader)
308         return;
309
310     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::RemoveLoadIdentifier(identifier), 0);
311
312     // It's possible that this WebResourceLoader might be just about to message back to the NetworkProcess (e.g. ContinueWillSendRequest)
313     // but there's no point in doing so anymore.
314     loader->detachFromCoreLoader();
315 }
316
317 void WebLoaderStrategy::setDefersLoading(ResourceLoader* resourceLoader, bool defers)
318 {
319     ResourceLoadIdentifier identifier = resourceLoader->identifier();
320     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetDefersLoading(identifier, defers), 0);
321 }
322
323 void WebLoaderStrategy::crossOriginRedirectReceived(ResourceLoader*, const URL&)
324 {
325     // We handle cross origin redirects entirely within the NetworkProcess.
326     // We override this call in the WebProcess to make it a no-op.
327 }
328
329 void WebLoaderStrategy::servePendingRequests(ResourceLoadPriority)
330 {
331     // This overrides the base class version.
332     // We don't need to do anything as this is handled by the network process.
333 }
334
335 void WebLoaderStrategy::suspendPendingRequests()
336 {
337     // Network process does keep requests in pending state.
338 }
339
340 void WebLoaderStrategy::resumePendingRequests()
341 {
342     // Network process does keep requests in pending state.
343 }
344
345 void WebLoaderStrategy::networkProcessCrashed()
346 {
347     RELEASE_LOG_ERROR(Network, "WebLoaderStrategy::networkProcessCrashed: failing all pending resource loaders");
348
349     for (auto& loader : m_webResourceLoaders)
350         scheduleInternallyFailedLoad(*loader.value->resourceLoader());
351
352     m_webResourceLoaders.clear();
353 }
354
355 void WebLoaderStrategy::loadResourceSynchronously(NetworkingContext* context, unsigned long resourceLoadIdentifier, const ResourceRequest& request, StoredCredentials storedCredentials, ClientCredentialPolicy clientCredentialPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
356 {
357     WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(context);
358     // FIXME: Some entities in WebCore use WebCore's "EmptyFrameLoaderClient" instead of having a proper WebFrameLoaderClient.
359     // EmptyFrameLoaderClient shouldn't exist and everything should be using a WebFrameLoaderClient,
360     // but in the meantime we have to make sure not to mis-cast.
361     WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
362     WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : 0;
363     WebPage* webPage = webFrame ? webFrame->page() : 0;
364
365     NetworkResourceLoadParameters loadParameters;
366     loadParameters.identifier = resourceLoadIdentifier;
367     loadParameters.webPageID = webPage ? webPage->pageID() : 0;
368     loadParameters.webFrameID = webFrame ? webFrame->frameID() : 0;
369     loadParameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
370     loadParameters.request = request;
371     loadParameters.contentSniffingPolicy = SniffContent;
372     loadParameters.allowStoredCredentials = storedCredentials;
373     loadParameters.clientCredentialPolicy = clientCredentialPolicy;
374     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = context->shouldClearReferrerOnHTTPSToHTTPRedirect();
375
376     data.shrink(0);
377
378     HangDetectionDisabler hangDetectionDisabler;
379
380     if (!WebProcess::singleton().networkConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, data), 0)) {
381         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);
382         if (auto* page = webPage->corePage())
383             page->diagnosticLoggingClient().logDiagnosticMessage(WebCore::DiagnosticLoggingKeys::internalErrorKey(), WebCore::DiagnosticLoggingKeys::synchronousMessageFailedKey(), WebCore::ShouldSample::No);
384         response = ResourceResponse();
385         error = internalError(request.url());
386     }
387 }
388
389 void WebLoaderStrategy::createPingHandle(NetworkingContext* networkingContext, ResourceRequest& request, HTTPHeaderMap&& originalRequestHeaders, Ref<SecurityOrigin>&& sourceOrigin, ContentSecurityPolicy* contentSecurityPolicy, const FetchOptions& options)
390 {
391     // It's possible that call to createPingHandle might be made during initial empty Document creation before a NetworkingContext exists.
392     // It is not clear that we should send ping loads during that process anyways.
393     if (!networkingContext)
394         return;
395
396     WebFrameNetworkingContext* webContext = static_cast<WebFrameNetworkingContext*>(networkingContext);
397     WebFrameLoaderClient* webFrameLoaderClient = webContext->webFrameLoaderClient();
398     WebFrame* webFrame = webFrameLoaderClient ? webFrameLoaderClient->webFrame() : nullptr;
399     WebPage* webPage = webFrame ? webFrame->page() : nullptr;
400     
401     NetworkResourceLoadParameters loadParameters;
402     loadParameters.request = request;
403     loadParameters.originalRequestHeaders = WTFMove(originalRequestHeaders);
404     loadParameters.sourceOrigin = WTFMove(sourceOrigin);
405     loadParameters.sessionID = webPage ? webPage->sessionID() : PAL::SessionID::defaultSessionID();
406     loadParameters.allowStoredCredentials = options.credentials == FetchOptions::Credentials::Omit ? DoNotAllowStoredCredentials : AllowStoredCredentials;
407     loadParameters.mode = options.mode;
408     loadParameters.shouldFollowRedirects = options.redirect == FetchOptions::Redirect::Follow;
409     loadParameters.shouldClearReferrerOnHTTPSToHTTPRedirect = networkingContext->shouldClearReferrerOnHTTPSToHTTPRedirect();
410     if (contentSecurityPolicy)
411         loadParameters.cspResponseHeaders = contentSecurityPolicy->responseHeaders();
412
413     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::LoadPing(WTFMove(loadParameters)), 0);
414 }
415
416 void WebLoaderStrategy::storeDerivedDataToCache(const SHA1::Digest& bodyHash, const String& type, const String& partition, WebCore::SharedBuffer& data)
417 {
418     NetworkCache::DataKey key { partition, type, bodyHash };
419     IPC::SharedBufferDataReference dataReference { &data };
420     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::StoreDerivedDataToCache(key, dataReference), 0);
421 }
422
423 void WebLoaderStrategy::setCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
424 {
425     WebProcess::singleton().networkConnection().connection().send(Messages::NetworkConnectionToWebProcess::SetCaptureExtraNetworkLoadMetricsEnabled(enabled), 0);
426 }
427
428 } // namespace WebKit