devtools-protocol 0.0.1454823 → 0.0.1456087

package/json/browser_protocol.json

@@ -14616,6 +14616,75 @@
                         }
                     ]
                 },
+                {
+                    "id": "DirectUDPSocketOptions",
+                    "experimental": true,
+                    "type": "object",
+                    "properties": [
+                        {
+                            "name": "remoteAddr",
+                            "optional": true,
+                            "type": "string"
+                        },
+                        {
+                            "name": "remotePort",
+                            "description": "Unsigned int 16.",
+                            "optional": true,
+                            "type": "integer"
+                        },
+                        {
+                            "name": "localAddr",
+                            "optional": true,
+                            "type": "string"
+                        },
+                        {
+                            "name": "localPort",
+                            "description": "Unsigned int 16.",
+                            "optional": true,
+                            "type": "integer"
+                        },
+                        {
+                            "name": "dnsQueryType",
+                            "optional": true,
+                            "$ref": "DirectSocketDnsQueryType"
+                        },
+                        {
+                            "name": "sendBufferSize",
+                            "description": "Expected to be unsigned integer.",
+                            "optional": true,
+                            "type": "number"
+                        },
+                        {
+                            "name": "receiveBufferSize",
+                            "description": "Expected to be unsigned integer.",
+                            "optional": true,
+                            "type": "number"
+                        }
+                    ]
+                },
+                {
+                    "id": "DirectUDPMessage",
+                    "experimental": true,
+                    "type": "object",
+                    "properties": [
+                        {
+                            "name": "data",
+                            "type": "string"
+                        },
+                        {
+                            "name": "remoteAddr",
+                            "description": "Null for connected mode.",
+                            "optional": true,
+                            "type": "string"
+                        },
+                        {
+                            "name": "remotePort",
+                            "description": "Null for connected mode.\nExpected to be unsigned integer.",
+                            "optional": true,
+                            "type": "integer"
+                        }
+                    ]
+                },
                 {
                     "id": "PrivateNetworkRequestPolicy",
                     "experimental": true,
@@ -15175,6 +15244,13 @@
                             "description": "Longest post body size (in bytes) that would be included in requestWillBeSent notification",
                             "optional": true,
                             "type": "integer"
+                        },
+                        {
+                            "name": "reportDirectSocketTraffic",
+                            "description": "Whether DirectSocket chunk send/receive events should be reported.",
+                            "experimental": true,
+                            "optional": true,
+                            "type": "boolean"
                         }
                     ]
                 },
@@ -16412,8 +16488,67 @@
                     ]
                 },
                 {
-                    "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.",
+                    "name": "directUDPSocketCreated",
+                    "description": "Fired upon direct_socket.UDPSocket creation.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "options",
+                            "$ref": "DirectUDPSocketOptions"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        },
+                        {
+                            "name": "initiator",
+                            "optional": true,
+                            "$ref": "Initiator"
+                        }
+                    ]
+                },
+                {
+                    "name": "directUDPSocketOpened",
+                    "description": "Fired when direct_socket.UDPSocket connection is opened.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "localAddr",
+                            "type": "string"
+                        },
+                        {
+                            "name": "localPort",
+                            "description": "Expected to be unsigned integer.",
+                            "type": "integer"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        },
+                        {
+                            "name": "remoteAddr",
+                            "optional": true,
+                            "type": "string"
+                        },
+                        {
+                            "name": "remotePort",
+                            "description": "Expected to be unsigned integer.",
+                            "optional": true,
+                            "type": "integer"
+                        }
+                    ]
+                },
+                {
+                    "name": "directUDPSocketAborted",
+                    "description": "Fired when direct_socket.UDPSocket is aborted.",
                     "experimental": true,
                     "parameters": [
                         {
@@ -16430,6 +16565,59 @@
                         }
                     ]
                 },
