Attachment #400507 for bug #207446

View Details Raw Unified Return to Bug 207446

| Differences between



2020-02-29  Pavel Feldman  <pavel.feldman@gmail.com>

        Web Inspector: introduce request interception
        https://bugs.webkit.org/show_bug.cgi?id=207446

        Reviewed by NOBODY (OOPS!).

        This change introduces network request interception to the Network 
        protocol domain. It adds Network.interceptWithRequest notification that
        can be continued, modified or fulfilled. NetworkStage enum can now have
        'request' and 'response' values.

        * inspector/protocol/Network.json:

2020-05-12  Ross Kirsling  <ross.kirsling@sony.com>

        Fix existing usage of final/override/virtual in JSC and WTF



2020-02-29  Pavel Feldman  <pavel.feldman@gmail.com>

        Web Inspector: introduce request interception
        https://bugs.webkit.org/show_bug.cgi?id=207446

        Reviewed by NOBODY (OOPS!).

        This change introduces network request interception to the Network 
        protocol domain. It adds Network.interceptWithRequest notification that
        can be continued, modified or fulfilled. NetworkStage enum can now have
        'request' and 'response' values.

        Test: inspector/network/intercept-request.html

        * inspector/InspectorInstrumentation.cpp:
        (WebCore::InspectorInstrumentation::willInterceptImpl):
        (WebCore::InspectorInstrumentation::shouldInterceptRequestImpl):
        (WebCore::InspectorInstrumentation::interceptRequestImpl):
        * inspector/InspectorInstrumentation.h:
        (WebCore::InspectorInstrumentation::willIntercept):
        (WebCore::InspectorInstrumentation::shouldInterceptRequest):
        (WebCore::InspectorInstrumentation::interceptRequest):
        * inspector/InspectorInstrumentationWebKit.cpp:
        (WebCore::InspectorInstrumentationWebKit::shouldInterceptRequestInternal):
        (WebCore::InspectorInstrumentationWebKit::interceptRequestInternal):
        * inspector/InspectorInstrumentationWebKit.h:
        (WebCore::InspectorInstrumentationWebKit::shouldInterceptRequest):
        (WebCore::InspectorInstrumentationWebKit::interceptRequest):
        * inspector/agents/InspectorNetworkAgent.cpp:
        (WebCore::InspectorNetworkAgent::disable):
        (WebCore::InspectorNetworkAgent::shouldIntercept):
        (WebCore::InspectorNetworkAgent::continuePendingRequests):
        (WebCore::InspectorNetworkAgent::setInterceptionEnabled):
        (WebCore::InspectorNetworkAgent::addInterception):
        (WebCore::InspectorNetworkAgent::removeInterception):
        (WebCore::InspectorNetworkAgent::willIntercept):
        (WebCore::InspectorNetworkAgent::shouldInterceptRequest):
        (WebCore::InspectorNetworkAgent::shouldInterceptResponse):
        (WebCore::InspectorNetworkAgent::interceptRequest):
        (WebCore::InspectorNetworkAgent::interceptContinue):
        (WebCore::InspectorNetworkAgent::interceptWithRequest):
        (WebCore::InspectorNetworkAgent::interceptWithResponse):
        * inspector/agents/InspectorNetworkAgent.h:
        (WebCore::InspectorNetworkAgent::PendingInterceptRequest::PendingInterceptRequest):
        (WebCore::InspectorNetworkAgent::Intercept::operator== const):
        * loader/cache/CachedResourceLoader.cpp:
        (WebCore::CachedResourceLoader::requestResource):
        (WebCore::CachedResourceLoader::preload):

2020-05-12  Eric Carlson  <eric.carlson@apple.com>

        Poster set after playback begins should be ignored



2020-05-13  Pavel  <pavel.feldman@gmail.com>

        Web Inspector: introduce request interception
        https://bugs.webkit.org/show_bug.cgi?id=207446

        Reviewed by NOBODY (OOPS!).

        This change introduces network request interception to the Network 
        protocol domain. It adds Network.interceptWithRequest notification that
        can be continued, modified or fulfilled. NetworkStage enum can now have
        'request' and 'response' values.

        * UserInterface/Controllers/NetworkManager.js:
        (WI.NetworkManager.prototype.initializeTarget):
        (WI.NetworkManager.prototype.addLocalResourceOverride):
        (WI.NetworkManager.prototype.removeLocalResourceOverride):
        (WI.NetworkManager.prototype.requestIntercepted):
        (WI.NetworkManager.prototype.responseIntercepted):
        (WI.NetworkManager.prototype._handleResourceOverrideDisabledChanged):
        * UserInterface/Protocol/NetworkObserver.js:
        (WI.NetworkObserver.prototype.requestIntercepted):

2020-05-11  Devin Rousso  <drousso@apple.com>

        Web Inspector: Network: Timing: gaps around the "Resource does not have timing data" message



2020-02-29  Pavel Feldman  <pavel.feldman@gmail.com>

        Web Inspector: introduce request interception
        https://bugs.webkit.org/show_bug.cgi?id=207446

        Reviewed by NOBODY (OOPS!).

        This change introduces network request interception to the Network 
        protocol domain. It adds Network.interceptWithRequest notification that
        can be continued, modified or fulfilled. NetworkStage enum can now have
        'request' and 'response' values.

        * WebProcess/Network/WebLoaderStrategy.cpp:
        (WebKit::WebLoaderStrategy::scheduleLoad):

2020-05-12  Carlos Garcia Campos  <cgarcia@igalia.com>

        [GTK] Rework drag and drop handling in preparation for GTK4

Lines 155-161 a/Source/JavaScriptCore/inspector/protocol/Network.json_sec1
- a/Source/JavaScriptCore/inspector/protocol/Network.json -11 / +58 lines
155	"id": "NetworkStage",	155	"id": "NetworkStage",
156	"type": "string",	156	"type": "string",
157	"description": "Different stages of a network request.",	157	"description": "Different stages of a network request.",
158	"enum": ["response"]	158	"enum": ["request", "response"]
		159	},
		160	{
		161	"id": "ResourceErrorType",
		162	"type": "string",
		163	"description": "Different stages of a network request.",
		164	"enum": ["General", "AccessControl", "Cancellation", "Timeout"]
159	}	165	}
160	],	166	],
161	"commands": [	167	"commands": [
Lines 238-247 a/Source/JavaScriptCore/inspector/protocol/Network.json_sec2
238	"name": "addInterception",	244	"name": "addInterception",
239	"description": "Add an interception.",	245	"description": "Add an interception.",
240	"parameters": [	246	"parameters": [
241	{ "name": "url", "type": "string" },	247	{ "name": "url", "type": "string", "description": "URL pattern to intercept, intercept everything if not specified or empty" },
		248	{ "name": "stage", "$ref": "NetworkStage", "description": "Stage to intercept." },
242	{ "name": "caseSensitive", "type": "boolean", "optional": true, "description": "If false, ignores letter casing of `url` parameter." },	249	{ "name": "caseSensitive", "type": "boolean", "optional": true, "description": "If false, ignores letter casing of `url` parameter." },
243	{ "name": "isRegex", "type": "boolean", "optional": true, "description": "If true, treats `url` parameter as a regular expression." },	250	{ "name": "isRegex", "type": "boolean", "optional": true, "description": "If true, treats `url` parameter as a regular expression." }
244	{ "name": "stage", "$ref": "NetworkStage", "optional": true, "description": "If not present this applies to all network stages." }
245	]	251	]
246	},	252	},
247	{	253	{
Lines 249-264 a/Source/JavaScriptCore/inspector/protocol/Network.json_sec3
249	"description": "Remove an interception.",	255	"description": "Remove an interception.",
250	"parameters": [	256	"parameters": [
251	{ "name": "url", "type": "string" },	257	{ "name": "url", "type": "string" },
		258	{ "name": "stage", "$ref": "NetworkStage", "description": "Stage to intercept." },
252	{ "name": "caseSensitive", "type": "boolean", "optional": true, "description": "If false, ignores letter casing of `url` parameter." },	259	{ "name": "caseSensitive", "type": "boolean", "optional": true, "description": "If false, ignores letter casing of `url` parameter." },
253	{ "name": "isRegex", "type": "boolean", "optional": true, "description": "If true, treats `url` parameter as a regular expression." },	260	{ "name": "isRegex", "type": "boolean", "optional": true, "description": "If true, treats `url` parameter as a regular expression." }
254	{ "name": "stage", "$ref": "NetworkStage", "optional": true, "description": "If not present this applies to all network stages." }
255	]	261	]
256	},	262	},
257	{	263	{
258	"name": "interceptContinue",	264	"name": "interceptContinue",
259	"description": "Continue an interception with no modifications.",	265	"description": "Continue request or response without modifications.",
260	"parameters": [	266	"parameters": [
261	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network request or response to continue." }	267	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network request or response to continue." },
		268	{ "name": "stage", "$ref": "NetworkStage", "description": "Stage to continue." }
		269	]
		270	},
		271	{
		272	"name": "interceptWithRequest",
		273	"description": "Replace intercepted request with the provided one.",
		274	"parameters": [
		275	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network request or response to continue." },
		276	{ "name": "method", "type": "string", "optional": true,"description": "HTTP request method." },
		277	{ "name": "url", "type": "string", "optional": true,"description": "HTTP request url." },
		278	{ "name": "headers", "$ref": "Headers", "optional": true, "description": "HTTP response headers. Pass through original values if unmodified." },
		279	{ "name": "postData", "type": "string", "optional": true, "description": "HTTP POST request data, base64-encoded." }
262	]	280	]
263	},	281	},
264	{	282	{
Lines 266-278 a/Source/JavaScriptCore/inspector/protocol/Network.json_sec4
266	"description": "Provide response content for an intercepted response.",	284	"description": "Provide response content for an intercepted response.",
267	"parameters": [	285	"parameters": [
268	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network response to modify." },	286	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network response to modify." },
269	{ "name": "content", "type": "string" },	287	{ "name": "content", "type": "string", "optional": true },
270	{ "name": "base64Encoded", "type": "boolean", "description": "True, if content was sent as base64." },	288	{ "name": "base64Encoded", "type": "boolean", "optional": true, "description": "True, if content was sent as base64." },
271	{ "name": "mimeType", "type": "string", "optional": true, "description": "MIME Type for the data." },	289	{ "name": "mimeType", "type": "string", "optional": true, "description": "MIME Type for the data." },
272	{ "name": "status", "type": "integer", "optional": true, "description": "HTTP response status code. Pass through original values if unmodified." },	290	{ "name": "status", "type": "integer", "optional": true, "description": "HTTP response status code. Pass through original values if unmodified." },
273	{ "name": "statusText", "type": "string", "optional": true, "description": "HTTP response status text. Pass through original values if unmodified." },	291	{ "name": "statusText", "type": "string", "optional": true, "description": "HTTP response status text. Pass through original values if unmodified." },
274	{ "name": "headers", "$ref": "Headers", "optional": true, "description": "HTTP response headers. Pass through original values if unmodified." }	292	{ "name": "headers", "$ref": "Headers", "optional": true, "description": "HTTP response headers. Pass through original values if unmodified." }
275	]	293	]
		294	},
		295	{
		296	"name": "interceptRequestWithResponse",
		297	"description": "Provide response content for an intercepted response.",
		298	"parameters": [
		299	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network response to modify." },
		300	{ "name": "content", "type": "string" },
		301	{ "name": "base64Encoded", "type": "boolean", "optional": true, "description": "True, if content was sent as base64." },
		302	{ "name": "mimeType", "type": "string", "description": "MIME Type for the data." },
		303	{ "name": "status", "type": "integer", "description": "HTTP response status code. Pass through original values if unmodified." },
		304	{ "name": "statusText", "type": "string", "description": "HTTP response status text. Pass through original values if unmodified." },
		305	{ "name": "headers", "$ref": "Headers", "description": "HTTP response headers. Pass through original values if unmodified." }
		306	]
		307	},
		308	{
		309	"name": "interceptRequestWithError",
		310	"description": "Fail request or response with given error type.",
		311	"parameters": [
		312	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for the intercepted Network request to fail." },
		313	{ "name": "errorType", "$ref": "ResourceErrorType", "description": "Deliver error reason for the request failure." }
		314	]
276	}	315	}
277	],	316	],
278	"events": [	317	"events": [
Lines 348-356 a/Source/JavaScriptCore/inspector/protocol/Network.json_sec5
348	{ "name": "resource", "$ref": "CachedResource", "description": "Cached resource data." }	387	{ "name": "resource", "$ref": "CachedResource", "description": "Cached resource data." }
349	]	388	]
350	},	389	},
		390	{
		391	"name": "requestIntercepted",
		392	"description": "Fired when HTTP request has been intercepted. The frontend must respond with <code>Network.interceptContinue</code>, <code>Network.interceptWithRequest</code>` or <code>Network.interceptWithResponse</code>` to resolve this request.",
		393	"parameters": [
		394	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>." },
		395	{ "name": "request", "$ref": "Request", "description": "Original request content that would proceed if this is continued." }
		396	]
		397	},
351	{	398	{
352	"name": "responseIntercepted",	399	"name": "responseIntercepted",
353	"description": "Fired when HTTP response has been intercepted. The frontend must response with <code>Network.interceptContinue</code> or <code>Network.interceptWithRespons</code>` to continue this response.",	400	"description": "Fired when HTTP response has been intercepted. The frontend must response with <code>Network.interceptContinue</code> or <code>Network.interceptWithResponse</code>` to continue this response.",
354	"parameters": [	401	"parameters": [
355	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>." },	402	{ "name": "requestId", "$ref": "RequestId", "description": "Identifier for this intercepted network. Corresponds with an earlier <code>Network.requestWillBeSent</code>." },
356	{ "name": "response", "$ref": "Response", "description": "Original response content that would proceed if this is continued." }	403	{ "name": "response", "$ref": "Response", "description": "Original response content that would proceed if this is continued." }

Lines 810-819 void InspectorInstrumentation::willDestroyCachedResourceImpl(CachedResource& cac a/Source/WebCore/inspector/InspectorInstrumentation.cpp_sec1
- a/Source/WebCore/inspector/InspectorInstrumentation.cpp -2 / +15 lines
810	}	810	}
811	}	811	}
812		812
813	bool InspectorInstrumentation::willInterceptRequestImpl(InstrumentingAgents& instrumentingAgents, const ResourceRequest& request)	813	bool InspectorInstrumentation::willInterceptImpl(InstrumentingAgents& instrumentingAgents, const ResourceRequest& request)
814	{	814	{
815	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())	815	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())
816	return networkAgent->willInterceptRequest(request);	816	return networkAgent->willIntercept(request);
		817	return false;
		818	}
		819
		820	bool InspectorInstrumentation::shouldInterceptRequestImpl(InstrumentingAgents& instrumentingAgents, const ResourceRequest& request)
		821	{
		822	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())
		823	return networkAgent->shouldInterceptRequest(request);
