devtools-protocol 0.0.1446921 → 0.0.1447524

package/json/browser_protocol.json

@@ -16330,6 +16330,63 @@
                         }
                     ]
                 },
+                {
+                    "name": "directTCPSocketChunkSent",
+                    "description": "Fired when data is sent to tcp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "data",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directTCPSocketChunkReceived",
+                    "description": "Fired when data is received from tcp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "data",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directTCPSocketChunkError",
+                    "description": "Fired when there is an error\nwhen writing to tcp direct socket stream.\nFor example, if user writes illegal type like string\ninstead of ArrayBuffer or ArrayBufferView.\nThere's no reporting for reading, because\nwe cannot know errors on the other side.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "errorMessage",
+                            "type": "string"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
                 {
                     "name": "requestWillBeSentExtraInfo",
                     "description": "Fired when additional information about a requestWillBeSent event is available from the\nnetwork stack. Not every requestWillBeSent event will have an additional\nrequestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent\nor requestWillBeSentExtraInfo will be fired first for the same request.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devtools-protocol",
-  "version": "0.0.1446921",
+  "version": "0.0.1447524",
   "description": "The Chrome DevTools Protocol JSON",
   "repository": "https://github.com/ChromeDevTools/devtools-protocol",
   "author": "The Chromium Authors",

package/pdl/browser_protocol.pdl

@@ -7512,6 +7512,32 @@ domain Network
       RequestId identifier
       MonotonicTime timestamp
 
+  # Fired when data is sent to tcp direct socket stream.
+  experimental event directTCPSocketChunkSent
+    parameters
+      RequestId identifier
+      binary data
+      MonotonicTime timestamp
+
+  # Fired when data is received from tcp direct socket stream.
+  experimental event directTCPSocketChunkReceived
+    parameters
+      RequestId identifier
+      binary data
+      MonotonicTime timestamp
+
+  # Fired when there is an error
+  # when writing to tcp direct socket stream.
+  # For example, if user writes illegal type like string
+  # instead of ArrayBuffer or ArrayBufferView.
+  # There's no reporting for reading, because
+  # we cannot know errors on the other side.
+  experimental event directTCPSocketChunkError
+    parameters
+      RequestId identifier
+      string errorMessage
+      MonotonicTime timestamp
+
   experimental type PrivateNetworkRequestPolicy extends string
     enum
       Allow

package/types/protocol-mapping.d.ts

@@ -367,6 +367,23 @@ export namespace ProtocolMapping {
          * Fired when direct_socket.TCPSocket is closed.
          */
         'Network.directTCPSocketClosed': [Protocol.Network.DirectTCPSocketClosedEvent];
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        'Network.directTCPSocketChunkSent': [Protocol.Network.DirectTCPSocketChunkSentEvent];
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        'Network.directTCPSocketChunkReceived': [Protocol.Network.DirectTCPSocketChunkReceivedEvent];
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        'Network.directTCPSocketChunkError': [Protocol.Network.DirectTCPSocketChunkErrorEvent];
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional

package/types/protocol-proxy-api.d.ts

@@ -2731,6 +2731,26 @@ export namespace ProtocolProxyApi {
          */
         on(event: 'directTCPSocketClosed', listener: (params: Protocol.Network.DirectTCPSocketClosedEvent) => void): void;
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        on(event: 'directTCPSocketChunkSent', listener: (params: Protocol.Network.DirectTCPSocketChunkSentEvent) => void): void;
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        on(event: 'directTCPSocketChunkReceived', listener: (params: Protocol.Network.DirectTCPSocketChunkReceivedEvent) => void): void;
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        on(event: 'directTCPSocketChunkError', listener: (params: Protocol.Network.DirectTCPSocketChunkErrorEvent) => void): void;
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional

package/types/protocol-tests-proxy-api.d.ts

@@ -2919,6 +2919,32 @@ export namespace ProtocolTestsProxyApi {
         offDirectTCPSocketClosed(listener: (event: { params: Protocol.Network.DirectTCPSocketClosedEvent }) => void): void;
         onceDirectTCPSocketClosed(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketClosedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketClosedEvent }>;
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        onDirectTCPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => void): void;
+        offDirectTCPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => void): void;
+        onceDirectTCPSocketChunkSent(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkSentEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkSentEvent }>;
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        onDirectTCPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => void): void;
+        offDirectTCPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => void): void;
+        onceDirectTCPSocketChunkReceived(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkReceivedEvent }>;
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        onDirectTCPSocketChunkError(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => void): void;
+        offDirectTCPSocketChunkError(listener: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => void): void;
+        onceDirectTCPSocketChunkError(eventMatcher?: (event: { params: Protocol.Network.DirectTCPSocketChunkErrorEvent }) => boolean): Promise<{ params: Protocol.Network.DirectTCPSocketChunkErrorEvent }>;
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional

package/types/protocol.d.ts

@@ -12819,6 +12819,38 @@ export namespace Protocol {
             timestamp: MonotonicTime;
         }
 
+        /**
+         * Fired when data is sent to tcp direct socket stream.
+         */
+        export interface DirectTCPSocketChunkSentEvent {
+            identifier: RequestId;
+            data: string;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when data is received from tcp direct socket stream.
+         */
+        export interface DirectTCPSocketChunkReceivedEvent {
+            identifier: RequestId;
+            data: string;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when there is an error
+         * when writing to tcp direct socket stream.
+         * For example, if user writes illegal type like string
+         * instead of ArrayBuffer or ArrayBufferView.
+         * There's no reporting for reading, because
+         * we cannot know errors on the other side.
+         */
+        export interface DirectTCPSocketChunkErrorEvent {
+            identifier: RequestId;
+            errorMessage: string;
+            timestamp: MonotonicTime;
+        }
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional