devtools-protocol 0.0.1453708 → 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.",
@@ -23372,6 +23560,17 @@
                         "excessiveReports"
                     ]
                 },
+                {
+                    "id": "AttributionReportingReportResult",
+                    "experimental": true,
+                    "type": "string",
+                    "enum": [
+                        "sent",
+                        "prohibited",
+                        "failedToAssemble",
+                        "expired"
+                    ]
+                },
                 {
                     "id": "RelatedWebsiteSet",
                     "description": "A single Related Website Set object.",
@@ -24263,6 +24462,40 @@
                             "$ref": "AttributionReportingAggregatableResult"
                         }
                     ]
+                },
+                {
+                    "name": "attributionReportingReportSent",
+                    "experimental": true,
+                    "parameters": [
+                        {
+                            "name": "url",
+                            "type": "string"
+                        },
+                        {
+                            "name": "body",
+                            "type": "object"
+                        },
+                        {
+                            "name": "result",
+                            "$ref": "AttributionReportingReportResult"
+                        },
+                        {
+                            "name": "netError",
+                            "description": "If result is `sent`, populated with net/HTTP status.",
+                            "optional": true,
+                            "type": "integer"
+                        },
+                        {
+                            "name": "netErrorName",
+                            "optional": true,
+                            "type": "string"
+                        },
+                        {
+                            "name": "httpStatusCode",
+                            "optional": true,
+                            "type": "integer"
+                        }
+                    ]
                 }
             ]
         },
@@ -28169,6 +28402,15 @@
                         "unsubscribe-from-notifications"
                     ]
                 },
+                {
+                    "id": "DescriptorOperationType",
+                    "description": "Indicates the various types of descriptor operation.",
+                    "type": "string",
+                    "enum": [
+                        "read",
+                        "write"
+                    ]
+                },
                 {
                     "id": "ManufacturerData",
                     "description": "Stores the manufacturer data",
@@ -28405,6 +28647,29 @@
                         }
                     ]
                 },
+                {
+                    "name": "simulateDescriptorOperationResponse",
+                    "description": "Simulates the response from the descriptor with |descriptorId| for a\ndescriptor operation of |type|. The |code| value follows the Error\nCodes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.\nThe |data| is expected to exist when simulating a successful read operation\nresponse.",
+                    "parameters": [
+                        {
+                            "name": "descriptorId",
+                            "type": "string"
+                        },
+                        {
+                            "name": "type",
+                            "$ref": "DescriptorOperationType"
+                        },
+                        {
+                            "name": "code",
+                            "type": "integer"
+                        },
+                        {
+                            "name": "data",
+                            "optional": true,
+                            "type": "string"
+                        }
+                    ]
+                },
                 {
                     "name": "addService",
                     "description": "Adds a service with |serviceUuid| to the peripheral with |address|.",
@@ -28501,6 +28766,16 @@
                             "type": "string"
                         }
                     ]
+                },
+                {
+                    "name": "simulateGATTDisconnection",
+                    "description": "Simulates a GATT disconnection from the peripheral with |address|.",
+                    "parameters": [
+                        {
+                            "name": "address",
+                            "type": "string"
+                        }
+                    ]
                 }
             ],
             "events": [
@@ -28541,6 +28816,25 @@
                             "$ref": "CharacteristicWriteType"
                         }
                     ]
+                },
+                {
+                    "name": "descriptorOperationReceived",
+                    "description": "Event for when a descriptor operation of |type| to the descriptor\nrespresented by |descriptorId| happened. |data| is expected to exist when\n|type| is write.",
+                    "parameters": [
+                        {
+                            "name": "descriptorId",
+                            "type": "string"
+                        },
+                        {
+                            "name": "type",
+                            "$ref": "CharacteristicOperationType"
+                        },
+                        {
+                            "name": "data",
+                            "optional": true,
+                            "type": "string"
+                        }
+                    ]
                 }
             ]
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devtools-protocol",
-  "version": "0.0.1453708",
+  "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
@@ -11380,6 +11444,28 @@ experimental domain Storage
       AttributionReportingEventLevelResult eventLevel
       AttributionReportingAggregatableResult aggregatable
 