817	return false;	824	return false;
818	}	825	}
819		826
Lines 824-829 bool InspectorInstrumentation::shouldInterceptResponseImpl(InstrumentingAgents& a/Source/WebCore/inspector/InspectorInstrumentation.cpp_sec2
824	return false;	831	return false;
825	}	832	}
826		833
		834	void InspectorInstrumentation::interceptRequestImpl(InstrumentingAgents& instrumentingAgents, ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
		835	{
		836	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())
		837	networkAgent->interceptRequest(loader, WTFMove(handler));
		838	}
		839
827	void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	840	void InspectorInstrumentation::interceptResponseImpl(InstrumentingAgents& instrumentingAgents, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
828	{	841	{
829	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())	842	if (auto* networkAgent = instrumentingAgents.inspectorNetworkAgent())



#include "HitTestResult.h"
#include "InspectorInstrumentationPublic.h"
#include "Page.h"
#include "ResourceLoader.h"
#include "StorageArea.h"
#include "WebAnimation.h"
#include "WorkerInspectorProxy.h"

    static void defaultAppearanceDidChange(Page&, bool useDarkAppearance);
    static void willDestroyCachedResource(CachedResource&);

    static bool willIntercept(const Frame*, const ResourceRequest&);
    static bool shouldInterceptRequest(const Frame&, const ResourceRequest&);
    static bool shouldInterceptResponse(const Frame&, const ResourceResponse&);
    static void interceptRequest(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
    static void interceptResponse(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);

    static void addMessageToConsole(Page&, std::unique_ptr<Inspector::ConsoleMessage>);

    static void defaultAppearanceDidChangeImpl(InstrumentingAgents&, bool useDarkAppearance);
    static void willDestroyCachedResourceImpl(CachedResource&);

    static bool willInterceptImpl(InstrumentingAgents&, const ResourceRequest&);
    static bool shouldInterceptRequestImpl(InstrumentingAgents&, const ResourceRequest&);
    static bool shouldInterceptResponseImpl(InstrumentingAgents&, const ResourceResponse&);
    static void interceptRequestImpl(InstrumentingAgents&, ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
    static void interceptResponseImpl(InstrumentingAgents&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);

    static void addMessageToConsoleImpl(InstrumentingAgents&, std::unique_ptr<Inspector::ConsoleMessage>);

    willDestroyCachedResourceImpl(cachedResource);
}

inline bool InspectorInstrumentation::willIntercept(const Frame* frame, const ResourceRequest& request)
{
    FAST_RETURN_IF_NO_FRONTENDS(false);
    if (auto* instrumentingAgents = instrumentingAgentsForFrame(frame))
        return willInterceptImpl(*instrumentingAgents, request);
    return false;
}

inline bool InspectorInstrumentation::shouldInterceptRequest(const Frame& frame, const ResourceRequest& request)
{
    ASSERT(InspectorInstrumentationPublic::hasFrontends());
    if (auto* instrumentingAgents = instrumentingAgentsForFrame(frame))
        return shouldInterceptRequestImpl(*instrumentingAgents, request);
    return false;
}


    return false;
}

inline void InspectorInstrumentation::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
{
    ASSERT(InspectorInstrumentation::shouldInterceptRequest(loader.frame(), loader.request()));
    if (auto* instrumentingAgents = instrumentingAgentsForFrame(loader.frame()))
        interceptRequestImpl(*instrumentingAgents, loader, WTFMove(handler));
}

inline void InspectorInstrumentation::interceptResponse(const Frame& frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
{
    ASSERT(InspectorInstrumentation::shouldInterceptResponse(frame, response));

Lines 30-40 a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp_sec1
- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.cpp +10 lines
30		30
31	namespace WebCore {	31	namespace WebCore {
32		32
		33	bool InspectorInstrumentationWebKit::shouldInterceptRequestInternal(const Frame& frame, const ResourceRequest& request)
		34	{
		35	return InspectorInstrumentation::shouldInterceptRequest(frame, request);
		36	}
		37
33	bool InspectorInstrumentationWebKit::shouldInterceptResponseInternal(const Frame& frame, const ResourceResponse& response)	38	bool InspectorInstrumentationWebKit::shouldInterceptResponseInternal(const Frame& frame, const ResourceResponse& response)
34	{	39	{
35	return InspectorInstrumentation::shouldInterceptResponse(frame, response);	40	return InspectorInstrumentation::shouldInterceptResponse(frame, response);
36	}	41	}
37		42
		43	void InspectorInstrumentationWebKit::interceptRequestInternal(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
		44	{
		45	InspectorInstrumentation::interceptRequest(loader, WTFMove(handler));
		46	}
		47
38	void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	48	void InspectorInstrumentationWebKit::interceptResponseInternal(const Frame& frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
39	{	49	{
40	InspectorInstrumentation::interceptResponse(frame, response, identifier, WTFMove(handler));	50	InspectorInstrumentation::interceptResponse(frame, response, identifier, WTFMove(handler));




class WEBCORE_EXPORT InspectorInstrumentationWebKit {
public:
    static bool shouldInterceptRequest(const Frame*, const ResourceRequest&);
    static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);
    static void interceptRequest(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
    static void interceptResponse(const Frame*, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);

private:
    static bool shouldInterceptRequestInternal(const Frame&, const ResourceRequest&);
    static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);
    static void interceptRequestInternal(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
    static void interceptResponseInternal(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
};

inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)
{
    FAST_RETURN_IF_NO_FRONTENDS(false);
    if (!frame)
        return false;

    return shouldInterceptRequestInternal(*frame, request);
}

inline bool InspectorInstrumentationWebKit::shouldInterceptResponse(const Frame* frame, const ResourceResponse& response)
{
    FAST_RETURN_IF_NO_FRONTENDS(false);

    return shouldInterceptResponseInternal(*frame, response);
}

inline void InspectorInstrumentationWebKit::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
{
    ASSERT(InspectorInstrumentationWebKit::shouldInterceptRequest(loader.frame(), loader.request()));
    interceptRequestInternal(loader, WTFMove(handler));
}

inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
{
    ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));



#include "Document.h"
#include "DocumentLoader.h"
#include "DocumentThreadableLoader.h"
#include "FormData.h"
#include "Frame.h"
#include "FrameLoader.h"
#include "HTTPHeaderMap.h"

    m_resourcesData->clear();
    m_extraRequestHeaders.clear();

    continuePendingRequests();
    continuePendingResponses();

    setResourceCachingDisabled(false);
}

bool InspectorNetworkAgent::shouldIntercept(URL url, NetworkStage networkStage)
{
    url.removeFragmentIdentifier();


        return false;

    for (auto& intercept : m_intercepts) {
        if (intercept.networkStage != networkStage)
            continue;
        if (intercept.url.isEmpty())
            return true;
        auto searchStringType = intercept.isRegex ? ContentSearchUtilities::SearchStringType::Regex : ContentSearchUtilities::SearchStringType::ExactString;
        auto regex = ContentSearchUtilities::createRegularExpressionForSearchString(intercept.url, intercept.caseSensitive, searchStringType);
        if (regex.match(urlString) != -1)

    return false;
}

void InspectorNetworkAgent::continuePendingRequests()
{
    for (auto& pendingRequest : m_pendingInterceptRequests.values()) {
        ResourceLoader* loader = pendingRequest->m_loader.get();
        if (loader->identifier())
            pendingRequest->m_completionHandler(&loader->request());
    }
    m_pendingInterceptRequests.clear();
}

void InspectorNetworkAgent::continuePendingResponses()
{
    for (auto& pendingInterceptResponse : m_pendingInterceptResponses.values())


    m_interceptionEnabled = enabled;

    if (!m_interceptionEnabled) {
        continuePendingRequests();
        continuePendingResponses();
    }
}

void InspectorNetworkAgent::addInterception(ErrorString& errorString, const String& url, const String& networkStageString, const bool* optionalCaseSensitive, const bool* optionalIsRegex)
{
    if (networkStageString) {
        auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(*networkStageString);
        if (!networkStage) {
            errorString = makeString("Unknown networkStage: "_s, *networkStageString);
            return;
        }
    }

    Intercept intercept;
    intercept.url = url;
    if (optionalCaseSensitive)
        intercept.caseSensitive = *optionalCaseSensitive;
    if (optionalIsRegex)
        intercept.isRegex = *optionalIsRegex;
    auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
    if (!networkStage) {
        errorString = makeString("Unknown networkStage: "_s, networkStageString);
        return;
    }
    intercept.networkStage = networkStage.value();

    if (!m_intercepts.appendIfNotContains(intercept))
        errorString = "Intercept for given url and given isRegex already exists"_s;
}

void InspectorNetworkAgent::removeInterception(ErrorString& errorString, const String& url, const String& networkStageString, const bool* optionalCaseSensitive, const bool* optionalIsRegex)
{
    if (networkStageString) {
        auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(*networkStageString);
        if (!networkStage) {
            errorString = makeString("Unknown networkStage: "_s, *networkStageString);
            return;
        }
    }

    Intercept intercept;
    intercept.url = url;
    if (optionalCaseSensitive)
        intercept.caseSensitive = *optionalCaseSensitive;
    if (optionalIsRegex)
        intercept.isRegex = *optionalIsRegex;
    auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
    if (!networkStage) {
        errorString = makeString("Unknown networkStage: "_s, networkStageString);
        return;
    }
    intercept.networkStage = networkStage.value();

    if (!m_intercepts.removeAll(intercept))
        errorString = "Missing intercept for given url and given isRegex"_s;
}

bool InspectorNetworkAgent::willIntercept(const ResourceRequest& request)
{
    if (!m_interceptionEnabled)
        return false;

    return shouldIntercept(request.url(), NetworkStage::Request) || shouldIntercept(request.url(), NetworkStage::Response);
}

bool InspectorNetworkAgent::shouldInterceptRequest(const ResourceRequest& request)
{
    if (!m_interceptionEnabled)
        return false;

    return shouldIntercept(request.url(), NetworkStage::Request);
}

bool InspectorNetworkAgent::shouldInterceptResponse(const ResourceResponse& response)

    if (!m_interceptionEnabled)
        return false;

    return shouldIntercept(response.url(), NetworkStage::Response);
}

void InspectorNetworkAgent::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
{
    ASSERT(m_enabled);
    ASSERT(m_interceptionEnabled);

    String requestId = IdentifiersFactory::requestId(loader.identifier());
    if (m_pendingInterceptRequests.contains(requestId)) {
        handler(&loader.request());
        return;
    }
    m_pendingInterceptRequests.set(requestId, makeUnique<PendingInterceptRequest>(&loader, WTFMove(handler)));
    m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));
}

void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)

    m_frontendDispatcher->responseIntercepted(requestId, buildObjectForResourceResponse(response, nullptr));
}

void InspectorNetworkAgent::interceptContinue(ErrorString& errorString, const String& requestId, const String& networkStageString)
{
    auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
    if (!networkStage) {
        errorString = makeString("Unknown networkStage: "_s, networkStageString);
        return;
    }

    if (networkStage.value() == NetworkStage::Request) {
        auto pendingInterceptRequest = m_pendingInterceptRequests.take(requestId);
        if (pendingInterceptRequest) {
            pendingInterceptRequest->m_completionHandler(&pendingInterceptRequest->m_loader->request());
            return;
        }
        errorString = "Missing pending intercept request for given requestId"_s;
        return;
    }

    auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);
    if (pendingInterceptResponse) {
        pendingInterceptResponse->respondWithOriginalResponse();
        return;
    }
    errorString = "Missing pending intercept response for given requestId"_s;
}

void InspectorNetworkAgent::interceptWithRequest(ErrorString& errorString, const String& requestId, const String* method, const String* url, const JSON::Object* headers, const String* postData)
{
    auto pendingRequest = m_pendingInterceptRequests.take(requestId);
    if (pendingRequest) {
        ResourceLoader* loader = pendingRequest->m_loader.get();
        if (!loader->identifier()) {
            // Do not throw upon continue of canceled requests.
            return;
        }
        // Safe to const cast at this point, we are only adjusting the method / headers / post.
        ResourceRequest request = loader->request();
        if (url)
            request.setURL(URL({ }, *url));
        if (method)
            request.setHTTPMethod(*method);
        if (headers) {
            HTTPHeaderMap explicitHeaders;
            for (auto& [key, value] : *headers) {
                String headerValue;
                if (value->asString(headerValue))
                    explicitHeaders.add(key, headerValue);
            }
            request.setHTTPHeaderFields(WTFMove(explicitHeaders));
        }
        if (postData) {
            Vector<uint8_t> buffer;
            if (!base64Decode(*postData, buffer)) {
                errorString = "Unable to decode given postData"_s;
                return;
            }
            request.setHTTPBody(FormData::create(buffer));
        }
        pendingRequest->m_completionHandler(&request);
        return;
    }

    errorString = "Missing pending intercept request for given requestId"_s;
}

void InspectorNetworkAgent::interceptWithResponse(ErrorString& errorString, const String& requestId, const String* content, const bool* base64Encoded, const String* mimeType, const int* status, const String* statusText, const JSON::Object* headers)
{
    auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);
    if (!pendingInterceptResponse) {

    }

    RefPtr<SharedBuffer> overrideData;
    if (base64Encoded && *base64Encoded && content) {
        Vector<uint8_t> buffer;
        if (!base64Decode(*content, buffer)) {
            errorString = "Unable to decode given content"_s;
            pendingInterceptResponse->respondWithOriginalResponse();
            return;
        }
        overrideData = SharedBuffer::create(WTFMove(buffer));
    } else if (content)
        overrideData = SharedBuffer::create(content->utf8().data(), content->utf8().length());

    pendingInterceptResponse->respond(overrideResponse, overrideData);
}

void InspectorNetworkAgent::interceptRequestWithResponse(ErrorString& errorString, const String& requestId, const String& content, const bool* base64Encoded, const String& mimeType, int status, const String& statusText, const JSON::Object& headers)
{
    auto pendingRequest = m_pendingInterceptRequests.take(requestId);
    if (!pendingRequest) {
        errorString = "Missing pending intercept response for given requestId"_s;
        return;
    }

    RefPtr<ResourceLoader> loader = pendingRequest->m_loader.get();
    if (!loader->identifier()) {
        errorString = "Unable to fulfill request, it has already been processed"_s;
        return;
    }
    RefPtr<SharedBuffer> data;
    if (base64Encoded && *base64Encoded) {
        Vector<uint8_t> buffer;
        if (!base64Decode(content, buffer)) {
            errorString = "Unable to decode given content"_s;
            return;
        }
        data = SharedBuffer::create(WTFMove(buffer));
    } else
        data = SharedBuffer::create(content.utf8().data(), content.utf8().length());

    // Mimic data URL load behavior - report didReceiveResponse & didFinishLoading.
    ResourceResponse response(pendingRequest->m_loader->url(), mimeType, data->size(), String());
    response.setSource(ResourceResponse::Source::InspectorOverride);
    response.setHTTPStatusCode(status);
    response.setHTTPStatusText(statusText);
    HTTPHeaderMap explicitHeaders;
    for (auto& header : headers) {
        String headerValue;
        if (header.value->asString(headerValue))
            explicitHeaders.add(header.key, headerValue);
    }
    response.setHTTPHeaderFields(WTFMove(explicitHeaders));
    response.setHTTPHeaderField(HTTPHeaderName::ContentType, response.mimeType());
    loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() mutable {
        if (buffer->size())
            loader->didReceiveBuffer(WTFMove(buffer), buffer->size(), DataPayloadWholeResource);
        loader->didFinishLoading(NetworkLoadMetrics());
    });
    pendingRequest->m_completionHandler(nullptr);
}

void InspectorNetworkAgent::interceptRequestWithError(ErrorString& errorString, const String& requestId, const String& errorTypeString)
{
    auto pendingRequest = m_pendingInterceptRequests.take(requestId);
    if (!pendingRequest) {
        errorString = "Missing pending intercept response for given requestId"_s;
        return;
    }

    ResourceLoader* loader = pendingRequest->m_loader.get();
    if (!loader->identifier()) {
        errorString = "Unable to abort request, it has already been processed"_s;
        return;
    }

    auto errorType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::ResourceErrorType>(errorTypeString);
    if (!errorType) {
        errorString = "Unknown error type"_s;
        return;
    }

    ResourceError error;
    switch (errorType.value()) {
    case Inspector::Protocol::Network::ResourceErrorType::General:
        error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request intercepted"_s, ResourceError::Type::General);
        break;
    case Inspector::Protocol::Network::ResourceErrorType::AccessControl:
        error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Access denied"_s, ResourceError::Type::AccessControl);
        break;
    case Inspector::Protocol::Network::ResourceErrorType::Cancellation:
        error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request canceled"_s, ResourceError::Type::Cancellation);
        break;
    case Inspector::Protocol::Network::ResourceErrorType::Timeout:
        error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request timed out"_s, ResourceError::Type::Timeout);
        break;
    default:
        ASSERT_NOT_REACHED();
        return;
    }
    loader->didFail(error);
    pendingRequest->m_completionHandler(nullptr);
}

bool InspectorNetworkAgent::shouldTreatAsText(const String& mimeType)
{
    return startsWithLettersIgnoringASCIICase(mimeType, "text/")

Lines 88-97 public: a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h_sec1
- a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h -7 / +31 lines
88	void getSerializedCertificate(ErrorString&, const String& requestId, String* serializedCertificate) final;	88	void getSerializedCertificate(ErrorString&, const String& requestId, String* serializedCertificate) final;
89	void resolveWebSocket(ErrorString&, const String& requestId, const String* objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) final;	89	void resolveWebSocket(ErrorString&, const String& requestId, const String* objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) final;
90	void setInterceptionEnabled(ErrorString&, bool enabled) final;	90	void setInterceptionEnabled(ErrorString&, bool enabled) final;
91	void addInterception(ErrorString&, const String& url, const bool* caseSensitive, const bool* isRegex, const String* networkStageString) final;	91	void addInterception(ErrorString&, const String& url, const String& networkStageString, const bool* caseSensitive, const bool* isRegex) final;
92	void removeInterception(ErrorString&, const String& url, const bool* caseSensitive, const bool* isRegex, const String* networkStageString) final;	92	void removeInterception(ErrorString&, const String& url, const String& networkStageString, const bool* caseSensitive, const bool* isRegex) final;
93	void interceptContinue(ErrorString&, const String& requestId) final;	93	void interceptContinue(ErrorString&, const String& requestId, const String& networkStageString) final;
94	void interceptWithResponse(ErrorString&, const String& requestId, const String& content, bool base64Encoded, const String* mimeType, const int* status, const String* statusText, const JSON::Object* headers) final;	94	void interceptWithRequest(ErrorString&, const String& requestId, const String* method, const String* url, const JSON::Object* headers, const String* postData) final;
		95	void interceptWithResponse(ErrorString&, const String& requestId, const String* content, const bool* base64Encoded, const String* mimeType, const int* status, const String* statusText, const JSON::Object* headers) final;
		96	void interceptRequestWithResponse(ErrorString&, const String& requestId, const String& content, const bool* base64Encoded, const String& mimeType, int status, const String& statusText, const JSON::Object& headers) final;
		97	void interceptRequestWithError(ErrorString&, const String& requestId, const String& errorType) final;
95		98
96	// InspectorInstrumentation	99	// InspectorInstrumentation
97	void willRecalculateStyle();	100	void willRecalculateStyle();
Lines 118-126 public: a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h_sec2
118	void mainFrameNavigated(DocumentLoader&);	121	void mainFrameNavigated(DocumentLoader&);
119	void setInitialScriptContent(unsigned long identifier, const String& sourceString);	122	void setInitialScriptContent(unsigned long identifier, const String& sourceString);
120	void didScheduleStyleRecalculation(Document&);	123	void didScheduleStyleRecalculation(Document&);
121	bool willInterceptRequest(const ResourceRequest&);	124	bool willIntercept(const ResourceRequest&);
		125	bool shouldInterceptRequest(const ResourceRequest&);
122	bool shouldInterceptResponse(const ResourceResponse&);	126	bool shouldInterceptResponse(const ResourceResponse&);
123	void interceptResponse(const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	127	void interceptResponse(const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
		128	void interceptRequest(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
124		129
125	void searchOtherRequests(const JSC::Yarr::RegularExpression&, RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::SearchResult>>&);	130	void searchOtherRequests(const JSC::Yarr::RegularExpression&, RefPtr<JSON::ArrayOf<Inspector::Protocol::Page::SearchResult>>&);
126	void searchInRequest(ErrorString&, const String& requestId, const String& query, bool caseSensitive, bool isRegex, RefPtr<JSON::ArrayOf<Inspector::Protocol::GenericTypes::SearchMatch>>&);	131	void searchInRequest(ErrorString&, const String& requestId, const String& query, bool caseSensitive, bool isRegex, RefPtr<JSON::ArrayOf<Inspector::Protocol::GenericTypes::SearchMatch>>&);
Lines 140-146 private: a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h_sec3
140		145
141	void willSendRequest(unsigned long identifier, DocumentLoader*, ResourceRequest&, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType);	146	void willSendRequest(unsigned long identifier, DocumentLoader*, ResourceRequest&, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType);
142		147
143	bool shouldIntercept(URL);	148	using NetworkStage = Inspector::Protocol::Network::NetworkStage;
		149	bool shouldIntercept(URL, NetworkStage);
		150	void continuePendingRequests();
144	void continuePendingResponses();	151	void continuePendingResponses();
145		152
146	WebSocket* webSocketForRequestId(const String& requestId);	153	WebSocket* webSocketForRequestId(const String& requestId);
Lines 153-158 private: a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h_sec4
153		160
154	double timestamp();	161	double timestamp();
155		162
		163	class PendingInterceptRequest {
		164	WTF_MAKE_NONCOPYABLE(PendingInterceptRequest);
		165	WTF_MAKE_FAST_ALLOCATED;
		166	public:
		167	PendingInterceptRequest(ResourceLoader* loader, CompletionHandler<void(const ResourceRequest*)>&& completionHandler)
		168	: m_loader(loader)
		169	, m_completionHandler(WTFMove(completionHandler))
		170	{ }
		171
		172	PendingInterceptRequest() = default;
		173	RefPtr<ResourceLoader> m_loader;
		174	CompletionHandler<void(const ResourceRequest*)> m_completionHandler;
		175	};
		176
156	class PendingInterceptResponse {	177	class PendingInterceptResponse {
157	WTF_MAKE_NONCOPYABLE(PendingInterceptResponse);	178	WTF_MAKE_NONCOPYABLE(PendingInterceptResponse);
158	WTF_MAKE_FAST_ALLOCATED;	179	WTF_MAKE_FAST_ALLOCATED;
Lines 204-218 private: a/Source/WebCore/inspector/agents/InspectorNetworkAgent.h_sec5
204	String url;	225	String url;
205	bool caseSensitive { true };	226	bool caseSensitive { true };
206	bool isRegex { false };	227	bool isRegex { false };
		228	NetworkStage networkStage { NetworkStage::Response };
207		229
208	inline bool operator==(const Intercept& other) const	230	inline bool operator==(const Intercept& other) const
209	{	231	{
210	return url == other.url	232	return url == other.url
211	&& caseSensitive == other.caseSensitive	233	&& caseSensitive == other.caseSensitive
212	&& isRegex == other.isRegex;	234	&& isRegex == other.isRegex
		235	&& networkStage == other.networkStage;
213	}	236	}
214	};	237	};
215	Vector<Intercept> m_intercepts;	238	Vector<Intercept> m_intercepts;
		239	HashMap<String, std::unique_ptr<PendingInterceptRequest>> m_pendingInterceptRequests;
216	HashMap<String, std::unique_ptr<PendingInterceptResponse>> m_pendingInterceptResponses;	240	HashMap<String, std::unique_ptr<PendingInterceptResponse>> m_pendingInterceptResponses;
217		241
218	// FIXME: InspectorNetworkAgent should not be aware of style recalculation.	242	// FIXME: InspectorNetworkAgent should not be aware of style recalculation.




    request.updateReferrerPolicy(document() ? document()->referrerPolicy() : ReferrerPolicy::NoReferrerWhenDowngrade);

    if (InspectorInstrumentation::willIntercept(&frame, request.resourceRequest()))
        request.setCachingPolicy(CachingPolicy::DisallowCaching);

    auto& page = *frame.page();


ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
{
    if (InspectorInstrumentation::willIntercept(frame(), request.resourceRequest()))
        return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, request.resourceRequest().url(), "Inspector intercept"_s });

    if (request.charset().isEmpty() && (type == CachedResource::Type::Script || type == CachedResource::Type::CSSStyleSheet))



                            url: localResourceOverride.url,
                            caseSensitive: localResourceOverride.isCaseSensitive,
                            isRegex: localResourceOverride.isRegex,
                            stage: InspectorBackend.Enum.Network.NetworkStage.Response,
                        });
                    }
                }

                url: localResourceOverride.url,
                caseSensitive: localResourceOverride.isCaseSensitive,
                isRegex: localResourceOverride.isRegex,
                stage: InspectorBackend.Enum.Network.NetworkStage.Response,
            };

            // COMPATIBILITY (iOS 13.0): Network.addInterception did not exist.

                url: localResourceOverride.url,
                caseSensitive: localResourceOverride.isCaseSensitive,
                isRegex: localResourceOverride.isRegex,
                stage: InspectorBackend.Enum.Network.NetworkStage.Response,
            };

            // COMPATIBILITY (iOS 13.0): Network.removeInterception did not exist.

        this._resourceRequestIdentifierMap.delete(requestIdentifier);
    }

    requestIntercepted(target, requestId, request)
    {
        this.dispatchEventToListeners(WI.NetworkManager.Event.RequestIntercepted, {target, requestId, request});
    }

    responseIntercepted(target, requestId, response)
    {
        let url = WI.urlWithoutFragment(response.url);
        let localResourceOverride = this.localResourceOverrideForURL(url);
        if (!localResourceOverride || localResourceOverride.disabled) {
            target.NetworkAgent.interceptContinue(requestId, InspectorBackend.Enum.Network.NetworkStage.Response);
            return;
        }


            url: localResourceOverride.url,
            caseSensitive: localResourceOverride.isCaseSensitive,
            isRegex: localResourceOverride.isRegex,
            stage: InspectorBackend.Enum.Network.NetworkStage.Response,
        };

        // COMPATIBILITY (iOS 13.0): Network.addInterception / Network.removeInterception did not exist.

    BootstrapScriptDestroyed: "network-manager-bootstrap-script-destroyed",
    LocalResourceOverrideAdded: "network-manager-local-resource-override-added",
    LocalResourceOverrideRemoved: "network-manager-local-resource-override-removed",
    RequestIntercepted: "network-manager-request-intercepted"
};

