chore(rpc): scope client-side handles (#2796)

Author: pavelfeldman

src/rpc/client/browser.ts

@@ -19,7 +19,7 @@ import { BrowserChannel, BrowserInitializer } from '../channels';
 import { BrowserContext } from './browserContext';
 import { Page } from './page';
 import { ChannelOwner } from './channelOwner';
-import { Connection } from './connection';
+import { ConnectionScope } from './connection';
 import { Events } from '../../events';
 
 export class Browser extends ChannelOwner<BrowserChannel, BrowserInitializer> {
@@ -36,12 +36,13 @@ export class Browser extends ChannelOwner<BrowserChannel, BrowserInitializer> {
     return browser ? Browser.from(browser) : null;
   }
 
-  constructor(connection: Connection, channel: BrowserChannel, initializer: BrowserInitializer) {
-    super(connection, channel, initializer);
-    channel.on('close', () => {
+  constructor(scope: ConnectionScope, guid: string, initializer: BrowserInitializer) {
+    super(scope, guid, initializer, true);
+    this._channel.on('close', () => {
       this._isConnected = false;
       this.emit(Events.Browser.Disconnected);
       this._isClosedOrClosing = true;
+      this._scope.dispose();
     });
   }
 

src/rpc/client/browserContext.ts

@@ -23,7 +23,7 @@ import { BrowserContextChannel, BrowserContextInitializer } from '../channels';
 import { ChannelOwner } from './channelOwner';
 import { helper } from '../../helper';
 import { Browser } from './browser';
-import { Connection } from './connection';
+import { ConnectionScope } from './connection';
 import { Events } from '../../events';
 import { TimeoutSettings } from '../../timeoutSettings';
 
@@ -44,8 +44,8 @@ export class BrowserContext extends ChannelOwner<BrowserContextChannel, BrowserC
     return context ? BrowserContext.from(context) : null;
   }
 
-  constructor(connection: Connection, channel: BrowserContextChannel, initializer: BrowserContextInitializer) {
-    super(connection, channel, initializer);
+  constructor(scope: ConnectionScope, guid: string, initializer: BrowserContextInitializer) {
+    super(scope, guid, initializer, true);
     initializer.pages.map(p => {
       const page = Page.from(p);
       this._pages.add(page);
@@ -193,6 +193,7 @@ export class BrowserContext extends ChannelOwner<BrowserContextChannel, BrowserC
     }
     this._pendingWaitForEvents.clear();
     this.emit(Events.BrowserContext.Close);
+    this._scope.dispose();
   }
 
   async close(): Promise<void> {

src/rpc/client/browserServer.ts

@@ -16,7 +16,7 @@
 
 import { ChildProcess } from 'child_process';
 import { BrowserServerChannel, BrowserServerInitializer } from '../channels';
-import { Connection } from './connection';
+import { ConnectionScope } from './connection';
 import { ChannelOwner } from './channelOwner';
 import { Events } from '../../events';
 
@@ -25,9 +25,9 @@ export class BrowserServer extends ChannelOwner<BrowserServerChannel, BrowserSer
     return request._object;
   }
 
-  constructor(connection: Connection, channel: BrowserServerChannel, initializer: BrowserServerInitializer) {
-    super(connection, channel, initializer);
-    channel.on('close', () => this.emit(Events.BrowserServer.Close));
+  constructor(scope: ConnectionScope, guid: string, initializer: BrowserServerInitializer) {
+    super(scope, guid, initializer);
+    this._channel.on('close', () => this.emit(Events.BrowserServer.Close));
   }
 
   process(): ChildProcess {

src/rpc/client/browserType.ts

@@ -19,12 +19,12 @@ import { BrowserTypeChannel, BrowserTypeInitializer } from '../channels';
 import { Browser } from './browser';
 import { BrowserContext } from './browserContext';
 import { ChannelOwner } from './channelOwner';
-import { Connection } from './connection';
+import { ConnectionScope } from './connection';
 import { BrowserServer } from './browserServer';
 
 export class BrowserType extends ChannelOwner<BrowserTypeChannel, BrowserTypeInitializer> {
-  constructor(connection: Connection, channel: BrowserTypeChannel, initializer: BrowserTypeInitializer) {
-    super(connection, channel, initializer);
+  constructor(scope: ConnectionScope, guid: string, initializer: BrowserTypeInitializer) {
+    super(scope, guid, initializer);
   }
 
   executablePath(): string {

src/rpc/client/channelOwner.ts

@@ -16,19 +16,38 @@
 
 import { EventEmitter } from 'events';
 import { Channel } from '../channels';
-import { Connection } from './connection';
+import { ConnectionScope } from './connection';
 
 export abstract class ChannelOwner<T extends Channel, Initializer> extends EventEmitter {
   readonly _channel: T;
   readonly _initializer: Initializer;
-  readonly _connection: Connection;
-  static clientSymbol = Symbol('client');
+  readonly _scope: ConnectionScope;
 
-  constructor(connection: Connection, channel: T, initializer: Initializer) {
+  constructor(scope: ConnectionScope, guid: string, initializer: Initializer, isScope?: boolean) {
     super();
-    this._connection = connection;
-    this._channel = channel;
+    this._scope = isScope ? scope.createChild(guid) : scope;
+    const base = new EventEmitter();
+    this._channel = new Proxy(base, {
+      get: (obj: any, prop) => {
+        if (String(prop).startsWith('_'))
+          return obj[prop];
+        if (prop === 'then')
+          return obj.then;
+        if (prop === 'emit')
+          return obj.emit;
+        if (prop === 'on')
+          return obj.on;
+        if (prop === 'once')
+          return obj.once;
+        if (prop === 'addEventListener')
+          return obj.addListener;
+        if (prop === 'removeEventListener')
+          return obj.removeListener;
+        return (params: any) => scope.sendMessageToServer({ guid, method: String(prop), params });
+      },
+    });
+    this._channel._object = this;
+    this._channel._guid = guid;
     this._initializer = initializer;
-    (channel as any)[ChannelOwner.clientSymbol] = this;
   }
 }