feat(rpc): return objects for every protocol command (#2950)

For future extensibility, returning objects with fields instead
of plain strings or channels.

Author: dgozman

src/rpc/channels.ts

@@ -26,8 +26,9 @@ export class Accessibility {
     this._channel = channel;
   }
 
-  snapshot(options: { interestingOnly?: boolean; root?: ElementHandle } = {}): Promise<types.SerializedAXNode | null> {
+  async snapshot(options: { interestingOnly?: boolean; root?: ElementHandle } = {}): Promise<types.SerializedAXNode | null> {
     const root = options.root ? options.root._elementChannel : undefined;
-    return this._channel.accessibilitySnapshot({ interestingOnly: options.interestingOnly, root });
+    const result = await this._channel.accessibilitySnapshot({ interestingOnly: options.interestingOnly, root });
+    return result.rootAXNode;
   }
 }

src/rpc/client/accessibility.ts

@@ -53,7 +53,7 @@ export class Browser extends ChannelOwner<BrowserChannel, BrowserInitializer> {
   async newContext(options: types.BrowserContextOptions & { logger?: LoggerSink } = {}): Promise<BrowserContext> {
     const logger = options.logger;
     options = { ...options, logger: undefined };
-    const context = BrowserContext.from(await this._channel.newContext(options));
+    const context = BrowserContext.from((await this._channel.newContext(options)).context);
     this._contexts.add(context);
     context._logger = logger || this._logger;
     return context;

src/rpc/client/browser.ts

@@ -53,9 +53,9 @@ export class BrowserContext extends ChannelOwner<BrowserContextChannel, BrowserC
       this._browser = parent;
     this._browserName = browserName;
 
-    this._channel.on('bindingCall', bindingCall => this._onBinding(BindingCall.from(bindingCall)));
+    this._channel.on('bindingCall', ({binding}) => this._onBinding(BindingCall.from(binding)));
     this._channel.on('close', () => this._onClose());
-    this._channel.on('page', page => this._onPage(Page.from(page)));
+    this._channel.on('page', ({page}) => this._onPage(Page.from(page)));
     this._channel.on('route', ({ route, request }) => this._onRoute(network.Route.from(route), network.Request.from(request)));
     this._closedPromise = new Promise(f => this.once(Events.BrowserContext.Close, f));
   }
@@ -99,15 +99,15 @@ export class BrowserContext extends ChannelOwner<BrowserContextChannel, BrowserC
   async newPage(): Promise<Page> {
     if (this._ownerPage)
       throw new Error('Please use browser.newContext()');
-    return Page.from(await this._channel.newPage());
+    return Page.from((await this._channel.newPage()).page);
   }
 
   async cookies(urls?: string | string[]): Promise<network.NetworkCookie[]> {
     if (!urls)
       urls = [];
     if (urls && typeof urls === 'string')
       urls = [ urls ];
-    return this._channel.cookies({ urls: urls as string[] });
+    return (await this._channel.cookies({ urls: urls as string[] })).cookies;
   }
 
   async addCookies(cookies: network.SetNetworkCookieParam[]): Promise<void> {

src/rpc/client/browserContext.ts

@@ -43,28 +43,29 @@ export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeIni
   async launch(options: types.LaunchOptions & { logger?: LoggerSink } = {}): Promise<Browser> {
     const logger = options.logger;
     options = { ...options, logger: undefined };
-    const browser = Browser.from(await this._channel.launch(options));
+    const browser = Browser.from((await this._channel.launch(options)).browser);
     browser._logger = logger;
     return browser;
   }
 
   async launchServer(options: types.LaunchServerOptions & { logger?: LoggerSink } = {}): Promise<BrowserServer> {
     options = { ...options, logger: undefined };
-    return BrowserServer.from(await this._channel.launchServer(options));
+    return BrowserServer.from((await this._channel.launchServer(options)).server);
   }
 
   async launchPersistentContext(userDataDir: string, options: types.LaunchOptions & types.BrowserContextOptions & { logger?: LoggerSink } = {}): Promise<BrowserContext> {
     const logger = options.logger;
     options = { ...options, logger: undefined };
-    const context = BrowserContext.from(await this._channel.launchPersistentContext({ userDataDir, ...options }));
+    const result = await this._channel.launchPersistentContext({ userDataDir, ...options });
+    const context = BrowserContext.from(result.context);
     context._logger = logger;
     return context;
   }
 
   async connect(options: types.ConnectOptions & { logger?: LoggerSink }): Promise<Browser> {
     const logger = options.logger;
     options = { ...options, logger: undefined };
-    const browser = Browser.from(await this._channel.connect(options));
+    const browser = Browser.from((await this._channel.connect(options)).browser);
     browser._logger = logger;
     return browser;
   }

src/rpc/client/browserType.ts

@@ -47,7 +47,7 @@ export class CDPSession extends ChannelOwner<CDPSessionChannel, CDPSessionInitia
     params?: Protocol.CommandParameters[T]
   ): Promise<Protocol.CommandReturnValues[T]> {
     const result = await this._channel.send({ method, params });
-    return result as Protocol.CommandReturnValues[T];
+    return result.result as Protocol.CommandReturnValues[T];
   }
 
   async detach() {

src/rpc/client/cdpSession.ts

@@ -20,14 +20,14 @@ import { Browser } from './browser';
 
 export class ChromiumBrowser extends Browser {
   async newBrowserCDPSession(): Promise<CDPSession> {
-    return CDPSession.from(await this._channel.crNewBrowserCDPSession());
+    return CDPSession.from((await this._channel.crNewBrowserCDPSession()).session);
   }
 
   async startTracing(page?: Page, options: { path?: string; screenshots?: boolean; categories?: string[]; } = {}) {
     await this._channel.crStartTracing({ ...options, page: page ? page._channel : undefined });
   }
 
   async stopTracing(): Promise<Buffer> {
-    return Buffer.from(await this._channel.crStopTracing(), 'base64');
+    return Buffer.from((await this._channel.crStopTracing()).binary, 'base64');
   }
 }

src/rpc/client/chromiumBrowser.ts

@@ -29,16 +29,16 @@ export class ChromiumBrowserContext extends BrowserContext {
 
   constructor(parent: ChannelOwner, type: string, guid: string, initializer: BrowserContextInitializer) {
     super(parent, type, guid, initializer, 'chromium');
-    this._channel.on('crBackgroundPage', pageChannel => {
-      const page = Page.from(pageChannel);
-      this._backgroundPages.add(page);
-      this.emit(ChromiumEvents.CRBrowserContext.BackgroundPage, page);
+    this._channel.on('crBackgroundPage', ({ page }) => {
+      const backgroundPage = Page.from(page);
+      this._backgroundPages.add(backgroundPage);
+      this.emit(ChromiumEvents.CRBrowserContext.BackgroundPage, backgroundPage);
     });
-    this._channel.on('crServiceWorker', serviceWorkerChannel => {
-      const worker = Worker.from(serviceWorkerChannel);
-      worker._context = this;
-      this._serviceWorkers.add(worker);
-      this.emit(ChromiumEvents.CRBrowserContext.ServiceWorker, worker);
+    this._channel.on('crServiceWorker', ({worker}) => {
+      const serviceWorker = Worker.from(worker);
+      serviceWorker._context = this;
+      this._serviceWorkers.add(serviceWorker);
+      this.emit(ChromiumEvents.CRBrowserContext.ServiceWorker, serviceWorker);
     });
   }
 
@@ -51,6 +51,7 @@ export class ChromiumBrowserContext extends BrowserContext {
   }
 
   async newCDPSession(page: Page): Promise<CDPSession> {
-    return CDPSession.from(await this._channel.crNewCDPSession({ page: page._channel }));
+    const result = await this._channel.crNewCDPSession({ page: page._channel });
+    return CDPSession.from(result.session);
   }
 }

src/rpc/client/chromiumBrowserContext.ts

@@ -29,14 +29,14 @@ export class Coverage {
   }
 
   async stopJSCoverage(): Promise<types.JSCoverageEntry[]> {
-    return await this._channel.crStopJSCoverage();
+    return (await this._channel.crStopJSCoverage()).entries;
   }
 
   async startCSSCoverage(options: types.CSSCoverageOptions = {}) {
     await this._channel.crStartCSSCoverage(options);
   }
 
   async stopCSSCoverage(): Promise<types.CSSCoverageEntry[]> {
-    return await this._channel.crStopCSSCoverage();
+    return (await this._channel.crStopCSSCoverage()).entries;
   }
 }

src/rpc/client/coverage.ts

@@ -37,18 +37,18 @@ export class Download extends ChannelOwner<DownloadChannel, DownloadInitializer>
   }
 
   async path(): Promise<string | null> {
-    return this._channel.path();
+    return (await this._channel.path()).value;
   }
 
   async failure(): Promise<string | null> {
-    return this._channel.failure();
+    return (await this._channel.failure()).error;
   }
 
   async createReadStream(): Promise<Readable | null> {
-    const s = await this._channel.stream();
-    if (!s)
+    const result = await this._channel.stream();
+    if (!result.stream)
       return null;
-    const stream = Stream.from(s);
+    const stream = Stream.from(result.stream);
     return stream.stream();
   }