Lines 108-113 WI.NetworkObserver = class NetworkObserver extends InspectorBackend.Dispatcher a/Source/WebInspectorUI/UserInterface/Protocol/NetworkObserver.js_sec1
- a/Source/WebInspectorUI/UserInterface/Protocol/NetworkObserver.js +5 lines
108	// FIXME: Not implemented.	108	// FIXME: Not implemented.
109	}	109	}
110		110
		111	requestIntercepted(requestId, request)
		112	{
		113	WI.networkManager.requestIntercepted(this._target, requestId, request);
		114	}
		115
111	responseIntercepted(requestId, response)	116	responseIntercepted(requestId, response)
112	{	117	{
113	WI.networkManager.responseIntercepted(this._target, requestId, response);	118	WI.networkManager.responseIntercepted(this._target, requestId, response);



#include <WebCore/Frame.h>
#include <WebCore/FrameLoader.h>
#include <WebCore/HTMLFrameOwnerElement.h>
#include <WebCore/InspectorInstrumentationWebKit.h>
#include <WebCore/NetscapePlugInStreamLoader.h>
#include <WebCore/NetworkLoadInformation.h>
#include <WebCore/PlatformStrategies.h>


    if (!tryLoadingUsingURLSchemeHandler(resourceLoader, trackingParameters)) {
        WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL will be scheduled with the NetworkProcess");

        if (resourceLoader.options().serviceWorkerRegistrationIdentifier || !InspectorInstrumentationWebKit::shouldInterceptRequest(resourceLoader.frame(), resourceLoader.request())) {
            scheduleLoadFromNetworkProcess(resourceLoader, resourceLoader.request(), trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));
            return;
        }

        InspectorInstrumentationWebKit::interceptRequest(resourceLoader, [this, protectedResourceLoader = makeRefPtr(&resourceLoader), trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, resource](const ResourceRequest* request) mutable {
            if (request)
                scheduleLoadFromNetworkProcess(*protectedResourceLoader, *request, trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));
            return;
        });
    }

    WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL not handled by any handlers");