+  experimental type AttributionReportingReportResult extends string
+    enum
+      # A network request was attempted for the report.
+      sent
+      # No request was attempted because of browser policy.
+      prohibited
+      # No request was attempted because of an error in report assembly,
+      # e.g. the aggregation service was unavailable.
+      failedToAssemble
+      # No request was attempted because the report's expiry passed.
+      expired
+
+  experimental event attributionReportingReportSent
+    parameters
+      string url
+      object body
+      AttributionReportingReportResult result
+      # If result is `sent`, populated with net/HTTP status.
+      optional integer netError
+      optional string netErrorName
+      optional integer httpStatusCode
+
   # A single Related Website Set object.
   experimental type RelatedWebsiteSet extends object
     properties
@@ -13385,6 +13471,12 @@ experimental domain BluetoothEmulation
       subscribe-to-notifications
       unsubscribe-from-notifications
 
+  # Indicates the various types of descriptor operation.
+  type DescriptorOperationType extends string
+    enum
+      read
+      write
+
   # Stores the manufacturer data
   type ManufacturerData extends object
     properties
@@ -13481,6 +13573,18 @@ experimental domain BluetoothEmulation
       integer code
       optional binary data
 
+  # Simulates the response from the descriptor with |descriptorId| for a
+  # descriptor operation of |type|. The |code| value follows the Error
+  # Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+  # The |data| is expected to exist when simulating a successful read operation
+  # response.
+  command simulateDescriptorOperationResponse
+    parameters
+      string descriptorId
+      DescriptorOperationType type
+      integer code
+      optional binary data
+
   # Adds a service with |serviceUuid| to the peripheral with |address|.
   command addService
     parameters
@@ -13527,6 +13631,11 @@ experimental domain BluetoothEmulation
     parameters
       string descriptorId
 
+  # Simulates a GATT disconnection from the peripheral with |address|.
+  command simulateGATTDisconnection
+    parameters
+      string address
+
   # Event for when a GATT operation of |type| to the peripheral with |address|
   # happened.
   event gattOperationReceived
@@ -13543,3 +13652,12 @@ experimental domain BluetoothEmulation
       CharacteristicOperationType type
       optional binary data
       optional CharacteristicWriteType writeType
+
+  # Event for when a descriptor operation of |type| to the descriptor
+  # respresented by |descriptorId| happened. |data| is expected to exist when
+  # |type| is write.
+  event descriptorOperationReceived
+    parameters
+      string descriptorId
+      CharacteristicOperationType type
+      optional binary data

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.
+         * Fired upon direct_socket.UDPSocket creation.
          */
-        'Network.directTCPSocketChunkError': [Protocol.Network.DirectTCPSocketChunkErrorEvent];
+        '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
@@ -645,6 +660,7 @@ export namespace ProtocolMapping {
         'Storage.storageBucketDeleted': [Protocol.Storage.StorageBucketDeletedEvent];
         'Storage.attributionReportingSourceRegistered': [Protocol.Storage.AttributionReportingSourceRegisteredEvent];
         'Storage.attributionReportingTriggerRegistered': [Protocol.Storage.AttributionReportingTriggerRegisteredEvent];
+        'Storage.attributionReportingReportSent': [Protocol.Storage.AttributionReportingReportSentEvent];
         /**
          * Issued when attached to target because of auto-attach or `attachToTarget` command.
          */
@@ -847,6 +863,12 @@ export namespace ProtocolMapping {
          * expected to exist when |type| is write.
          */
         'BluetoothEmulation.characteristicOperationReceived': [Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent];
+        /**
+         * Event for when a descriptor operation of |type| to the descriptor
+         * respresented by |descriptorId| happened. |data| is expected to exist when
+         * |type| is write.
+         */
+        'BluetoothEmulation.descriptorOperationReceived': [Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent];
     }
 
     export interface Commands {
@@ -5365,6 +5387,17 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest];
             returnType: void;
         };
+        /**
+         * Simulates the response from the descriptor with |descriptorId| for a
+         * descriptor operation of |type|. The |code| value follows the Error
+         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+         * The |data| is expected to exist when simulating a successful read operation
+         * response.
+         */
+        'BluetoothEmulation.simulateDescriptorOperationResponse': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest];
+            returnType: void;
+        };
         /**
          * Adds a service with |serviceUuid| to the peripheral with |address|.
          */
@@ -5410,6 +5443,13 @@ export namespace ProtocolMapping {
             paramsType: [Protocol.BluetoothEmulation.RemoveDescriptorRequest];
             returnType: void;
         };
+        /**
+         * Simulates a GATT disconnection from the peripheral with |address|.
+         */
+        'BluetoothEmulation.simulateGATTDisconnection': {
+            paramsType: [Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest];
+            returnType: void;
+        };
     }
 }
 

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.
+         * Fired upon direct_socket.UDPSocket creation.
          */
