GeezerVison

function onClientRequestStart({ request }) {

function onClientRequestCreated({ request }) {

request[kInspectorRequestId] = getNextRequestId();

const { 0: host, 1: headers } = convertHeaderObject(request.getHeaders());

function enable() {

dc.subscribe('http.client.request.start', onClientRequestStart);

dc.subscribe('http.client.request.created', onClientRequestCreated);

dc.subscribe('http.client.request.error', onClientRequestError);

dc.subscribe('http.client.response.finish', onClientResponseFinish);

function disable() {

dc.unsubscribe('http.client.request.start', onClientRequestStart);

dc.unsubscribe('http.client.request.created', onClientRequestCreated);

dc.unsubscribe('http.client.request.error', onClientRequestError);

dc.unsubscribe('http.client.response.finish', onClientResponseFinish);

function disable() {

dc.subscribe('undici:request:create', onClientRequestStart);

dc.subscribe('undici:request:error', onClientRequestError);

dc.subscribe('undici:request:headers', onClientResponseHeaders);

dc.subscribe('undici:request:trailers', onClientResponseFinish);

dc.unsubscribe('undici:request:create', onClientRequestStart);

dc.unsubscribe('undici:request:error', onClientRequestError);

dc.unsubscribe('undici:request:headers', onClientResponseHeaders);

dc.unsubscribe('undici:request:trailers', onClientResponseFinish);

module.exports = {

.build();

}

NetworkAgent::NetworkAgent(NetworkInspector* inspector)

: inspector_(inspector) {

NetworkAgent::NetworkAgent(NetworkInspector* inspector,

v8_inspector::V8Inspector* v8_inspector)

: inspector_(inspector), v8_inspector_(v8_inspector) {

event_notifier_map_["requestWillBeSent"] = &NetworkAgent::requestWillBeSent;

event_notifier_map_["responseReceived"] = &NetworkAgent::responseReceived;

event_notifier_map_["loadingFailed"] = &NetworkAgent::loadingFailed;

String method;

request->getString("method", &method);

std::unique_ptr<Network::Initiator> initiator =

Network::Initiator::create()

.setType(Network::Initiator::TypeEnum::Script)

.setStack(

v8_inspector_->captureStackTrace(true)->buildInspectorObject(0))

.build();

ErrorSupport errors;

errors.Push();

errors.SetName("headers");

frontend_->requestWillBeSent(request_id,

createRequest(url, method, std::move(headers)),

std::move(initiator),

timestamp,

wall_time);

}

class NetworkAgent : public Network::Backend {

public:

explicit NetworkAgent(NetworkInspector* inspector);

explicit NetworkAgent(NetworkInspector* inspector,

v8_inspector::V8Inspector* v8_inspector);

void Wire(UberDispatcher* dispatcher);

private:

NetworkInspector* inspector_;

v8_inspector::V8Inspector* v8_inspector_;

std::shared_ptr<Network::Frontend> frontend_;

using EventNotifier =

void (NetworkAgent::*)(std::unique_ptr<protocol::DictionaryValue>);

namespace node {

namespace inspector {

NetworkInspector::NetworkInspector(Environment* env)

NetworkInspector::NetworkInspector(Environment* env,

v8_inspector::V8Inspector* v8_inspector)

: enabled_(false), env_(env) {

network_agent_ = std::make_unique<protocol::NetworkAgent>(this);

network_agent_ = std::make_unique<protocol::NetworkAgent>(this, v8_inspector);

}

NetworkInspector::~NetworkInspector() {

network_agent_.reset();

class NetworkInspector {

public:

explicit NetworkInspector(Environment* env);

explicit NetworkInspector(Environment* env,

v8_inspector::V8Inspector* v8_inspector);

~NetworkInspector();

void Wire(protocol::UberDispatcher* dispatcher);

'action_name': 'node_protocol_generated_sources',

'inputs': [

'node_protocol_config.json',

'node_protocol.pdl',

'<(SHARED_INTERMEDIATE_DIR)/src/node_protocol.json',

'<@(node_protocol_files)',

'<(protocol_tool_path)/code_generator.py',

# Partial support for Network domain of ChromeDevTools Protocol.

# https://chromedevtools.github.io/devtools-protocol/tot/Network

experimental domain Network

depends on Runtime

# Resource type as it was perceived by the rendering engine.

type ResourceType extends string

enum

# Monotonically increasing time in seconds since an arbitrary point in the past.

type MonotonicTime extends number

# Information about the request initiator.

type Initiator extends object

properties

# Type of this initiator.

enum type

parser

script

preload

SignedExchange

preflight

other

# Initiator JavaScript stack trace, set for Script only.

# Requires the Debugger domain to be enabled.

optional Runtime.StackTrace stack

# Initiator URL, set for Parser type or for Script type (when script is importing module) or for SignedExchange type.

optional string url

# Initiator line number, set for Parser type or for Script type (when script is importing

# module) (0-based).

optional number lineNumber

# Initiator column number, set for Parser type or for Script type (when script is importing

# module) (0-based).

optional number columnNumber

# Set if another request triggered this request (e.g. preflight).

optional RequestId requestId

# HTTP request data.

type Request extends object

properties

RequestId requestId

# Request data.

Request request

# Request initiator.

Initiator initiator

# Timestamp.

MonotonicTime timestamp

# Timestamp.

"output": "node/inspector/protocol",

"namespace": ["node", "inspector", "protocol"]

},

"imported": {

"path": "../../deps/v8/include/js_protocol.pdl",

"header": "<v8-inspector-protocol.h>",

"namespace": ["v8_inspector", "protocol"],

"options": [

{

"domain": "Runtime",

"imported": ["StackTrace"]

}

]

},

"exported": {

"package": "include/inspector",

"output": "../../include/inspector",

}

runtime_agent_ = std::make_unique<protocol::RuntimeAgent>();

runtime_agent_->Wire(node_dispatcher_.get());

network_inspector_ = std::make_unique<NetworkInspector>(env);

network_inspector_ =

std::make_unique<NetworkInspector>(env, inspector.get());

network_inspector_->Wire(node_dispatcher_.get());

}