2020-05-28  Pavel  <pavel.feldman@gmail.com>

        Web Inspector: introduce request interception
        https://bugs.webkit.org/show_bug.cgi?id=207446

        Reviewed by NOBODY (OOPS!).

        This change introduces network request interception to the Network
        protocol domain. It adds Network.interceptWithRequest notification that
        can be continued, modified or fulfilled. NetworkStage enum can now have
        'request' and 'response' values.

        * http/tests/inspector/network/intercept-request-main-resource-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-main-resource-with-response-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-main-resource-with-response.html: Added.
        * http/tests/inspector/network/intercept-request-main-resource.html: Added.
        * http/tests/inspector/network/intercept-request-properties-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-properties.html: Added.
        * http/tests/inspector/network/intercept-request-subresource-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-subresource-with-error-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-subresource-with-error.html: Added.
        * http/tests/inspector/network/intercept-request-subresource-with-response-expected.txt: Added.
        * http/tests/inspector/network/intercept-request-subresource-with-response.html: Added.
        * http/tests/inspector/network/intercept-request-subresource.html: Added.
        * http/tests/inspector/network/resources/intercept-echo.php: Added.
        * http/tests/inspector/network/resources/intercept-request-overriden-page.html: Added.
        * http/tests/inspector/network/resources/intercept-request-overriden-script.js: Added.
        * http/tests/inspector/resources/protocol-test.js:
        * inspector/network/intercept-request-expected.txt: Added.
        * inspector/network/intercept-request.html: Added.
        * inspector/network/local-resource-override-continue-response.html:
        * inspector/network/resources/data2.json: Added.

2020-05-12  Fujii Hironori  <Hironori.Fujii@sony.com>

        [WinCairo][WK1] requestAnimationFrame doesn't work since r244182 in Accelerated Compositing mode

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-expected.txt +3 lines
	1	ALERT: ORIGINAL HTML CONTENT
	2	ALERT: REPLACED HTML CONTENT
	3	Overridden page content

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-with-response-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-with-response-expected.txt +3 lines
	1	ALERT: ORIGINAL HTML CONTENT
	2	ALERT: REPLACED HTML CONTENT
	3	Overridden page content



<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.MainResource with response",
        description: "Main resource uses request interception on next page load and fulfills request",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/intercept-request-main-resource-with-response.html",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithResponse = (event) => {
                let {target, requestId, request} = event.data;
                target.NetworkAgent.interceptRequestWithResponse.invoke({
                    requestId,
                    mimeType: "text/html",
                    content: `<!DOCTYPE html><html><head><script src="../resources/inspector-test.js"></`+`script></head><body><p>Overridden page content</p><script>alert("REPLACED HTML CONTENT"); TestPage.completeTest();</`+`script></body></html>`,
                    status: 200,
                    statusText: "OK",
                    headers: {},
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithResponse);

            InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception intercepting the main resource load with response.</p>
<script>alert("ORIGINAL HTML CONTENT");</script>
</body>
</html>



<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.MainResource",
        description: "Main resource uses request interception on next page load",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/intercept-request-main-resource.html",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                target.NetworkAgent.interceptWithRequest.invoke({
                    url: "http://127.0.0.1:8000/inspector/network/resources/intercept-request-overriden-page.html",
                    requestId
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception intercepting the main resource load.</p>
<script>alert("ORIGINAL HTML CONTENT");</script>
</body>
</html>



Test request interception altering request properties.


== Running test suite: Network.interceptRequest
-- Running test case: Network.interceptRequest.Method
Method=POST

-- Running test case: Network.interceptRequest.Headers
Overriden header:overriden

-- Running test case: Network.interceptRequest.PostData
Overriden value: overriden




<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
async function fetchData(url)
{
    let response = await fetch(url);
    return await response.text();
}

async function postData(url)
{
    let response = await fetch(url, {
        method: "POST",
        headers: {
            "Content-Type": "application/x-www-form-urlencoded"
        },
        body: "value=original"
    });
    return await response.text();
}

function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.Method",
        description: "Tests request method interception",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/resources/intercept-echo.php?method",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                if (!request.url.includes('?method'))
                    return;
                target.NetworkAgent.interceptWithRequest.invoke({
                    requestId,
                    method: "POST",
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            let response = await target.RuntimeAgent.evaluate("fetchData('resources/intercept-echo.php?method')");
            response = await target.RuntimeAgent.awaitPromise(response.result.objectId, true);
            let data = eval('(' + response.result.value + ')');
            InspectorTest.log("Method=" + data.method);
        }
    });

    suite.addTestCase({
        name: "Network.interceptRequest.Headers",
        description: "Tests request headers interception",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/resources/intercept-echo.php?headers",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                if (!request.url.includes('?headers'))
                    return;
                target.NetworkAgent.interceptWithRequest.invoke({
                    requestId,
                    headers: { "value": "overriden" },
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            let response = await target.RuntimeAgent.evaluate("fetchData('resources/intercept-echo.php?headers')");
            response = await target.RuntimeAgent.awaitPromise(response.result.objectId, true);
            let data = eval('(' + response.result.value + ')');
            InspectorTest.log("Overriden header:" + data.headers.value);
        }
    });

    suite.addTestCase({
        name: "Network.interceptRequest.PostData",
        description: "Tests request post data interception",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/resources/intercept-echo.php?postData",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                if (!request.url.includes('?postData'))
                    return;
                target.NetworkAgent.interceptWithRequest.invoke({
                    requestId,
                    method: "POST",
                    postData: btoa("value=overriden"),
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            let response = await target.RuntimeAgent.evaluate("postData('resources/intercept-echo.php?postData')");
            response = await target.RuntimeAgent.awaitPromise(response.result.objectId, true);
            let data = eval('(' + response.result.value + ')');
            InspectorTest.log("Overriden value: " + data.post.value);
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception altering request properties.</p>
</body>
</html>



ALERT: DEFAULT override.js TEXT
ALERT: OVERRIDEN override.js TEXT
Test request interception intercepting the subresource load.


== Running test suite: Network.interceptRequest
-- Running test case: Network.interceptRequest.Subresource


Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-with-error-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-with-error-expected.txt +7 lines
	1	ALERT: DEFAULT override.js TEXT
	2	Test request interception with error for the subresource load.
	3
	4
	5	== Running test suite: Network.interceptRequest
	6	-- Running test case: Network.interceptRequest.Subresource with error
	7



<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.Subresource with error",
        description: "Subresource uses request interception with error",
        async test() {
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/resources/override.js",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });
    
            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                target.NetworkAgent.interceptRequestWithError.invoke({
                    requestId,
                    errorType: "General",
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            await InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception with error for the subresource load.</p>
<script src="resources/override.js"></script>
</body>
</html>



ALERT: DEFAULT override.js TEXT
ALERT: OVERRIDDEN override.js TEXT
Test request interception with response for the subresource load.


== Running test suite: Network.interceptRequest
-- Running test case: Network.interceptRequest.Subresource with response




<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.Subresource with response",
        description: "Subresource uses request interception with response",
        async test() {
          InspectorTest.debug();
            let target = WI.assumingMainTarget();
            await target.NetworkAgent.addInterception.invoke({
                url: "http://127.0.0.1:8000/inspector/network/resources/override.js",
                stage: InspectorBackend.Enum.Network.NetworkStage.Request,
            });

            let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                target.NetworkAgent.interceptRequestWithResponse.invoke({
                    requestId,
                    mimeType: "text/javascript",
                    content: `alert("OVERRIDDEN override.js TEXT"); TestPage.dispatchEventToFrontend("OverrideContentDidLoad");`,
                    status: 200,
                    statusText: "OK",
                    headers: {},
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            await InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
            await InspectorTest.awaitEvent("OverrideContentDidLoad");
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception with response for the subresource load.</p>
<script src="resources/override.js"></script>
</body>
</html>



<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");

    suite.addTestCase({
        name: "Network.interceptRequest.Subresource",
        description: "Subresource uses request interception",
        async test() {
					  let target = WI.assumingMainTarget()
						await target.NetworkAgent.addInterception.invoke({
								url: "http://127.0.0.1:8000/inspector/network/resources/override.js",
								stage: InspectorBackend.Enum.Network.NetworkStage.Request,
						});

						let interceptWithRequest = (event) => {
                let {target, requestId, request} = event.data;
                target.NetworkAgent.interceptWithRequest.invoke({
                    url: "http://127.0.0.1:8000/inspector/network/resources/intercept-request-overriden-script.js",
                    requestId
                });
            };
            WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithRequest);

            await InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
						await InspectorTest.awaitEvent("OverrideContentDidLoad");
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception intercepting the subresource load.</p>
<script src="resources/override.js"></script>
</body>
</html>



<?php
$method = $_SERVER['REQUEST_METHOD'];
echo "{\n";
echo "  \"method\": \"$method\",\n";
echo "  \"headers\": {\n";
foreach (getallheaders() as $name => $value) {
	echo "    \"$name\": \"$value\",\n";
}
echo "  },\n";
echo "  \"post\": {\n";
foreach ($_POST as $name => $value){
	echo "    \"$name\": \"$value\",\n";
}
echo "  },\n";
echo "}\n";
?>



<!DOCTYPE html>
<html>
	  <head>
				<script src="../resources/inspector-test.js">
				</script>
		</head>
	  <body>
				<p>Overridden page content</p>
				<script>alert("REPLACED HTML CONTENT"); TestPage.completeTest();</script>
		</body>
</html>

Line 0 a/LayoutTests/http/tests/inspector/network/resources/intercept-request-overriden-script.js_sec1
- a/LayoutTests/http/tests/inspector/network/resources/intercept-request-overriden-script.js +2 lines
	1	alert("OVERRIDEN override.js TEXT");
	2	TestPage.dispatchEventToFrontend("OverrideContentDidLoad");



    if (typeof testFunction !== "function") {
        alert("Failed to send test() because it is not a function.");
        testRunner.notifyDone();
        return;
    }

    let url = testRunner.inspectorTestStubURL;
    if (!url) {
        alert("Failed to obtain inspector test stub URL.");
        testRunner.notifyDone();
        return;
    }

    function runInitializationMethodsInFrontend(initializers)



Test request interception.


== Running test suite: Network request interception
-- Running test case: setUp
-- Running test case: Network request interception: requestIntercepted.interceptContinue
Response data: '{"alpha":"beta","gamma":12345}'

-- Running test case: Network request interception: requestIntercepted.interceptWithRequest
text: intercepted request


-- Running test case: Network request interception: requestIntercepted.interceptRequestWithResponse
text: intercepted data
status: 200
statusText: OK
mimeType: application/octet-stream
my-header: my-value

-- Running test case: Network request interception: requestIntercepted.interceptRequestWithError
Request error: 'Request canceled'




<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<script src="../../http/tests/inspector/resources/protocol-test.js"></script>
<script>

async function fetchData() {
    try {
        let response = await fetch('resources/data.json');
        return {
            text: await response.text(),
            status: response.status,
            statusText: response.statusText,
            mimeType: response.headers.get('content-type'),
            header: response.headers.get('my-header'),
        };
    } catch (e) {
        return e.message;
    }
}

function test()
{
    let suite = ProtocolTest.createAsyncSuite("Network request interception");

    function printFetchResult(result)
    {
        ProtocolTest.log("text: " + result.text);
        ProtocolTest.log("status: " + result.status);
        ProtocolTest.log("statusText: " + result.statusText);
        ProtocolTest.log("mimeType: " + result.mimeType);
        ProtocolTest.log("my-header: " + result.header);
    }

    let url;
    suite.addTestCase({
        name: "setUp",
        async test() {
            let [result1, result2, {result}] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Network.enable", params: {}}),
                InspectorProtocol.awaitCommand({method: "Runtime.enable", params: {}}),
                InspectorProtocol.awaitCommand({method: "Runtime.evaluate", params: {
                    expression: "document.URL",
                }}),
                InspectorProtocol.awaitCommand({method: "Network.setInterceptionEnabled", params: {
                    enabled: true,
                }}),
            ]);

            let baseURL = result.value.substring(0, result.value.lastIndexOf("/"));
            url = baseURL + "/resources/data.json";
            await InspectorProtocol.awaitCommand({method: "Network.addInterception", params: { url, stage: "request" }});
        }
    });

    suite.addTestCase({
        name: "Network request interception: requestIntercepted.interceptContinue",
        description: "Test continue intercepted request.",
        async test() {
            // Fetch URL and intercept it.
            let [fetchResultPromise, interceptedEvent] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.evaluate", params: {
                    expression: "fetchData()",
                }}),
                InspectorProtocol.awaitEvent({event: "Network.requestIntercepted"}),
            ]);

            // Let the load continue.
            let [fetchResult] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.awaitPromise", params: {
                    promiseObjectId: fetchResultPromise.result.objectId,
                    returnByValue: true,
                }}),
                InspectorProtocol.awaitCommand({method: "Network.interceptContinue", params: {
                    requestId: interceptedEvent.params.requestId,
                    stage: "request",
                }}),
            ]);
            ProtocolTest.log("Response data: '" + fetchResult.result.value.text.trim() + "'");
        }
    });

    suite.addTestCase({
        name: "Network request interception: requestIntercepted.interceptWithRequest",
        description: "Test fulfill intercepted request with response.",
        async test() {
            // Fetch URL and intercept it.
            let [fetchResultPromise, interceptedEvent] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.evaluate", params: {
                    expression: "fetchData()",
                }}),
                InspectorProtocol.awaitEvent({event: "Network.requestIntercepted"}),
            ]);

            // Fulfill the request with data.
            let [fetchResult] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.awaitPromise", params: {
                    promiseObjectId: fetchResultPromise.result.objectId,
                    returnByValue: true,
                }}),
                InspectorProtocol.awaitCommand({method: "Network.interceptWithRequest", params: {
                    requestId: interceptedEvent.params.requestId,
                    url: url.replace('data.json', 'data2.json'),
                }}),
            ]);
            ProtocolTest.log("text: " + fetchResult.result.value.text);
        }
    });

    suite.addTestCase({
        name: "Network request interception: requestIntercepted.interceptRequestWithResponse",
        description: "Test fulfill intercepted request with response.",
        async test() {
            // Fetch URL and intercept it.
            let [fetchResultPromise, interceptedEvent] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.evaluate", params: {
                    expression: "fetchData()",
                }}),
                InspectorProtocol.awaitEvent({event: "Network.requestIntercepted"}),
            ]);

            // Fulfill the request with data.
            let [fetchResult] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.awaitPromise", params: {
                    promiseObjectId: fetchResultPromise.result.objectId,
                    returnByValue: true
                }}),
                InspectorProtocol.awaitCommand({method: "Network.interceptRequestWithResponse", params: {
                    requestId: interceptedEvent.params.requestId,
                    status: 200,
                    statusText: "OK",
                    headers: { "my-header": "my-value" },
                    mimeType: "application/octet-stream",
                    content: btoa("intercepted data"),
                    base64Encoded: true,
                }}),
            ]);
            printFetchResult(fetchResult.result.value);
        }
    });

    suite.addTestCase({
        name: "Network request interception: requestIntercepted.interceptRequestWithError",
        description: "Test abort intercepted request with error.",
        async test() {
            // Fetch URL and intercept it.
            let [fetchResultPromise, interceptedEvent] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.evaluate", params: {
                    expression: "fetchData()",
                }}),
                InspectorProtocol.awaitEvent({event: "Network.requestIntercepted"}),
            ]);

            // Abort the request as canceled.
            let [fetchResult] = await Promise.all([
                InspectorProtocol.awaitCommand({method: "Runtime.awaitPromise", params: {
                    promiseObjectId: fetchResultPromise.result.objectId,
                    returnByValue: true,
                }}),
                InspectorProtocol.awaitCommand({method: "Network.interceptRequestWithError", params: {
                    requestId: interceptedEvent.params.requestId,
                    errorType: "Cancellation",
                }}),
            ]);
            ProtocolTest.log("Request error: '" + fetchResult.result.value + "'");
        }
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
<p>Test request interception.</p>
</body>
</html>