+                {
+                    "name": "directUDPSocketClosed",
+                    "description": "Fired when direct_socket.UDPSocket is closed.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directUDPSocketChunkSent",
+                    "description": "Fired when message is sent to udp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "message",
+                            "$ref": "DirectUDPMessage"
+                        },
+                        {
+                            "name": "timestamp",
+                            "$ref": "MonotonicTime"
+                        }
+                    ]
+                },
+                {
+                    "name": "directUDPSocketChunkReceived",
+                    "description": "Fired when message is received from udp direct socket stream.",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "identifier",
+                            "$ref": "RequestId"
+                        },
+                        {
+                            "name": "message",
+                            "$ref": "DirectUDPMessage"
+                        },
+                        {
+                            "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.1454823",
+  "version": "0.0.1456087",
   "description": "The Chrome DevTools Protocol JSON",
   "repository": "https://github.com/ChromeDevTools/devtools-protocol",
   "author": "The Chromium Authors",

package/pdl/browser_protocol.pdl

@@ -7018,6 +7018,8 @@ domain Network
       experimental optional integer maxResourceBufferSize
       # Longest post body size (in bytes) that would be included in requestWillBeSent notification
       optional integer maxPostDataSize
+      # Whether DirectSocket chunk send/receive events should be reported.
+      experimental optional boolean reportDirectSocketTraffic
 
   # Returns all browser cookies. Depending on the backend support, will return detailed cookie
   # information in the `cookies` field.
@@ -7549,18 +7551,80 @@ domain Network
       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
+  experimental type DirectUDPSocketOptions extends object
+    properties
+      optional string remoteAddr
+      # Unsigned int 16.
+      optional integer remotePort
+
+      optional string localAddr
+      # Unsigned int 16.
+      optional integer localPort
+
+      optional DirectSocketDnsQueryType dnsQueryType
+
+      # Expected to be unsigned integer.
+      optional number sendBufferSize
+      # Expected to be unsigned integer.
+      optional number receiveBufferSize
+
+
+  # Fired upon direct_socket.UDPSocket creation.
+  experimental event directUDPSocketCreated
+    parameters
+      RequestId identifier
+      DirectUDPSocketOptions options
+      MonotonicTime timestamp
+      optional Initiator initiator
+
+  # Fired when direct_socket.UDPSocket connection is opened.
+  experimental event directUDPSocketOpened
+    parameters
+      RequestId identifier
+      string localAddr
+      # Expected to be unsigned integer.
+      integer localPort
+      MonotonicTime timestamp
+      optional string remoteAddr
+      # Expected to be unsigned integer.
+      optional integer remotePort
+
+  # Fired when direct_socket.UDPSocket is aborted.
+  experimental event directUDPSocketAborted
     parameters
       RequestId identifier
       string errorMessage
       MonotonicTime timestamp
 
+  # Fired when direct_socket.UDPSocket is closed.
+  experimental event directUDPSocketClosed
+    parameters
+      RequestId identifier
+      MonotonicTime timestamp
+
+  experimental type DirectUDPMessage extends object
+    properties
+      binary data
+      # Null for connected mode.
+      optional string remoteAddr
+      # Null for connected mode.
+      # Expected to be unsigned integer.
+      optional integer remotePort
+
+  # Fired when message is sent to udp direct socket stream.
+  experimental event directUDPSocketChunkSent
+    parameters
+      RequestId identifier
+      DirectUDPMessage message
+      MonotonicTime timestamp
+
+  # Fired when message is received from udp direct socket stream.
+  experimental event directUDPSocketChunkReceived
+    parameters
+      RequestId identifier
+      DirectUDPMessage message
+      MonotonicTime timestamp
+
   experimental type PrivateNetworkRequestPolicy extends string
     enum
       Allow

package/types/protocol-mapping.d.ts

@@ -376,14 +376,29 @@ export namespace ProtocolMapping {
          */
         '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 upon direct_socket.UDPSocket creation.
+         */
+        'Network.directUDPSocketCreated': [Protocol.Network.DirectUDPSocketCreatedEvent];
+        /**
+         * Fired when direct_socket.UDPSocket connection is opened.
+         */
+        'Network.directUDPSocketOpened': [Protocol.Network.DirectUDPSocketOpenedEvent];
+        /**
+         * Fired when direct_socket.UDPSocket is aborted.
+         */
+        'Network.directUDPSocketAborted': [Protocol.Network.DirectUDPSocketAbortedEvent];
+        /**
+         * Fired when direct_socket.UDPSocket is closed.
+         */
+        'Network.directUDPSocketClosed': [Protocol.Network.DirectUDPSocketClosedEvent];
+        /**
+         * Fired when message is sent to udp direct socket stream.
+         */
+        'Network.directUDPSocketChunkSent': [Protocol.Network.DirectUDPSocketChunkSentEvent];
+        /**
+         * Fired when message is received from udp direct socket stream.
+         */
+        'Network.directUDPSocketChunkReceived': [Protocol.Network.DirectUDPSocketChunkReceivedEvent];
         /**
          * 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

@@ -2748,14 +2748,34 @@ export namespace ProtocolProxyApi {
         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 upon direct_socket.UDPSocket creation.
+         */
+        on(event: 'directUDPSocketCreated', listener: (params: Protocol.Network.DirectUDPSocketCreatedEvent) => void): void;
+
+        /**
+         * Fired when direct_socket.UDPSocket connection is opened.
+         */
+        on(event: 'directUDPSocketOpened', listener: (params: Protocol.Network.DirectUDPSocketOpenedEvent) => void): void;
+
+        /**
+         * Fired when direct_socket.UDPSocket is aborted.
+         */
+        on(event: 'directUDPSocketAborted', listener: (params: Protocol.Network.DirectUDPSocketAbortedEvent) => void): void;
+
+        /**
+         * Fired when direct_socket.UDPSocket is closed.
+         */
+        on(event: 'directUDPSocketClosed', listener: (params: Protocol.Network.DirectUDPSocketClosedEvent) => void): void;
+
+        /**
+         * Fired when message is sent to udp direct socket stream.
+         */
+        on(event: 'directUDPSocketChunkSent', listener: (params: Protocol.Network.DirectUDPSocketChunkSentEvent) => void): void;
+
+        /**
+         * Fired when message is received from udp direct socket stream.
+         */
+        on(event: 'directUDPSocketChunkReceived', listener: (params: Protocol.Network.DirectUDPSocketChunkReceivedEvent) => void): void;
 
         /**
          * Fired when additional information about a requestWillBeSent event is available from the

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

@@ -2940,16 +2940,46 @@ export namespace ProtocolTestsProxyApi {
         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 upon direct_socket.UDPSocket creation.
+         */
+        onDirectUDPSocketCreated(listener: (event: { params: Protocol.Network.DirectUDPSocketCreatedEvent }) => void): void;
+        offDirectUDPSocketCreated(listener: (event: { params: Protocol.Network.DirectUDPSocketCreatedEvent }) => void): void;
+        onceDirectUDPSocketCreated(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketCreatedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketCreatedEvent }>;
+
+        /**
+         * Fired when direct_socket.UDPSocket connection is opened.
+         */
+        onDirectUDPSocketOpened(listener: (event: { params: Protocol.Network.DirectUDPSocketOpenedEvent }) => void): void;
+        offDirectUDPSocketOpened(listener: (event: { params: Protocol.Network.DirectUDPSocketOpenedEvent }) => void): void;
+        onceDirectUDPSocketOpened(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketOpenedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketOpenedEvent }>;
+
+        /**
+         * Fired when direct_socket.UDPSocket is aborted.
+         */
+        onDirectUDPSocketAborted(listener: (event: { params: Protocol.Network.DirectUDPSocketAbortedEvent }) => void): void;
+        offDirectUDPSocketAborted(listener: (event: { params: Protocol.Network.DirectUDPSocketAbortedEvent }) => void): void;
+        onceDirectUDPSocketAborted(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketAbortedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketAbortedEvent }>;
+
+        /**
+         * Fired when direct_socket.UDPSocket is closed.
+         */
+        onDirectUDPSocketClosed(listener: (event: { params: Protocol.Network.DirectUDPSocketClosedEvent }) => void): void;
+        offDirectUDPSocketClosed(listener: (event: { params: Protocol.Network.DirectUDPSocketClosedEvent }) => void): void;
+        onceDirectUDPSocketClosed(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketClosedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketClosedEvent }>;
+
+        /**
+         * Fired when message is sent to udp direct socket stream.
+         */
+        onDirectUDPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectUDPSocketChunkSentEvent }) => void): void;
+        offDirectUDPSocketChunkSent(listener: (event: { params: Protocol.Network.DirectUDPSocketChunkSentEvent }) => void): void;
+        onceDirectUDPSocketChunkSent(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketChunkSentEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketChunkSentEvent }>;
+
+        /**
+         * Fired when message is received from udp direct socket stream.
+         */
+        onDirectUDPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectUDPSocketChunkReceivedEvent }) => void): void;
+        offDirectUDPSocketChunkReceived(listener: (event: { params: Protocol.Network.DirectUDPSocketChunkReceivedEvent }) => void): void;
+        onceDirectUDPSocketChunkReceived(eventMatcher?: (event: { params: Protocol.Network.DirectUDPSocketChunkReceivedEvent }) => boolean): Promise<{ params: Protocol.Network.DirectUDPSocketChunkReceivedEvent }>;
 
         /**
          * Fired when additional information about a requestWillBeSent event is available from the

package/types/protocol.d.ts

@@ -11715,6 +11715,41 @@ export namespace Protocol {
             dnsQueryType?: DirectSocketDnsQueryType;
         }
 
+        export interface DirectUDPSocketOptions {
+            remoteAddr?: string;
+            /**
+             * Unsigned int 16.
+             */
+            remotePort?: integer;
+            localAddr?: string;
+            /**
+             * Unsigned int 16.
+             */
+            localPort?: integer;
+            dnsQueryType?: DirectSocketDnsQueryType;
+            /**
+             * Expected to be unsigned integer.
+             */
+            sendBufferSize?: number;
+            /**
+             * Expected to be unsigned integer.
+             */
+            receiveBufferSize?: number;
+        }
+
+        export interface DirectUDPMessage {
+            data: string;
+            /**
+             * Null for connected mode.
+             */
+            remoteAddr?: string;
+            /**
+             * Null for connected mode.
+             * Expected to be unsigned integer.
+             */
+            remotePort?: integer;
+        }
+
         export type PrivateNetworkRequestPolicy = ('Allow' | 'BlockFromInsecureToMorePrivate' | 'WarnFromInsecureToMorePrivate' | 'PreflightBlock' | 'PreflightWarn' | 'PermissionBlock' | 'PermissionWarn');
 
         export type IPAddressSpace = ('Local' | 'Private' | 'Public' | 'Unknown');