-        on(event: 'directTCPSocketChunkError', listener: (params: Protocol.Network.DirectTCPSocketChunkErrorEvent) => void): void;
+        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
@@ -3832,6 +3852,8 @@ export namespace ProtocolProxyApi {
 
         on(event: 'attributionReportingTriggerRegistered', listener: (params: Protocol.Storage.AttributionReportingTriggerRegisteredEvent) => void): void;
 
+        on(event: 'attributionReportingReportSent', listener: (params: Protocol.Storage.AttributionReportingReportSentEvent) => void): void;
+
     }
 
     export interface SystemInfoApi {
@@ -4579,6 +4601,15 @@ export namespace ProtocolProxyApi {
          */
         simulateCharacteristicOperationResponse(params: Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest): Promise<void>;
 
+        /**
+         * Simulates the response from the descriptor with |descriptorId| for a
+         * descriptor operation of |type|. The |code| value follows the Error
+         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+         * The |data| is expected to exist when simulating a successful read operation
+         * response.
+         */
+        simulateDescriptorOperationResponse(params: Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest): Promise<void>;
+
         /**
          * Adds a service with |serviceUuid| to the peripheral with |address|.
          */
@@ -4612,6 +4643,11 @@ export namespace ProtocolProxyApi {
          */
         removeDescriptor(params: Protocol.BluetoothEmulation.RemoveDescriptorRequest): Promise<void>;
 
+        /**
+         * Simulates a GATT disconnection from the peripheral with |address|.
+         */
+        simulateGATTDisconnection(params: Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest): Promise<void>;
+
         /**
          * Event for when a GATT operation of |type| to the peripheral with |address|
          * happened.
@@ -4625,6 +4661,13 @@ export namespace ProtocolProxyApi {
          */
         on(event: 'characteristicOperationReceived', listener: (params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent) => void): void;
 
+        /**
+         * Event for when a descriptor operation of |type| to the descriptor
+         * respresented by |descriptorId| happened. |data| is expected to exist when
+         * |type| is write.
+         */
+        on(event: 'descriptorOperationReceived', listener: (params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent) => void): void;
+
     }
 }
 

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.
+         * Fired upon direct_socket.UDPSocket creation.
          */
-        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 }>;
+        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
@@ -4154,6 +4184,10 @@ export namespace ProtocolTestsProxyApi {
         offAttributionReportingTriggerRegistered(listener: (event: { params: Protocol.Storage.AttributionReportingTriggerRegisteredEvent }) => void): void;
         onceAttributionReportingTriggerRegistered(eventMatcher?: (event: { params: Protocol.Storage.AttributionReportingTriggerRegisteredEvent }) => boolean): Promise<{ params: Protocol.Storage.AttributionReportingTriggerRegisteredEvent }>;
 
+        onAttributionReportingReportSent(listener: (event: { params: Protocol.Storage.AttributionReportingReportSentEvent }) => void): void;
+        offAttributionReportingReportSent(listener: (event: { params: Protocol.Storage.AttributionReportingReportSentEvent }) => void): void;
+        onceAttributionReportingReportSent(eventMatcher?: (event: { params: Protocol.Storage.AttributionReportingReportSentEvent }) => boolean): Promise<{ params: Protocol.Storage.AttributionReportingReportSentEvent }>;
+
     }
 
     export interface SystemInfoApi {
@@ -4989,6 +5023,15 @@ export namespace ProtocolTestsProxyApi {
          */
         simulateCharacteristicOperationResponse(params: Protocol.BluetoothEmulation.SimulateCharacteristicOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
 
+        /**
+         * Simulates the response from the descriptor with |descriptorId| for a
+         * descriptor operation of |type|. The |code| value follows the Error
+         * Codes from Bluetooth Core Specification Vol 3 Part F 3.4.1.1 Error Response.
+         * The |data| is expected to exist when simulating a successful read operation
+         * response.
+         */
+        simulateDescriptorOperationResponse(params: Protocol.BluetoothEmulation.SimulateDescriptorOperationResponseRequest): Promise<{id: number, result: void, sessionId: string}>;
+
         /**
          * Adds a service with |serviceUuid| to the peripheral with |address|.
          */
@@ -5022,6 +5065,11 @@ export namespace ProtocolTestsProxyApi {
          */
         removeDescriptor(params: Protocol.BluetoothEmulation.RemoveDescriptorRequest): Promise<{id: number, result: void, sessionId: string}>;
 
+        /**
+         * Simulates a GATT disconnection from the peripheral with |address|.
+         */
+        simulateGATTDisconnection(params: Protocol.BluetoothEmulation.SimulateGATTDisconnectionRequest): Promise<{id: number, result: void, sessionId: string}>;
+
         /**
          * Event for when a GATT operation of |type| to the peripheral with |address|
          * happened.
@@ -5039,6 +5087,15 @@ export namespace ProtocolTestsProxyApi {
         offCharacteristicOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => void): void;
         onceCharacteristicOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.CharacteristicOperationReceivedEvent }>;
 
+        /**
+         * Event for when a descriptor operation of |type| to the descriptor
+         * respresented by |descriptorId| happened. |data| is expected to exist when
+         * |type| is write.
+         */
+        onDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
+        offDescriptorOperationReceived(listener: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => void): void;
+        onceDescriptorOperationReceived(eventMatcher?: (event: { params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }) => boolean): Promise<{ params: Protocol.BluetoothEmulation.DescriptorOperationReceivedEvent }>;
+
     }
 }
 

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 DirectUDPSocketCreatedEvent {
+            identifier: RequestId;
+            options: DirectUDPSocketOptions;
+            timestamp: MonotonicTime;
+            initiator?: Initiator;
+        }
+
+        /**
+         * Fired when direct_socket.UDPSocket connection is opened.
          */
-        export interface DirectTCPSocketChunkErrorEvent {
+        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
@@ -16826,6 +16914,8 @@ export namespace Protocol {
 
         export type AttributionReportingAggregatableResult = ('success' | 'internalError' | 'noCapacityForAttributionDestination' | 'noMatchingSources' | 'excessiveAttributions' | 'excessiveReportingOrigins' | 'noHistograms' | 'insufficientBudget' | 'insufficientNamedBudget' | 'noMatchingSourceFilterData' | 'notRegistered' | 'prohibitedByBrowserPolicy' | 'deduplicated' | 'reportWindowPassed' | 'excessiveReports');
 
+        export type AttributionReportingReportResult = ('sent' | 'prohibited' | 'failedToAssemble' | 'expired');
+
         /**
          * A single Related Website Set object.
          */
@@ -17345,6 +17435,18 @@ export namespace Protocol {
             eventLevel: AttributionReportingEventLevelResult;
             aggregatable: AttributionReportingAggregatableResult;
         }
+
+        export interface AttributionReportingReportSentEvent {
+            url: string;
+            body: any;
+            result: AttributionReportingReportResult;
+            /**
+             * If result is `sent`, populated with net/HTTP status.
+             */
+            netError?: integer;
+            netErrorName?: string;
+            httpStatusCode?: integer;
+        }
     }
 
     /**
@@ -19664,6 +19766,11 @@ export namespace Protocol {
          */
         export type CharacteristicOperationType = ('read' | 'write' | 'subscribe-to-notifications' | 'unsubscribe-from-notifications');
 
+        /**
+         * Indicates the various types of descriptor operation.
+         */
+        export type DescriptorOperationType = ('read' | 'write');
+
         /**
          * Stores the manufacturer data
          */
@@ -19767,6 +19874,13 @@ export namespace Protocol {
             data?: string;
         }
 
+        export interface SimulateDescriptorOperationResponseRequest {
+            descriptorId: string;
+            type: DescriptorOperationType;
+            code: integer;
+            data?: string;
+        }
+
         export interface AddServiceRequest {
             address: string;
             serviceUuid: string;
@@ -19816,6 +19930,10 @@ export namespace Protocol {
             descriptorId: string;
         }
 
+        export interface SimulateGATTDisconnectionRequest {
+            address: string;
+        }
+
         /**
          * Event for when a GATT operation of |type| to the peripheral with |address|
          * happened.
@@ -19836,6 +19954,17 @@ export namespace Protocol {
             data?: string;
             writeType?: CharacteristicWriteType;
         }
+
+        /**
+         * Event for when a descriptor operation of |type| to the descriptor
+         * respresented by |descriptorId| happened. |data| is expected to exist when
+         * |type| is write.
+         */
+        export interface DescriptorOperationReceivedEvent {
+            descriptorId: string;
+            type: CharacteristicOperationType;
+            data?: string;
+        }
     }
 }