Lines 46-52 function test() a/LayoutTests/inspector/network/local-resource-override-continue-response.html_sec1
- a/LayoutTests/inspector/network/local-resource-override-continue-response.html -1 / +1 lines
46	// Let the load continue.	46	// Let the load continue.
47	await Promise.all([	47	await Promise.all([
48	InspectorProtocol.awaitEvent({event: "Network.responseReceived"}),	48	InspectorProtocol.awaitEvent({event: "Network.responseReceived"}),
49	InspectorProtocol.awaitCommand({method: "Network.interceptContinue", params: {requestId: messageObject.params.requestId}}),	49	InspectorProtocol.awaitCommand({method: "Network.interceptContinue", params: {requestId: messageObject.params.requestId, stage: "response"}}),
50	]);	50	]);
51	ProtocolTest.pass("Response received.");	51	ProtocolTest.pass("Response received.");
52		52

Line 0 a/LayoutTests/inspector/network/resources/data2.json_sec1
- a/LayoutTests/inspector/network/resources/data2.json +1 lines
		1	intercepted request

Return to Bug 207446

Lines 846-852 ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::requ a/Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec1
- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp -2 / +2 lines
846		846
847	request.updateReferrerPolicy(document() ? document()->referrerPolicy() : ReferrerPolicy::NoReferrerWhenDowngrade);	847	request.updateReferrerPolicy(document() ? document()->referrerPolicy() : ReferrerPolicy::NoReferrerWhenDowngrade);
848		848
849	if (InspectorInstrumentation::willInterceptRequest(&frame, request.resourceRequest()))	849	if (InspectorInstrumentation::willIntercept(&frame, request.resourceRequest()))
850	request.setCachingPolicy(CachingPolicy::DisallowCaching);	850	request.setCachingPolicy(CachingPolicy::DisallowCaching);
851		851
852	auto& page = *frame.page();	852	auto& page = *frame.page();
Lines 1436-1442 Vector<Ref<SVGImage>> CachedResourceLoader::allCachedSVGImages() const a/Source/WebCore/loader/cache/CachedResourceLoader.cpp_sec2
1436		1436
1437	ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)	1437	ResourceErrorOr<CachedResourceHandle<CachedResource>> CachedResourceLoader::preload(CachedResource::Type type, CachedResourceRequest&& request)
1438	{	1438	{
1439	if (InspectorInstrumentation::willInterceptRequest(frame(), request.resourceRequest()))	1439	if (InspectorInstrumentation::willIntercept(frame(), request.resourceRequest()))
1440	return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, request.resourceRequest().url(), "Inspector intercept"_s });	1440	return makeUnexpected(ResourceError { errorDomainWebKitInternal, 0, request.resourceRequest().url(), "Inspector intercept"_s });
1441		1441
1442	if (request.charset().isEmpty() && (type == CachedResource::Type::Script \|\| type == CachedResource::Type::CSSStyleSheet))	1442	if (request.charset().isEmpty() && (type == CachedResource::Type::Script \|\| type == CachedResource::Type::CSSStyleSheet))

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +14 lines
		1	2020-02-29 Pavel Feldman <pavel.feldman@gmail.com>
		2
		3	Web Inspector: introduce request interception
		4	https://bugs.webkit.org/show_bug.cgi?id=207446
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This change introduces network request interception to the Network
		9	protocol domain. It adds Network.interceptWithRequest notification that
		10	can be continued, modified or fulfilled. NetworkStage enum can now have
		11	'request' and 'response' values.
		12
		13	* inspector/protocol/Network.json:
		14
1	2020-05-12 Ross Kirsling <ross.kirsling@sony.com>	15	2020-05-12 Ross Kirsling <ross.kirsling@sony.com>
2		16
3	Fix existing usage of final/override/virtual in JSC and WTF	17	Fix existing usage of final/override/virtual in JSC and WTF

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +49 lines
		1	2020-02-29 Pavel Feldman <pavel.feldman@gmail.com>
		2
		3	Web Inspector: introduce request interception
		4	https://bugs.webkit.org/show_bug.cgi?id=207446
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This change introduces network request interception to the Network
		9	protocol domain. It adds Network.interceptWithRequest notification that
		10	can be continued, modified or fulfilled. NetworkStage enum can now have
		11	'request' and 'response' values.
		12
		13	Test: inspector/network/intercept-request.html
		14
		15	* inspector/InspectorInstrumentation.cpp:
		16	(WebCore::InspectorInstrumentation::willInterceptImpl):
		17	(WebCore::InspectorInstrumentation::shouldInterceptRequestImpl):
		18	(WebCore::InspectorInstrumentation::interceptRequestImpl):
		19	* inspector/InspectorInstrumentation.h:
		20	(WebCore::InspectorInstrumentation::willIntercept):
		21	(WebCore::InspectorInstrumentation::shouldInterceptRequest):
		22	(WebCore::InspectorInstrumentation::interceptRequest):
		23	* inspector/InspectorInstrumentationWebKit.cpp:
		24	(WebCore::InspectorInstrumentationWebKit::shouldInterceptRequestInternal):
		25	(WebCore::InspectorInstrumentationWebKit::interceptRequestInternal):
		26	* inspector/InspectorInstrumentationWebKit.h:
		27	(WebCore::InspectorInstrumentationWebKit::shouldInterceptRequest):
		28	(WebCore::InspectorInstrumentationWebKit::interceptRequest):
		29	* inspector/agents/InspectorNetworkAgent.cpp:
		30	(WebCore::InspectorNetworkAgent::disable):
		31	(WebCore::InspectorNetworkAgent::shouldIntercept):
		32	(WebCore::InspectorNetworkAgent::continuePendingRequests):
		33	(WebCore::InspectorNetworkAgent::setInterceptionEnabled):
		34	(WebCore::InspectorNetworkAgent::addInterception):
		35	(WebCore::InspectorNetworkAgent::removeInterception):
		36	(WebCore::InspectorNetworkAgent::willIntercept):
		37	(WebCore::InspectorNetworkAgent::shouldInterceptRequest):
		38	(WebCore::InspectorNetworkAgent::shouldInterceptResponse):
		39	(WebCore::InspectorNetworkAgent::interceptRequest):
		40	(WebCore::InspectorNetworkAgent::interceptContinue):
		41	(WebCore::InspectorNetworkAgent::interceptWithRequest):
		42	(WebCore::InspectorNetworkAgent::interceptWithResponse):
		43	* inspector/agents/InspectorNetworkAgent.h:
		44	(WebCore::InspectorNetworkAgent::PendingInterceptRequest::PendingInterceptRequest):
		45	(WebCore::InspectorNetworkAgent::Intercept::operator== const):
		46	* loader/cache/CachedResourceLoader.cpp:
		47	(WebCore::CachedResourceLoader::requestResource):
		48	(WebCore::CachedResourceLoader::preload):
		49
1	2020-05-12 Eric Carlson <eric.carlson@apple.com>	50	2020-05-12 Eric Carlson <eric.carlson@apple.com>
2		51
3	Poster set after playback begins should be ignored	52	Poster set after playback begins should be ignored

Lines 1-3 a/Source/WebInspectorUI/ChangeLog_sec1
- a/Source/WebInspectorUI/ChangeLog +22 lines
		1	2020-05-13 Pavel <pavel.feldman@gmail.com>
		2
		3	Web Inspector: introduce request interception
		4	https://bugs.webkit.org/show_bug.cgi?id=207446
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This change introduces network request interception to the Network
		9	protocol domain. It adds Network.interceptWithRequest notification that
		10	can be continued, modified or fulfilled. NetworkStage enum can now have
		11	'request' and 'response' values.
		12
		13	* UserInterface/Controllers/NetworkManager.js:
		14	(WI.NetworkManager.prototype.initializeTarget):
		15	(WI.NetworkManager.prototype.addLocalResourceOverride):
		16	(WI.NetworkManager.prototype.removeLocalResourceOverride):
		17	(WI.NetworkManager.prototype.requestIntercepted):
		18	(WI.NetworkManager.prototype.responseIntercepted):
		19	(WI.NetworkManager.prototype._handleResourceOverrideDisabledChanged):
		20	* UserInterface/Protocol/NetworkObserver.js:
		21	(WI.NetworkObserver.prototype.requestIntercepted):
		22
1	2020-05-11 Devin Rousso <drousso@apple.com>	23	2020-05-11 Devin Rousso <drousso@apple.com>
2		24
3	Web Inspector: Network: Timing: gaps around the "Resource does not have timing data" message	25	Web Inspector: Network: Timing: gaps around the "Resource does not have timing data" message

Lines 1-3 a/Source/WebKit/ChangeLog_sec1
- a/Source/WebKit/ChangeLog +15 lines
		1	2020-02-29 Pavel Feldman <pavel.feldman@gmail.com>
		2
		3	Web Inspector: introduce request interception
		4	https://bugs.webkit.org/show_bug.cgi?id=207446
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This change introduces network request interception to the Network
		9	protocol domain. It adds Network.interceptWithRequest notification that
		10	can be continued, modified or fulfilled. NetworkStage enum can now have
		11	'request' and 'response' values.
		12
		13	* WebProcess/Network/WebLoaderStrategy.cpp:
		14	(WebKit::WebLoaderStrategy::scheduleLoad):
		15
1	2020-05-12 Carlos Garcia Campos <cgarcia@igalia.com>	16	2020-05-12 Carlos Garcia Campos <cgarcia@igalia.com>
2		17
3	[GTK] Rework drag and drop handling in preparation for GTK4	18	[GTK] Rework drag and drop handling in preparation for GTK4

Lines 45-50 a/Source/WebCore/inspector/InspectorInstrumentation.h_sec1
- a/Source/WebCore/inspector/InspectorInstrumentation.h -4 / +24 lines
45	#include "HitTestResult.h"	45	#include "HitTestResult.h"
46	#include "InspectorInstrumentationPublic.h"	46	#include "InspectorInstrumentationPublic.h"
47	#include "Page.h"	47	#include "Page.h"
		48	#include "ResourceLoader.h"
48	#include "StorageArea.h"	49	#include "StorageArea.h"
49	#include "WebAnimation.h"	50	#include "WebAnimation.h"
50	#include "WorkerInspectorProxy.h"	51	#include "WorkerInspectorProxy.h"
Lines 232-239 public: a/Source/WebCore/inspector/InspectorInstrumentation.h_sec2
232	static void defaultAppearanceDidChange(Page&, bool useDarkAppearance);	233	static void defaultAppearanceDidChange(Page&, bool useDarkAppearance);
233	static void willDestroyCachedResource(CachedResource&);	234	static void willDestroyCachedResource(CachedResource&);
234		235
235	static bool willInterceptRequest(const Frame*, const ResourceRequest&);	236	static bool willIntercept(const Frame*, const ResourceRequest&);
		237	static bool shouldInterceptRequest(const Frame&, const ResourceRequest&);
