chore: make BrowserContext an interface, with 3 implementations (#1075)

This is in preparation for moving targets to BrowserContext, so that one can work with targets in default context.
microsoft · Feb 24, 2020 · a43b409 · a43b409
1 parent 3677818
commit a43b409
Show file tree

Hide file tree

Showing 4 changed files with 416 additions and 373 deletions.
diff --git a/src/browserContext.ts b/src/browserContext.ts
@@ -19,26 +19,8 @@ import { Page } from './page';
 import * as network from './network';
 import * as types from './types';
 import { helper } from './helper';
-import * as platform from './platform';
-import { Events } from './events';
 import { TimeoutSettings } from './timeoutSettings';
 
-export interface BrowserContextDelegate {
-  pages(): Promise<Page[]>;
-  existingPages(): Page[];
-  newPage(): Promise<Page>;
-  close(): Promise<void>;
-
-  cookies(): Promise<network.NetworkCookie[]>;
-  setCookies(cookies: network.SetNetworkCookieParam[]): Promise<void>;
-  clearCookies(): Promise<void>;
-
-  setPermissions(origin: string, permissions: string[]): Promise<void>;
-  clearPermissions(): Promise<void>;
-
-  setGeolocation(geolocation: types.Geolocation | null): Promise<void>;
-}
-
 export type BrowserContextOptions = {
   viewport?: types.Viewport | null,
   ignoreHTTPSErrors?: boolean,
@@ -51,106 +33,44 @@ export type BrowserContextOptions = {
   permissions?: { [key: string]: string[] };
 };
 
-export class BrowserContext extends platform.EventEmitter {
-  private readonly _delegate: BrowserContextDelegate;
-  readonly _options: BrowserContextOptions;
-  readonly _timeoutSettings: TimeoutSettings;
-  private _closed = false;
-
-  constructor(delegate: BrowserContextDelegate, options: BrowserContextOptions) {
-    super();
-    this._delegate = delegate;
-    this._timeoutSettings = new TimeoutSettings();
-    this._options = { ...options };
-    if (!this._options.viewport && this._options.viewport !== null)
-      this._options.viewport = { width: 1280, height: 720 };
-    if (this._options.viewport)
-      this._options.viewport = { ...this._options.viewport };
-    if (this._options.geolocation)
-      this._options.geolocation = verifyGeolocation(this._options.geolocation);
-  }
-
-  async _initialize() {
-    const entries = Object.entries(this._options.permissions || {});
-    await Promise.all(entries.map(entry => this.setPermissions(entry[0], entry[1])));
-    if (this._options.geolocation)
-      await this.setGeolocation(this._options.geolocation);
-  }
-
-  _existingPages(): Page[] {
-    return this._delegate.existingPages();
-  }
-
-  setDefaultNavigationTimeout(timeout: number) {
-    this._timeoutSettings.setDefaultNavigationTimeout(timeout);
-  }
-
-  setDefaultTimeout(timeout: number) {
-    this._timeoutSettings.setDefaultTimeout(timeout);
-  }
-
-  async pages(): Promise<Page[]> {
-    return this._delegate.pages();
-  }
-
-  async newPage(): Promise<Page> {
-    const pages = this._delegate.existingPages();
-    for (const page of pages) {
-      if (page._ownedContext)
-        throw new Error('Please use browser.newContext() for multi-page scripts that share the context.');
-    }
-    return this._delegate.newPage();
-  }
-
-  async cookies(...urls: string[]): Promise<network.NetworkCookie[]> {
-    return network.filterCookies(await this._delegate.cookies(), urls);
-  }
-
-  async setCookies(cookies: network.SetNetworkCookieParam[]) {
-    await this._delegate.setCookies(network.rewriteCookies(cookies));
-  }
-
-  async clearCookies() {
-    await this._delegate.clearCookies();
-  }
-
-  async setPermissions(origin: string, permissions: string[]): Promise<void> {
-    await this._delegate.setPermissions(origin, permissions);
-  }
-
-  async clearPermissions() {
-    await this._delegate.clearPermissions();
-  }
-
-  async setGeolocation(geolocation: types.Geolocation | null): Promise<void> {
-    if (geolocation)
-      geolocation = verifyGeolocation(geolocation);
-    this._options.geolocation = geolocation || undefined;
-    await this._delegate.setGeolocation(geolocation);
-  }
+export interface BrowserContext {
+  setDefaultNavigationTimeout(timeout: number): void;
+  setDefaultTimeout(timeout: number): void;
+  pages(): Promise<Page[]>;
+  newPage(): Promise<Page>;
+  cookies(...urls: string[]): Promise<network.NetworkCookie[]>;
+  setCookies(cookies: network.SetNetworkCookieParam[]): Promise<void>;
+  clearCookies(): Promise<void>;
+  setPermissions(origin: string, permissions: string[]): Promise<void>;
+  clearPermissions(): Promise<void>;
+  setGeolocation(geolocation: types.Geolocation | null): Promise<void>;
+  close(): Promise<void>;
 
-  async close() {
-    if (this._closed)
-      return;
-    await this._delegate.close();
-    this._closed = true;
-    this.emit(Events.BrowserContext.Close);
-  }
+  _existingPages(): Page[];
+  readonly _timeoutSettings: TimeoutSettings;
+  readonly _options: BrowserContextOptions;
+}
 
-  static validateOptions(options: BrowserContextOptions) {
-    if (options.geolocation)
-      verifyGeolocation(options.geolocation);
+export function assertBrowserContextIsNotOwned(context: BrowserContext) {
+  const pages = context._existingPages();
+  for (const page of pages) {
+    if (page._ownedContext)
+      throw new Error('Please use browser.newContext() for multi-page scripts that share the context.');
   }
+}
 
-  _browserClosed() {
-    this._closed = true;
-    for (const page of this._delegate.existingPages())
-      page._didClose();
-    this.emit(Events.BrowserContext.Close);
-  }
+export function validateBrowserContextOptions(options: BrowserContextOptions): BrowserContextOptions {
+  const result = { ...options };
+  if (!result.viewport && result.viewport !== null)
+    result.viewport = { width: 1280, height: 720 };
+  if (result.viewport)
+    result.viewport = { ...result.viewport };
+  if (result.geolocation)
+    result.geolocation = verifyGeolocation(result.geolocation);
+  return result;
 }
 
-function verifyGeolocation(geolocation: types.Geolocation): types.Geolocation {
+export function verifyGeolocation(geolocation: types.Geolocation): types.Geolocation {
   const result = { ...geolocation };
   result.accuracy = result.accuracy || 0;
   const { longitude, latitude, accuracy } = result;