Changeset 224788 in webkit


Ignore:
Timestamp:
Nov 13, 2017, 3:15:57 PM (8 years ago)
Author:
Joseph Pecoraro
Message:

Web Inspector: Include a NetworkAgent in ServiceWorkers for network debugging
​https://bugs.webkit.org/show_bug.cgi?id=179513
<rdar://problem/35456402>

Reviewed by Brian Burg.

In order to show Network requests for a ServiceWorker, we need to add
inspector networking hooks for Worker loads. While we show Network
requests for DedicatedWorkers, we do that through the Page during Page
inspection. In ServiceWorker inspection, the remote connection is
connected to the ServiceWorkerThreadProxy, and interacts with the
WorkerGlobalScope without making any assumptions about a Page existing.
We don't want to make any assumptions about a Page/Document being needed
for Network hooks, so we should add new hooks that will work in the
WorkerGlobalScope's context.

This patch adds InspectorInstrumentation networking hooks for workers inside
of the WorkerThreadableLoader bridge. This is where the majority of Worker
initiated network requests happen (Fetch/XHR, but not WebSockets). The hooks
are simpler versions of the existing network hooks for a Page, and allow for
complete inspector networking information (will send, did receive response,
did receive data, success, failure, and timing metrics).

This patch generalizes InspectorNetworkAgent to work for a Page and Worker.
Some of the existing functionality was specific to a Page (frameId/loaderId)
but did not make sense for a Worker. In order to handle these cases, all
of the unique logic was extracted out into virtual methods that subclasses
PageNetworkAgent and WorkerNetworkAgent provide as appropriate. The majority
of NetworkAgent remains unchanged and algorithms are shared.

We needed to change the existing InspectorInstrumentation networking hooks
to allow for an optional DocumentLoader. This way we can keep all of the
same hooks leading inside of NetworkAgent, but loads for a Page will have a
DocumentLoader, and loads for a ServiceWorker will not.

While the WorkerNetworkAgent would work for a DedicatedWorker, we still
only create it for a ServiceWorker. The existing behavior of showing Network
loads for a DedicatedWorker will continue to go through the Page inspector
so we can avoid creating a NetworkAgent for DedicatedWorkers. If we created
a way to directly inspect a DedicatedWorker we could look at making this
always available, but it would require extra work to function perfectly.

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • inspector/InspectorAllInOne.cpp:

Add new files.

  • inspector/InspectorController.cpp:

(WebCore::InspectorController::InspectorController):
(WebCore::InspectorController::createLazyAgents):
Switch from InspectorNetworkAgent to PageNetworkAgent.

  • inspector/WorkerInspectorController.h:
  • inspector/WorkerInspectorController.cpp:

(WebCore::WorkerInspectorController::WorkerInspectorController):
(WebCore::WorkerInspectorController::workerAgentContext):
(WebCore::WorkerInspectorController::createLazyAgents):
Create a WorkerNetworkAgent when inside of a ServiceWorker.
Also start the lazy agent pattern for agents that can defer
creation until a frontend attached.

(WebCore::WorkerInspectorController::connectFrontend):
(WebCore::WorkerInspectorController::disconnectFrontend):
When frontends connect/disconnect toggle the necessary states.
Also start the execution stopwatch, otherwise it will always be at 0.

  • inspector/InspectorInstrumentation.cpp:

(WebCore::InspectorInstrumentation::willSendRequestImpl):
(WebCore::InspectorInstrumentation::willSendRequestOfTypeImpl):
(WebCore::InspectorInstrumentation::didLoadResourceFromMemoryCacheImpl):
(WebCore::InspectorInstrumentation::didReceiveResourceResponseImpl):
(WebCore::InspectorInstrumentation::didFinishLoadingImpl):
(WebCore::InspectorInstrumentation::didFailLoadingImpl):
(WebCore::InspectorInstrumentation::frameDetachedFromParentImpl):

  • inspector/InspectorInstrumentation.h:

(WebCore::InspectorInstrumentation::willSendRequest):
(WebCore::InspectorInstrumentation::didReceiveResourceResponse):
(WebCore::InspectorInstrumentation::didReceiveData):
(WebCore::InspectorInstrumentation::didFinishLoading):
(WebCore::InspectorInstrumentation::didFailLoading):
Add Worker networking hooks that pass through to the same general hooks.

  • loader/WorkerThreadableLoader.cpp:

(WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishLoading):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFail):
(WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishTiming):

  • loader/WorkerThreadableLoader.h:

Use the new worker networking instrumentation hooks.

  • loader/ThreadableLoader.cpp:

(WebCore::ThreadableLoader::create):
Drive-by: use a move.

  • inspector/agents/InspectorNetworkAgent.h:
  • inspector/agents/InspectorNetworkAgent.cpp:

(WebCore::InspectorNetworkAgent::InspectorNetworkAgent):
(WebCore::InspectorNetworkAgent::willSendRequest):
(WebCore::InspectorNetworkAgent::willSendRequestOfType):
(WebCore::InspectorNetworkAgent::didReceiveResponse):
(WebCore::InspectorNetworkAgent::didFinishLoading):
(WebCore::InspectorNetworkAgent::didFailLoading):
(WebCore::InspectorNetworkAgent::didLoadResourceFromMemoryCache):
(WebCore::InspectorNetworkAgent::buildInitiatorObject):
(WebCore::InspectorNetworkAgent::enable):
(WebCore::InspectorNetworkAgent::disable):
(WebCore::InspectorNetworkAgent::setResourceCachingDisabled):
(WebCore::InspectorNetworkAgent::loadResource):
(WebCore::InspectorNetworkAgent::webSocketForRequestId):
(WebCore::InspectorNetworkAgent::resolveWebSocket):
(WebCore::InspectorNetworkAgent::mainFrameNavigated):
Extract logic for subclasses. Transition to DocumentLoader being null.

  • inspector/agents/page/PageNetworkAgent.h:
  • inspector/agents/page/PageNetworkAgent.cpp: Added.

(WebCore::PageNetworkAgent::PageNetworkAgent):
(WebCore::PageNetworkAgent::loaderIdentifier):
(WebCore::PageNetworkAgent::frameIdentifier):
(WebCore::PageNetworkAgent::setResourceCachingDisabled):
(WebCore::PageNetworkAgent::scriptExecutionContext):
Extracted Page implementation. This is just moving from the original.

  • inspector/agents/worker/WorkerNetworkAgent.h:
  • inspector/agents/worker/WorkerNetworkAgent.cpp:

(WebCore::WorkerNetworkAgent::WorkerNetworkAgent):
(WebCore::WorkerNetworkAgent::loaderIdentifier):
(WebCore::WorkerNetworkAgent::frameIdentifier):
(WebCore::WorkerNetworkAgent::setResourceCachingDisabled):
(WebCore::WorkerNetworkAgent::scriptExecutionContext):
Implement for a worker.

  • inspector/agents/worker/WorkerDebuggerAgent.cpp:

(WebCore::WorkerDebuggerAgent::WorkerDebuggerAgent):

  • inspector/agents/worker/WorkerConsoleAgent.cpp:

(WebCore::WorkerConsoleAgent::WorkerConsoleAgent):

  • inspector/agents/worker/WorkerRuntimeAgent.cpp:

(WebCore::WorkerRuntimeAgent::WorkerRuntimeAgent):
Add some assertions for all Worker agents for clarify.

  • workers/WorkerDebuggerProxy.h:
  • workers/WorkerGlobalScope.h:

(WebCore::WorkerGlobalScope::identifier const):
(WebCore::WorkerGlobalScope::createUniqueIdentifier):
Provide a way to get unique identifiers in a worker. For the Page
this is done through the Page's ProgressTracker. For a Worker we just
put this on the WorkerGlobalScope. This is used for request ids.

  • workers/WorkerMessagingProxy.h:
  • workers/WorkerMessagingProxy.cpp:

(WebCore::WorkerMessagingProxy::setResourceCachingDisabled):

  • workers/service/context/ServiceWorkerThreadProxy.h:
  • workers/service/context/ServiceWorkerThreadProxy.cpp:

(WebCore::ServiceWorkerThreadProxy::setResourceCachingDisabled):
Add a debug method for disabling the resource cache from a worker.
In service workers this sets the override flag on the hidden page.