236	static bool shouldInterceptResponse(const Frame&, const ResourceResponse&);	238	static bool shouldInterceptResponse(const Frame&, const ResourceResponse&);
		239	static void interceptRequest(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
237	static void interceptResponse(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	240	static void interceptResponse(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
238		241
239	static void addMessageToConsole(Page&, std::unique_ptr<Inspector::ConsoleMessage>);	242	static void addMessageToConsole(Page&, std::unique_ptr<Inspector::ConsoleMessage>);
Lines 437-444 private: a/Source/WebCore/inspector/InspectorInstrumentation.h_sec3
437	static void defaultAppearanceDidChangeImpl(InstrumentingAgents&, bool useDarkAppearance);	440	static void defaultAppearanceDidChangeImpl(InstrumentingAgents&, bool useDarkAppearance);
438	static void willDestroyCachedResourceImpl(CachedResource&);	441	static void willDestroyCachedResourceImpl(CachedResource&);
439		442
440	static bool willInterceptRequestImpl(InstrumentingAgents&, const ResourceRequest&);	443	static bool willInterceptImpl(InstrumentingAgents&, const ResourceRequest&);
		444	static bool shouldInterceptRequestImpl(InstrumentingAgents&, const ResourceRequest&);
441	static bool shouldInterceptResponseImpl(InstrumentingAgents&, const ResourceResponse&);	445	static bool shouldInterceptResponseImpl(InstrumentingAgents&, const ResourceResponse&);
		446	static void interceptRequestImpl(InstrumentingAgents&, ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
442	static void interceptResponseImpl(InstrumentingAgents&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	447	static void interceptResponseImpl(InstrumentingAgents&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
443		448
444	static void addMessageToConsoleImpl(InstrumentingAgents&, std::unique_ptr<Inspector::ConsoleMessage>);	449	static void addMessageToConsoleImpl(InstrumentingAgents&, std::unique_ptr<Inspector::ConsoleMessage>);
Lines 1249-1259 inline void InspectorInstrumentation::willDestroyCachedResource(CachedResource& a/Source/WebCore/inspector/InspectorInstrumentation.h_sec4
1249	willDestroyCachedResourceImpl(cachedResource);	1254	willDestroyCachedResourceImpl(cachedResource);
1250	}	1255	}
1251		1256
1252	inline bool InspectorInstrumentation::willInterceptRequest(const Frame* frame, const ResourceRequest& request)	1257	inline bool InspectorInstrumentation::willIntercept(const Frame* frame, const ResourceRequest& request)
1253	{	1258	{
1254	FAST_RETURN_IF_NO_FRONTENDS(false);	1259	FAST_RETURN_IF_NO_FRONTENDS(false);
1255	if (auto* instrumentingAgents = instrumentingAgentsForFrame(frame))	1260	if (auto* instrumentingAgents = instrumentingAgentsForFrame(frame))
1256	return willInterceptRequestImpl(*instrumentingAgents, request);	1261	return willInterceptImpl(*instrumentingAgents, request);
		1262	return false;
		1263	}
		1264
		1265	inline bool InspectorInstrumentation::shouldInterceptRequest(const Frame& frame, const ResourceRequest& request)
		1266	{
		1267	ASSERT(InspectorInstrumentationPublic::hasFrontends());
		1268	if (auto* instrumentingAgents = instrumentingAgentsForFrame(frame))
		1269	return shouldInterceptRequestImpl(*instrumentingAgents, request);
1257	return false;	1270	return false;
1258	}	1271	}
1259		1272
Lines 1265-1270 inline bool InspectorInstrumentation::shouldInterceptResponse(const Frame& frame a/Source/WebCore/inspector/InspectorInstrumentation.h_sec5
1265	return false;	1278	return false;
1266	}	1279	}
1267		1280
		1281	inline void InspectorInstrumentation::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
		1282	{
		1283	ASSERT(InspectorInstrumentation::shouldInterceptRequest(loader.frame(), loader.request()));
		1284	if (auto* instrumentingAgents = instrumentingAgentsForFrame(loader.frame()))
		1285	interceptRequestImpl(*instrumentingAgents, loader, WTFMove(handler));
		1286	}
		1287
1268	inline void InspectorInstrumentation::interceptResponse(const Frame& frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	1288	inline void InspectorInstrumentation::interceptResponse(const Frame& frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
1269	{	1289	{
1270	ASSERT(InspectorInstrumentation::shouldInterceptResponse(frame, response));	1290	ASSERT(InspectorInstrumentation::shouldInterceptResponse(frame, response));

Lines 36-49 class SharedBuffer; a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h_sec1
- a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h +19 lines
36		36
37	class WEBCORE_EXPORT InspectorInstrumentationWebKit {	37	class WEBCORE_EXPORT InspectorInstrumentationWebKit {
38	public:	38	public:
		39	static bool shouldInterceptRequest(const Frame*, const ResourceRequest&);
39	static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);	40	static bool shouldInterceptResponse(const Frame*, const ResourceResponse&);
		41	static void interceptRequest(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
40	static void interceptResponse(const Frame*, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	42	static void interceptResponse(const Frame*, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
41		43
42	private:	44	private:
		45	static bool shouldInterceptRequestInternal(const Frame&, const ResourceRequest&);
43	static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);	46	static bool shouldInterceptResponseInternal(const Frame&, const ResourceResponse&);
		47	static void interceptRequestInternal(ResourceLoader&, CompletionHandler<void(const ResourceRequest*)>&&);
44	static void interceptResponseInternal(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);	48	static void interceptResponseInternal(const Frame&, const ResourceResponse&, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&&);
45	};	49	};
46		50
		51	inline bool InspectorInstrumentationWebKit::shouldInterceptRequest(const Frame* frame, const ResourceRequest& request)
		52	{
		53	FAST_RETURN_IF_NO_FRONTENDS(false);
		54	if (!frame)
		55	return false;
		56
		57	return shouldInterceptRequestInternal(*frame, request);
		58	}
		59
47	inline bool InspectorInstrumentationWebKit::shouldInterceptResponse(const Frame* frame, const ResourceResponse& response)	60	inline bool InspectorInstrumentationWebKit::shouldInterceptResponse(const Frame* frame, const ResourceResponse& response)
48	{	61	{
49	FAST_RETURN_IF_NO_FRONTENDS(false);	62	FAST_RETURN_IF_NO_FRONTENDS(false);
Lines 53-58 inline bool InspectorInstrumentationWebKit::shouldInterceptResponse(const Frame* a/Source/WebCore/inspector/InspectorInstrumentationWebKit.h_sec2
53	return shouldInterceptResponseInternal(*frame, response);	66	return shouldInterceptResponseInternal(*frame, response);
54	}	67	}
55		68
		69	inline void InspectorInstrumentationWebKit::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
		70	{
		71	ASSERT(InspectorInstrumentationWebKit::shouldInterceptRequest(loader.frame(), loader.request()));
		72	interceptRequestInternal(loader, WTFMove(handler));
		73	}
		74
56	inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	75	inline void InspectorInstrumentationWebKit::interceptResponse(const Frame* frame, const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
57	{	76	{
58	ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));	77	ASSERT(InspectorInstrumentationWebKit::shouldInterceptResponse(frame, response));

Lines 43-48 a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec1
- a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp -36 / +209 lines
43	#include "Document.h"	43	#include "Document.h"
44	#include "DocumentLoader.h"	44	#include "DocumentLoader.h"
45	#include "DocumentThreadableLoader.h"	45	#include "DocumentThreadableLoader.h"
		46	#include "FormData.h"
46	#include "Frame.h"	47	#include "Frame.h"
47	#include "FrameLoader.h"	48	#include "FrameLoader.h"
48	#include "HTTPHeaderMap.h"	49	#include "HTTPHeaderMap.h"
Lines 841-852 void InspectorNetworkAgent::disable(ErrorString&) a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec2
841	m_resourcesData->clear();	842	m_resourcesData->clear();
842	m_extraRequestHeaders.clear();	843	m_extraRequestHeaders.clear();
843		844
		845	continuePendingRequests();
844	continuePendingResponses();	846	continuePendingResponses();
845		847
846	setResourceCachingDisabled(false);	848	setResourceCachingDisabled(false);
847	}	849	}
848		850
849	bool InspectorNetworkAgent::shouldIntercept(URL url)	851	bool InspectorNetworkAgent::shouldIntercept(URL url, NetworkStage networkStage)
850	{	852	{
851	url.removeFragmentIdentifier();	853	url.removeFragmentIdentifier();
852		854
Lines 855-860 bool InspectorNetworkAgent::shouldIntercept(URL url) a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec3
855	return false;	857	return false;
856		858
857	for (auto& intercept : m_intercepts) {	859	for (auto& intercept : m_intercepts) {
		860	if (intercept.networkStage != networkStage)
		861	continue;
		862	if (intercept.url.isEmpty())
		863	return true;
858	auto searchStringType = intercept.isRegex ? ContentSearchUtilities::SearchStringType::Regex : ContentSearchUtilities::SearchStringType::ExactString;	864	auto searchStringType = intercept.isRegex ? ContentSearchUtilities::SearchStringType::Regex : ContentSearchUtilities::SearchStringType::ExactString;
859	auto regex = ContentSearchUtilities::createRegularExpressionForSearchString(intercept.url, intercept.caseSensitive, searchStringType);	865	auto regex = ContentSearchUtilities::createRegularExpressionForSearchString(intercept.url, intercept.caseSensitive, searchStringType);
860	if (regex.match(urlString) != -1)	866	if (regex.match(urlString) != -1)
Lines 864-869 bool InspectorNetworkAgent::shouldIntercept(URL url) a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec4
864	return false;	870	return false;
865	}	871	}
866		872
		873	void InspectorNetworkAgent::continuePendingRequests()
		874	{
		875	for (auto& pendingRequest : m_pendingInterceptRequests.values()) {
		876	ResourceLoader* loader = pendingRequest->m_loader.get();
		877	if (loader->identifier())
		878	pendingRequest->m_completionHandler(&loader->request());
		879	}
		880	m_pendingInterceptRequests.clear();
		881	}
		882
867	void InspectorNetworkAgent::continuePendingResponses()	883	void InspectorNetworkAgent::continuePendingResponses()
868	{	884	{
869	for (auto& pendingInterceptResponse : m_pendingInterceptResponses.values())	885	for (auto& pendingInterceptResponse : m_pendingInterceptResponses.values())
Lines 1029-1090 void InspectorNetworkAgent::setInterceptionEnabled(ErrorString& errorString, boo a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec5
1029		1045
1030	m_interceptionEnabled = enabled;	1046	m_interceptionEnabled = enabled;
1031		1047
1032	if (!m_interceptionEnabled)	1048	if (!m_interceptionEnabled) {
		1049	continuePendingRequests();
1033	continuePendingResponses();	1050	continuePendingResponses();
		1051	}
1034	}	1052	}
1035		1053
1036	void InspectorNetworkAgent::addInterception(ErrorString& errorString, const String& url, const bool* optionalCaseSensitive, const bool* optionalIsRegex, const String* networkStageString)	1054	void InspectorNetworkAgent::addInterception(ErrorString& errorString, const String& url, const String& networkStageString, const bool* optionalCaseSensitive, const bool* optionalIsRegex)
1037	{	1055	{
1038	if (networkStageString) {
1039	auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(*networkStageString);
1040	if (!networkStage) {
1041	errorString = makeString("Unknown networkStage: "_s, *networkStageString);
1042	return;
1043	}
1044	}
1045
1046	Intercept intercept;	1056	Intercept intercept;
1047	intercept.url = url;	1057	intercept.url = url;
1048	if (optionalCaseSensitive)	1058	if (optionalCaseSensitive)
1049	intercept.caseSensitive = *optionalCaseSensitive;	1059	intercept.caseSensitive = *optionalCaseSensitive;
1050	if (optionalIsRegex)	1060	if (optionalIsRegex)
1051	intercept.isRegex = *optionalIsRegex;	1061	intercept.isRegex = *optionalIsRegex;
1052		1062	auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
1053	// FIXME: Support intercepting requests.	1063	if (!networkStage) {
		1064	errorString = makeString("Unknown networkStage: "_s, networkStageString);
		1065	return;
		1066	}
		1067	intercept.networkStage = networkStage.value();
1054		1068
1055	if (!m_intercepts.appendIfNotContains(intercept))	1069	if (!m_intercepts.appendIfNotContains(intercept))
1056	errorString = "Intercept for given url and given isRegex already exists"_s;	1070	errorString = "Intercept for given url and given isRegex already exists"_s;
1057	}	1071	}
1058		1072
1059	void InspectorNetworkAgent::removeInterception(ErrorString& errorString, const String& url, const bool* optionalCaseSensitive, const bool* optionalIsRegex, const String* networkStageString)	1073	void InspectorNetworkAgent::removeInterception(ErrorString& errorString, const String& url, const String& networkStageString, const bool* optionalCaseSensitive, const bool* optionalIsRegex)
1060	{	1074	{
1061	if (networkStageString) {
1062	auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(*networkStageString);
1063	if (!networkStage) {
1064	errorString = makeString("Unknown networkStage: "_s, *networkStageString);
1065	return;
1066	}
1067	}
1068
1069	Intercept intercept;	1075	Intercept intercept;
1070	intercept.url = url;	1076	intercept.url = url;
1071	if (optionalCaseSensitive)	1077	if (optionalCaseSensitive)
1072	intercept.caseSensitive = *optionalCaseSensitive;	1078	intercept.caseSensitive = *optionalCaseSensitive;
1073	if (optionalIsRegex)	1079	if (optionalIsRegex)
1074	intercept.isRegex = *optionalIsRegex;	1080	intercept.isRegex = *optionalIsRegex;
1075		1081	auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
1076	// FIXME: Support intercepting requests.	1082	if (!networkStage) {
		1083	errorString = makeString("Unknown networkStage: "_s, networkStageString);
		1084	return;
		1085	}
		1086	intercept.networkStage = networkStage.value();
1077		1087
1078	if (!m_intercepts.removeAll(intercept))	1088	if (!m_intercepts.removeAll(intercept))
1079	errorString = "Missing intercept for given url and given isRegex"_s;	1089	errorString = "Missing intercept for given url and given isRegex"_s;
1080	}	1090	}
1081		1091
1082	bool InspectorNetworkAgent::willInterceptRequest(const ResourceRequest& request)	1092	bool InspectorNetworkAgent::willIntercept(const ResourceRequest& request)
		1093	{
		1094	if (!m_interceptionEnabled)
		1095	return false;
		1096
		1097	return shouldIntercept(request.url(), NetworkStage::Request) \|\| shouldIntercept(request.url(), NetworkStage::Response);
		1098	}
		1099
		1100	bool InspectorNetworkAgent::shouldInterceptRequest(const ResourceRequest& request)
1083	{	1101	{
1084	if (!m_interceptionEnabled)	1102	if (!m_interceptionEnabled)
1085	return false;	1103	return false;
1086		1104
1087	return shouldIntercept(request.url());	1105	return shouldIntercept(request.url(), NetworkStage::Request);
1088	}	1106	}
1089		1107
1090	bool InspectorNetworkAgent::shouldInterceptResponse(const ResourceResponse& response)	1108	bool InspectorNetworkAgent::shouldInterceptResponse(const ResourceResponse& response)
Lines 1092-1098 bool InspectorNetworkAgent::shouldInterceptResponse(const ResourceResponse& resp a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec6
1092	if (!m_interceptionEnabled)	1110	if (!m_interceptionEnabled)
1093	return false;	1111	return false;
1094		1112
1095	return shouldIntercept(response.url());	1113	return shouldIntercept(response.url(), NetworkStage::Response);
		1114	}
		1115
		1116	void InspectorNetworkAgent::interceptRequest(ResourceLoader& loader, CompletionHandler<void(const ResourceRequest*)>&& handler)
		1117	{
		1118	ASSERT(m_enabled);
		1119	ASSERT(m_interceptionEnabled);
		1120
		1121	String requestId = IdentifiersFactory::requestId(loader.identifier());
		1122	if (m_pendingInterceptRequests.contains(requestId)) {
		1123	handler(&loader.request());
		1124	return;
		1125	}
		1126	m_pendingInterceptRequests.set(requestId, makeUnique<PendingInterceptRequest>(&loader, WTFMove(handler)));
		1127	m_frontendDispatcher->requestIntercepted(requestId, buildObjectForResourceRequest(loader.request()));
1096	}	1128	}
1097		1129
1098	void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)	1130	void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, unsigned long identifier, CompletionHandler<void(const ResourceResponse&, RefPtr<SharedBuffer>)>&& handler)
Lines 1112-1129 void InspectorNetworkAgent::interceptResponse(const ResourceResponse& response, a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec7
1112	m_frontendDispatcher->responseIntercepted(requestId, buildObjectForResourceResponse(response, nullptr));	1144	m_frontendDispatcher->responseIntercepted(requestId, buildObjectForResourceResponse(response, nullptr));
1113	}	1145	}
1114		1146
1115	void InspectorNetworkAgent::interceptContinue(ErrorString& errorString, const String& requestId)	1147	void InspectorNetworkAgent::interceptContinue(ErrorString& errorString, const String& requestId, const String& networkStageString)
1116	{	1148	{
		1149	auto networkStage = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::NetworkStage>(networkStageString);
		1150	if (!networkStage) {
		1151	errorString = makeString("Unknown networkStage: "_s, networkStageString);
		1152	return;
		1153	}
		1154
		1155	if (networkStage.value() == NetworkStage::Request) {
		1156	auto pendingInterceptRequest = m_pendingInterceptRequests.take(requestId);
		1157	if (pendingInterceptRequest) {
		1158	pendingInterceptRequest->m_completionHandler(&pendingInterceptRequest->m_loader->request());
		1159	return;
		1160	}
		1161	errorString = "Missing pending intercept request for given requestId"_s;
		1162	return;
		1163	}
		1164
1117	auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);	1165	auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);
1118	if (!pendingInterceptResponse) {	1166	if (pendingInterceptResponse) {
1119	errorString = "Missing pending intercept response for given requestId"_s;	1167	pendingInterceptResponse->respondWithOriginalResponse();
		1168	return;
		1169	}
		1170	errorString = "Missing pending intercept response for given requestId"_s;
		1171	}
		1172
		1173	void InspectorNetworkAgent::interceptWithRequest(ErrorString& errorString, const String& requestId, const String* method, const String* url, const JSON::Object* headers, const String* postData)
		1174	{
		1175	auto pendingRequest = m_pendingInterceptRequests.take(requestId);
		1176	if (pendingRequest) {
		1177	ResourceLoader* loader = pendingRequest->m_loader.get();
		1178	if (!loader->identifier()) {
		1179	// Do not throw upon continue of canceled requests.
		1180	return;
		1181	}
		1182	// Safe to const cast at this point, we are only adjusting the method / headers / post.
		1183	ResourceRequest request = loader->request();
		1184	if (url)
		1185	request.setURL(URL({ }, *url));
		1186	if (method)
		1187	request.setHTTPMethod(*method);
		1188	if (headers) {
		1189	HTTPHeaderMap explicitHeaders;
		1190	for (auto& [key, value] : *headers) {
		1191	String headerValue;
		1192	if (value->asString(headerValue))
		1193	explicitHeaders.add(key, headerValue);
		1194	}
		1195	request.setHTTPHeaderFields(WTFMove(explicitHeaders));
		1196	}
		1197	if (postData) {
		1198	Vector<uint8_t> buffer;
		1199	if (!base64Decode(*postData, buffer)) {
		1200	errorString = "Unable to decode given postData"_s;
		1201	return;
		1202	}
		1203	request.setHTTPBody(FormData::create(buffer));
		1204	}
		1205	pendingRequest->m_completionHandler(&request);
1120	return;	1206	return;
1121	}	1207	}
1122		1208
1123	pendingInterceptResponse->respondWithOriginalResponse();	1209	errorString = "Missing pending intercept request for given requestId"_s;
1124	}	1210	}
1125		1211
1126	void InspectorNetworkAgent::interceptWithResponse(ErrorString& errorString, const String& requestId, const String& content, bool base64Encoded, const String* mimeType, const int* status, const String* statusText, const JSON::Object* headers)	1212	void InspectorNetworkAgent::interceptWithResponse(ErrorString& errorString, const String& requestId, const String* content, const bool* base64Encoded, const String* mimeType, const int* status, const String* statusText, const JSON::Object* headers)
1127	{	1213	{
1128	auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);	1214	auto pendingInterceptResponse = m_pendingInterceptResponses.take(requestId);
1129	if (!pendingInterceptResponse) {	1215	if (!pendingInterceptResponse) {
Lines 1152-1171 void InspectorNetworkAgent::interceptWithResponse(ErrorString& errorString, cons a/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp_sec8
1152	}	1238	}
1153		1239
1154	RefPtr<SharedBuffer> overrideData;	1240	RefPtr<SharedBuffer> overrideData;
1155	if (base64Encoded) {	1241	if (base64Encoded && *base64Encoded && content) {
1156	Vector<uint8_t> buffer;	1242	Vector<uint8_t> buffer;
1157	if (!base64Decode(content, buffer)) {	1243	if (!base64Decode(*content, buffer)) {
1158	errorString = "Unable to decode given content"_s;	1244	errorString = "Unable to decode given content"_s;
1159	pendingInterceptResponse->respondWithOriginalResponse();	1245	pendingInterceptResponse->respondWithOriginalResponse();
1160	return;	1246	return;
1161	}	1247	}
1162	overrideData = SharedBuffer::create(WTFMove(buffer));	1248	overrideData = SharedBuffer::create(WTFMove(buffer));
1163	} else	1249	} else if (content)
1164	overrideData = SharedBuffer::create(content.utf8().data(), content.utf8().length());	1250	overrideData = SharedBuffer::create(content->utf8().data(), content->utf8().length());
1165		1251
1166	pendingInterceptResponse->respond(overrideResponse, overrideData);	1252	pendingInterceptResponse->respond(overrideResponse, overrideData);
1167	}	1253	}
1168		1254
		1255	void InspectorNetworkAgent::interceptRequestWithResponse(ErrorString& errorString, const String& requestId, const String& content, const bool* base64Encoded, const String& mimeType, int status, const String& statusText, const JSON::Object& headers)
		1256	{
		1257	auto pendingRequest = m_pendingInterceptRequests.take(requestId);
		1258	if (!pendingRequest) {
		1259	errorString = "Missing pending intercept response for given requestId"_s;
		1260	return;
		1261	}
		1262
		1263	RefPtr<ResourceLoader> loader = pendingRequest->m_loader.get();
		1264	if (!loader->identifier()) {
		1265	errorString = "Unable to fulfill request, it has already been processed"_s;
		1266	return;
		1267	}
		1268	RefPtr<SharedBuffer> data;
		1269	if (base64Encoded && *base64Encoded) {
		1270	Vector<uint8_t> buffer;
		1271	if (!base64Decode(content, buffer)) {
		1272	errorString = "Unable to decode given content"_s;
		1273	return;
		1274	}
		1275	data = SharedBuffer::create(WTFMove(buffer));
		1276	} else
		1277	data = SharedBuffer::create(content.utf8().data(), content.utf8().length());
		1278
		1279	// Mimic data URL load behavior - report didReceiveResponse & didFinishLoading.
		1280	ResourceResponse response(pendingRequest->m_loader->url(), mimeType, data->size(), String());
		1281	response.setSource(ResourceResponse::Source::InspectorOverride);
		1282	response.setHTTPStatusCode(status);
		1283	response.setHTTPStatusText(statusText);
		1284	HTTPHeaderMap explicitHeaders;
		1285	for (auto& header : headers) {
		1286	String headerValue;
		1287	if (header.value->asString(headerValue))
		1288	explicitHeaders.add(header.key, headerValue);
		1289	}
		1290	response.setHTTPHeaderFields(WTFMove(explicitHeaders));
		1291	response.setHTTPHeaderField(HTTPHeaderName::ContentType, response.mimeType());
		1292	loader->didReceiveResponse(response, [loader, buffer = data.releaseNonNull()]() mutable {
		1293	if (buffer->size())
		1294	loader->didReceiveBuffer(WTFMove(buffer), buffer->size(), DataPayloadWholeResource);
		1295	loader->didFinishLoading(NetworkLoadMetrics());
		1296	});
		1297	pendingRequest->m_completionHandler(nullptr);
		1298	}
		1299
		1300	void InspectorNetworkAgent::interceptRequestWithError(ErrorString& errorString, const String& requestId, const String& errorTypeString)
		1301	{
		1302	auto pendingRequest = m_pendingInterceptRequests.take(requestId);
		1303	if (!pendingRequest) {
		1304	errorString = "Missing pending intercept response for given requestId"_s;
		1305	return;
		1306	}
		1307
		1308	ResourceLoader* loader = pendingRequest->m_loader.get();
		1309	if (!loader->identifier()) {
		1310	errorString = "Unable to abort request, it has already been processed"_s;
		1311	return;
		1312	}
		1313
		1314	auto errorType = Inspector::Protocol::InspectorHelpers::parseEnumValueFromString<Inspector::Protocol::Network::ResourceErrorType>(errorTypeString);
		1315	if (!errorType) {
		1316	errorString = "Unknown error type"_s;
		1317	return;
		1318	}
1319
1320	ResourceError error;
1321	switch (errorType.value()) {
1322	case Inspector::Protocol::Network::ResourceErrorType::General:
1323	error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request intercepted"_s, ResourceError::Type::General);
1324	break;
1325	case Inspector::Protocol::Network::ResourceErrorType::AccessControl:
1326	error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Access denied"_s, ResourceError::Type::AccessControl);
1327	break;
1328	case Inspector::Protocol::Network::ResourceErrorType::Cancellation:
1329	error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request canceled"_s, ResourceError::Type::Cancellation);
1330	break;
1331	case Inspector::Protocol::Network::ResourceErrorType::Timeout:
1332	error = ResourceError(errorDomainWebKitInternal, 0, loader->url(), "Request timed out"_s, ResourceError::Type::Timeout);
1333	break;
1334	default:
1335	ASSERT_NOT_REACHED();
1336	return;
1337	}
1338	loader->didFail(error);
1339	pendingRequest->m_completionHandler(nullptr);
1340	}
1341
1169	bool InspectorNetworkAgent::shouldTreatAsText(const String& mimeType)	1342	bool InspectorNetworkAgent::shouldTreatAsText(const String& mimeType)
1170	{	1343	{
1171	return startsWithLettersIgnoringASCIICase(mimeType, "text/")	1344	return startsWithLettersIgnoringASCIICase(mimeType, "text/")

Lines 161-167 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec1
- a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js -5 / +11 lines
161	url: localResourceOverride.url,	161	url: localResourceOverride.url,
162	caseSensitive: localResourceOverride.isCaseSensitive,	162	caseSensitive: localResourceOverride.isCaseSensitive,
163	isRegex: localResourceOverride.isRegex,	163	isRegex: localResourceOverride.isRegex,
164	networkStage: InspectorBackend.Enum.Network.NetworkStage.Response,	164	stage: InspectorBackend.Enum.Network.NetworkStage.Response,
165	});	165	});
166	}	166	}
167	}	167	}
Lines 364-370 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec2
364	url: localResourceOverride.url,	364	url: localResourceOverride.url,
365	caseSensitive: localResourceOverride.isCaseSensitive,	365	caseSensitive: localResourceOverride.isCaseSensitive,
366	isRegex: localResourceOverride.isRegex,	366	isRegex: localResourceOverride.isRegex,
367	networkStage: InspectorBackend.Enum.Network.NetworkStage.Response,	367	stage: InspectorBackend.Enum.Network.NetworkStage.Response,
368	};	368	};
369		369
370	// COMPATIBILITY (iOS 13.0): Network.addInterception did not exist.	370	// COMPATIBILITY (iOS 13.0): Network.addInterception did not exist.
Lines 397-403 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec3
397	url: localResourceOverride.url,	397	url: localResourceOverride.url,
398	caseSensitive: localResourceOverride.isCaseSensitive,	398	caseSensitive: localResourceOverride.isCaseSensitive,
399	isRegex: localResourceOverride.isRegex,	399	isRegex: localResourceOverride.isRegex,
400	networkStage: InspectorBackend.Enum.Network.NetworkStage.Response,	400	stage: InspectorBackend.Enum.Network.NetworkStage.Response,
401	};	401	};
402		402
403	// COMPATIBILITY (iOS 13.0): Network.removeInterception did not exist.	403	// COMPATIBILITY (iOS 13.0): Network.removeInterception did not exist.
Lines 906-917 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec4
906	this._resourceRequestIdentifierMap.delete(requestIdentifier);	906	this._resourceRequestIdentifierMap.delete(requestIdentifier);
907	}	907	}
908		908
		909	requestIntercepted(target, requestId, request)
		910	{
		911	this.dispatchEventToListeners(WI.NetworkManager.Event.RequestIntercepted, {target, requestId, request});
		912	}
		913
