Attachment 341982 Details for Bug 186312 – Patch

[patch] Patch

bug-186312-20180605115932.patch (text/plain), 40.21 KB, created by youenn fablet on 2018-06-05 11:59:32 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2018-06-05 11:59:32 PDT

Size: 40.21 KB

patch

obsolete

>Subversion Revision: 232461
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index e3825a91b31568bea6d3e397138e820dcce619bb..2e3ba9a541e3c2d1ad66854eadf8bdab4d51873e 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,25 @@
>+2018-06-05  Youenn Fablet  <youenn@apple.com>
>+
>+        Network Preflights do not show in WebInspector after moving CORS checks to NetworkProcess
>+        https://bugs.webkit.org/show_bug.cgi?id=186312
>+        <rdar://problem/40495434>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        No change of behavior in regular conditions.
>+        All intermediate requests/responses are now buffered in NetworkProcess if Web inspector shows up.
>+        Add NetworkLoadInformation and NetworkIntermediateLoadInformation for that purpose.
>+
>+        Add a new LoaderStrategy method to grab this information from NetworkProcess synchronously.
>+
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * loader/LoaderStrategy.cpp:
>+        (WebCore::LoaderStrategy::intermediateLoadInformationFromResourceLoadIdentifier):
>+        * loader/LoaderStrategy.h:
>+        * platform/network/NetworkLoadInformation.h: Added.
>+        (WebCore::NetworkIntermediateLoadInformation::encode const):
>+        (WebCore::NetworkIntermediateLoadInformation::decode):
>+
> 2018-06-04  Youenn Fablet  <youenn@apple.com>
> 
>         ServiceWorker registration should store any script fetched through importScripts
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index e4874e8954d9ab33ab479fa380db524c5b3a59e6..bcfb9ad8eb67eefa1edafeb35380c2f3fc0e033e 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,54 @@
>+2018-06-05  Youenn Fablet  <youenn@apple.com>
>+
>+        Network Preflights do not show in WebInspector after moving CORS checks to NetworkProcess
>+        https://bugs.webkit.org/show_bug.cgi?id=186312
>+        <rdar://problem/40495434>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add buffering of all request/response of a given load, including redirections and preflights.
>+        This buffering is switched on/off by a boolean which is switched on in case Web Inspector is launched.
>+
>+        Buffering is done in NetworkLoadChecker.
>+        We add ways to retrieve preflight information from NetworkCORSPreflightChecker.
>+
>+        Implement LoaderStrategy new methods through sync IPC.
>+
>+        * NetworkProcess/NetworkCORSPreflightChecker.cpp:
>+        (WebKit::NetworkCORSPreflightChecker::NetworkCORSPreflightChecker):
>+        (WebKit::NetworkCORSPreflightChecker::startPreflight):
>+        (WebKit::NetworkCORSPreflightChecker::willPerformHTTPRedirection):
>+        (WebKit::NetworkCORSPreflightChecker::didReceiveResponseNetworkSession):
>+        (WebKit::NetworkCORSPreflightChecker::didCompleteWithError):
>+        (WebKit::NetworkCORSPreflightChecker::takeInformation):
>+        * NetworkProcess/NetworkCORSPreflightChecker.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        (WebKit::NetworkConnectionToWebProcess::takeNetworkLoadInformationRequest):
>+        (WebKit::NetworkConnectionToWebProcess::takeNetworkLoadIntermediateInformation):
>+        (WebKit::NetworkConnectionToWebProcess::addNetworkLoadInformation):
>+        (WebKit::NetworkConnectionToWebProcess::addNetworkLoadInformationMetrics):
>+        (WebKit::NetworkConnectionToWebProcess::addNetworkLoadInformationResponse): Deleted.
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkLoadChecker.cpp:
>+        (WebKit::NetworkLoadChecker::NetworkLoadChecker):
>+        (WebKit::NetworkLoadChecker::check):
>+        (WebKit::NetworkLoadChecker::checkRedirection):
>+        (WebKit::NetworkLoadChecker::checkResponse):
>+        (WebKit::NetworkLoadChecker::checkCORSRequestWithPreflight):
>+        (WebKit::NetworkLoadChecker::storeRedirection):
>+        * NetworkProcess/NetworkLoadChecker.h:
>+        (WebKit::NetworkLoadChecker::takeNetworkLoadInformation):
>+        * NetworkProcess/NetworkResourceLoader.cpp:
>+        (WebKit::NetworkResourceLoader::didReceiveResponse):
>+        (WebKit::NetworkResourceLoader::willSendRedirectedRequest):
>+        (WebKit::NetworkResourceLoader::didRetrieveCacheEntry):
>+        * NetworkProcess/PingLoad.cpp:
>+        (WebKit::PingLoad::PingLoad):
>+        * Scripts/webkit/messages.py:
>+        * WebProcess/Network/WebLoaderStrategy.cpp:
>+        (WebKit::WebLoaderStrategy::intermediateLoadInformationFromResourceLoadIdentifier):
>+        * WebProcess/Network/WebLoaderStrategy.h:
>+
> 2018-06-04  Youenn Fablet  <youenn@apple.com>
> 
>         ServiceWorker registration should store any script fetched through importScripts
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 1673aa9a530ca3d2e91685fa1c4051a2ee5910db..deee3f6288f3e2037780aae825e8d0595c71b697 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -1082,6 +1082,7 @@
> 		4161E2D51FE48DC500EC2E96 /* FetchLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 4147E2B51C89912600A7E715 /* FetchLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		4162A451101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A44E101145AE00DFF3ED /* DedicatedWorkerGlobalScope.h */; };
> 		4162A4581011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */; };
>+		416D75A220C651A500D02D2C /* NetworkLoadInformation.h in Headers */ = {isa = PBXBuildFile; fileRef = 416D759F20C6441300D02D2C /* NetworkLoadInformation.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		416E0B3A209BC3CB004A95D9 /* FetchIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */ = {isa = PBXBuildFile; fileRef = 416E29A5102FA962007FC14E /* WorkerReportingProxy.h */; };
> 		416E6FE81BBD12DF000A3F64 /* ReadableStreamInternalsBuiltins.h in Headers */ = {isa = PBXBuildFile; fileRef = 9B03D8061BB3110D00B764D9 /* ReadableStreamInternalsBuiltins.h */; settings = {ATTRIBUTES = (Private, ); }; };
>@@ -7226,6 +7227,7 @@
> 		4162A44F101145AE00DFF3ED /* DedicatedWorkerGlobalScope.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = DedicatedWorkerGlobalScope.idl; sourceTree = "<group>"; };
> 		4162A4551011464700DFF3ED /* JSDedicatedWorkerGlobalScope.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDedicatedWorkerGlobalScope.cpp; sourceTree = "<group>"; };
> 		4162A4561011464700DFF3ED /* JSDedicatedWorkerGlobalScope.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSDedicatedWorkerGlobalScope.h; sourceTree = "<group>"; };
>+		416D759F20C6441300D02D2C /* NetworkLoadInformation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkLoadInformation.h; sourceTree = "<group>"; };
> 		416E0B37209BC3C2004A95D9 /* FetchIdentifier.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = FetchIdentifier.h; sourceTree = "<group>"; };
> 		416E29A5102FA962007FC14E /* WorkerReportingProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerReportingProxy.h; sourceTree = "<group>"; };
> 		4170A2E91D8C0CC000318452 /* JSDOMWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSDOMWrapper.cpp; sourceTree = "<group>"; };
>@@ -19007,6 +19009,7 @@
> 				514C765D0CE923A1007EF3CD /* HTTPParsers.cpp */,
> 				514C765E0CE923A1007EF3CD /* HTTPParsers.h */,
> 				628D214B12131ED10055DCFC /* NetworkingContext.h */,
>+				416D759F20C6441300D02D2C /* NetworkLoadInformation.h */,
> 				8A81BF8411DCFD9000DA2B98 /* NetworkLoadMetrics.h */,
> 				1A7FA61A0DDA3BBE0028F8A5 /* NetworkStateNotifier.cpp */,
> 				1A7FA6180DDA3B3A0028F8A5 /* NetworkStateNotifier.h */,
>@@ -29441,6 +29444,7 @@
> 				656D37430ADBA5DE00A4554D /* NetscapePlugInStreamLoader.h in Headers */,
> 				A19D934B1AA11B1E00B46C24 /* NetworkExtensionContentFilter.h in Headers */,
> 				628D214C12131ED10055DCFC /* NetworkingContext.h in Headers */,
>+				416D75A220C651A500D02D2C /* NetworkLoadInformation.h in Headers */,
> 				8A81BF8511DCFD9000DA2B98 /* NetworkLoadMetrics.h in Headers */,
> 				59C27F07138D28CF0079B7E2 /* NetworkResourcesData.h in Headers */,
> 				1A7FA6190DDA3B3A0028F8A5 /* NetworkStateNotifier.h in Headers */,
>diff --git a/Source/WebCore/loader/LoaderStrategy.cpp b/Source/WebCore/loader/LoaderStrategy.cpp
>index 838642d9de6097f0d63d5ad48bbf55358adcb487..0f6ecfa13b814b75681a9caee26b1fed91b4a510 100644
>--- a/Source/WebCore/loader/LoaderStrategy.cpp
>+++ b/Source/WebCore/loader/LoaderStrategy.cpp
>@@ -26,8 +26,7 @@
> #include "config.h"
> #include "LoaderStrategy.h"
> 
>-#include "NetworkLoadMetrics.h"
>-#include "ResourceResponse.h"
>+#include "NetworkLoadInformation.h"
> 
> namespace WebCore {
> 
>@@ -43,6 +42,9 @@ NetworkLoadMetrics LoaderStrategy::networkMetricsFromResourceLoadIdentifier(uint
>     return { };
> }
> 
>-} // namespace WebCore
>-
>+Vector<NetworkIntermediateLoadInformation> LoaderStrategy::intermediateLoadInformationFromResourceLoadIdentifier(uint64_t /* resourceLoadIdentifier */)
>+{
>+    return { };
>+}
> 
>+} // namespace WebCore
>diff --git a/Source/WebCore/loader/LoaderStrategy.h b/Source/WebCore/loader/LoaderStrategy.h
>index f142b57727b3f598af1fa297e2d993bb3e156640..cbaea305b1d32617d7fdc5949053540f107db93e 100644
>--- a/Source/WebCore/loader/LoaderStrategy.h
>+++ b/Source/WebCore/loader/LoaderStrategy.h
>@@ -42,6 +42,7 @@ class FrameLoader;
> class HTTPHeaderMap;
> class NetscapePlugInStreamLoader;
> class NetscapePlugInStreamLoaderClient;
>+struct NetworkIntermediateLoadInformation;
> class NetworkLoadMetrics;
> class ResourceError;
> class ResourceLoader;
>@@ -85,6 +86,7 @@ public:
>     virtual bool havePerformedSecurityChecks(const ResourceResponse&) const { return false; }
> 
>     virtual ResourceResponse responseFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
>+    virtual Vector<NetworkIntermediateLoadInformation> intermediateLoadInformationFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
>     virtual NetworkLoadMetrics networkMetricsFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier);
> 
> protected:
>diff --git a/Source/WebCore/platform/network/NetworkLoadInformation.h b/Source/WebCore/platform/network/NetworkLoadInformation.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..ea5e8e6b9ffb98853f86563b63568f98604cfd07
>--- /dev/null
>+++ b/Source/WebCore/platform/network/NetworkLoadInformation.h
>@@ -0,0 +1,89 @@
>+/*
>+ * Copyright (C) 2018 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "NetworkLoadMetrics.h"
>+#include "ResourceRequest.h"
>+#include "ResourceResponse.h"
>+#include <wtf/EnumTraits.h>
>+#include <wtf/Vector.h>
>+
>+namespace WebCore {
>+
>+struct NetworkIntermediateLoadInformation {
>+    enum class Type { Redirection, Preflight };
>+    Type type;
>+    ResourceRequest request;
>+    ResourceResponse response;
>+    NetworkLoadMetrics metrics;
>+
>+    template<class Encoder> void encode(Encoder&) const;
>+    template<class Decoder> static std::optional<NetworkIntermediateLoadInformation> decode(Decoder&);
>+};
>+
>+struct NetworkLoadInformation {
>+    ResourceRequest request;
>+    ResourceResponse response;
>+    NetworkLoadMetrics metrics;
>+    Vector<NetworkIntermediateLoadInformation> intermediateLoads;
>+};
>+
>+}
>+
>+namespace WTF {
>+template<> struct EnumTraits<WebCore::NetworkIntermediateLoadInformation::Type> {
>+    using values = EnumValues<
>+        WebCore::NetworkIntermediateLoadInformation::Type,
>+        WebCore::NetworkIntermediateLoadInformation::Type::Redirection,
>+        WebCore::NetworkIntermediateLoadInformation::Type::Preflight
>+    >;
>+};
>+}
>+
>+namespace WebCore {
>+
>+template<class Encoder> inline void NetworkIntermediateLoadInformation::encode(Encoder& encoder) const
>+{
>+    encoder << type << request << response << metrics;
>+}
>+
>+template<class Decoder> inline std::optional<NetworkIntermediateLoadInformation> NetworkIntermediateLoadInformation::decode(Decoder& decoder)
>+{
>+    NetworkIntermediateLoadInformation information;
>+
>+    if (!decoder.decode(information.type))
>+        return std::nullopt;
>+    if (!decoder.decode(information.request))
>+        return std::nullopt;
>+    if (!decoder.decode(information.response))
>+        return std::nullopt;
>+    if (!decoder.decode(information.metrics))
>+        return std::nullopt;
>+
>+    return information;
>+}
>+
>+}
>diff --git a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>index 29250baaed205f32af218bdb386471788f13cd2a..d7bfccd94917082ea5bb20071eeba8241418d3b2 100644
>--- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.cpp
>@@ -39,9 +39,10 @@ namespace WebKit {
> 
> using namespace WebCore;
> 
>-NetworkCORSPreflightChecker::NetworkCORSPreflightChecker(Parameters&& parameters, CompletionCallback&& completionCallback)
>+NetworkCORSPreflightChecker::NetworkCORSPreflightChecker(Parameters&& parameters, bool shouldCaptureExtraNetworkLoadMetrics, CompletionCallback&& completionCallback)
>     : m_parameters(WTFMove(parameters))
>     , m_completionCallback(WTFMove(completionCallback))
>+    , m_shouldCaptureExtraNetworkLoadMetrics(shouldCaptureExtraNetworkLoadMetrics)
> {
> }
> 
>@@ -67,6 +68,9 @@ void NetworkCORSPreflightChecker::startPreflight()
>     if (!m_parameters.userAgent.isNull())
>         loadParameters.request.setHTTPHeaderField(HTTPHeaderName::UserAgent, m_parameters.userAgent);
> 
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation = NetworkIntermediateLoadInformation { NetworkIntermediateLoadInformation::Type::Preflight, loadParameters.request, { }, { } };
>+
>     if (auto* networkSession = SessionTracker::networkSession(loadParameters.sessionID)) {
>         m_task = NetworkDataTask::create(*networkSession, *this, WTFMove(loadParameters));
>         m_task->resume();
>@@ -76,6 +80,9 @@ void NetworkCORSPreflightChecker::startPreflight()
> 
> void NetworkCORSPreflightChecker::willPerformHTTPRedirection(WebCore::ResourceResponse&& response, WebCore::ResourceRequest&&, RedirectCompletionHandler&& completionHandler)
> {
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation.response = WTFMove(response);
>+
>     RELEASE_LOG_IF_ALLOWED("willPerformHTTPRedirection");
>     completionHandler({ });
>     m_completionCallback(ResourceError { errorDomainWebKitInternal, 0, m_parameters.originalRequest.url(), ASCIILiteral("Preflight response is not successful"), ResourceError::Type::AccessControl });
>@@ -97,6 +104,10 @@ void NetworkCORSPreflightChecker::didReceiveChallenge(const WebCore::Authenticat
> void NetworkCORSPreflightChecker::didReceiveResponseNetworkSession(WebCore::ResourceResponse&& response, ResponseCompletionHandler&& completionHandler)
> {
>     RELEASE_LOG_IF_ALLOWED("didReceiveResponseNetworkSession");
>+
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation.response = response;
>+
>     m_response = WTFMove(response);
>     completionHandler(PolicyAction::Use);
> }
>@@ -106,8 +117,11 @@ void NetworkCORSPreflightChecker::didReceiveData(Ref<WebCore::SharedBuffer>&&)
>     RELEASE_LOG_IF_ALLOWED("didReceiveData");
> }
> 
>-void NetworkCORSPreflightChecker::didCompleteWithError(const WebCore::ResourceError& preflightError, const WebCore::NetworkLoadMetrics&)
>+void NetworkCORSPreflightChecker::didCompleteWithError(const WebCore::ResourceError& preflightError, const WebCore::NetworkLoadMetrics& metrics)
> {
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation.metrics = metrics;
>+
>     if (!preflightError.isNull()) {
>         RELEASE_LOG_IF_ALLOWED("didCompleteWithError");
>         auto error = preflightError;
>@@ -145,4 +159,10 @@ void NetworkCORSPreflightChecker::cannotShowURL()
>     m_completionCallback(ResourceError { errorDomainWebKitInternal, 0, m_parameters.originalRequest.url(), ASCIILiteral("Preflight response was blocked"), ResourceError::Type::AccessControl });
> }
> 
>+NetworkIntermediateLoadInformation NetworkCORSPreflightChecker::takeInformation()
>+{
>+    ASSERT(m_shouldCaptureExtraNetworkLoadMetrics);
>+    return WTFMove(m_loadInformation);
>+}
>+
> } // Namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>index 42e69e60df1ede2749cf056fffdc4040a5255406..3a19a0e8f2bf8acc53acab8a53fe31c4c0523b34 100644
>--- a/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>+++ b/Source/WebKit/NetworkProcess/NetworkCORSPreflightChecker.h
>@@ -26,8 +26,7 @@
> #pragma once
> 
> #include "NetworkDataTask.h"
>-#include <WebCore/ResourceRequest.h>
>-#include <WebCore/ResourceResponse.h>
>+#include <WebCore/NetworkLoadInformation.h>
> #include <WebCore/StoredCredentialsPolicy.h>
> #include <pal/SessionID.h>
> #include <wtf/CompletionHandler.h>
>@@ -52,12 +51,14 @@ public:
>     };
>     using CompletionCallback = CompletionHandler<void(WebCore::ResourceError&&)>;
> 
>-    NetworkCORSPreflightChecker(Parameters&&, CompletionCallback&&);
>+    NetworkCORSPreflightChecker(Parameters&&, bool shouldCaptureExtraNetworkLoadMetrics, CompletionCallback&&);
>     ~NetworkCORSPreflightChecker();
>     const WebCore::ResourceRequest& originalRequest() const { return m_parameters.originalRequest; }
> 
>     void startPreflight();
> 
>+    WebCore::NetworkIntermediateLoadInformation takeInformation();
>+
> private:
>     void willPerformHTTPRedirection(WebCore::ResourceResponse&&, WebCore::ResourceRequest&&, RedirectCompletionHandler&&) final;
>     void didReceiveChallenge(const WebCore::AuthenticationChallenge&, ChallengeCompletionHandler&&) final;
>@@ -72,6 +73,8 @@ private:
>     WebCore::ResourceResponse m_response;
>     CompletionCallback m_completionCallback;
>     RefPtr<NetworkDataTask> m_task;
>+    bool m_shouldCaptureExtraNetworkLoadMetrics { false };
>+    WebCore::NetworkIntermediateLoadInformation m_loadInformation;
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index 15e5b211e8f9c37791f1a09e33e83a8543867583..2b747f473a1c26623ef22942bb2a5aa8ea701110 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -33,6 +33,7 @@
> #include "NetworkConnectionToWebProcessMessages.h"
> #include "NetworkMDNSRegister.h"
> #include "NetworkRTCProvider.h"
>+#include <WebCore/NetworkLoadInformation.h>
> #include <WebCore/ResourceLoadPriority.h>
> #include <wtf/RefCounted.h>
> 
>@@ -77,33 +78,37 @@ public:
>     void cleanupForSuspension(Function<void()>&&);
>     void endSuspension();
> 
>-    // FIXME: We should store all redirected request/responses.
>-    struct NetworkLoadInformation {
>-        WebCore::ResourceResponse response;
>-        WebCore::NetworkLoadMetrics metrics;
>-    };
>+    void takeNetworkLoadInformationRequest(ResourceLoadIdentifier identifier, WebCore::ResourceRequest& request)
>+    {
>+        request = m_networkLoadInformationByID.get(identifier).request;
>+    }
> 
>     void takeNetworkLoadInformationResponse(ResourceLoadIdentifier identifier, WebCore::ResourceResponse& response)
>     {
>         response = m_networkLoadInformationByID.get(identifier).response;
>     }
> 
>+    void takeNetworkLoadIntermediateInformation(ResourceLoadIdentifier identifier, Vector<WebCore::NetworkIntermediateLoadInformation>& information)
>+    {
>+        information = m_networkLoadInformationByID.get(identifier).intermediateLoads;
>+    }
>+
>     void takeNetworkLoadInformationMetrics(ResourceLoadIdentifier identifier, WebCore::NetworkLoadMetrics& metrics)
>     {
>         metrics = m_networkLoadInformationByID.take(identifier).metrics;
>     }
> 
>-    void addNetworkLoadInformationResponse(ResourceLoadIdentifier identifier, const WebCore::ResourceResponse& response)
>+    void addNetworkLoadInformation(ResourceLoadIdentifier identifier, WebCore::NetworkLoadInformation&& information)
>     {
>         ASSERT(!m_networkLoadInformationByID.contains(identifier));
>-        m_networkLoadInformationByID.add(identifier, NetworkLoadInformation { response, { } });
>+        m_networkLoadInformationByID.add(identifier, WTFMove(information));
>     }
> 
>     void addNetworkLoadInformationMetrics(ResourceLoadIdentifier identifier, const WebCore::NetworkLoadMetrics& metrics)
>     {
>         ASSERT(m_networkLoadInformationByID.contains(identifier));
>         m_networkLoadInformationByID.ensure(identifier, [] {
>-            return NetworkLoadInformation { };
>+            return WebCore::NetworkLoadInformation { };
>         }).iterator->value.metrics = metrics;
>     }
> 
>@@ -221,7 +226,7 @@ private:
>     HashMap<String, RefPtr<WebCore::BlobDataFileReference>> m_blobDataFileReferences;
>     Vector<ResourceNetworkActivityTracker> m_networkActivityTrackers;
> 
>-    HashMap<ResourceLoadIdentifier, NetworkLoadInformation> m_networkLoadInformationByID;
>+    HashMap<ResourceLoadIdentifier, WebCore::NetworkLoadInformation> m_networkLoadInformationByID;
> 
> 
> #if USE(LIBWEBRTC)
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>index f4ec63311f77a3be67187b896d52a0178baf7154..0d359700f1ff3f1200ff0a3d77fe0d02ca168f85 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -66,6 +66,8 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
>     RemoveOriginAccessWhitelistEntry(String sourceOrigin, String destinationProtocol, String destinationHost, bool allowDestinationSubdomains);
>     ResetOriginAccessWhitelists();
> 
>+    TakeNetworkLoadInformationRequest(uint64_t resourceLoadIdentifier) -> (WebCore::ResourceRequest request);
>     TakeNetworkLoadInformationResponse(uint64_t resourceLoadIdentifier) -> (WebCore::ResourceResponse response);
>+    TakeNetworkLoadIntermediateInformation(uint64_t resourceLoadIdentifier) -> (Vector<WebCore::NetworkIntermediateLoadInformation> intermediateLoads);
>     TakeNetworkLoadInformationMetrics(uint64_t resourceLoadIdentifier) -> (WebCore::NetworkLoadMetrics networkMetrics);
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkLoadChecker.cpp b/Source/WebKit/NetworkProcess/NetworkLoadChecker.cpp
>index d0f21256534a9be2de01838b9e0ba6965caa074d..779eb9575b394e5e80d79ab72b5e7b3b99bcfb6c 100644
>--- a/Source/WebKit/NetworkProcess/NetworkLoadChecker.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkLoadChecker.cpp
>@@ -52,7 +52,7 @@ static inline bool isSameOrigin(const URL& url, const SecurityOrigin* origin)
>     return url.protocolIsData() || url.protocolIsBlob() || !origin || origin->canRequest(url);
> }
> 
>-NetworkLoadChecker::NetworkLoadChecker(NetworkConnectionToWebProcess& connection, uint64_t webPageID, uint64_t webFrameID, ResourceLoadIdentifier loadIdentifier, FetchOptions&& options, PAL::SessionID sessionID, HTTPHeaderMap&& originalRequestHeaders, URL&& url, RefPtr<SecurityOrigin>&& sourceOrigin, PreflightPolicy preflightPolicy, String&& referrer)
>+NetworkLoadChecker::NetworkLoadChecker(NetworkConnectionToWebProcess& connection, uint64_t webPageID, uint64_t webFrameID, ResourceLoadIdentifier loadIdentifier, FetchOptions&& options, PAL::SessionID sessionID, HTTPHeaderMap&& originalRequestHeaders, URL&& url, RefPtr<SecurityOrigin>&& sourceOrigin, PreflightPolicy preflightPolicy, String&& referrer, bool shouldCaptureExtraNetworkLoadMetrics)
>     : m_connection(connection)
>     , m_webPageID(webPageID)
>     , m_webFrameID(webFrameID)
>@@ -64,6 +64,7 @@ NetworkLoadChecker::NetworkLoadChecker(NetworkConnectionToWebProcess& connection
>     , m_origin(WTFMove(sourceOrigin))
>     , m_preflightPolicy(preflightPolicy)
>     , m_referrer(WTFMove(referrer))
>+    , m_shouldCaptureExtraNetworkLoadMetrics(shouldCaptureExtraNetworkLoadMetrics)
> {
>     m_isSameOriginRequest = isSameOrigin(m_url, m_origin.get());
>     switch (options.credentials) {
>@@ -85,6 +86,9 @@ void NetworkLoadChecker::check(ResourceRequest&& request, ValidationHandler&& ha
> {
>     ASSERT(!isChecking());
> 
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation.request = request;
>+
>     m_firstRequestHeaders = request.httpHeaderFields();
>     // FIXME: We should not get this information from the request but directly from some NetworkProcess setting.
>     m_dntHeaderValue = m_firstRequestHeaders.get(HTTPHeaderName::DNT);
>@@ -154,6 +158,16 @@ bool NetworkLoadChecker::shouldCrossOriginResourcePolicyPolicyCancelLoad(const R
>     RELEASE_ASSERT_NOT_REACHED();
> }
> 
>+ResourceError NetworkLoadChecker::checkResponse(ResourceResponse& response)
>+{
>+    auto error = validateResponse(response);
>+
>+    if (m_shouldCaptureExtraNetworkLoadMetrics)
>+        m_loadInformation.response = response;
>+
>+    return error;
>+}
>+
> ResourceError NetworkLoadChecker::validateResponse(ResourceResponse& response)
> {
>     if (m_redirectCount)
>@@ -358,7 +372,7 @@ void NetworkLoadChecker::checkCORSRequestWithPreflight(ResourceRequest&& request
>         m_sessionID,
>         m_storedCredentialsPolicy
>     };
>-    m_corsPreflightChecker = std::make_unique<NetworkCORSPreflightChecker>(WTFMove(parameters), [this, request = WTFMove(request), handler = WTFMove(handler), isRedirected = isRedirected()](auto&& error) mutable {
>+    m_corsPreflightChecker = std::make_unique<NetworkCORSPreflightChecker>(WTFMove(parameters), m_shouldCaptureExtraNetworkLoadMetrics, [this, request = WTFMove(request), handler = WTFMove(handler), isRedirected = isRedirected()](auto&& error) mutable {
>         RELEASE_LOG_IF_ALLOWED("checkCORSRequestWithPreflight - makeCrossOriginAccessRequestWithPreflight preflight complete, success: %d forRedirect? %d", error.isNull(), isRedirected);
> 
>         if (!error.isNull()) {
>@@ -366,6 +380,9 @@ void NetworkLoadChecker::checkCORSRequestWithPreflight(ResourceRequest&& request
>             return;
>         }
> 
>+        if (m_shouldCaptureExtraNetworkLoadMetrics)
>+            m_loadInformation.intermediateLoads.append(m_corsPreflightChecker->takeInformation());
>+
>         auto corsPreflightChecker = WTFMove(m_corsPreflightChecker);
>         updateRequestForAccessControl(request, *m_origin, m_storedCredentialsPolicy);
>         handler(WTFMove(request));
>@@ -435,4 +452,11 @@ void NetworkLoadChecker::enqueueSecurityPolicyViolationEvent(WebCore::SecurityPo
>         m_connection->connection().send(Messages::WebPage::EnqueueSecurityPolicyViolationEvent { m_webFrameID, WTFMove(eventInit) }, m_webPageID);
> }
> 
>+void NetworkLoadChecker::storeRedirectionIfNeeded(WebCore::ResourceRequest&& request, WebCore::ResourceResponse&& response)
>+{
>+    if (!m_shouldCaptureExtraNetworkLoadMetrics)
>+        return;
>+    m_loadInformation.intermediateLoads.append(NetworkIntermediateLoadInformation { NetworkIntermediateLoadInformation::Type::Redirection, WTFMove(request), WTFMove(response), { } });
>+}
>+
> } // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/NetworkLoadChecker.h b/Source/WebKit/NetworkProcess/NetworkLoadChecker.h
>index ec74892706f80ca0329b9c0dfd4d495d60680518..a91279d4c4a6082129d9223aee66ecf24721777e 100644
>--- a/Source/WebKit/NetworkProcess/NetworkLoadChecker.h
>+++ b/Source/WebKit/NetworkProcess/NetworkLoadChecker.h
>@@ -28,8 +28,8 @@
> #include "NetworkContentRuleListManager.h"
> #include "NetworkResourceLoadParameters.h"
> #include <WebCore/ContentSecurityPolicyClient.h>
>+#include <WebCore/NetworkLoadInformation.h>
> #include <WebCore/ResourceError.h>
>-#include <WebCore/ResourceResponse.h>
> #include <WebCore/SecurityPolicyViolationEvent.h>
> #include <wtf/CompletionHandler.h>
> #include <wtf/Expected.h>
>@@ -46,7 +46,7 @@ class NetworkCORSPreflightChecker;
> 
> class NetworkLoadChecker : public WebCore::ContentSecurityPolicyClient {
> public:
>-    NetworkLoadChecker(NetworkConnectionToWebProcess&, uint64_t webPageID, uint64_t webFrameID, ResourceLoadIdentifier, WebCore::FetchOptions&&, PAL::SessionID, WebCore::HTTPHeaderMap&&, WebCore::URL&&, RefPtr<WebCore::SecurityOrigin>&&, WebCore::PreflightPolicy, String&& referrer);
>+    NetworkLoadChecker(NetworkConnectionToWebProcess&, uint64_t webPageID, uint64_t webFrameID, ResourceLoadIdentifier, WebCore::FetchOptions&&, PAL::SessionID, WebCore::HTTPHeaderMap&&, WebCore::URL&&, RefPtr<WebCore::SecurityOrigin>&&, WebCore::PreflightPolicy, String&& referrer, bool shouldCaptureExtraNetworkLoadMetrics);
>     ~NetworkLoadChecker();
> 
>     using RequestOrError = Expected<WebCore::ResourceRequest, WebCore::ResourceError>;
>@@ -55,7 +55,7 @@ public:
>     void checkRedirection(WebCore::ResourceResponse&, WebCore::ResourceRequest&&, ValidationHandler&&);
>     void prepareRedirectedRequest(WebCore::ResourceRequest&);
> 
>-    WebCore::ResourceError validateResponse(WebCore::ResourceResponse&);
>+    WebCore::ResourceError checkResponse(WebCore::ResourceResponse&);
> 
>     void setCSPResponseHeaders(WebCore::ContentSecurityPolicyResponseHeaders&& headers) { m_cspResponseHeaders = WTFMove(headers); }
> #if ENABLE(CONTENT_EXTENSIONS)
>@@ -71,6 +71,9 @@ public:
> 
>     WeakPtrFactory<NetworkLoadChecker>& weakPtrFactory() { return m_weakFactory; }
> 
>+    WebCore::NetworkLoadInformation takeNetworkLoadInformation() { return WTFMove(m_loadInformation); }
>+    void storeRedirectionIfNeeded(WebCore::ResourceRequest&&, WebCore::ResourceResponse&&);
>+
> private:
>     WebCore::ContentSecurityPolicy* contentSecurityPolicy();
>     bool isChecking() const { return !!m_corsPreflightChecker; }
>@@ -82,6 +85,8 @@ private:
> 
>     void continueCheckingRequest(WebCore::ResourceRequest&&, ValidationHandler&&);
> 
>+    WebCore::ResourceError validateResponse(WebCore::ResourceResponse&);
>+
>     bool doesNotNeedCORSCheck(const WebCore::URL&) const;
>     void checkCORSRequest(WebCore::ResourceRequest&&, ValidationHandler&&);
>     void checkCORSRedirectedRequest(WebCore::ResourceRequest&&, ValidationHandler&&);
>@@ -135,6 +140,8 @@ private:
>     String m_dntHeaderValue;
>     String m_referrer;
>     WeakPtrFactory<NetworkLoadChecker> m_weakFactory;
>+    bool m_shouldCaptureExtraNetworkLoadMetrics { false };
>+    WebCore::NetworkLoadInformation m_loadInformation;
> };
> 
> }
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>index 4a9880a631a89ec2806cb8098f99e27fe8a97449..639bec26371bb435961b3e6557a6bf6b00e21a51 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>@@ -119,7 +119,7 @@ NetworkResourceLoader::NetworkResourceLoader(NetworkResourceLoadParameters&& par
>     }
> 
>     if (synchronousReply || parameters.shouldRestrictHTTPResponseAccess) {
>-        m_networkLoadChecker = std::make_unique<NetworkLoadChecker>(m_connection, m_parameters.webPageID, m_parameters.webFrameID, identifier(), FetchOptions { m_parameters.options }, m_parameters.sessionID, HTTPHeaderMap { m_parameters.originalRequestHeaders }, URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef(), m_parameters.preflightPolicy, originalRequest().httpReferrer());
>+        m_networkLoadChecker = std::make_unique<NetworkLoadChecker>(m_connection, m_parameters.webPageID, m_parameters.webFrameID, identifier(), FetchOptions { m_parameters.options }, m_parameters.sessionID, HTTPHeaderMap { m_parameters.originalRequestHeaders }, URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef(), m_parameters.preflightPolicy, originalRequest().httpReferrer(), shouldCaptureExtraNetworkLoadMetrics());
>         if (m_parameters.cspResponseHeaders)
>             m_networkLoadChecker->setCSPResponseHeaders(ContentSecurityPolicyResponseHeaders { m_parameters.cspResponseHeaders.value() });
> #if ENABLE(CONTENT_EXTENSIONS)
>@@ -426,8 +426,8 @@ auto NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon
> 
>     m_response = WTFMove(receivedResponse);
> 
>-    if (shouldCaptureExtraNetworkLoadMetrics())
>-        m_connection->addNetworkLoadInformationResponse(identifier(), m_response);
>+    if (shouldCaptureExtraNetworkLoadMetrics() && m_networkLoadChecker)
>+        m_connection->addNetworkLoadInformation(identifier(), m_networkLoadChecker->takeNetworkLoadInformation());
> 
>     // For multipart/x-mixed-replace didReceiveResponseAsync gets called multiple times and buffering would require special handling.
>     if (!isSynchronous() && m_response.isMultipart())
>@@ -455,7 +455,7 @@ auto NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon
>     }
> 
>     if (m_networkLoadChecker) {
>-        auto error = m_networkLoadChecker->validateResponse(m_response);
>+        auto error = m_networkLoadChecker->checkResponse(m_response);
>         if (!error.isNull()) {
>             RunLoop::main().dispatch([protectedThis = makeRef(*this), error = WTFMove(error)] {
>                 if (protectedThis->m_networkLoad)
>@@ -568,7 +568,7 @@ void NetworkResourceLoader::didBlockAuthenticationChallenge()
>     send(Messages::WebResourceLoader::DidBlockAuthenticationChallenge());
> }
> 
>-void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, WebCore::ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
>+void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request, ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
> {
>     ++m_redirectCount;
> 
>@@ -576,6 +576,7 @@ void NetworkResourceLoader::willSendRedirectedRequest(ResourceRequest&& request,
>         m_cache->storeRedirect(request, redirectResponse, redirectRequest);
> 
>     if (m_networkLoadChecker) {
>+        m_networkLoadChecker->storeRedirectionIfNeeded(ResourceRequest { request }, ResourceResponse { redirectResponse });
>         m_networkLoadChecker->checkRedirection(redirectResponse, WTFMove(redirectRequest), [protectedThis = makeRef(*this), this, storedCredentialsPolicy = m_networkLoadChecker->storedCredentialsPolicy(), request = WTFMove(request), redirectResponse](auto&& result) mutable {
>             if (!result.has_value()) {
>                 if (result.error().isCancellation())
>@@ -761,7 +762,7 @@ void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::
>         return;
>     }
>     if (m_networkLoadChecker) {
>-        auto error = m_networkLoadChecker->validateResponse(response);
>+        auto error = m_networkLoadChecker->checkResponse(response);
>         if (!error.isNull()) {
>             didFailLoading(error);
>             return;
>diff --git a/Source/WebKit/NetworkProcess/PingLoad.cpp b/Source/WebKit/NetworkProcess/PingLoad.cpp
>index 1aece4792d2e6ead4b042dbd393c41177b690ac2..a098c3c7cd3542b3baede6e1a4fe11e545647e05 100644
>--- a/Source/WebKit/NetworkProcess/PingLoad.cpp
>+++ b/Source/WebKit/NetworkProcess/PingLoad.cpp
>@@ -42,7 +42,7 @@ PingLoad::PingLoad(NetworkResourceLoadParameters&& parameters, NetworkConnection
>     : m_parameters(WTFMove(parameters))
>     , m_completionHandler(WTFMove(completionHandler))
>     , m_timeoutTimer(*this, &PingLoad::timeoutTimerFired)
>-    , m_networkLoadChecker(makeUniqueRef<NetworkLoadChecker>(connection, m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, FetchOptions { m_parameters.options}, m_parameters.sessionID, WTFMove(m_parameters.originalRequestHeaders), URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef(), m_parameters.preflightPolicy, m_parameters.request.httpReferrer()))
>+    , m_networkLoadChecker(makeUniqueRef<NetworkLoadChecker>(connection, m_parameters.webPageID, m_parameters.webFrameID, m_parameters.identifier, FetchOptions { m_parameters.options}, m_parameters.sessionID, WTFMove(m_parameters.originalRequestHeaders), URL { m_parameters.request.url() }, m_parameters.sourceOrigin.copyRef(), m_parameters.preflightPolicy, m_parameters.request.httpReferrer(), false))
> {
> 
>     if (m_parameters.cspResponseHeaders)
>diff --git a/Source/WebKit/Scripts/webkit/messages.py b/Source/WebKit/Scripts/webkit/messages.py
>index 16e2867a9b0820a3a857d409a51f61260721dbb6..15c58089f929d4fbc7ee8157fddbce676abb4ec0 100644
>--- a/Source/WebKit/Scripts/webkit/messages.py
>+++ b/Source/WebKit/Scripts/webkit/messages.py
>@@ -388,6 +388,7 @@ def headers_for_type(type):
>         'WebCore::IncludeSecureCookies': ['<WebCore/CookiesStrategy.h>'],
>         'WebCore::KeyframeValueList': ['<WebCore/GraphicsLayer.h>'],
>         'WebCore::KeypressCommand': ['<WebCore/KeyboardEvent.h>'],
>+        'WebCore::NetworkIntermediateLoadInformation': ['<WebCore/NetworkLoadInformation.h>'],
>         'WebCore::PasteboardCustomData': ['<WebCore/Pasteboard.h>'],
>         'WebCore::PasteboardImage': ['<WebCore/Pasteboard.h>'],
>         'WebCore::PasteboardURL': ['<WebCore/Pasteboard.h>'],
>diff --git a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>index 097b8bbd3ecf4551f671eb3a847ebf3e920e0ea6..bd385f72049abdfb67cf2ac71ffb10cde7894dec 100644
>--- a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>+++ b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>@@ -56,10 +56,10 @@
> #include <WebCore/Frame.h>
> #include <WebCore/FrameLoader.h>
> #include <WebCore/NetscapePlugInStreamLoader.h>
>+#include <WebCore/NetworkLoadInformation.h>
> #include <WebCore/PlatformStrategies.h>
> #include <WebCore/ReferrerPolicy.h>
> #include <WebCore/ResourceLoader.h>
>-#include <WebCore/ResourceResponse.h>
> #include <WebCore/RuntimeEnabledFeatures.h>
> #include <WebCore/SecurityOrigin.h>
> #include <WebCore/Settings.h>
>@@ -658,6 +658,13 @@ ResourceResponse WebLoaderStrategy::responseFromResourceLoadIdentifier(uint64_t
>     return response;
> }
> 
>+Vector<NetworkIntermediateLoadInformation> WebLoaderStrategy::intermediateLoadInformationFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier)
>+{
>+    Vector<NetworkIntermediateLoadInformation> information;
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendSync(Messages::NetworkConnectionToWebProcess::TakeNetworkLoadIntermediateInformation { resourceLoadIdentifier }, Messages::NetworkConnectionToWebProcess::TakeNetworkLoadIntermediateInformation::Reply { information }, 0, Seconds::infinity(), IPC::SendSyncOption::DoNotProcessIncomingMessagesWhenWaitingForSyncReply);
>+    return information;
>+}
>+
> NetworkLoadMetrics WebLoaderStrategy::networkMetricsFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier)
> {
>     NetworkLoadMetrics networkMetrics;
>diff --git a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>index ed023fcb9f8b6c5b6d24f57abd1dd1893f300b08..da94f233b9a40c7764280a5275919f123cd55836 100644
>--- a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>+++ b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>@@ -92,6 +92,7 @@ private:
>     bool tryLoadingUsingURLSchemeHandler(WebCore::ResourceLoader&);
> 
>     WebCore::ResourceResponse responseFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier) final;
>+    Vector<WebCore::NetworkIntermediateLoadInformation> intermediateLoadInformationFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier) final;
>     WebCore::NetworkLoadMetrics networkMetricsFromResourceLoadIdentifier(uint64_t resourceLoadIdentifier) final;
> 
>     bool shouldPerformSecurityChecks() const final;

Actions: View | Formatted Diff | Diff

Attachments on bug 186312: 341982 | 341985 | 341994 | 342616 | 342676 | 342691 | 343052