Filip/playwright
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

feat(rpc): allow sending metadata with rpc calls (#3836)

Browse source 
Currently, metadata does only contain the stack trace,
and we send it from the JS client.
This commit is contained in:
Dmitry Gozman 2020-09-10 19:25:44 -07:00 committed by GitHub
parent d2771ebfea
commit 9e41518c92
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 189 additions and 163 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/client/channelOwner.ts
View file

@ -19,7 +19,7 @@ import * as channels from '../protocol/channels';
import type { Connection } from './connection'; import type { Connection } from './connection';
import type { Logger } from './types'; import type { Logger } from './types';
import { debugLogger } from '../utils/debugLogger'; import { debugLogger } from '../utils/debugLogger';
import { isUnderTest } from '../utils/utils'; import { rewriteErrorMessage } from '../utils/stackTrace';
export abstract class ChannelOwner<T extends channels.Channel = channels.Channel, Initializer = {}> extends EventEmitter { export abstract class ChannelOwner<T extends channels.Channel = channels.Channel, Initializer = {}> extends EventEmitter {
private _connection: Connection; private _connection: Connection;
@ -89,9 +89,6 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
} }
protected async _wrapApiCall<T>(apiName: string, func: () => Promise<T>, logger?: Logger): Promise<T> { protected async _wrapApiCall<T>(apiName: string, func: () => Promise<T>, logger?: Logger): Promise<T> {
const stackObject: any = {};
Error.captureStackTrace(stackObject);
const stack = stackObject.stack.startsWith('Error') ? stackObject.stack.substring(5) : stackObject.stack;
logger = logger || this._logger; logger = logger || this._logger;
try { try {
logApiCall(logger, `=> ${apiName} started`); logApiCall(logger, `=> ${apiName} started`);
@ -100,9 +97,7 @@ export abstract class ChannelOwner<T extends channels.Channel = channels.Channel
return result; return result;
} catch (e) { } catch (e) {
logApiCall(logger, `<= ${apiName} failed`); logApiCall(logger, `<= ${apiName} failed`);
const innerStack = (isUnderTest() && e.stack) ? e.stack.substring(e.stack.indexOf(e.message) + e.message.length) : ''; rewriteErrorMessage(e, `${apiName}: ` + e.message);
e.message = `${apiName}: ` + e.message;
e.stack = e.message + innerStack + stack;
throw e; throw e;
} }
} }

15
src/client/connection.ts
View file

@ -41,6 +41,7 @@ import { FirefoxBrowser } from './firefoxBrowser';
import { debugLogger } from '../utils/debugLogger'; import { debugLogger } from '../utils/debugLogger';
import { SelectorsOwner } from './selectors'; import { SelectorsOwner } from './selectors';
import { Video } from './video'; import { Video } from './video';
import { isUnderTest } from '../utils/utils';
class Root extends ChannelOwner<channels.Channel, {}> { class Root extends ChannelOwner<channels.Channel, {}> {
constructor(connection: Connection) { constructor(connection: Connection) {
@ -71,12 +72,22 @@ export class Connection {
} }
async sendMessageToServer(type: string, guid: string, method: string, params: any): Promise<any> { async sendMessageToServer(type: string, guid: string, method: string, params: any): Promise<any> {
const stackObject: any = {};
Error.captureStackTrace(stackObject);
const stack = stackObject.stack.startsWith('Error') ? stackObject.stack.substring(5) : stackObject.stack;
const id = ++this._lastId; const id = ++this._lastId;
const validated = method === 'debugScopeState' ? params : validateParams(type, method, params); const validated = method === 'debugScopeState' ? params : validateParams(type, method, params);
const converted = { id, guid, method, params: validated }; const converted = { id, guid, method, params: validated };
// Do not include metadata in debug logs to avoid noise.
debugLogger.log('channel:command', converted); debugLogger.log('channel:command', converted);
this.onmessage(converted); this.onmessage({ ...converted, metadata: { stack } });
return new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject })); try {
return await new Promise((resolve, reject) => this._callbacks.set(id, { resolve, reject }));
} catch (e) {
const innerStack = (isUnderTest() && e.stack) ? e.stack.substring(e.stack.indexOf(e.message) + e.message.length) : '';
e.stack = e.message + innerStack + stack;
throw e;
}
} }
_debugScopeState(): any { _debugScopeState(): any {

9
src/dispatchers/dispatcher.ts
View file

@ -19,6 +19,7 @@ import * as channels from '../protocol/channels';
import { serializeError } from '../protocol/serializers'; import { serializeError } from '../protocol/serializers';
import { createScheme, Validator, ValidationError } from '../protocol/validator'; import { createScheme, Validator, ValidationError } from '../protocol/validator';
import { assert, createGuid, debugAssert, isUnderTest } from '../utils/utils'; import { assert, createGuid, debugAssert, isUnderTest } from '../utils/utils';
import { tOptional } from '../protocol/validatorPrimitives';
export const dispatcherSymbol = Symbol('dispatcher'); export const dispatcherSymbol = Symbol('dispatcher');
@ -122,6 +123,7 @@ export class DispatcherConnection {
private _rootDispatcher: Root; private _rootDispatcher: Root;
onmessage = (message: object) => {}; onmessage = (message: object) => {};
private _validateParams: (type: string, method: string, params: any) => any; private _validateParams: (type: string, method: string, params: any) => any;
private _validateMetadata: (metadata: any) => any;
sendMessageToClient(guid: string, method: string, params: any, disallowDispatchers?: boolean) { sendMessageToClient(guid: string, method: string, params: any, disallowDispatchers?: boolean) {
const allowDispatchers = !disallowDispatchers; const allowDispatchers = !disallowDispatchers;
@ -152,6 +154,9 @@ export class DispatcherConnection {
throw new ValidationError(`Unknown scheme for ${type}.${method}`); throw new ValidationError(`Unknown scheme for ${type}.${method}`);
return scheme[name](params, ''); return scheme[name](params, '');
}; };
this._validateMetadata = (metadata: any): any => {
return tOptional(scheme['Metadata'])(metadata, '');
};
} }
rootDispatcher(): Dispatcher<any, any> { rootDispatcher(): Dispatcher<any, any> {
@ -159,7 +164,7 @@ export class DispatcherConnection {
} }
async dispatch(message: object) { async dispatch(message: object) {
const { id, guid, method, params } = message as any; const { id, guid, method, params, metadata } = message as any;
const dispatcher = this._dispatchers.get(guid); const dispatcher = this._dispatchers.get(guid);
if (!dispatcher) { if (!dispatcher) {
this.onmessage({ id, error: serializeError(new Error('Target browser or context has been closed')) }); this.onmessage({ id, error: serializeError(new Error('Target browser or context has been closed')) });
@ -171,7 +176,7 @@ export class DispatcherConnection {
} }
try { try {
const validated = this._validateParams(dispatcher._type, method, params); const validated = this._validateParams(dispatcher._type, method, params);
const result = await (dispatcher as any)[method](validated); const result = await (dispatcher as any)[method](validated, this._validateMetadata(metadata));
this.onmessage({ id, result: this._replaceDispatchersWithGuids(result, true) }); this.onmessage({ id, result: this._replaceDispatchersWithGuids(result, true) });
} catch (e) { } catch (e) {
this.onmessage({ id, error: serializeError(e) }); this.onmessage({ id, error: serializeError(e) });

306
src/protocol/channels.ts
View file

@ -23,6 +23,10 @@ export type Binary = string;
export interface Channel extends EventEmitter { export interface Channel extends EventEmitter {
} }
export type Metadata = {
stack?: string,
};
export type SerializedValue = { export type SerializedValue = {
n?: number, n?: number,
b?: boolean, b?: boolean,
@ -121,7 +125,7 @@ export interface RemoteBrowserChannel extends Channel {
// ----------- Selectors ----------- // ----------- Selectors -----------
export type SelectorsInitializer = {}; export type SelectorsInitializer = {};
export interface SelectorsChannel extends Channel { export interface SelectorsChannel extends Channel {
register(params: SelectorsRegisterParams): Promise<SelectorsRegisterResult>; register(params: SelectorsRegisterParams, metadata?: Metadata): Promise<SelectorsRegisterResult>;
} }
export type SelectorsRegisterParams = { export type SelectorsRegisterParams = {
name: string, name: string,
@ -139,8 +143,8 @@ export type BrowserTypeInitializer = {
name: string, name: string,
}; };
export interface BrowserTypeChannel extends Channel { export interface BrowserTypeChannel extends Channel {
launch(params: BrowserTypeLaunchParams): Promise<BrowserTypeLaunchResult>; launch(params: BrowserTypeLaunchParams, metadata?: Metadata): Promise<BrowserTypeLaunchResult>;
launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams): Promise<BrowserTypeLaunchPersistentContextResult>; launchPersistentContext(params: BrowserTypeLaunchPersistentContextParams, metadata?: Metadata): Promise<BrowserTypeLaunchPersistentContextResult>;
} }
export type BrowserTypeLaunchParams = { export type BrowserTypeLaunchParams = {
executablePath?: string, executablePath?: string,
@ -325,11 +329,11 @@ export type BrowserInitializer = {
}; };
export interface BrowserChannel extends Channel { export interface BrowserChannel extends Channel {
on(event: 'close', callback: (params: BrowserCloseEvent) => void): this; on(event: 'close', callback: (params: BrowserCloseEvent) => void): this;
close(params?: BrowserCloseParams): Promise<BrowserCloseResult>; close(params?: BrowserCloseParams, metadata?: Metadata): Promise<BrowserCloseResult>;
newContext(params: BrowserNewContextParams): Promise<BrowserNewContextResult>; newContext(params: BrowserNewContextParams, metadata?: Metadata): Promise<BrowserNewContextResult>;
crNewBrowserCDPSession(params?: BrowserCrNewBrowserCDPSessionParams): Promise<BrowserCrNewBrowserCDPSessionResult>; crNewBrowserCDPSession(params?: BrowserCrNewBrowserCDPSessionParams, metadata?: Metadata): Promise<BrowserCrNewBrowserCDPSessionResult>;
crStartTracing(params: BrowserCrStartTracingParams): Promise<BrowserCrStartTracingResult>; crStartTracing(params: BrowserCrStartTracingParams, metadata?: Metadata): Promise<BrowserCrStartTracingResult>;
crStopTracing(params?: BrowserCrStopTracingParams): Promise<BrowserCrStopTracingResult>; crStopTracing(params?: BrowserCrStopTracingParams, metadata?: Metadata): Promise<BrowserCrStopTracingResult>;
} }
export type BrowserCloseEvent = {}; export type BrowserCloseEvent = {};
export type BrowserCloseParams = {}; export type BrowserCloseParams = {};
@ -447,23 +451,23 @@ export interface BrowserContextChannel extends Channel {
on(event: 'route', callback: (params: BrowserContextRouteEvent) => void): this; on(event: 'route', callback: (params: BrowserContextRouteEvent) => void): this;
on(event: 'crBackgroundPage', callback: (params: BrowserContextCrBackgroundPageEvent) => void): this; on(event: 'crBackgroundPage', callback: (params: BrowserContextCrBackgroundPageEvent) => void): this;
on(event: 'crServiceWorker', callback: (params: BrowserContextCrServiceWorkerEvent) => void): this; on(event: 'crServiceWorker', callback: (params: BrowserContextCrServiceWorkerEvent) => void): this;
addCookies(params: BrowserContextAddCookiesParams): Promise<BrowserContextAddCookiesResult>; addCookies(params: BrowserContextAddCookiesParams, metadata?: Metadata): Promise<BrowserContextAddCookiesResult>;
addInitScript(params: BrowserContextAddInitScriptParams): Promise<BrowserContextAddInitScriptResult>; addInitScript(params: BrowserContextAddInitScriptParams, metadata?: Metadata): Promise<BrowserContextAddInitScriptResult>;
clearCookies(params?: BrowserContextClearCookiesParams): Promise<BrowserContextClearCookiesResult>; clearCookies(params?: BrowserContextClearCookiesParams, metadata?: Metadata): Promise<BrowserContextClearCookiesResult>;
clearPermissions(params?: BrowserContextClearPermissionsParams): Promise<BrowserContextClearPermissionsResult>; clearPermissions(params?: BrowserContextClearPermissionsParams, metadata?: Metadata): Promise<BrowserContextClearPermissionsResult>;
close(params?: BrowserContextCloseParams): Promise<BrowserContextCloseResult>; close(params?: BrowserContextCloseParams, metadata?: Metadata): Promise<BrowserContextCloseResult>;
cookies(params: BrowserContextCookiesParams): Promise<BrowserContextCookiesResult>; cookies(params: BrowserContextCookiesParams, metadata?: Metadata): Promise<BrowserContextCookiesResult>;
exposeBinding(params: BrowserContextExposeBindingParams): Promise<BrowserContextExposeBindingResult>; exposeBinding(params: BrowserContextExposeBindingParams, metadata?: Metadata): Promise<BrowserContextExposeBindingResult>;
grantPermissions(params: BrowserContextGrantPermissionsParams): Promise<BrowserContextGrantPermissionsResult>; grantPermissions(params: BrowserContextGrantPermissionsParams, metadata?: Metadata): Promise<BrowserContextGrantPermissionsResult>;
newPage(params?: BrowserContextNewPageParams): Promise<BrowserContextNewPageResult>; newPage(params?: BrowserContextNewPageParams, metadata?: Metadata): Promise<BrowserContextNewPageResult>;
setDefaultNavigationTimeoutNoReply(params: BrowserContextSetDefaultNavigationTimeoutNoReplyParams): Promise<BrowserContextSetDefaultNavigationTimeoutNoReplyResult>; setDefaultNavigationTimeoutNoReply(params: BrowserContextSetDefaultNavigationTimeoutNoReplyParams, metadata?: Metadata): Promise<BrowserContextSetDefaultNavigationTimeoutNoReplyResult>;
setDefaultTimeoutNoReply(params: BrowserContextSetDefaultTimeoutNoReplyParams): Promise<BrowserContextSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: BrowserContextSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<BrowserContextSetDefaultTimeoutNoReplyResult>;
setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams): Promise<BrowserContextSetExtraHTTPHeadersResult>; setExtraHTTPHeaders(params: BrowserContextSetExtraHTTPHeadersParams, metadata?: Metadata): Promise<BrowserContextSetExtraHTTPHeadersResult>;
setGeolocation(params: BrowserContextSetGeolocationParams): Promise<BrowserContextSetGeolocationResult>; setGeolocation(params: BrowserContextSetGeolocationParams, metadata?: Metadata): Promise<BrowserContextSetGeolocationResult>;
setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams): Promise<BrowserContextSetHTTPCredentialsResult>; setHTTPCredentials(params: BrowserContextSetHTTPCredentialsParams, metadata?: Metadata): Promise<BrowserContextSetHTTPCredentialsResult>;
setNetworkInterceptionEnabled(params: BrowserContextSetNetworkInterceptionEnabledParams): Promise<BrowserContextSetNetworkInterceptionEnabledResult>; setNetworkInterceptionEnabled(params: BrowserContextSetNetworkInterceptionEnabledParams, metadata?: Metadata): Promise<BrowserContextSetNetworkInterceptionEnabledResult>;
setOffline(params: BrowserContextSetOfflineParams): Promise<BrowserContextSetOfflineResult>; setOffline(params: BrowserContextSetOfflineParams, metadata?: Metadata): Promise<BrowserContextSetOfflineResult>;
crNewCDPSession(params: BrowserContextCrNewCDPSessionParams): Promise<BrowserContextCrNewCDPSessionResult>; crNewCDPSession(params: BrowserContextCrNewCDPSessionParams, metadata?: Metadata): Promise<BrowserContextCrNewCDPSessionResult>;
} }
export type BrowserContextBindingCallEvent = { export type BrowserContextBindingCallEvent = {
binding: BindingCallChannel, binding: BindingCallChannel,
@ -659,37 +663,37 @@ export interface PageChannel extends Channel {
on(event: 'route', callback: (params: PageRouteEvent) => void): this; on(event: 'route', callback: (params: PageRouteEvent) => void): this;
on(event: 'videoStarted', callback: (params: PageVideoStartedEvent) => void): this; on(event: 'videoStarted', callback: (params: PageVideoStartedEvent) => void): this;
on(event: 'worker', callback: (params: PageWorkerEvent) => void): this; on(event: 'worker', callback: (params: PageWorkerEvent) => void): this;
setDefaultNavigationTimeoutNoReply(params: PageSetDefaultNavigationTimeoutNoReplyParams): Promise<PageSetDefaultNavigationTimeoutNoReplyResult>; setDefaultNavigationTimeoutNoReply(params: PageSetDefaultNavigationTimeoutNoReplyParams, metadata?: Metadata): Promise<PageSetDefaultNavigationTimeoutNoReplyResult>;
setDefaultTimeoutNoReply(params: PageSetDefaultTimeoutNoReplyParams): Promise<PageSetDefaultTimeoutNoReplyResult>; setDefaultTimeoutNoReply(params: PageSetDefaultTimeoutNoReplyParams, metadata?: Metadata): Promise<PageSetDefaultTimeoutNoReplyResult>;
setFileChooserInterceptedNoReply(params: PageSetFileChooserInterceptedNoReplyParams): Promise<PageSetFileChooserInterceptedNoReplyResult>; setFileChooserInterceptedNoReply(params: PageSetFileChooserInterceptedNoReplyParams, metadata?: Metadata): Promise<PageSetFileChooserInterceptedNoReplyResult>;
addInitScript(params: PageAddInitScriptParams): Promise<PageAddInitScriptResult>; addInitScript(params: PageAddInitScriptParams, metadata?: Metadata): Promise<PageAddInitScriptResult>;
close(params: PageCloseParams): Promise<PageCloseResult>; close(params: PageCloseParams, metadata?: Metadata): Promise<PageCloseResult>;
emulateMedia(params: PageEmulateMediaParams): Promise<PageEmulateMediaResult>; emulateMedia(params: PageEmulateMediaParams, metadata?: Metadata): Promise<PageEmulateMediaResult>;
exposeBinding(params: PageExposeBindingParams): Promise<PageExposeBindingResult>; exposeBinding(params: PageExposeBindingParams, metadata?: Metadata): Promise<PageExposeBindingResult>;
goBack(params: PageGoBackParams): Promise<PageGoBackResult>; goBack(params: PageGoBackParams, metadata?: Metadata): Promise<PageGoBackResult>;
goForward(params: PageGoForwardParams): Promise<PageGoForwardResult>; goForward(params: PageGoForwardParams, metadata?: Metadata): Promise<PageGoForwardResult>;
opener(params?: PageOpenerParams): Promise<PageOpenerResult>; opener(params?: PageOpenerParams, metadata?: Metadata): Promise<PageOpenerResult>;
reload(params: PageReloadParams): Promise<PageReloadResult>; reload(params: PageReloadParams, metadata?: Metadata): Promise<PageReloadResult>;
screenshot(params: PageScreenshotParams): Promise<PageScreenshotResult>; screenshot(params: PageScreenshotParams, metadata?: Metadata): Promise<PageScreenshotResult>;
setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams): Promise<PageSetExtraHTTPHeadersResult>; setExtraHTTPHeaders(params: PageSetExtraHTTPHeadersParams, metadata?: Metadata): Promise<PageSetExtraHTTPHeadersResult>;
setNetworkInterceptionEnabled(params: PageSetNetworkInterceptionEnabledParams): Promise<PageSetNetworkInterceptionEnabledResult>; setNetworkInterceptionEnabled(params: PageSetNetworkInterceptionEnabledParams, metadata?: Metadata): Promise<PageSetNetworkInterceptionEnabledResult>;
setViewportSize(params: PageSetViewportSizeParams): Promise<PageSetViewportSizeResult>; setViewportSize(params: PageSetViewportSizeParams, metadata?: Metadata): Promise<PageSetViewportSizeResult>;
keyboardDown(params: PageKeyboardDownParams): Promise<PageKeyboardDownResult>; keyboardDown(params: PageKeyboardDownParams, metadata?: Metadata): Promise<PageKeyboardDownResult>;
keyboardUp(params: PageKeyboardUpParams): Promise<PageKeyboardUpResult>; keyboardUp(params: PageKeyboardUpParams, metadata?: Metadata): Promise<PageKeyboardUpResult>;
keyboardInsertText(params: PageKeyboardInsertTextParams): Promise<PageKeyboardInsertTextResult>; keyboardInsertText(params: PageKeyboardInsertTextParams, metadata?: Metadata): Promise<PageKeyboardInsertTextResult>;
keyboardType(params: PageKeyboardTypeParams): Promise<PageKeyboardTypeResult>; keyboardType(params: PageKeyboardTypeParams, metadata?: Metadata): Promise<PageKeyboardTypeResult>;
keyboardPress(params: PageKeyboardPressParams): Promise<PageKeyboardPressResult>; keyboardPress(params: PageKeyboardPressParams, metadata?: Metadata): Promise<PageKeyboardPressResult>;
mouseMove(params: PageMouseMoveParams): Promise<PageMouseMoveResult>; mouseMove(params: PageMouseMoveParams, metadata?: Metadata): Promise<PageMouseMoveResult>;
mouseDown(params: PageMouseDownParams): Promise<PageMouseDownResult>; mouseDown(params: PageMouseDownParams, metadata?: Metadata): Promise<PageMouseDownResult>;
mouseUp(params: PageMouseUpParams): Promise<PageMouseUpResult>; mouseUp(params: PageMouseUpParams, metadata?: Metadata): Promise<PageMouseUpResult>;
mouseClick(params: PageMouseClickParams): Promise<PageMouseClickResult>; mouseClick(params: PageMouseClickParams, metadata?: Metadata): Promise<PageMouseClickResult>;
accessibilitySnapshot(params: PageAccessibilitySnapshotParams): Promise<PageAccessibilitySnapshotResult>; accessibilitySnapshot(params: PageAccessibilitySnapshotParams, metadata?: Metadata): Promise<PageAccessibilitySnapshotResult>;
pdf(params: PagePdfParams): Promise<PagePdfResult>; pdf(params: PagePdfParams, metadata?: Metadata): Promise<PagePdfResult>;
crStartJSCoverage(params: PageCrStartJSCoverageParams): Promise<PageCrStartJSCoverageResult>; crStartJSCoverage(params: PageCrStartJSCoverageParams, metadata?: Metadata): Promise<PageCrStartJSCoverageResult>;
crStopJSCoverage(params?: PageCrStopJSCoverageParams): Promise<PageCrStopJSCoverageResult>; crStopJSCoverage(params?: PageCrStopJSCoverageParams, metadata?: Metadata): Promise<PageCrStopJSCoverageResult>;
crStartCSSCoverage(params: PageCrStartCSSCoverageParams): Promise<PageCrStartCSSCoverageResult>; crStartCSSCoverage(params: PageCrStartCSSCoverageParams, metadata?: Metadata): Promise<PageCrStartCSSCoverageResult>;
crStopCSSCoverage(params?: PageCrStopCSSCoverageParams): Promise<PageCrStopCSSCoverageResult>; crStopCSSCoverage(params?: PageCrStopCSSCoverageParams, metadata?: Metadata): Promise<PageCrStopCSSCoverageResult>;
bringToFront(params?: PageBringToFrontParams): Promise<PageBringToFrontResult>; bringToFront(params?: PageBringToFrontParams, metadata?: Metadata): Promise<PageBringToFrontResult>;
} }
export type PageBindingCallEvent = { export type PageBindingCallEvent = {
binding: BindingCallChannel, binding: BindingCallChannel,
@ -1080,38 +1084,38 @@ export type FrameInitializer = {
export interface FrameChannel extends Channel { export interface FrameChannel extends Channel {
on(event: 'loadstate', callback: (params: FrameLoadstateEvent) => void): this; on(event: 'loadstate', callback: (params: FrameLoadstateEvent) => void): this;
on(event: 'navigated', callback: (params: FrameNavigatedEvent) => void): this; on(event: 'navigated', callback: (params: FrameNavigatedEvent) => void): this;
evalOnSelector(params: FrameEvalOnSelectorParams): Promise<FrameEvalOnSelectorResult>; evalOnSelector(params: FrameEvalOnSelectorParams, metadata?: Metadata): Promise<FrameEvalOnSelectorResult>;
evalOnSelectorAll(params: FrameEvalOnSelectorAllParams): Promise<FrameEvalOnSelectorAllResult>; evalOnSelectorAll(params: FrameEvalOnSelectorAllParams, metadata?: Metadata): Promise<FrameEvalOnSelectorAllResult>;
addScriptTag(params: FrameAddScriptTagParams): Promise<FrameAddScriptTagResult>; addScriptTag(params: FrameAddScriptTagParams, metadata?: Metadata): Promise<FrameAddScriptTagResult>;
addStyleTag(params: FrameAddStyleTagParams): Promise<FrameAddStyleTagResult>; addStyleTag(params: FrameAddStyleTagParams, metadata?: Metadata): Promise<FrameAddStyleTagResult>;
check(params: FrameCheckParams): Promise<FrameCheckResult>; check(params: FrameCheckParams, metadata?: Metadata): Promise<FrameCheckResult>;
click(params: FrameClickParams): Promise<FrameClickResult>; click(params: FrameClickParams, metadata?: Metadata): Promise<FrameClickResult>;
content(params?: FrameContentParams): Promise<FrameContentResult>; content(params?: FrameContentParams, metadata?: Metadata): Promise<FrameContentResult>;
dblclick(params: FrameDblclickParams): Promise<FrameDblclickResult>; dblclick(params: FrameDblclickParams, metadata?: Metadata): Promise<FrameDblclickResult>;
dispatchEvent(params: FrameDispatchEventParams): Promise<FrameDispatchEventResult>; dispatchEvent(params: FrameDispatchEventParams, metadata?: Metadata): Promise<FrameDispatchEventResult>;
evaluateExpression(params: FrameEvaluateExpressionParams): Promise<FrameEvaluateExpressionResult>; evaluateExpression(params: FrameEvaluateExpressionParams, metadata?: Metadata): Promise<FrameEvaluateExpressionResult>;
evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams): Promise<FrameEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: FrameEvaluateExpressionHandleParams, metadata?: Metadata): Promise<FrameEvaluateExpressionHandleResult>;
fill(params: FrameFillParams): Promise<FrameFillResult>; fill(params: FrameFillParams, metadata?: Metadata): Promise<FrameFillResult>;
focus(params: FrameFocusParams): Promise<FrameFocusResult>; focus(params: FrameFocusParams, metadata?: Metadata): Promise<FrameFocusResult>;
frameElement(params?: FrameFrameElementParams): Promise<FrameFrameElementResult>; frameElement(params?: FrameFrameElementParams, metadata?: Metadata): Promise<FrameFrameElementResult>;
getAttribute(params: FrameGetAttributeParams): Promise<FrameGetAttributeResult>; getAttribute(params: FrameGetAttributeParams, metadata?: Metadata): Promise<FrameGetAttributeResult>;
goto(params: FrameGotoParams): Promise<FrameGotoResult>; goto(params: FrameGotoParams, metadata?: Metadata): Promise<FrameGotoResult>;
hover(params: FrameHoverParams): Promise<FrameHoverResult>; hover(params: FrameHoverParams, metadata?: Metadata): Promise<FrameHoverResult>;
innerHTML(params: FrameInnerHTMLParams): Promise<FrameInnerHTMLResult>; innerHTML(params: FrameInnerHTMLParams, metadata?: Metadata): Promise<FrameInnerHTMLResult>;
innerText(params: FrameInnerTextParams): Promise<FrameInnerTextResult>; innerText(params: FrameInnerTextParams, metadata?: Metadata): Promise<FrameInnerTextResult>;
press(params: FramePressParams): Promise<FramePressResult>; press(params: FramePressParams, metadata?: Metadata): Promise<FramePressResult>;
querySelector(params: FrameQuerySelectorParams): Promise<FrameQuerySelectorResult>; querySelector(params: FrameQuerySelectorParams, metadata?: Metadata): Promise<FrameQuerySelectorResult>;
querySelectorAll(params: FrameQuerySelectorAllParams): Promise<FrameQuerySelectorAllResult>; querySelectorAll(params: FrameQuerySelectorAllParams, metadata?: Metadata): Promise<FrameQuerySelectorAllResult>;
selectOption(params: FrameSelectOptionParams): Promise<FrameSelectOptionResult>; selectOption(params: FrameSelectOptionParams, metadata?: Metadata): Promise<FrameSelectOptionResult>;
setContent(params: FrameSetContentParams): Promise<FrameSetContentResult>; setContent(params: FrameSetContentParams, metadata?: Metadata): Promise<FrameSetContentResult>;
setInputFiles(params: FrameSetInputFilesParams): Promise<FrameSetInputFilesResult>; setInputFiles(params: FrameSetInputFilesParams, metadata?: Metadata): Promise<FrameSetInputFilesResult>;
textContent(params: FrameTextContentParams): Promise<FrameTextContentResult>; textContent(params: FrameTextContentParams, metadata?: Metadata): Promise<FrameTextContentResult>;
title(params?: FrameTitleParams): Promise<FrameTitleResult>; title(params?: FrameTitleParams, metadata?: Metadata): Promise<FrameTitleResult>;
type(params: FrameTypeParams): Promise<FrameTypeResult>; type(params: FrameTypeParams, metadata?: Metadata): Promise<FrameTypeResult>;
uncheck(params: FrameUncheckParams): Promise<FrameUncheckResult>; uncheck(params: FrameUncheckParams, metadata?: Metadata): Promise<FrameUncheckResult>;
waitForFunction(params: FrameWaitForFunctionParams): Promise<FrameWaitForFunctionResult>; waitForFunction(params: FrameWaitForFunctionParams, metadata?: Metadata): Promise<FrameWaitForFunctionResult>;
waitForSelector(params: FrameWaitForSelectorParams): Promise<FrameWaitForSelectorResult>; waitForSelector(params: FrameWaitForSelectorParams, metadata?: Metadata): Promise<FrameWaitForSelectorResult>;
extendInjectedScript(params: FrameExtendInjectedScriptParams): Promise<FrameExtendInjectedScriptResult>; extendInjectedScript(params: FrameExtendInjectedScriptParams, metadata?: Metadata): Promise<FrameExtendInjectedScriptResult>;
} }
export type FrameLoadstateEvent = { export type FrameLoadstateEvent = {
add?: 'load' | 'domcontentloaded' | 'networkidle', add?: 'load' | 'domcontentloaded' | 'networkidle',
@ -1528,8 +1532,8 @@ export type WorkerInitializer = {
}; };
export interface WorkerChannel extends Channel { export interface WorkerChannel extends Channel {
on(event: 'close', callback: (params: WorkerCloseEvent) => void): this; on(event: 'close', callback: (params: WorkerCloseEvent) => void): this;
evaluateExpression(params: WorkerEvaluateExpressionParams): Promise<WorkerEvaluateExpressionResult>; evaluateExpression(params: WorkerEvaluateExpressionParams, metadata?: Metadata): Promise<WorkerEvaluateExpressionResult>;
evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams): Promise<WorkerEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: WorkerEvaluateExpressionHandleParams, metadata?: Metadata): Promise<WorkerEvaluateExpressionHandleResult>;
} }
export type WorkerCloseEvent = {}; export type WorkerCloseEvent = {};
export type WorkerEvaluateExpressionParams = { export type WorkerEvaluateExpressionParams = {
@ -1561,12 +1565,12 @@ export type JSHandleInitializer = {
}; };
export interface JSHandleChannel extends Channel { export interface JSHandleChannel extends Channel {
on(event: 'previewUpdated', callback: (params: JSHandlePreviewUpdatedEvent) => void): this; on(event: 'previewUpdated', callback: (params: JSHandlePreviewUpdatedEvent) => void): this;
dispose(params?: JSHandleDisposeParams): Promise<JSHandleDisposeResult>; dispose(params?: JSHandleDisposeParams, metadata?: Metadata): Promise<JSHandleDisposeResult>;
evaluateExpression(params: JSHandleEvaluateExpressionParams): Promise<JSHandleEvaluateExpressionResult>; evaluateExpression(params: JSHandleEvaluateExpressionParams, metadata?: Metadata): Promise<JSHandleEvaluateExpressionResult>;
evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams): Promise<JSHandleEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: JSHandleEvaluateExpressionHandleParams, metadata?: Metadata): Promise<JSHandleEvaluateExpressionHandleResult>;
getPropertyList(params?: JSHandleGetPropertyListParams): Promise<JSHandleGetPropertyListResult>; getPropertyList(params?: JSHandleGetPropertyListParams, metadata?: Metadata): Promise<JSHandleGetPropertyListResult>;
getProperty(params: JSHandleGetPropertyParams): Promise<JSHandleGetPropertyResult>; getProperty(params: JSHandleGetPropertyParams, metadata?: Metadata): Promise<JSHandleGetPropertyResult>;
jsonValue(params?: JSHandleJsonValueParams): Promise<JSHandleJsonValueResult>; jsonValue(params?: JSHandleJsonValueParams, metadata?: Metadata): Promise<JSHandleJsonValueResult>;
} }
export type JSHandlePreviewUpdatedEvent = { export type JSHandlePreviewUpdatedEvent = {
preview: string, preview: string,
@ -1622,35 +1626,35 @@ export type JSHandleJsonValueResult = {
// ----------- ElementHandle ----------- // ----------- ElementHandle -----------
export type ElementHandleInitializer = {}; export type ElementHandleInitializer = {};
export interface ElementHandleChannel extends JSHandleChannel { export interface ElementHandleChannel extends JSHandleChannel {
evalOnSelector(params: ElementHandleEvalOnSelectorParams): Promise<ElementHandleEvalOnSelectorResult>; evalOnSelector(params: ElementHandleEvalOnSelectorParams, metadata?: Metadata): Promise<ElementHandleEvalOnSelectorResult>;
evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams): Promise<ElementHandleEvalOnSelectorAllResult>; evalOnSelectorAll(params: ElementHandleEvalOnSelectorAllParams, metadata?: Metadata): Promise<ElementHandleEvalOnSelectorAllResult>;
boundingBox(params?: ElementHandleBoundingBoxParams): Promise<ElementHandleBoundingBoxResult>; boundingBox(params?: ElementHandleBoundingBoxParams, metadata?: Metadata): Promise<ElementHandleBoundingBoxResult>;
check(params: ElementHandleCheckParams): Promise<ElementHandleCheckResult>; check(params: ElementHandleCheckParams, metadata?: Metadata): Promise<ElementHandleCheckResult>;
click(params: ElementHandleClickParams): Promise<ElementHandleClickResult>; click(params: ElementHandleClickParams, metadata?: Metadata): Promise<ElementHandleClickResult>;
contentFrame(params?: ElementHandleContentFrameParams): Promise<ElementHandleContentFrameResult>; contentFrame(params?: ElementHandleContentFrameParams, metadata?: Metadata): Promise<ElementHandleContentFrameResult>;
dblclick(params: ElementHandleDblclickParams): Promise<ElementHandleDblclickResult>; dblclick(params: ElementHandleDblclickParams, metadata?: Metadata): Promise<ElementHandleDblclickResult>;
dispatchEvent(params: ElementHandleDispatchEventParams): Promise<ElementHandleDispatchEventResult>; dispatchEvent(params: ElementHandleDispatchEventParams, metadata?: Metadata): Promise<ElementHandleDispatchEventResult>;
fill(params: ElementHandleFillParams): Promise<ElementHandleFillResult>; fill(params: ElementHandleFillParams, metadata?: Metadata): Promise<ElementHandleFillResult>;
focus(params?: ElementHandleFocusParams): Promise<ElementHandleFocusResult>; focus(params?: ElementHandleFocusParams, metadata?: Metadata): Promise<ElementHandleFocusResult>;
getAttribute(params: ElementHandleGetAttributeParams): Promise<ElementHandleGetAttributeResult>; getAttribute(params: ElementHandleGetAttributeParams, metadata?: Metadata): Promise<ElementHandleGetAttributeResult>;
hover(params: ElementHandleHoverParams): Promise<ElementHandleHoverResult>; hover(params: ElementHandleHoverParams, metadata?: Metadata): Promise<ElementHandleHoverResult>;
innerHTML(params?: ElementHandleInnerHTMLParams): Promise<ElementHandleInnerHTMLResult>; innerHTML(params?: ElementHandleInnerHTMLParams, metadata?: Metadata): Promise<ElementHandleInnerHTMLResult>;
innerText(params?: ElementHandleInnerTextParams): Promise<ElementHandleInnerTextResult>; innerText(params?: ElementHandleInnerTextParams, metadata?: Metadata): Promise<ElementHandleInnerTextResult>;
ownerFrame(params?: ElementHandleOwnerFrameParams): Promise<ElementHandleOwnerFrameResult>; ownerFrame(params?: ElementHandleOwnerFrameParams, metadata?: Metadata): Promise<ElementHandleOwnerFrameResult>;
press(params: ElementHandlePressParams): Promise<ElementHandlePressResult>; press(params: ElementHandlePressParams, metadata?: Metadata): Promise<ElementHandlePressResult>;
querySelector(params: ElementHandleQuerySelectorParams): Promise<ElementHandleQuerySelectorResult>; querySelector(params: ElementHandleQuerySelectorParams, metadata?: Metadata): Promise<ElementHandleQuerySelectorResult>;
querySelectorAll(params: ElementHandleQuerySelectorAllParams): Promise<ElementHandleQuerySelectorAllResult>; querySelectorAll(params: ElementHandleQuerySelectorAllParams, metadata?: Metadata): Promise<ElementHandleQuerySelectorAllResult>;
screenshot(params: ElementHandleScreenshotParams): Promise<ElementHandleScreenshotResult>; screenshot(params: ElementHandleScreenshotParams, metadata?: Metadata): Promise<ElementHandleScreenshotResult>;
scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams): Promise<ElementHandleScrollIntoViewIfNeededResult>; scrollIntoViewIfNeeded(params: ElementHandleScrollIntoViewIfNeededParams, metadata?: Metadata): Promise<ElementHandleScrollIntoViewIfNeededResult>;
selectOption(params: ElementHandleSelectOptionParams): Promise<ElementHandleSelectOptionResult>; selectOption(params: ElementHandleSelectOptionParams, metadata?: Metadata): Promise<ElementHandleSelectOptionResult>;
selectText(params: ElementHandleSelectTextParams): Promise<ElementHandleSelectTextResult>; selectText(params: ElementHandleSelectTextParams, metadata?: Metadata): Promise<ElementHandleSelectTextResult>;
setInputFiles(params: ElementHandleSetInputFilesParams): Promise<ElementHandleSetInputFilesResult>; setInputFiles(params: ElementHandleSetInputFilesParams, metadata?: Metadata): Promise<ElementHandleSetInputFilesResult>;
textContent(params?: ElementHandleTextContentParams): Promise<ElementHandleTextContentResult>; textContent(params?: ElementHandleTextContentParams, metadata?: Metadata): Promise<ElementHandleTextContentResult>;
type(params: ElementHandleTypeParams): Promise<ElementHandleTypeResult>; type(params: ElementHandleTypeParams, metadata?: Metadata): Promise<ElementHandleTypeResult>;
uncheck(params: ElementHandleUncheckParams): Promise<ElementHandleUncheckResult>; uncheck(params: ElementHandleUncheckParams, metadata?: Metadata): Promise<ElementHandleUncheckResult>;
waitForElementState(params: ElementHandleWaitForElementStateParams): Promise<ElementHandleWaitForElementStateResult>; waitForElementState(params: ElementHandleWaitForElementStateParams, metadata?: Metadata): Promise<ElementHandleWaitForElementStateResult>;
waitForSelector(params: ElementHandleWaitForSelectorParams): Promise<ElementHandleWaitForSelectorResult>; waitForSelector(params: ElementHandleWaitForSelectorParams, metadata?: Metadata): Promise<ElementHandleWaitForSelectorResult>;
createSelectorForTest(params: ElementHandleCreateSelectorForTestParams): Promise<ElementHandleCreateSelectorForTestResult>; createSelectorForTest(params: ElementHandleCreateSelectorForTestParams, metadata?: Metadata): Promise<ElementHandleCreateSelectorForTestResult>;
} }
export type ElementHandleEvalOnSelectorParams = { export type ElementHandleEvalOnSelectorParams = {
selector: string, selector: string,
@ -1987,7 +1991,7 @@ export type RequestInitializer = {
redirectedFrom?: RequestChannel, redirectedFrom?: RequestChannel,
}; };
export interface RequestChannel extends Channel { export interface RequestChannel extends Channel {
response(params?: RequestResponseParams): Promise<RequestResponseResult>; response(params?: RequestResponseParams, metadata?: Metadata): Promise<RequestResponseResult>;
} }
export type RequestResponseParams = {}; export type RequestResponseParams = {};
export type RequestResponseOptions = {}; export type RequestResponseOptions = {};
@ -2000,9 +2004,9 @@ export type RouteInitializer = {
request: RequestChannel, request: RequestChannel,
}; };
export interface RouteChannel extends Channel { export interface RouteChannel extends Channel {
abort(params: RouteAbortParams): Promise<RouteAbortResult>; abort(params: RouteAbortParams, metadata?: Metadata): Promise<RouteAbortResult>;
continue(params: RouteContinueParams): Promise<RouteContinueResult>; continue(params: RouteContinueParams, metadata?: Metadata): Promise<RouteContinueResult>;
fulfill(params: RouteFulfillParams): Promise<RouteFulfillResult>; fulfill(params: RouteFulfillParams, metadata?: Metadata): Promise<RouteFulfillResult>;
} }
export type RouteAbortParams = { export type RouteAbortParams = {
errorCode?: string, errorCode?: string,
@ -2060,8 +2064,8 @@ export type ResponseInitializer = {
}[], }[],
}; };
export interface ResponseChannel extends Channel { export interface ResponseChannel extends Channel {
body(params?: ResponseBodyParams): Promise<ResponseBodyResult>; body(params?: ResponseBodyParams, metadata?: Metadata): Promise<ResponseBodyResult>;
finished(params?: ResponseFinishedParams): Promise<ResponseFinishedResult>; finished(params?: ResponseFinishedParams, metadata?: Metadata): Promise<ResponseFinishedResult>;
} }
export type ResponseBodyParams = {}; export type ResponseBodyParams = {};
export type ResponseBodyOptions = {}; export type ResponseBodyOptions = {};
@ -2095,8 +2099,8 @@ export type BindingCallInitializer = {
args: SerializedValue[], args: SerializedValue[],
}; };
export interface BindingCallChannel extends Channel { export interface BindingCallChannel extends Channel {
reject(params: BindingCallRejectParams): Promise<BindingCallRejectResult>; reject(params: BindingCallRejectParams, metadata?: Metadata): Promise<BindingCallRejectResult>;
resolve(params: BindingCallResolveParams): Promise<BindingCallResolveResult>; resolve(params: BindingCallResolveParams, metadata?: Metadata): Promise<BindingCallResolveResult>;
} }
export type BindingCallRejectParams = { export type BindingCallRejectParams = {
error: SerializedError, error: SerializedError,
@ -2120,8 +2124,8 @@ export type DialogInitializer = {
defaultValue: string, defaultValue: string,
}; };
export interface DialogChannel extends Channel { export interface DialogChannel extends Channel {
accept(params: DialogAcceptParams): Promise<DialogAcceptResult>; accept(params: DialogAcceptParams, metadata?: Metadata): Promise<DialogAcceptResult>;
dismiss(params?: DialogDismissParams): Promise<DialogDismissResult>; dismiss(params?: DialogDismissParams, metadata?: Metadata): Promise<DialogDismissResult>;
} }
export type DialogAcceptParams = { export type DialogAcceptParams = {
promptText?: string, promptText?: string,
@ -2137,7 +2141,7 @@ export type DialogDismissResult = void;
// ----------- Video ----------- // ----------- Video -----------
export type VideoInitializer = {}; export type VideoInitializer = {};
export interface VideoChannel extends Channel { export interface VideoChannel extends Channel {
path(params?: VideoPathParams): Promise<VideoPathResult>; path(params?: VideoPathParams, metadata?: Metadata): Promise<VideoPathResult>;
} }
export type VideoPathParams = {}; export type VideoPathParams = {};
export type VideoPathOptions = {}; export type VideoPathOptions = {};
@ -2151,12 +2155,12 @@ export type DownloadInitializer = {
suggestedFilename: string, suggestedFilename: string,
}; };
export interface DownloadChannel extends Channel { export interface DownloadChannel extends Channel {
path(params?: DownloadPathParams): Promise<DownloadPathResult>; path(params?: DownloadPathParams, metadata?: Metadata): Promise<DownloadPathResult>;
saveAs(params: DownloadSaveAsParams): Promise<DownloadSaveAsResult>; saveAs(params: DownloadSaveAsParams, metadata?: Metadata): Promise<DownloadSaveAsResult>;
saveAsStream(params?: DownloadSaveAsStreamParams): Promise<DownloadSaveAsStreamResult>; saveAsStream(params?: DownloadSaveAsStreamParams, metadata?: Metadata): Promise<DownloadSaveAsStreamResult>;
failure(params?: DownloadFailureParams): Promise<DownloadFailureResult>; failure(params?: DownloadFailureParams, metadata?: Metadata): Promise<DownloadFailureResult>;
stream(params?: DownloadStreamParams): Promise<DownloadStreamResult>; stream(params?: DownloadStreamParams, metadata?: Metadata): Promise<DownloadStreamResult>;
delete(params?: DownloadDeleteParams): Promise<DownloadDeleteResult>; delete(params?: DownloadDeleteParams, metadata?: Metadata): Promise<DownloadDeleteResult>;
} }
export type DownloadPathParams = {}; export type DownloadPathParams = {};
export type DownloadPathOptions = {}; export type DownloadPathOptions = {};
@ -2192,8 +2196,8 @@ export type DownloadDeleteResult = void;
// ----------- Stream ----------- // ----------- Stream -----------
export type StreamInitializer = {}; export type StreamInitializer = {};
export interface StreamChannel extends Channel { export interface StreamChannel extends Channel {
read(params: StreamReadParams): Promise<StreamReadResult>; read(params: StreamReadParams, metadata?: Metadata): Promise<StreamReadResult>;
close(params?: StreamCloseParams): Promise<StreamCloseResult>; close(params?: StreamCloseParams, metadata?: Metadata): Promise<StreamCloseResult>;
} }
export type StreamReadParams = { export type StreamReadParams = {
size?: number, size?: number,
@ -2212,8 +2216,8 @@ export type StreamCloseResult = void;
export type CDPSessionInitializer = {}; export type CDPSessionInitializer = {};
export interface CDPSessionChannel extends Channel { export interface CDPSessionChannel extends Channel {
on(event: 'event', callback: (params: CDPSessionEventEvent) => void): this; on(event: 'event', callback: (params: CDPSessionEventEvent) => void): this;
send(params: CDPSessionSendParams): Promise<CDPSessionSendResult>; send(params: CDPSessionSendParams, metadata?: Metadata): Promise<CDPSessionSendResult>;
detach(params?: CDPSessionDetachParams): Promise<CDPSessionDetachResult>; detach(params?: CDPSessionDetachParams, metadata?: Metadata): Promise<CDPSessionDetachResult>;
} }
export type CDPSessionEventEvent = { export type CDPSessionEventEvent = {
method: string, method: string,
@ -2236,7 +2240,7 @@ export type CDPSessionDetachResult = void;
// ----------- Electron ----------- // ----------- Electron -----------
export type ElectronInitializer = {}; export type ElectronInitializer = {};
export interface ElectronChannel extends Channel { export interface ElectronChannel extends Channel {
launch(params: ElectronLaunchParams): Promise<ElectronLaunchResult>; launch(params: ElectronLaunchParams, metadata?: Metadata): Promise<ElectronLaunchResult>;
} }
export type ElectronLaunchParams = { export type ElectronLaunchParams = {
executablePath: string, executablePath: string,
@ -2273,10 +2277,10 @@ export interface ElectronApplicationChannel extends Channel {
on(event: 'context', callback: (params: ElectronApplicationContextEvent) => void): this; on(event: 'context', callback: (params: ElectronApplicationContextEvent) => void): this;
on(event: 'close', callback: (params: ElectronApplicationCloseEvent) => void): this; on(event: 'close', callback: (params: ElectronApplicationCloseEvent) => void): this;
on(event: 'window', callback: (params: ElectronApplicationWindowEvent) => void): this; on(event: 'window', callback: (params: ElectronApplicationWindowEvent) => void): this;
newBrowserWindow(params: ElectronApplicationNewBrowserWindowParams): Promise<ElectronApplicationNewBrowserWindowResult>; newBrowserWindow(params: ElectronApplicationNewBrowserWindowParams, metadata?: Metadata): Promise<ElectronApplicationNewBrowserWindowResult>;
evaluateExpression(params: ElectronApplicationEvaluateExpressionParams): Promise<ElectronApplicationEvaluateExpressionResult>; evaluateExpression(params: ElectronApplicationEvaluateExpressionParams, metadata?: Metadata): Promise<ElectronApplicationEvaluateExpressionResult>;
evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams): Promise<ElectronApplicationEvaluateExpressionHandleResult>; evaluateExpressionHandle(params: ElectronApplicationEvaluateExpressionHandleParams, metadata?: Metadata): Promise<ElectronApplicationEvaluateExpressionHandleResult>;
close(params?: ElectronApplicationCloseParams): Promise<ElectronApplicationCloseResult>; close(params?: ElectronApplicationCloseParams, metadata?: Metadata): Promise<ElectronApplicationCloseResult>;
} }
export type ElectronApplicationContextEvent = { export type ElectronApplicationContextEvent = {
context: BrowserContextChannel, context: BrowserContextChannel,

8
src/protocol/protocol.yml
View file

@ -12,6 +12,14 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
# This object can be send with any rpc call in the "metadata" field.
Metadata:
type: object
properties:
stack: string?
SerializedValue: SerializedValue:
type: object type: object
# Exactly one of the properties must be present. # Exactly one of the properties must be present.

3
src/protocol/validator.ts
View file

@ -33,6 +33,9 @@ export function createScheme(tChannel: (name: string) => Validator): Scheme {
}; };
}; };
scheme.Metadata = tObject({
stack: tOptional(tString),
});
scheme.SerializedValue = tObject({ scheme.SerializedValue = tObject({
n: tOptional(tNumber), n: tOptional(tNumber),
b: tOptional(tBoolean), b: tOptional(tBoolean),

2
utils/generate_channels.js
View file

@ -212,7 +212,7 @@ for (const [name, item] of Object.entries(protocol)) {
const returns = objectType(method.returns || {}, ''); const returns = objectType(method.returns || {}, '');
ts_types.set(resultName, method.returns ? returns.ts : 'void'); ts_types.set(resultName, method.returns ? returns.ts : 'void');
channels_ts.push(` ${methodName}(params${method.parameters ? '' : '?'}: ${paramsName}): Promise<${resultName}>;`); channels_ts.push(` ${methodName}(params${method.parameters ? '' : '?'}: ${paramsName}, metadata?: Metadata): Promise<${resultName}>;`);
} }
channels_ts.push(`}`); channels_ts.push(`}`);