Location:
trunk/Source/WebCore
Files:
1 added
23 edited
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r224787 r224788  
     12017-11-13  Joseph Pecoraro  <pecoraro@apple.com>
     2
     3        Web Inspector: Include a NetworkAgent in ServiceWorkers for network debugging
     4        https://bugs.webkit.org/show_bug.cgi?id=179513
     5        <rdar://problem/35456402>
     6
     7        Reviewed by Brian Burg.
     8
     9        In order to show Network requests for a ServiceWorker, we need to add
     10        inspector networking hooks for Worker loads. While we show Network
     11        requests for DedicatedWorkers, we do that through the Page during Page
     12        inspection. In ServiceWorker inspection, the remote connection is
     13        connected to the ServiceWorkerThreadProxy, and interacts with the
     14        WorkerGlobalScope without making any assumptions about a Page existing.
     15        We don't want to make any assumptions about a Page/Document being needed
     16        for Network hooks, so we should add new hooks that will work in the
     17        WorkerGlobalScope's context.
     18
     19        This patch adds InspectorInstrumentation networking hooks for workers inside
     20        of the WorkerThreadableLoader bridge. This is where the majority of Worker
     21        initiated network requests happen (Fetch/XHR, but not WebSockets). The hooks
     22        are simpler versions of the existing network hooks for a Page, and allow for
     23        complete inspector networking information (will send, did receive response,
     24        did receive data, success, failure, and timing metrics).
     25
     26        This patch generalizes InspectorNetworkAgent to work for a Page and Worker.
     27        Some of the existing functionality was specific to a Page (frameId/loaderId)
     28        but did not make sense for a Worker. In order to handle these cases, all
     29        of the unique logic was extracted out into virtual methods that subclasses
     30        PageNetworkAgent and WorkerNetworkAgent provide as appropriate. The majority
     31        of NetworkAgent remains unchanged and algorithms are shared.
     32
     33        We needed to change the existing InspectorInstrumentation networking hooks
     34        to allow for an optional DocumentLoader. This way we can keep all of the
     35        same hooks leading inside of NetworkAgent, but loads for a Page will have a
     36        DocumentLoader, and loads for a ServiceWorker will not.
     37
     38        While the WorkerNetworkAgent would work for a DedicatedWorker, we still
     39        only create it for a ServiceWorker. The existing behavior of showing Network
     40        loads for a DedicatedWorker will continue to go through the Page inspector
     41        so we can avoid creating a NetworkAgent for DedicatedWorkers. If we created
     42        a way to directly inspect a DedicatedWorker we could look at making this
     43        always available, but it would require extra work to function perfectly.
     44
     45        * Sources.txt:
     46        * WebCore.xcodeproj/project.pbxproj:
     47        * inspector/InspectorAllInOne.cpp:
     48        Add new files.
     49
     50        * inspector/InspectorController.cpp:
     51        (WebCore::InspectorController::InspectorController):
     52        (WebCore::InspectorController::createLazyAgents):
     53        Switch from InspectorNetworkAgent to PageNetworkAgent.
     54
     55        * inspector/WorkerInspectorController.h:
     56        * inspector/WorkerInspectorController.cpp:
     57        (WebCore::WorkerInspectorController::WorkerInspectorController):
     58        (WebCore::WorkerInspectorController::workerAgentContext):
     59        (WebCore::WorkerInspectorController::createLazyAgents):
     60        Create a WorkerNetworkAgent when inside of a ServiceWorker.
     61        Also start the lazy agent pattern for agents that can defer
     62        creation until a frontend attached.
     63
     64        (WebCore::WorkerInspectorController::connectFrontend):
     65        (WebCore::WorkerInspectorController::disconnectFrontend):
     66        When frontends connect/disconnect toggle the necessary states.
     67        Also start the execution stopwatch, otherwise it will always be at 0.
     68
     69        * inspector/InspectorInstrumentation.cpp:
     70        (WebCore::InspectorInstrumentation::willSendRequestImpl):
     71        (WebCore::InspectorInstrumentation::willSendRequestOfTypeImpl):
     72        (WebCore::InspectorInstrumentation::didLoadResourceFromMemoryCacheImpl):
     73        (WebCore::InspectorInstrumentation::didReceiveResourceResponseImpl):
     74        (WebCore::InspectorInstrumentation::didFinishLoadingImpl):
     75        (WebCore::InspectorInstrumentation::didFailLoadingImpl):
     76        (WebCore::InspectorInstrumentation::frameDetachedFromParentImpl):
     77        * inspector/InspectorInstrumentation.h:
     78        (WebCore::InspectorInstrumentation::willSendRequest):
     79        (WebCore::InspectorInstrumentation::didReceiveResourceResponse):
     80        (WebCore::InspectorInstrumentation::didReceiveData):
     81        (WebCore::InspectorInstrumentation::didFinishLoading):
     82        (WebCore::InspectorInstrumentation::didFailLoading):
     83        Add Worker networking hooks that pass through to the same general hooks.
     84
     85        * loader/WorkerThreadableLoader.cpp:
     86        (WebCore::WorkerThreadableLoader::MainThreadBridge::MainThreadBridge):
     87        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveResponse):
     88        (WebCore::WorkerThreadableLoader::MainThreadBridge::didReceiveData):
     89        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishLoading):
     90        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFail):
     91        (WebCore::WorkerThreadableLoader::MainThreadBridge::didFinishTiming):
     92        * loader/WorkerThreadableLoader.h:
     93        Use the new worker networking instrumentation hooks.
     94
     95        * loader/ThreadableLoader.cpp:
     96        (WebCore::ThreadableLoader::create):
     97        Drive-by: use a move.
     98
     99        * inspector/agents/InspectorNetworkAgent.h:
     100        * inspector/agents/InspectorNetworkAgent.cpp:
     101        (WebCore::InspectorNetworkAgent::InspectorNetworkAgent):
     102        (WebCore::InspectorNetworkAgent::willSendRequest):
     103        (WebCore::InspectorNetworkAgent::willSendRequestOfType):
     104        (WebCore::InspectorNetworkAgent::didReceiveResponse):
     105        (WebCore::InspectorNetworkAgent::didFinishLoading):
     106        (WebCore::InspectorNetworkAgent::didFailLoading):
     107        (WebCore::InspectorNetworkAgent::didLoadResourceFromMemoryCache):
     108        (WebCore::InspectorNetworkAgent::buildInitiatorObject):
     109        (WebCore::InspectorNetworkAgent::enable):
     110        (WebCore::InspectorNetworkAgent::disable):
     111        (WebCore::InspectorNetworkAgent::setResourceCachingDisabled):
     112        (WebCore::InspectorNetworkAgent::loadResource):
     113        (WebCore::InspectorNetworkAgent::webSocketForRequestId):
     114        (WebCore::InspectorNetworkAgent::resolveWebSocket):
     115        (WebCore::InspectorNetworkAgent::mainFrameNavigated):
     116        Extract logic for subclasses. Transition to DocumentLoader being null.
     117
     118        * inspector/agents/page/PageNetworkAgent.h:
     119        * inspector/agents/page/PageNetworkAgent.cpp: Added.
     120        (WebCore::PageNetworkAgent::PageNetworkAgent):
     121        (WebCore::PageNetworkAgent::loaderIdentifier):
     122        (WebCore::PageNetworkAgent::frameIdentifier):
     123        (WebCore::PageNetworkAgent::setResourceCachingDisabled):
     124        (WebCore::PageNetworkAgent::scriptExecutionContext):
     125        Extracted Page implementation. This is just moving from the original.
     126
     127        * inspector/agents/worker/WorkerNetworkAgent.h:
     128        * inspector/agents/worker/WorkerNetworkAgent.cpp:
     129        (WebCore::WorkerNetworkAgent::WorkerNetworkAgent):
     130        (WebCore::WorkerNetworkAgent::loaderIdentifier):
     131        (WebCore::WorkerNetworkAgent::frameIdentifier):
     132        (WebCore::WorkerNetworkAgent::setResourceCachingDisabled):
     133        (WebCore::WorkerNetworkAgent::scriptExecutionContext):
     134        Implement for a worker.
     135       
     136        * inspector/agents/worker/WorkerDebuggerAgent.cpp:
     137        (WebCore::WorkerDebuggerAgent::WorkerDebuggerAgent):
     138        * inspector/agents/worker/WorkerConsoleAgent.cpp:
     139        (WebCore::WorkerConsoleAgent::WorkerConsoleAgent):
     140        * inspector/agents/worker/WorkerRuntimeAgent.cpp:
     141        (WebCore::WorkerRuntimeAgent::WorkerRuntimeAgent):
     142        Add some assertions for all Worker agents for clarify.
     143
     144        * workers/WorkerDebuggerProxy.h:
     145        * workers/WorkerGlobalScope.h:
     146        (WebCore::WorkerGlobalScope::identifier const):
     147        (WebCore::WorkerGlobalScope::createUniqueIdentifier):
     148        Provide a way to get unique identifiers in a worker. For the Page
     149        this is done through the Page's ProgressTracker. For a Worker we just
     150        put this on the WorkerGlobalScope. This is used for request ids.
     151
     152        * workers/WorkerMessagingProxy.h:
     153        * workers/WorkerMessagingProxy.cpp:
     154        (WebCore::WorkerMessagingProxy::setResourceCachingDisabled):
     155        * workers/service/context/ServiceWorkerThreadProxy.h:
     156        * workers/service/context/ServiceWorkerThreadProxy.cpp:
     157        (WebCore::ServiceWorkerThreadProxy::setResourceCachingDisabled):
     158        Add a debug method for disabling the resource cache from a worker.
     159        In service workers this sets the override flag on the hidden page.
     160
    11612017-11-08  Keith Miller  <keith_miller@apple.com>
    2162

  • trunk/Source/WebCore/Sources.txt

    r224707 r224788  
    11511151inspector/agents/page/PageDebuggerAgent.cpp
    11521152inspector/agents/page/PageHeapAgent.cpp
     1153inspector/agents/page/PageNetworkAgent.cpp
    11531154inspector/agents/page/PageRuntimeAgent.cpp
    11541155
    11551156inspector/agents/worker/WorkerConsoleAgent.cpp
    11561157inspector/agents/worker/WorkerDebuggerAgent.cpp
     1158inspector/agents/worker/WorkerNetworkAgent.cpp
    11571159inspector/agents/worker/WorkerRuntimeAgent.cpp
    11581160

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r224760 r224788  
    28792879                A5B81CCE1FAA44DE0037D1E6 /* WorkerDebuggerAgent.h in Headers */ = {isa = PBXBuildFile; fileRef = A5B81CCC1FAA44DA0037D1E6 /* WorkerDebuggerAgent.h */; };
    28802880                A5B81CCF1FAA44DE0037D1E6 /* WorkerRuntimeAgent.h in Headers */ = {isa = PBXBuildFile; fileRef = A5B81CC91FAA44DA0037D1E6 /* WorkerRuntimeAgent.h */; };
     2881                A5CB05241FB51F3300089B97 /* PageNetworkAgent.h in Headers */ = {isa = PBXBuildFile; fileRef = A5CB05211FB51F1700089B97 /* PageNetworkAgent.h */; };
     2882                A5CB05251FB51F3A00089B97 /* WorkerNetworkAgent.h in Headers */ = {isa = PBXBuildFile; fileRef = A5CB05231FB51F2400089B97 /* WorkerNetworkAgent.h */; };
    28812883                A5CE9F3F1E4C4174001BBE7C /* ResourceTiming.h in Headers */ = {isa = PBXBuildFile; fileRef = A5CE9F3C1E4BC586001BBE7C /* ResourceTiming.h */; };
    28822884                A5DEBDA416FB908700836FE0 /* WebKitPlaybackTargetAvailabilityEvent.h in Headers */ = {isa = PBXBuildFile; fileRef = A5DEBDA016FB908700836FE0 /* WebKitPlaybackTargetAvailabilityEvent.h */; };
    … …  
    1081110813                A5C974CF11485FF10066F2AB /* KeyEventCocoa.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = KeyEventCocoa.h; sourceTree = "<group>"; };
    1081210814                A5C974D011485FF10066F2AB /* KeyEventCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = KeyEventCocoa.mm; sourceTree = "<group>"; };
     10815                A5CB051F1FB51F1600089B97 /* PageNetworkAgent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PageNetworkAgent.cpp; sourceTree = "<group>"; };
     10816                A5CB05211FB51F1700089B97 /* PageNetworkAgent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PageNetworkAgent.h; sourceTree = "<group>"; };
     10817                A5CB05221FB51F2300089B97 /* WorkerNetworkAgent.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WorkerNetworkAgent.cpp; sourceTree = "<group>"; };
     10818                A5CB05231FB51F2400089B97 /* WorkerNetworkAgent.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WorkerNetworkAgent.h; sourceTree = "<group>"; };
    1081310819                A5CE9F3C1E4BC586001BBE7C /* ResourceTiming.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ResourceTiming.h; sourceTree = "<group>"; };
    1081410820                A5CE9F3E1E4C416B001BBE7C /* ResourceTiming.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ResourceTiming.cpp; sourceTree = "<group>"; };
    … …  
    2059520601                                A5B81CBA1FAA44B70037D1E6 /* PageHeapAgent.cpp */,
    2059620602                                A5B81CBC1FAA44B70037D1E6 /* PageHeapAgent.h */,
     20603                                A5CB051F1FB51F1600089B97 /* PageNetworkAgent.cpp */,
     20604                                A5CB05211FB51F1700089B97 /* PageNetworkAgent.h */,
    2059720605                                A5B81CC11FAA44B70037D1E6 /* PageRuntimeAgent.cpp */,
    2059820606                                A5B81CBF1FAA44B70037D1E6 /* PageRuntimeAgent.h */,
    … …  
    2060820616                                A5B81CC81FAA44DA0037D1E6 /* WorkerDebuggerAgent.cpp */,
    2060920617                                A5B81CCC1FAA44DA0037D1E6 /* WorkerDebuggerAgent.h */,
     20618                                A5CB05221FB51F2300089B97 /* WorkerNetworkAgent.cpp */,
     20619                                A5CB05231FB51F2400089B97 /* WorkerNetworkAgent.h */,
    2061020620                                A5B81CC71FAA44DA0037D1E6 /* WorkerRuntimeAgent.cpp */,
    2061120621                                A5B81CC91FAA44DA0037D1E6 /* WorkerRuntimeAgent.h */,
    … …  
    2841328423                                7A674BDC0F9EBF4E006CF099 /* PageGroupLoadDeferrer.h in Headers */,
    2841428424                                A5B81CC41FAA44BC0037D1E6 /* PageHeapAgent.h in Headers */,
     28425                                A5CB05241FB51F3300089B97 /* PageNetworkAgent.h in Headers */,
    2841528426                                2D5C9D0019C7B52E00B3C5C1 /* PageOverlay.h in Headers */,
    2841628427                                2D5C9D0219C7B52E00B3C5C1 /* PageOverlayController.h in Headers */,
    … …  
    2977529786                                E1271A0B0EEEC77A00F61213 /* WorkerNavigator.h in Headers */,
    2977629787                                1ABC7109170E5E1B00F9A9D6 /* WorkerNavigatorStorageQuota.h in Headers */,
     29788                                A5CB05251FB51F3A00089B97 /* WorkerNetworkAgent.h in Headers */,
    2977729789                                2E4346510F546A8200B0F1BA /* WorkerObjectProxy.h in Headers */,
    2977829790                                416E29A6102FA962007FC14E /* WorkerReportingProxy.h in Headers */,

  • trunk/Source/WebCore/inspector/InspectorAllInOne.cpp

    r218440 r224788  
    5858#include "PageDebuggerAgent.cpp"
    5959#include "PageHeapAgent.cpp"
     60#include "PageNetworkAgent.cpp"
    6061#include "PageRuntimeAgent.cpp"
    6162#include "PageScriptDebugServer.cpp"
    … …  
    6970#include "WorkerDebuggerAgent.cpp"
    7071#include "WorkerInspectorController.cpp"
     72#include "WorkerNetworkAgent.cpp"
    7173#include "WorkerRuntimeAgent.cpp"
    7274#include "WorkerScriptDebugServer.cpp"

  • trunk/Source/WebCore/inspector/InspectorController.cpp

    r224530 r224788  
    5151#include "InspectorLayerTreeAgent.h"
    5252#include "InspectorMemoryAgent.h"
    53 #include "InspectorNetworkAgent.h"
    5453#include "InspectorPageAgent.h"
    5554#include "InspectorTimelineAgent.h"
    … …  
    6564#include "PageDebuggerAgent.h"
    6665#include "PageHeapAgent.h"
     66#include "PageNetworkAgent.h"
    6767#include "PageRuntimeAgent.h"
    6868#include "PageScriptDebugServer.h"
    … …  
    150150
    151151    ASSERT(m_injectedScriptManager->commandLineAPIHost());
    152     if (CommandLineAPIHost* commandLineAPIHost = m_injectedScriptManager->commandLineAPIHost()) {
    153         commandLineAPIHost->init(
    154               m_inspectorAgent
    155             , consoleAgent
    156             , m_domAgent
    157             , domStorageAgent
    158             , databaseAgent
    159         );
    160     }
     152    if (CommandLineAPIHost* commandLineAPIHost = m_injectedScriptManager->commandLineAPIHost())
     153        commandLineAPIHost->init(m_inspectorAgent, consoleAgent, m_domAgent, domStorageAgent, databaseAgent);
    161154}
    162155
    … …  
    202195
    203196    m_agents.append(WTFMove(debuggerAgent));
    204     m_agents.append(std::make_unique<InspectorNetworkAgent>(pageContext, m_pageAgent));
     197    m_agents.append(std::make_unique<PageNetworkAgent>(pageContext, m_pageAgent));
    205198    m_agents.append(std::make_unique<InspectorCSSAgent>(pageContext, m_domAgent));
    206199    m_agents.append(std::make_unique<InspectorDOMDebuggerAgent>(pageContext, m_domAgent, debuggerAgentPtr));

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.cpp

    r224459 r224788  
    561561void InspectorInstrumentation::willSendRequestImpl(InstrumentingAgents& instrumentingAgents, unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse)
    562562{
    563     if (!loader)
    564         return;
    565 
    566     if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    567         networkAgent->willSendRequest(identifier, *loader, request, redirectResponse);
     563    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
     564        networkAgent->willSendRequest(identifier, loader, request, redirectResponse);
    568565}
    569566
    570567void InspectorInstrumentation::willSendRequestOfTypeImpl(InstrumentingAgents& instrumentingAgents, unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, LoadType loadType)
    571568{
    572     if (!loader)
    573         return;
    574 
    575     if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    576         networkAgent->willSendRequestOfType(identifier, *loader, request, loadType);
     569    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
     570        networkAgent->willSendRequestOfType(identifier, loader, request, loadType);
    577571}
    578572
    … …  
    586580
    587581    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    588         networkAgent->didLoadResourceFromMemoryCache(*loader, *cachedResource);
     582        networkAgent->didLoadResourceFromMemoryCache(loader, *cachedResource);
    589583}
    590584
    591585void InspectorInstrumentation::didReceiveResourceResponseImpl(InstrumentingAgents& instrumentingAgents, unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
    592586{
    593     if (!loader)
    594         return;
    595 
    596     if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    597         networkAgent->didReceiveResponse(identifier, *loader, response, resourceLoader);
     587    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
     588        networkAgent->didReceiveResponse(identifier, loader, response, resourceLoader);
    598589    if (WebConsoleAgent* consoleAgent = instrumentingAgents.webConsoleAgent())
    599590        consoleAgent->didReceiveResponse(identifier, response); // This should come AFTER resource notification, front-end relies on this.
    … …  
    614605void InspectorInstrumentation::didFinishLoadingImpl(InstrumentingAgents& instrumentingAgents, unsigned long identifier, DocumentLoader* loader, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)
    615606{
    616     if (!loader)
    617         return;
    618 
    619     if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    620         networkAgent->didFinishLoading(identifier, *loader, networkLoadMetrics, resourceLoader);
     607    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
     608        networkAgent->didFinishLoading(identifier, loader, networkLoadMetrics, resourceLoader);
    621609}
    622610
    623611void InspectorInstrumentation::didFailLoadingImpl(InstrumentingAgents& instrumentingAgents, unsigned long identifier, DocumentLoader* loader, const ResourceError& error)
    624612{
    625     if (!loader)
    626         return;
    627 
    628     if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
    629         networkAgent->didFailLoading(identifier, *loader, error);
     613    if (InspectorNetworkAgent* networkAgent = instrumentingAgents.inspectorNetworkAgent())
     614        networkAgent->didFailLoading(identifier, loader, error);
    630615    if (WebConsoleAgent* consoleAgent = instrumentingAgents.webConsoleAgent())
    631616        consoleAgent->didFailLoading(identifier, error); // This should come AFTER resource notification, front-end relies on this.
    … …  
    698683    if (InspectorPageAgent* pageAgent = instrumentingAgents.inspectorPageAgent())
    699684        pageAgent->frameDetached(frame);
    700 
    701685}
    702686

  • trunk/Source/WebCore/inspector/InspectorInstrumentation.h

    r224540 r224788  
    178178    static void didFinishLoading(Frame*, DocumentLoader*, unsigned long identifier, const NetworkLoadMetrics&, ResourceLoader*);
    179179    static void didFailLoading(Frame*, DocumentLoader*, unsigned long identifier, const ResourceError&);
    180     static void continueAfterXFrameOptionsDenied(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
    181     static void continueWithPolicyDownload(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
    182     static void continueWithPolicyIgnore(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
     180
     181    static void willSendRequest(WorkerGlobalScope&, unsigned long identifier, ResourceRequest&);
     182    static void didReceiveResourceResponse(WorkerGlobalScope&, unsigned long identifier, const ResourceResponse&);
     183    static void didReceiveData(WorkerGlobalScope&, unsigned long identifier, const char* data, int dataLength);
     184    static void didFinishLoading(WorkerGlobalScope&, unsigned long identifier, const NetworkLoadMetrics&);
     185    static void didFailLoading(WorkerGlobalScope&, unsigned long identifier, const ResourceError&);
    183186
    184187    // Some network requests do not go through the normal network loading path.
    … …  
    188191    static void willSendRequestOfType(Frame*, unsigned long identifier, DocumentLoader*, ResourceRequest&, LoadType);
    189192
     193    static void continueAfterXFrameOptionsDenied(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
     194    static void continueWithPolicyDownload(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
     195    static void continueWithPolicyIgnore(Frame&, unsigned long identifier, DocumentLoader&, const ResourceResponse&);
    190196    static void didFinishXHRLoading(ScriptExecutionContext*, unsigned long identifier, std::optional<String> decodedText);
    191197    static void willLoadXHRSynchronously(ScriptExecutionContext*);
    … …  
    908914}
    909915
     916inline void InspectorInstrumentation::willSendRequest(WorkerGlobalScope& workerGlobalScope, unsigned long identifier, ResourceRequest& request)
     917{
     918    FAST_RETURN_IF_NO_FRONTENDS(void());
     919    willSendRequestImpl(instrumentingAgentsForWorkerGlobalScope(workerGlobalScope), identifier, nullptr, request, ResourceResponse { });
     920}
     921
    910922inline void InspectorInstrumentation::willSendRequestOfType(Frame* frame, unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, LoadType loadType)
    911923{
    … …  
    925937    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForFrame(frame))
    926938        didReceiveResourceResponseImpl(*instrumentingAgents, identifier, loader, response, resourceLoader);
     939}
     940
     941inline void InspectorInstrumentation::didReceiveResourceResponse(WorkerGlobalScope& workerGlobalScope, unsigned long identifier, const ResourceResponse& response)
     942{
     943    didReceiveResourceResponseImpl(instrumentingAgentsForWorkerGlobalScope(workerGlobalScope), identifier, nullptr, response, nullptr);
    927944}
    928945
    … …  
    941958}
    942959
     960inline void InspectorInstrumentation::didReceiveData(WorkerGlobalScope& workerGlobalScope, unsigned long identifier, const char* data, int dataLength)
     961{
     962    FAST_RETURN_IF_NO_FRONTENDS(void());
     963    didReceiveDataImpl(instrumentingAgentsForWorkerGlobalScope(workerGlobalScope), identifier, data, dataLength, dataLength);
     964}
     965
    943966inline void InspectorInstrumentation::didFinishLoading(Frame* frame, DocumentLoader* loader, unsigned long identifier, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)
    944967{
     968    FAST_RETURN_IF_NO_FRONTENDS(void());
    945969    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForFrame(frame))
    946970        didFinishLoadingImpl(*instrumentingAgents, identifier, loader, networkLoadMetrics, resourceLoader);
    947971}
    948972
     973inline void InspectorInstrumentation::didFinishLoading(WorkerGlobalScope& workerGlobalScope, unsigned long identifier, const NetworkLoadMetrics& networkLoadMetrics)
     974{
     975    FAST_RETURN_IF_NO_FRONTENDS(void());
     976    didFinishLoadingImpl(instrumentingAgentsForWorkerGlobalScope(workerGlobalScope), identifier, nullptr, networkLoadMetrics, nullptr);
     977}
     978
    949979inline void InspectorInstrumentation::didFailLoading(Frame* frame, DocumentLoader* loader, unsigned long identifier, const ResourceError& error)
    950980{
    951981    if (InstrumentingAgents* instrumentingAgents = instrumentingAgentsForFrame(frame))
    952982        didFailLoadingImpl(*instrumentingAgents, identifier, loader, error);
     983}
     984
     985inline void InspectorInstrumentation::didFailLoading(WorkerGlobalScope& workerGlobalScope, unsigned long identifier, const ResourceError& error)
     986{
     987    didFailLoadingImpl(instrumentingAgentsForWorkerGlobalScope(workerGlobalScope), identifier, nullptr, error);
    953988}
    954989

  • trunk/Source/WebCore/inspector/WorkerInspectorController.cpp

    r223476 r224788  
    3636#include "WorkerDebuggerAgent.h"
    3737#include "WorkerGlobalScope.h"
     38#include "WorkerNetworkAgent.h"
    3839#include "WorkerRuntimeAgent.h"
    3940#include "WorkerThread.h"
    … …  
    4445#include <inspector/InspectorFrontendDispatchers.h>
    4546#include <inspector/InspectorFrontendRouter.h>
     47#include <inspector/agents/InspectorAgent.h>
    4648
     49#if ENABLE(SERVICE_WORKER)
     50#include "ServiceWorkerGlobalScope.h"
     51#endif
    4752
    4853namespace WebCore {
     54
    4955using namespace JSC;
    5056using namespace Inspector;
    … …  
    5965    , m_workerGlobalScope(workerGlobalScope)
    6066{
    61     AgentContext baseContext = {
    62         *this,
    63         *m_injectedScriptManager,
    64         m_frontendRouter.get(),
    65         m_backendDispatcher.get(),
    66     };
     67    ASSERT(workerGlobalScope.isContextThread());
    6768
    68     WebAgentContext webContext = {
    69         baseContext,
    70         m_instrumentingAgents.get(),
    71     };
     69    auto workerContext = workerAgentContext();
    7270
    73     WorkerAgentContext workerContext = {
    74         webContext,
    75         workerGlobalScope,
    76     };
     71    auto inspectorAgent = std::make_unique<InspectorAgent>(workerContext);
     72    auto heapAgent = std::make_unique<WebHeapAgent>(workerContext);
     73    auto consoleAgent = std::make_unique<WorkerConsoleAgent>(workerContext, heapAgent.get());
    7774
    78     auto heapAgent = std::make_unique<WebHeapAgent>(workerContext);
     75    m_instrumentingAgents->setInspectorAgent(inspectorAgent.get());
     76    m_instrumentingAgents->setWebConsoleAgent(consoleAgent.get());
    7977
     78    m_agents.append(WTFMove(inspectorAgent));
    8079    m_agents.append(std::make_unique<WorkerRuntimeAgent>(workerContext));
    8180    m_agents.append(std::make_unique<WorkerDebuggerAgent>(workerContext));
    82 
    83     auto consoleAgent = std::make_unique<WorkerConsoleAgent>(workerContext, heapAgent.get());
    84     m_instrumentingAgents->setWebConsoleAgent(consoleAgent.get());
    8581    m_agents.append(WTFMove(consoleAgent));
    86 
    8782    m_agents.append(WTFMove(heapAgent));
    8883
    89     if (CommandLineAPIHost* commandLineAPIHost = m_injectedScriptManager->commandLineAPIHost()) {
    90         commandLineAPIHost->init(
    91               nullptr // InspectorAgent
    92             , m_instrumentingAgents->webConsoleAgent()
    93             , nullptr // InspectorDOMAgent
    94             , nullptr // InspectorDOMStorageAgent
    95             , nullptr // InspectorDatabaseAgent
    96         );
    97     }
     84    if (CommandLineAPIHost* commandLineAPIHost = m_injectedScriptManager->commandLineAPIHost())
     85        commandLineAPIHost->init(m_instrumentingAgents->inspectorAgent(), m_instrumentingAgents->webConsoleAgent(), nullptr, nullptr, nullptr);
    9886}
    9987
    … …  
    120108    ASSERT(!m_forwardingChannel);
    121109
     110    createLazyAgents();
     111
     112    InspectorInstrumentation::frontendCreated();
     113
     114    m_executionStopwatch->reset();
     115    m_executionStopwatch->start();
     116
    122117    m_forwardingChannel = std::make_unique<WorkerToPageFrontendChannel>(m_workerGlobalScope);
    123118    m_frontendRouter->connectFrontend(m_forwardingChannel.get());
    … …  
    132127    ASSERT(m_forwardingChannel);
    133128
     129    InspectorInstrumentation::frontendDeleted();
     130
    134131    m_agents.willDestroyFrontendAndBackend(reason);
    135132    m_frontendRouter->disconnectFrontend(m_forwardingChannel.get());
    … …  
    140137{
    141138    m_backendDispatcher->dispatch(message);
     139}
     140
     141WorkerAgentContext WorkerInspectorController::workerAgentContext()
     142{
     143    AgentContext baseContext = {
     144        *this,
     145        *m_injectedScriptManager,
     146        m_frontendRouter.get(),
     147        m_backendDispatcher.get(),
     148    };
     149
     150    WebAgentContext webContext = {
     151        baseContext,
     152        m_instrumentingAgents.get(),
     153    };
     154
     155    WorkerAgentContext workerContext = {
     156        webContext,
     157        m_workerGlobalScope,
     158    };
     159
     160    return workerContext;
     161}
     162
     163void WorkerInspectorController::createLazyAgents()
     164{
     165    if (m_didCreateLazyAgents)
     166        return;
     167
     168    m_didCreateLazyAgents = true;
     169
     170#if ENABLE(SERVICE_WORKER)
     171    auto workerContext = workerAgentContext();
     172    if (is<ServiceWorkerGlobalScope>(m_workerGlobalScope))
     173        m_agents.append(std::make_unique<WorkerNetworkAgent>(workerContext));
     174#endif
    142175}
    143176

  • trunk/Source/WebCore/inspector/WorkerInspectorController.h

    r208008 r224788  
    4343class WebInjectedScriptManager;
    4444class WorkerGlobalScope;
     45struct WorkerAgentContext;
    4546
    4647class WorkerInspectorController final : public Inspector::InspectorEnvironment {
    … …  
    7172    friend class InspectorInstrumentation;
    7273
     74    WorkerAgentContext workerAgentContext();
     75    void createLazyAgents();
     76
    7377    Ref<InstrumentingAgents> m_instrumentingAgents;
    7478    std::unique_ptr<WebInjectedScriptManager> m_injectedScriptManager;
    … …  
    8084    WorkerGlobalScope& m_workerGlobalScope;
    8185    std::unique_ptr<Inspector::FrontendChannel> m_forwardingChannel;
     86    bool m_didCreateLazyAgents { false };
    8287};
    8388

  • trunk/Source/WebCore/inspector/agents/InspectorNetworkAgent.cpp

    r224704 r224788  
    7878#include <wtf/text/StringBuilder.h>
    7979
    80 
    8180typedef Inspector::NetworkBackendDispatcherHandler::LoadResourceCallback LoadResourceCallback;
    8281
    8382namespace WebCore {
     83
    8484using namespace Inspector;
    8585
    … …  
    9090public:
    9191    InspectorThreadableLoaderClient(RefPtr<LoadResourceCallback>&& callback)
    92         : m_callback(WTFMove(callback)) { }
     92        : m_callback(WTFMove(callback))
     93    {
     94    }
    9395
    9496    virtual ~InspectorThreadableLoaderClient() = default;
    … …  
    158160} // namespace
    159161
    160 InspectorNetworkAgent::InspectorNetworkAgent(WebAgentContext& context, InspectorPageAgent* pageAgent)
     162InspectorNetworkAgent::InspectorNetworkAgent(WebAgentContext& context)
    161163    : InspectorAgentBase(ASCIILiteral("Network"), context)
    162164    , m_frontendDispatcher(std::make_unique<Inspector::NetworkFrontendDispatcher>(context.frontendRouter))
    163165    , m_backendDispatcher(Inspector::NetworkBackendDispatcher::create(context.backendDispatcher, this))
    164166    , m_injectedScriptManager(context.injectedScriptManager)
    165     , m_pageAgent(pageAgent)
    166167    , m_resourcesData(std::make_unique<NetworkResourcesData>())
    167168{
    … …  
    337338}
    338339
    339 void InspectorNetworkAgent::willSendRequest(unsigned long identifier, DocumentLoader& loader, ResourceRequest& request, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType type)
     340void InspectorNetworkAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType type)
    340341{
    341342    if (request.hiddenFromInspector()) {
    … …  
    348349
    349350    String requestId = IdentifiersFactory::requestId(identifier);
    350     String loaderId = m_pageAgent->loaderId(&loader);
     351    String frameId = frameIdentifier(loader);
     352    String loaderId = loaderIdentifier(loader);
     353    String targetId = request.initiatorIdentifier();
    351354
    352355    if (type == InspectorPageAgent::OtherResource) {
    353356        if (m_loadingXHRSynchronously)
    354357            type = InspectorPageAgent::XHRResource;
    355         else if (equalIgnoringFragmentIdentifier(request.url(), loader.url()) && !loader.isCommitted())
     358        else if (loader && equalIgnoringFragmentIdentifier(request.url(), loader->url()) && !loader->isCommitted())
    356359            type = InspectorPageAgent::DocumentResource;
    357         else {
    358             for (auto& linkIcon : loader.linkIcons()) {
     360        else if (loader) {
     361            for (auto& linkIcon : loader->linkIcons()) {
    359362                if (equalIgnoringFragmentIdentifier(request.url(), linkIcon.url)) {
    360363                    type = InspectorPageAgent::ImageResource;
    … …  
    372375    auto protocolResourceType = InspectorPageAgent::resourceTypeJSON(type);
    373376
    374     RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = buildInitiatorObject(loader.frame() ? loader.frame()->document() : nullptr);
    375     String targetId = request.initiatorIdentifier();
    376 
    377     m_frontendDispatcher->requestWillBeSent(requestId, m_pageAgent->frameId(loader.frame()), m_pageAgent->loaderId(&loader), loader.url().string(), buildObjectForResourceRequest(request), sendTimestamp, walltime, initiatorObject, buildObjectForResourceResponse(redirectResponse, nullptr), type != InspectorPageAgent::OtherResource ? &protocolResourceType : nullptr, targetId.isEmpty() ? nullptr : &targetId);
     377    Document* document = loader && loader->frame() ? loader->frame()->document() : nullptr;
     378    auto initiatorObject = buildInitiatorObject(document);
     379
     380    String url = loader ? loader->url().string() : request.url();
     381    m_frontendDispatcher->requestWillBeSent(requestId, frameId, loaderId, url, buildObjectForResourceRequest(request), sendTimestamp, walltime, initiatorObject, buildObjectForResourceResponse(redirectResponse, nullptr), type != InspectorPageAgent::OtherResource ? &protocolResourceType : nullptr, targetId.isEmpty() ? nullptr : &targetId);
    378382}
    379383
    … …  
    398402}
    399403
    400 void InspectorNetworkAgent::willSendRequest(unsigned long identifier, DocumentLoader& loader, ResourceRequest& request, const ResourceResponse& redirectResponse)
    401 {
    402     auto* cachedResource = InspectorPageAgent::cachedResource(loader.frame(), request.url());
     404void InspectorNetworkAgent::willSendRequest(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, const ResourceResponse& redirectResponse)
     405{
     406    auto* cachedResource = loader ? InspectorPageAgent::cachedResource(loader->frame(), request.url()) : nullptr;
    403407    willSendRequest(identifier, loader, request, redirectResponse, resourceTypeForCachedResource(cachedResource));
    404408}
    405409
    406 void InspectorNetworkAgent::willSendRequestOfType(unsigned long identifier, DocumentLoader& loader, ResourceRequest& request, InspectorInstrumentation::LoadType loadType)
     410void InspectorNetworkAgent::willSendRequestOfType(unsigned long identifier, DocumentLoader* loader, ResourceRequest& request, InspectorInstrumentation::LoadType loadType)
    407411{
    408412    willSendRequest(identifier, loader, request, ResourceResponse(), resourceTypeForLoadType(loadType));
    409413}
    410414
    411 void InspectorNetworkAgent::didReceiveResponse(unsigned long identifier, DocumentLoader& loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
     415void InspectorNetworkAgent::didReceiveResponse(unsigned long identifier, DocumentLoader* loader, const ResourceResponse& response, ResourceLoader* resourceLoader)
    412416{
    413417    if (m_hiddenRequestIdentifiers.contains(identifier))
    … …  
    422426    if (resourceLoader && resourceLoader->isSubresourceLoader() && !isNotModified)
    423427        cachedResource = static_cast<SubresourceLoader*>(resourceLoader)->cachedResource();
    424     if (!cachedResource)
    425         cachedResource = InspectorPageAgent::cachedResource(loader.frame(), response.url());
     428    if (!cachedResource && loader)
     429        cachedResource = InspectorPageAgent::cachedResource(loader->frame(), response.url());
    426430
    427431    if (cachedResource) {
    … …  
    440444        type = newType;
    441445
    442     String frameId = m_pageAgent->frameId(loader.frame());
    443     String loaderId = m_pageAgent->loaderId(&loader);
     446    String frameId = frameIdentifier(loader);
     447    String loaderId = loaderIdentifier(loader);
    444448
    445449    m_resourcesData->responseReceived(requestId, frameId, response, type);
    … …  
    474478}
    475479
    476 void InspectorNetworkAgent::didFinishLoading(unsigned long identifier, DocumentLoader& loader, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)
     480void InspectorNetworkAgent::didFinishLoading(unsigned long identifier, DocumentLoader* loader, const NetworkLoadMetrics& networkLoadMetrics, ResourceLoader* resourceLoader)
    477481{
    478482    if (m_hiddenRequestIdentifiers.remove(identifier))
    … …  
    488492
    489493    String requestId = IdentifiersFactory::requestId(identifier);
    490     if (m_resourcesData->resourceType(requestId) == InspectorPageAgent::DocumentResource)
    491         m_resourcesData->addResourceSharedBuffer(requestId, loader.frameLoader()->documentLoader()->mainResourceData(), loader.frame()->document()->encoding());
     494    if (loader && m_resourcesData->resourceType(requestId) == InspectorPageAgent::DocumentResource)
     495        m_resourcesData->addResourceSharedBuffer(requestId, loader->frameLoader()->documentLoader()->mainResourceData(), loader->frame()->document()->encoding());
    492496
    493497    m_resourcesData->maybeDecodeDataToContent(requestId);
    … …  
    503507}
    504508
    505 void InspectorNetworkAgent::didFailLoading(unsigned long identifier, DocumentLoader& loader, const ResourceError& error)
     509void InspectorNetworkAgent::didFailLoading(unsigned long identifier, DocumentLoader* loader, const ResourceError& error)
    506510{
    507511    if (m_hiddenRequestIdentifiers.remove(identifier))
    … …  
    510514    String requestId = IdentifiersFactory::requestId(identifier);
    511515
    512     if (m_resourcesData->resourceType(requestId) == InspectorPageAgent::DocumentResource) {
    513         Frame* frame = loader.frame();
     516    if (loader && m_resourcesData->resourceType(requestId) == InspectorPageAgent::DocumentResource) {
     517        Frame* frame = loader->frame();
    514518        if (frame && frame->loader().documentLoader() && frame->document()) {
    515519            m_resourcesData->addResourceSharedBuffer(requestId,
    … …  
    523527}
    524528
    525 void InspectorNetworkAgent::didLoadResourceFromMemoryCache(DocumentLoader& loader, CachedResource& resource)
    526 {
    527     unsigned long identifier = loader.frame()->page()->progress().createUniqueIdentifier();
     529void InspectorNetworkAgent::didLoadResourceFromMemoryCache(DocumentLoader* loader, CachedResource& resource)
     530{
     531    ASSERT(loader);
     532    if (!loader)
     533        return;
     534
     535    unsigned long identifier = loader->frame()->page()->progress().createUniqueIdentifier();
    528536    String requestId = IdentifiersFactory::requestId(identifier);
    529     String loaderId = m_pageAgent->loaderId(&loader);
    530     String frameId = m_pageAgent->frameId(loader.frame());
     537    String loaderId = loaderIdentifier(loader);
     538    String frameId = frameIdentifier(loader);
    531539
    532540    m_resourcesData->resourceCreated(requestId, loaderId, resource);
    533541
    534     RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = buildInitiatorObject(loader.frame() ? loader.frame()->document() : nullptr);
     542    RefPtr<Inspector::Protocol::Network::Initiator> initiatorObject = buildInitiatorObject(loader->frame() ? loader->frame()->document() : nullptr);
    535543
    536544    // FIXME: It would be ideal to generate the Network.Response with the MemoryCache source
    … …  
    538546    // The frontend already knows for certain that this was served from the memory cache.
    539547
    540     m_frontendDispatcher->requestServedFromMemoryCache(requestId, frameId, loaderId, loader.url().string(), timestamp(), initiatorObject, buildObjectForCachedResource(&resource));
     548    m_frontendDispatcher->requestServedFromMemoryCache(requestId, frameId, loaderId, loader->url().string(), timestamp(), initiatorObject, buildObjectForCachedResource(&resource));
    541549}
    542550
    … …  
    608616RefPtr<Inspector::Protocol::Network::Initiator> InspectorNetworkAgent::buildInitiatorObject(Document* document)
    609617{
     618    // FIXME: Worker support.
     619    if (!isMainThread()) {
     620        return Inspector::Protocol::Network::Initiator::create()
     621            .setType(Inspector::Protocol::Network::Initiator::Type::Other)
     622            .release();
     623    }
     624
    610625    Ref<ScriptCallStack> stackTrace = createScriptCallStack(JSMainThreadExecState::currentState());
    611626    if (stackTrace->size() > 0) {
    … …  
    699714    m_instrumentingAgents.setInspectorNetworkAgent(this);
    700715
    701     LockHolder lock(WebSocket::allActiveWebSocketsMutex());
    702 
    703     for (WebSocket* webSocket : WebSocket::allActiveWebSockets(lock)) {
    704         if (!is<Document>(webSocket->scriptExecutionContext()) || !is<WebSocketChannel>(webSocket->channel().get()))
    705             continue;
    706 
    707         Document* document = downcast<Document>(webSocket->scriptExecutionContext());
    708         if (document->page() != &m_pageAgent->page())
    709             continue;
    710 
    711         WebSocketChannel* channel = downcast<WebSocketChannel>(webSocket->channel().get());
    712         if (!channel)
    713             continue;
    714 
    715         unsigned identifier = channel->identifier();
    716         didCreateWebSocket(identifier, webSocket->url());
    717         willSendWebSocketHandshakeRequest(identifier, channel->clientHandshakeRequest());
    718 
    719         if (channel->handshakeMode() == WebSocketHandshake::Connected)
    720             didReceiveWebSocketHandshakeResponse(identifier, channel->serverHandshakeResponse());
    721 
    722         if (webSocket->readyState() == WebSocket::CLOSED)
    723             didCloseWebSocket(identifier);
     716    {
     717        LockHolder lock(WebSocket::allActiveWebSocketsMutex());
     718
     719        for (WebSocket* webSocket : activeWebSockets(lock)) {
     720            ASSERT(is<WebSocketChannel>(webSocket->channel().get()));
     721            WebSocketChannel* channel = downcast<WebSocketChannel>(webSocket->channel().get());
     722
     723            unsigned identifier = channel->identifier();
     724            didCreateWebSocket(identifier, webSocket->url());
     725            willSendWebSocketHandshakeRequest(identifier, channel->clientHandshakeRequest());
     726
     727            if (channel->handshakeMode() == WebSocketHandshake::Connected)
     728                didReceiveWebSocketHandshakeResponse(identifier, channel->serverHandshakeResponse());
     729
     730            if (webSocket->readyState() == WebSocket::CLOSED)
     731                didCloseWebSocket(identifier);
     732        }
    724733    }
    725734}
    … …  
    732741    m_extraRequestHeaders.clear();
    733742
    734     m_pageAgent->page().setResourceCachingDisabledOverride(false);
     743    setResourceCachingDisabled(false);
    735744}
    736745
    … …  
    779788void InspectorNetworkAgent::setResourceCachingDisabled(ErrorString&, bool disabled)
    780789{
    781     m_pageAgent->page().setResourceCachingDisabledOverride(disabled);
     790    setResourceCachingDisabled(disabled);
    782791}
    783792
    784793void InspectorNetworkAgent::loadResource(ErrorString& errorString, const String& frameId, const String& urlString, Ref<LoadResourceCallback>&& callback)
    785794{
    786     Frame* frame = m_pageAgent->assertFrame(errorString, frameId);
    787     if (!frame)
    788         return;
    789 
    790     Document* document = frame->document();
    791     if (!document) {
    792         errorString = ASCIILiteral("No Document instance for the specified frame");
    793         return;
    794     }
    795 
    796     URL url = document->completeURL(urlString);
     795    auto* context = scriptExecutionContext(errorString, frameId);
     796    if (!context)
     797        return;
     798
     799    URL url = context->completeURL(urlString);
    797800    ResourceRequest request(url);
    798801    request.setHTTPMethod(ASCIILiteral("GET"));
    … …  
    808811    // InspectorThreadableLoaderClient deletes itself when the load completes or fails.
    809812    InspectorThreadableLoaderClient* inspectorThreadableLoaderClient = new InspectorThreadableLoaderClient(callback.copyRef());
    810     auto loader = DocumentThreadableLoader::create(*document, *inspectorThreadableLoaderClient, WTFMove(request), options);
     813    auto loader = ThreadableLoader::create(*context, *inspectorThreadableLoaderClient, WTFMove(request), options);
    811814    if (!loader)
    812815        return;
    … …  
    823826    LockHolder lock(WebSocket::allActiveWebSocketsMutex());
    824827
    825     for (WebSocket* webSocket : WebSocket::allActiveWebSockets(lock)) {
    826         if (!is<WebSocketChannel>(webSocket->channel().get()))
    827             continue;
    828 
     828    for (WebSocket* webSocket : activeWebSockets(lock)) {
     829        ASSERT(is<WebSocketChannel>(webSocket->channel().get()));
    829830        WebSocketChannel* channel = downcast<WebSocketChannel>(webSocket->channel().get());
    830         if (!channel)
    831             continue;
    832 
    833         if (IdentifiersFactory::requestId(channel->identifier()) != requestId)
    834             continue;
    835 
    836         // FIXME: <webkit.org/b/168475> Web Inspector: Correctly display iframe's and worker's WebSockets
    837         if (!is<Document>(webSocket->scriptExecutionContext()))
    838             continue;
    839 
    840         Document* document = downcast<Document>(webSocket->scriptExecutionContext());
    841         if (document->page() != &m_pageAgent->page())
    842             continue;
    843 
    844         return webSocket;
     831        if (IdentifiersFactory::requestId(channel->identifier()) == requestId)
     832            return webSocket;
    845833    }
    846834
    … …  
    862850    }
    863851
    864     // FIXME: <webkit.org/b/168475> Web Inspector: Correctly display iframe's and worker's WebSockets
    865     Document* document = downcast<Document>(webSocket->scriptExecutionContext());
    866     Frame* frame = document->frame();
     852    // FIXME: <https://webkit.org/b/168475> Web Inspector: Correctly display iframe's and worker's WebSockets
     853    if (!is<Document>(webSocket->scriptExecutionContext()))
     854        return;
     855
     856    auto* document = downcast<Document>(webSocket->scriptExecutionContext());
     857    auto* frame = document->frame();
    867858    if (!frame) {
    868859        errorString = ASCIILiteral("WebSocket belongs to document without a frame");
    … …  
    919910void InspectorNetworkAgent::mainFrameNavigated(DocumentLoader& loader)
    920911{
    921     m_resourcesData->clear(m_pageAgent->loaderId(&loader));
     912    m_resourcesData->clear(loaderIdentifier(&loader));
    922913}
    923914

  • trunk/Source/WebCore/inspector/agents/InspectorNetworkAgent.h

    r224345 r224788  
    6565typedef String ErrorString;
    6666
    67 class InspectorNetworkAgent final : public InspectorAgentBase, public Inspector::NetworkBackendDispatcherHandler {
     67class InspectorNetworkAgent : public InspectorAgentBase, public Inspector::NetworkBackendDispatcherHandler {
    6868    WTF_MAKE_FAST_ALLOCATED;
    6969public:
    70     InspectorNetworkAgent(WebAgentContext&, InspectorPageAgent*);
     70    explicit InspectorNetworkAgent(WebAgentContext&);
    7171    virtual ~InspectorNetworkAgent();
    7272
    … …  
    7777    void willRecalculateStyle();
    7878    void didRecalculateStyle();
    79     void willSendRequest(unsigned long identifier, DocumentLoader&, ResourceRequest&, const ResourceResponse& redirectResponse);
    80     void willSendRequestOfType(unsigned long identifier, DocumentLoader&, ResourceRequest&, InspectorInstrumentation::LoadType);
    81     void didReceiveResponse(unsigned long identifier, DocumentLoader&, const ResourceResponse&, ResourceLoader*);
     79    void willSendRequest(unsigned long identifier, DocumentLoader*, ResourceRequest&, const ResourceResponse& redirectResponse);
     80    void willSendRequestOfType(unsigned long identifier, DocumentLoader*, ResourceRequest&, InspectorInstrumentation::LoadType);
     81    void didReceiveResponse(unsigned long identifier, DocumentLoader*, const ResourceResponse&, ResourceLoader*);
    8282    void didReceiveData(unsigned long identifier, const char* data, int dataLength, int encodedDataLength);
    83     void didFinishLoading(unsigned long identifier, DocumentLoader&, const NetworkLoadMetrics&, ResourceLoader*);
    84     void didFailLoading(unsigned long identifier, DocumentLoader&, const ResourceError&);
    85     void didLoadResourceFromMemoryCache(DocumentLoader&, CachedResource&);
     83    void didFinishLoading(unsigned long identifier, DocumentLoader*, const NetworkLoadMetrics&, ResourceLoader*);
     84    void didFailLoading(unsigned long identifier, DocumentLoader*, const ResourceError&);
     85    void didLoadResourceFromMemoryCache(DocumentLoader*, CachedResource&);
    8686    void didReceiveThreadableLoaderResponse(unsigned long identifier, DocumentThreadableLoader&);
    8787    void didFinishXHRLoading(unsigned long identifier, const String& decodedText);
    … …  
    107107
    108108    // Called from frontend.
    109     void enable(ErrorString&) override;
    110     void disable(ErrorString&) override;
    111     void setExtraHTTPHeaders(ErrorString&, const Inspector::InspectorObject& headers) override;
    112     void getResponseBody(ErrorString&, const String& requestId, String* content, bool* base64Encoded) override;
    113     void setResourceCachingDisabled(ErrorString&, bool disabled) override;
    114     void loadResource(ErrorString&, const String& frameId, const String& url, Ref<LoadResourceCallback>&&) override;
    115     void resolveWebSocket(ErrorString&, const String& requestId, const String* const objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) override;
     109    void enable(ErrorString&) final;
     110    void disable(ErrorString&) final;
     111    void setExtraHTTPHeaders(ErrorString&, const Inspector::InspectorObject& headers) final;
     112    void getResponseBody(ErrorString&, const String& requestId, String* content, bool* base64Encoded) final;
     113    void setResourceCachingDisabled(ErrorString&, bool disabled) final;
     114    void loadResource(ErrorString&, const String& frameId, const String& url, Ref<LoadResourceCallback>&&) final;
     115    void resolveWebSocket(ErrorString&, const String& requestId, const String* const objectGroup, RefPtr<Inspector::Protocol::Runtime::RemoteObject>&) final;
     116
     117    virtual String loaderIdentifier(DocumentLoader*) = 0;
     118    virtual String frameIdentifier(DocumentLoader*) = 0;
     119    virtual Vector<WebSocket*> activeWebSockets(const LockHolder&) = 0;
     120    virtual void setResourceCachingDisabled(bool) = 0;
     121    virtual ScriptExecutionContext* scriptExecutionContext(ErrorString&, const String& frameId) = 0;
    116122
    117123private:
    118124    void enable();
    119125
    120     void willSendRequest(unsigned long identifier, DocumentLoader&, ResourceRequest&, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType);
     126    void willSendRequest(unsigned long identifier, DocumentLoader*, ResourceRequest&, const ResourceResponse& redirectResponse, InspectorPageAgent::ResourceType);
    121127
    122128    WebSocket* webSocketForRequestId(const String& requestId);
    … …  
    132138    RefPtr<Inspector::NetworkBackendDispatcher> m_backendDispatcher;
    133139    Inspector::InjectedScriptManager& m_injectedScriptManager;
    134     InspectorPageAgent* m_pageAgent { nullptr };
    135140
    136141    // FIXME: InspectorNetworkAgent should not be aware of style recalculation.

  • trunk/Source/WebCore/inspector/agents/page/PageNetworkAgent.h

    r224787 r224788  
    11/*
    2  * Copyright (C) 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #include "config.h"
    27 #include "WorkerConsoleAgent.h"
     26#pragma once
    2827
     28#include "InspectorNetworkAgent.h"
    2929
    3030namespace WebCore {
    31 using namespace Inspector;
    3231
    33 WorkerConsoleAgent::WorkerConsoleAgent(WorkerAgentContext& context, InspectorHeapAgent* heapAgent)
    34     : WebConsoleAgent(context, heapAgent)
    35 {
    36 }
     32class PageNetworkAgent final : public InspectorNetworkAgent {
     33    WTF_MAKE_FAST_ALLOCATED;
     34public:
     35    PageNetworkAgent(PageAgentContext&, InspectorPageAgent*);
     36    virtual ~PageNetworkAgent() = default;
     37
     38private:
     39    String loaderIdentifier(DocumentLoader*) final;
     40    String frameIdentifier(DocumentLoader*) final;
     41    Vector<WebSocket*> activeWebSockets(const LockHolder&) final;
     42    void setResourceCachingDisabled(bool) final;
     43    ScriptExecutionContext* scriptExecutionContext(ErrorString&, const String& frameId) final;
     44
     45    InspectorPageAgent* m_pageAgent { nullptr };
     46};
    3747
    3848} // namespace WebCore

  • trunk/Source/WebCore/inspector/agents/worker/WorkerConsoleAgent.cpp

    r224345 r224788  
    2727#include "WorkerConsoleAgent.h"
    2828
     29#include "WorkerGlobalScope.h"
    2930
    3031namespace WebCore {
     32
    3133using namespace Inspector;
    3234
    … …  
    3436    : WebConsoleAgent(context, heapAgent)
    3537{
     38    ASSERT(context.workerGlobalScope.isContextThread());
    3639}
    3740

  • trunk/Source/WebCore/inspector/agents/worker/WorkerDebuggerAgent.cpp

    r224345 r224788  
    3535#include <inspector/ScriptCallStackFactory.h>
    3636
     37namespace WebCore {
    3738
    38 namespace WebCore {
    3939using namespace JSC;
    4040using namespace Inspector;
    … …  
    4444    , m_workerGlobalScope(context.workerGlobalScope)
    4545{
     46    ASSERT(context.workerGlobalScope.isContextThread());
    4647}
    4748

  • trunk/Source/WebCore/inspector/agents/worker/WorkerNetworkAgent.cpp

    r224787 r224788  
    11/*
    2  * Copyright (C) 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2525
    2626#include "config.h"
    27 #include "WorkerConsoleAgent.h"
     27#include "WorkerNetworkAgent.h"
    2828
     29#include "WorkerDebuggerProxy.h"
     30#include "WorkerGlobalScope.h"
     31#include "WorkerThread.h"
    2932
    3033namespace WebCore {
     34
    3135using namespace Inspector;
    3236
    33 WorkerConsoleAgent::WorkerConsoleAgent(WorkerAgentContext& context, InspectorHeapAgent* heapAgent)
    34     : WebConsoleAgent(context, heapAgent)
     37WorkerNetworkAgent::WorkerNetworkAgent(WorkerAgentContext& context)
     38    : InspectorNetworkAgent(context)
     39    , m_workerGlobalScope(context.workerGlobalScope)
    3540{
     41    ASSERT(context.workerGlobalScope.isContextThread());
     42}
     43
     44String WorkerNetworkAgent::loaderIdentifier(DocumentLoader*)
     45{
     46    return { };
     47}
     48
     49String WorkerNetworkAgent::frameIdentifier(DocumentLoader*)
     50{
     51    return { };
     52}
     53
     54Vector<WebSocket*> WorkerNetworkAgent::activeWebSockets(const LockHolder&)
     55{
     56    // FIXME: <https://webkit.org/b/168475> Web Inspector: Correctly display worker's WebSockets
     57    return { };
     58}
     59
     60void WorkerNetworkAgent::setResourceCachingDisabled(bool disabled)
     61{
     62    m_workerGlobalScope.thread().workerDebuggerProxy().setResourceCachingDisabled(disabled);
     63}
     64
     65ScriptExecutionContext* WorkerNetworkAgent::scriptExecutionContext(ErrorString&, const String&)
     66{
     67    return &m_workerGlobalScope;
    3668}
    3769

  • trunk/Source/WebCore/inspector/agents/worker/WorkerNetworkAgent.h

    r224787 r224788  
    11/*
    2  * Copyright (C) 2016 Apple Inc. All rights reserved.
     2 * Copyright (C) 2017 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2424 */
    2525
    26 #include "config.h"
    27 #include "WorkerConsoleAgent.h"
     26#pragma once
    2827
     28#include "InspectorNetworkAgent.h"
    2929
    3030namespace WebCore {
    31 using namespace Inspector;
    3231
    33 WorkerConsoleAgent::WorkerConsoleAgent(WorkerAgentContext& context, InspectorHeapAgent* heapAgent)
    34     : WebConsoleAgent(context, heapAgent)
    35 {
    36 }
     32class WorkerNetworkAgent final : public InspectorNetworkAgent {
     33    WTF_MAKE_FAST_ALLOCATED;
     34public:
     35    explicit WorkerNetworkAgent(WorkerAgentContext&);
     36    virtual ~WorkerNetworkAgent() = default;
     37
     38private:
     39    String loaderIdentifier(DocumentLoader*) final;
     40    String frameIdentifier(DocumentLoader*) final;
     41    Vector<WebSocket*> activeWebSockets(const LockHolder&) final;
     42    void setResourceCachingDisabled(bool) final;
     43    ScriptExecutionContext* scriptExecutionContext(ErrorString&, const String& frameId) final;
     44
     45    WorkerGlobalScope& m_workerGlobalScope;
     46};
    3747
    3848} // namespace WebCore

  • trunk/Source/WebCore/inspector/agents/worker/WorkerRuntimeAgent.cpp

    r224345 r224788  
    3838#include <inspector/InjectedScriptManager.h>
    3939
     40namespace WebCore {
    4041
    41 namespace WebCore {
    4242using namespace Inspector;
    4343
    … …  
    4747    , m_workerGlobalScope(context.workerGlobalScope)
    4848{
     49    ASSERT(context.workerGlobalScope.isContextThread());
    4950}
    5051

  • trunk/Source/WebCore/loader/ThreadableLoader.cpp

    r223728 r224788  
    103103{
    104104    if (is<WorkerGlobalScope>(context))
    105         return WorkerThreadableLoader::create(downcast<WorkerGlobalScope>(context), client, WorkerRunLoop::defaultMode(), WTFMove(request), options, referrer);
     105        return WorkerThreadableLoader::create(downcast<WorkerGlobalScope>(context), client, WorkerRunLoop::defaultMode(), WTFMove(request), options, WTFMove(referrer));
    106106
    107107    return DocumentThreadableLoader::create(downcast<Document>(context), client, WTFMove(request), options, WTFMove(referrer));

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.cpp

    r224218 r224788  
    3636#include "Document.h"
    3737#include "DocumentThreadableLoader.h"
     38#include "InspectorInstrumentation.h"
    3839#include "Performance.h"
    3940#include "ResourceError.h"
    … …  
    107108    , m_loaderProxy(loaderProxy)
    108109    , m_taskMode(taskMode.isolatedCopy())
    109 {
    110 
     110    , m_workerRequestIdentifier(globalScope.createUniqueIdentifier())
     111{
    111112    auto* securityOrigin = globalScope.securityOrigin();
    112113    auto* contentSecurityPolicy = globalScope.contentSecurityPolicy();
    … …  
    131132        optionsCopy->options.serviceWorkerIdentifier = activeServiceWorker->identifier();
    132133#endif
     134
     135    InspectorInstrumentation::willSendRequest(globalScope, m_workerRequestIdentifier, request);
    133136
    134137    // Can we benefit from request being an r-value to create more efficiently its isolated copy?
    … …  
    196199void WorkerThreadableLoader::MainThreadBridge::didReceiveResponse(unsigned long identifier, const ResourceResponse& response)
    197200{
    198     m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), identifier, responseData = response.crossThreadData()] (ScriptExecutionContext& context) mutable {
    199         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    200         protectedWorkerClientWrapper->didReceiveResponse(identifier, ResourceResponse::fromCrossThreadData(WTFMove(responseData)));
     201    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), workerRequestIdentifier = m_workerRequestIdentifier, identifier, responseData = response.crossThreadData()] (ScriptExecutionContext& context) mutable {
     202        ASSERT(context.isWorkerGlobalScope());
     203        auto response = ResourceResponse::fromCrossThreadData(WTFMove(responseData));
     204        protectedWorkerClientWrapper->didReceiveResponse(identifier, response);
     205        InspectorInstrumentation::didReceiveResourceResponse(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, response);
    201206    }, m_taskMode);
    202207}
    … …  
    204209void WorkerThreadableLoader::MainThreadBridge::didReceiveData(const char* data, int dataLength)
    205210{
    206     Vector<char> vector(dataLength);
    207     memcpy(vector.data(), data, dataLength);
    208     m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), vector = WTFMove(vector)] (ScriptExecutionContext& context) mutable {
    209         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
    210         protectedWorkerClientWrapper->didReceiveData(vector.data(), vector.size());
     211    Vector<char> buffer(dataLength);
     212    memcpy(buffer.data(), data, dataLength);
     213    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), workerRequestIdentifier = m_workerRequestIdentifier, buffer = WTFMove(buffer)] (ScriptExecutionContext& context) mutable {
     214        ASSERT(context.isWorkerGlobalScope());
     215        protectedWorkerClientWrapper->didReceiveData(buffer.data(), buffer.size());
     216        InspectorInstrumentation::didReceiveData(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, buffer.data(), buffer.size());
    211217    }, m_taskMode);
    212218}
    … …  
    215221{
    216222    m_loadingFinished = true;
    217     m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), identifier] (ScriptExecutionContext& context) mutable {
    218         ASSERT_UNUSED(context, context.isWorkerGlobalScope());
     223    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), workerRequestIdentifier = m_workerRequestIdentifier, networkLoadMetrics = m_networkLoadMetrics.isolatedCopy(), identifier] (ScriptExecutionContext& context) mutable {
     224        ASSERT(context.isWorkerGlobalScope());
    219225        protectedWorkerClientWrapper->didFinishLoading(identifier);
     226        InspectorInstrumentation::didFinishLoading(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, networkLoadMetrics);
    220227    }, m_taskMode);
    221228}
    … …  
    224231{
    225232    m_loadingFinished = true;
    226     m_loaderProxy.postTaskForModeToWorkerGlobalScope([workerClientWrapper = Ref<ThreadableLoaderClientWrapper>(*m_workerClientWrapper), error = error.isolatedCopy()] (ScriptExecutionContext& context) mutable {
    227         ASSERT(context.isWorkerGlobalScope());
    228 
    229         ThreadableLoader::logError(context, error, workerClientWrapper->initiator());
    230 
    231         workerClientWrapper->didFail(error);
     233    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), workerRequestIdentifier = m_workerRequestIdentifier, error = error.isolatedCopy()] (ScriptExecutionContext& context) mutable {
     234        ASSERT(context.isWorkerGlobalScope());
     235        ThreadableLoader::logError(context, error, protectedWorkerClientWrapper->initiator());
     236        protectedWorkerClientWrapper->didFail(error);
     237        InspectorInstrumentation::didFailLoading(downcast<WorkerGlobalScope>(context), workerRequestIdentifier, error);
    232238    }, m_taskMode);
    233239}
    … …  
    235241void WorkerThreadableLoader::MainThreadBridge::didFinishTiming(const ResourceTiming& resourceTiming)
    236242{
     243    m_networkLoadMetrics = resourceTiming.networkLoadMetrics();
    237244    m_loaderProxy.postTaskForModeToWorkerGlobalScope([protectedWorkerClientWrapper = makeRef(*m_workerClientWrapper), resourceTiming = resourceTiming.isolatedCopy()] (ScriptExecutionContext& context) mutable {
    238245        ASSERT(context.isWorkerGlobalScope());

  • trunk/Source/WebCore/loader/WorkerThreadableLoader.h

    r223718 r224788  
    118118            // For use on the main thread.
    119119            String m_taskMode;
     120            unsigned long m_workerRequestIdentifier { 0 };
     121            NetworkLoadMetrics m_networkLoadMetrics;
    120122        };
    121123

  • trunk/Source/WebCore/workers/WorkerDebuggerProxy.h

    r224147 r224788  
    3737    virtual ~WorkerDebuggerProxy() = default;
    3838    virtual void postMessageToDebugger(const String&) = 0;
     39    virtual void setResourceCachingDisabled(bool) = 0;
    3940};
    4041

  • trunk/Source/WebCore/workers/WorkerGlobalScope.h

    r224321 r224788  
    6565    const URL& url() const final { return m_url; }
    6666    String origin() const final;
     67    const String& identifier() const { return m_identifier; }
    6768
    6869#if ENABLE(INDEXED_DATABASE)
    … …  
    118119    void createImageBitmap(ImageBitmap::Source&&, ImageBitmapOptions&&, ImageBitmap::Promise&&);
    119120    void createImageBitmap(ImageBitmap::Source&&, int sx, int sy, int sw, int sh, ImageBitmapOptions&&, ImageBitmap::Promise&&);
     121
     122    unsigned long createUniqueIdentifier() { return m_uniqueIdentifier++; }
    120123
    121124protected:
    … …  
    197200    PAL::SessionID m_sessionID;
    198201    RefPtr<WorkerCacheStorageConnection> m_cacheStorageConnection;
     202
     203    unsigned long m_uniqueIdentifier { 1 };
    199204};
    200205

  • trunk/Source/WebCore/workers/WorkerMessagingProxy.cpp

    r224459 r224788  
    178178}
    179179
     180void WorkerMessagingProxy::setResourceCachingDisabled(bool disabled)
     181{
     182    postTaskToLoader([disabled] (ScriptExecutionContext& context) {
     183        ASSERT(isMainThread());
     184        if (auto* page = downcast<Document>(context).page())
     185            page->setResourceCachingDisabled(disabled);
     186    });
     187}
     188
    180189void WorkerMessagingProxy::workerThreadCreated(DedicatedWorkerThread& workerThread)
    181190{

  • trunk/Source/WebCore/workers/WorkerMessagingProxy.h

    r224321 r224788  
    6666    // (Only use these functions in the worker context thread.)
    6767    void postMessageToDebugger(const String&) final;
     68    void setResourceCachingDisabled(bool) final;
    6869
    6970    // Implementation of WorkerLoaderProxy.

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.cpp

    r224368 r224788  
    9090}
    9191
     92void ServiceWorkerThreadProxy::setResourceCachingDisabled(bool disabled)
     93{
     94    postTaskToLoader([this, protectedThis = makeRef(*this), disabled] (ScriptExecutionContext&) {
     95        ASSERT(isMainThread());
     96        m_page->setResourceCachingDisabled(disabled);
     97    });   
     98}
     99
    92100Ref<CacheStorageConnection> ServiceWorkerThreadProxy::createCacheStorageConnection()
    93101{

  • trunk/Source/WebCore/workers/service/context/ServiceWorkerThreadProxy.h

    r224403 r224788  
    6464    // WorkerDebuggerProxy
    6565    void postMessageToDebugger(const String&) final;
     66    void setResourceCachingDisabled(bool) final;
    6667
    6768    UniqueRef<Page> m_page;
Note: See TracChangeset for help on using the changeset viewer.