@@ -11986,6 +12021,10 @@ export namespace Protocol {
              * Longest post body size (in bytes) that would be included in requestWillBeSent notification
              */
             maxPostDataSize?: integer;
+            /**
+             * Whether DirectSocket chunk send/receive events should be reported.
+             */
+            reportDirectSocketTraffic?: boolean;
         }
 
         export interface GetAllCookiesResponse {
@@ -12861,19 +12900,68 @@ export namespace Protocol {
         }
 
         /**
-         * 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.
+         * Fired upon direct_socket.UDPSocket creation.
          */
-        export interface DirectTCPSocketChunkErrorEvent {
+        export interface DirectUDPSocketCreatedEvent {
+            identifier: RequestId;
+            options: DirectUDPSocketOptions;
+            timestamp: MonotonicTime;
+            initiator?: Initiator;
+        }
+
+        /**
+         * Fired when direct_socket.UDPSocket connection is opened.
+         */
+        export interface DirectUDPSocketOpenedEvent {
+            identifier: RequestId;
+            localAddr: string;
+            /**
+             * Expected to be unsigned integer.
+             */
+            localPort: integer;
+            timestamp: MonotonicTime;
+            remoteAddr?: string;
+            /**
+             * Expected to be unsigned integer.
+             */
+            remotePort?: integer;
+        }
+
+        /**
+         * Fired when direct_socket.UDPSocket is aborted.
+         */
+        export interface DirectUDPSocketAbortedEvent {
             identifier: RequestId;
             errorMessage: string;
             timestamp: MonotonicTime;
         }
 
+        /**
+         * Fired when direct_socket.UDPSocket is closed.
+         */
+        export interface DirectUDPSocketClosedEvent {
+            identifier: RequestId;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when message is sent to udp direct socket stream.
+         */
+        export interface DirectUDPSocketChunkSentEvent {
+            identifier: RequestId;
+            message: DirectUDPMessage;
+            timestamp: MonotonicTime;
+        }
+
+        /**
+         * Fired when message is received from udp direct socket stream.
+         */
+        export interface DirectUDPSocketChunkReceivedEvent {
+            identifier: RequestId;
+            message: DirectUDPMessage;
+            timestamp: MonotonicTime;
+        }
+
         /**
          * Fired when additional information about a requestWillBeSent event is available from the
          * network stack. Not every requestWillBeSent event will have an additional