909	responseIntercepted(target, requestId, response)	914	responseIntercepted(target, requestId, response)
910	{	915	{
911	let url = WI.urlWithoutFragment(response.url);	916	let url = WI.urlWithoutFragment(response.url);
912	let localResourceOverride = this.localResourceOverrideForURL(url);	917	let localResourceOverride = this.localResourceOverrideForURL(url);
913	if (!localResourceOverride \|\| localResourceOverride.disabled) {	918	if (!localResourceOverride \|\| localResourceOverride.disabled) {
914	target.NetworkAgent.interceptContinue(requestId);	919	target.NetworkAgent.interceptContinue(requestId, InspectorBackend.Enum.Network.NetworkStage.Response);
915	return;	920	return;
916	}	921	}
917		922
Lines 1377-1383 WI.NetworkManager = class NetworkManager extends WI.Object a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec5
1377	url: localResourceOverride.url,	1382	url: localResourceOverride.url,
1378	caseSensitive: localResourceOverride.isCaseSensitive,	1383	caseSensitive: localResourceOverride.isCaseSensitive,
1379	isRegex: localResourceOverride.isRegex,	1384	isRegex: localResourceOverride.isRegex,
1380	networkStage: InspectorBackend.Enum.Network.NetworkStage.Response,	1385	stage: InspectorBackend.Enum.Network.NetworkStage.Response,
1381	};	1386	};
1382		1387
1383	// COMPATIBILITY (iOS 13.0): Network.addInterception / Network.removeInterception did not exist.	1388	// COMPATIBILITY (iOS 13.0): Network.addInterception / Network.removeInterception did not exist.
Lines 1433-1436 WI.NetworkManager.Event = { a/Source/WebInspectorUI/UserInterface/Controllers/NetworkManager.js_sec6
1433	BootstrapScriptDestroyed: "network-manager-bootstrap-script-destroyed",	1438	BootstrapScriptDestroyed: "network-manager-bootstrap-script-destroyed",
1434	LocalResourceOverrideAdded: "network-manager-local-resource-override-added",	1439	LocalResourceOverrideAdded: "network-manager-local-resource-override-added",
1435	LocalResourceOverrideRemoved: "network-manager-local-resource-override-removed",	1440	LocalResourceOverrideRemoved: "network-manager-local-resource-override-removed",
		1441	RequestIntercepted: "network-manager-request-intercepted"
1436	};	1442	};

Lines 58-63 a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp_sec1
- a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp -2 / +12 lines
58	#include <WebCore/Frame.h>	58	#include <WebCore/Frame.h>
59	#include <WebCore/FrameLoader.h>	59	#include <WebCore/FrameLoader.h>
60	#include <WebCore/HTMLFrameOwnerElement.h>	60	#include <WebCore/HTMLFrameOwnerElement.h>
		61	#include <WebCore/InspectorInstrumentationWebKit.h>
61	#include <WebCore/NetscapePlugInStreamLoader.h>	62	#include <WebCore/NetscapePlugInStreamLoader.h>
62	#include <WebCore/NetworkLoadInformation.h>	63	#include <WebCore/NetworkLoadInformation.h>
63	#include <WebCore/PlatformStrategies.h>	64	#include <WebCore/PlatformStrategies.h>
Lines 230-237 void WebLoaderStrategy::scheduleLoad(ResourceLoader& resourceLoader, CachedResou a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp_sec2
230		231
231	if (!tryLoadingUsingURLSchemeHandler(resourceLoader, trackingParameters)) {	232	if (!tryLoadingUsingURLSchemeHandler(resourceLoader, trackingParameters)) {
232	WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL will be scheduled with the NetworkProcess");	233	WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL will be scheduled with the NetworkProcess");
233	scheduleLoadFromNetworkProcess(resourceLoader, resourceLoader.request(), trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));	234
234	return;	235	if (resourceLoader.options().serviceWorkerRegistrationIdentifier \|\| !InspectorInstrumentationWebKit::shouldInterceptRequest(resourceLoader.frame(), resourceLoader.request())) {
		236	scheduleLoadFromNetworkProcess(resourceLoader, resourceLoader.request(), trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));
		237	return;
		238	}
		239
		240	InspectorInstrumentationWebKit::interceptRequest(resourceLoader, [this, protectedResourceLoader = makeRefPtr(&resourceLoader), trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, resource](const ResourceRequest* request) mutable {
		241	if (request)
		242	scheduleLoadFromNetworkProcess(protectedResourceLoader, request, trackingParameters, shouldClearReferrerOnHTTPSToHTTPRedirect, maximumBufferingTime(resource));
		243	return;
		244	});
235	}	245	}
236		246
237	WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL not handled by any handlers");	247	WEBLOADERSTRATEGY_RELEASE_LOG_IF_ALLOWED("scheduleLoad: URL not handled by any handlers");

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +33 lines
		1	2020-05-28 Pavel <pavel.feldman@gmail.com>
		2
		3	Web Inspector: introduce request interception
		4	https://bugs.webkit.org/show_bug.cgi?id=207446
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This change introduces network request interception to the Network
		9	protocol domain. It adds Network.interceptWithRequest notification that
		10	can be continued, modified or fulfilled. NetworkStage enum can now have
		11	'request' and 'response' values.
		12
		13	* http/tests/inspector/network/intercept-request-main-resource-expected.txt: Added.
		14	* http/tests/inspector/network/intercept-request-main-resource-with-response-expected.txt: Added.
		15	* http/tests/inspector/network/intercept-request-main-resource-with-response.html: Added.
		16	* http/tests/inspector/network/intercept-request-main-resource.html: Added.
		17	* http/tests/inspector/network/intercept-request-properties-expected.txt: Added.
		18	* http/tests/inspector/network/intercept-request-properties.html: Added.
		19	* http/tests/inspector/network/intercept-request-subresource-expected.txt: Added.
		20	* http/tests/inspector/network/intercept-request-subresource-with-error-expected.txt: Added.
		21	* http/tests/inspector/network/intercept-request-subresource-with-error.html: Added.
		22	* http/tests/inspector/network/intercept-request-subresource-with-response-expected.txt: Added.
		23	* http/tests/inspector/network/intercept-request-subresource-with-response.html: Added.
		24	* http/tests/inspector/network/intercept-request-subresource.html: Added.
		25	* http/tests/inspector/network/resources/intercept-echo.php: Added.
		26	* http/tests/inspector/network/resources/intercept-request-overriden-page.html: Added.
		27	* http/tests/inspector/network/resources/intercept-request-overriden-script.js: Added.
		28	* http/tests/inspector/resources/protocol-test.js:
		29	* inspector/network/intercept-request-expected.txt: Added.
		30	* inspector/network/intercept-request.html: Added.
		31	* inspector/network/local-resource-override-continue-response.html:
		32	* inspector/network/resources/data2.json: Added.
		33
1	2020-05-12 Fujii Hironori <Hironori.Fujii@sony.com>	34	2020-05-12 Fujii Hironori <Hironori.Fujii@sony.com>
2		35
3	[WinCairo][WK1] requestAnimationFrame doesn't work since r244182 in Accelerated Compositing mode	36	[WinCairo][WK1] requestAnimationFrame doesn't work since r244182 in Accelerated Compositing mode

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-with-response.html_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-main-resource-with-response.html +46 lines
	1	<!DOCTYPE html>
	2	<html>
	3	<head>
	4	<meta charset="utf-8">
	5	<script src="../resources/inspector-test.js"></script>
	6	<script>
	7	function test()
	8	{
	9	let suite = InspectorTest.createAsyncSuite("Network.interceptRequest");
	10
	11	suite.addTestCase({
	12	name: "Network.interceptRequest.MainResource with response",
	13	description: "Main resource uses request interception on next page load and fulfills request",
	14	async test() {
	15	let target = WI.assumingMainTarget();
	16	await target.NetworkAgent.addInterception.invoke({
	17	url: "http://127.0.0.1:8000/inspector/network/intercept-request-main-resource-with-response.html",
	18	stage: InspectorBackend.Enum.Network.NetworkStage.Request,
	19	});
	20
	21	let interceptWithResponse = (event) => {
	22	let {target, requestId, request} = event.data;
	23	target.NetworkAgent.interceptRequestWithResponse.invoke({
	24	requestId,
	25	mimeType: "text/html",
	26	content: `<!DOCTYPE html><html><head><script src="../resources/inspector-test.js"></`+`script></head><body><p>Overridden page content</p><script>alert("REPLACED HTML CONTENT"); TestPage.completeTest();</`+`script></body></html>`,
	27	status: 200,
	28	statusText: "OK",
	29	headers: {},
	30	});
	31	};
	32	WI.networkManager.addEventListener(WI.NetworkManager.Event.RequestIntercepted, interceptWithResponse);
	33
	34	InspectorTest.reloadPage({ignoreCache: false, revalidateAllResources: true});
	35	}
	36	});
	37
	38	suite.runTestCasesAndFinish();
	39	}
	40	</script>
	41	</head>
	42	<body onload="runTest()">
	43	<p>Test request interception intercepting the main resource load with response.</p>
	44	<script>alert("ORIGINAL HTML CONTENT");</script>
	45	</body>
	46	</html>

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-properties-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-properties-expected.txt +13 lines
	1	Test request interception altering request properties.
	2
	3
	4	== Running test suite: Network.interceptRequest
	5	-- Running test case: Network.interceptRequest.Method
	6	Method=POST
	7
	8	-- Running test case: Network.interceptRequest.Headers
	9	Overriden header:overriden
	10
	11	-- Running test case: Network.interceptRequest.PostData
	12	Overriden value: overriden
	13

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-expected.txt +8 lines
	1	ALERT: DEFAULT override.js TEXT
	2	ALERT: OVERRIDEN override.js TEXT
	3	Test request interception intercepting the subresource load.
	4
	5
	6	== Running test suite: Network.interceptRequest
	7	-- Running test case: Network.interceptRequest.Subresource
	8

Line 0 a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-with-response-expected.txt_sec1
- a/LayoutTests/http/tests/inspector/network/intercept-request-subresource-with-response-expected.txt +8 lines
	1	ALERT: DEFAULT override.js TEXT
	2	ALERT: OVERRIDDEN override.js TEXT
	3	Test request interception with response for the subresource load.
	4
	5
	6	== Running test suite: Network.interceptRequest
	7	-- Running test case: Network.interceptRequest.Subresource with response
	8

Line 0 a/LayoutTests/http/tests/inspector/network/resources/intercept-echo.php_sec1
- a/LayoutTests/http/tests/inspector/network/resources/intercept-echo.php +16 lines
	1	<?php
	2	$method = $_SERVER['REQUEST_METHOD'];
	3	echo "{\n";
	4	echo " \"method\": \"$method\",\n";
	5	echo " \"headers\": {\n";
	6	foreach (getallheaders() as $name => $value) {
	7	echo " \"$name\": \"$value\",\n";
	8	}
	9	echo " },\n";
	10	echo " \"post\": {\n";
	11	foreach ($_POST as $name => $value){
	12	echo " \"$name\": \"$value\",\n";
	13	}
	14	echo " },\n";
	15	echo "}\n";
	16	?>

Lines 87-98 TestPage.runTest = window.runTest = function() a/LayoutTests/http/tests/inspector/resources/protocol-test.js_sec1
- a/LayoutTests/http/tests/inspector/resources/protocol-test.js +2 lines
87	if (typeof testFunction !== "function") {	87	if (typeof testFunction !== "function") {
88	alert("Failed to send test() because it is not a function.");	88	alert("Failed to send test() because it is not a function.");
89	testRunner.notifyDone();	89	testRunner.notifyDone();
		90	return;
90	}	91	}
91		92
92	let url = testRunner.inspectorTestStubURL;	93	let url = testRunner.inspectorTestStubURL;
93	if (!url) {	94	if (!url) {
94	alert("Failed to obtain inspector test stub URL.");	95	alert("Failed to obtain inspector test stub URL.");
95	testRunner.notifyDone();	96	testRunner.notifyDone();
		97	return;
96	}	98	}
97		99
98	function runInitializationMethodsInFrontend(initializers)	100	function runInitializationMethodsInFrontend(initializers)

Line 0 a/LayoutTests/inspector/network/intercept-request-expected.txt_sec1
- a/LayoutTests/inspector/network/intercept-request-expected.txt +22 lines
	1	Test request interception.
	2
	3
	4	== Running test suite: Network request interception
	5	-- Running test case: setUp
	6	-- Running test case: Network request interception: requestIntercepted.interceptContinue
	7	Response data: '{"alpha":"beta","gamma":12345}'
	8
	9	-- Running test case: Network request interception: requestIntercepted.interceptWithRequest
	10	text: intercepted request
	11
	12
	13	-- Running test case: Network request interception: requestIntercepted.interceptRequestWithResponse
	14	text: intercepted data
	15	status: 200
	16	statusText: OK
	17	mimeType: application/octet-stream
	18	my-header: my-value
	19
	20	-- Running test case: Network request interception: requestIntercepted.interceptRequestWithError
	21	Request error: 'Request canceled'
	22