yujunjun/playwright
1
0
Fork 0
mirror of https://github.com/microsoft/playwright.git synced 2025-06-26 21:40:17 +00:00
Code Issues Packages Projects Releases Wiki Activity

browser(firefox): move context settings from creation to setters (#2193)

Browse Source 
Drive-by: simplify settings plumbing, fix addBinding bug.
This commit is contained in:
Dmitry Gozman 2020-05-12 07:32:25 -07:00 committed by GitHub
parent 054ee639b4
commit fdc9ce8e07
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 242 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
browser_patches/firefox/BUILD_NUMBER
View File

@ -1 +1 @@
1093 1094

353
browser_patches/firefox/patches/bootstrap.diff
View File

@ -1466,7 +1466,7 @@ index 0000000000000000000000000000000000000000..2b1fe7fa712ae210af3ebbccda084041
+ +
diff --git a/juggler/NetworkObserver.js b/juggler/NetworkObserver.js diff --git a/juggler/NetworkObserver.js b/juggler/NetworkObserver.js
new file mode 100644 new file mode 100644
index 0000000000000000000000000000000000000000..1a55b5498c18d2403eab21fe9149242f286157d4 index 0000000000000000000000000000000000000000..f803071bea317e4d3ce7341573622f6bddaaf547
--- /dev/null --- /dev/null
+++ b/juggler/NetworkObserver.js +++ b/juggler/NetworkObserver.js
@@ -0,0 +1,794 @@ @@ -0,0 +1,794 @@
@ -1758,7 +1758,7 @@ index 0000000000000000000000000000000000000000..1a55b5498c18d2403eab21fe9149242f
+ } + }
+ const browserContext = pageNetwork._target.browserContext(); + const browserContext = pageNetwork._target.browserContext();
+ if (browserContext) + if (browserContext)
+ this._appendExtraHTTPHeaders(httpChannel, browserContext.options.extraHTTPHeaders); + this._appendExtraHTTPHeaders(httpChannel, browserContext.extraHTTPHeaders);
+ this._appendExtraHTTPHeaders(httpChannel, pageNetwork._extraHTTPHeaders); + this._appendExtraHTTPHeaders(httpChannel, pageNetwork._extraHTTPHeaders);
+ const requestId = this._requestId(httpChannel); + const requestId = this._requestId(httpChannel);
+ const isRedirect = this._redirectMap.has(requestId); + const isRedirect = this._redirectMap.has(requestId);
@ -1804,9 +1804,9 @@ index 0000000000000000000000000000000000000000..1a55b5498c18d2403eab21fe9149242f
+ if (pageNetwork._requestInterceptionEnabled) + if (pageNetwork._requestInterceptionEnabled)
+ return true; + return true;
+ const browserContext = pageNetwork._target.browserContext(); + const browserContext = pageNetwork._target.browserContext();
+ if (browserContext && browserContext.options.requestInterceptionEnabled) + if (browserContext && browserContext.requestInterceptionEnabled)
+ return true; + return true;
+ if (browserContext && browserContext.options.onlineOverride === 'offline') + if (browserContext && browserContext.settings.onlineOverride === 'offline')
+ return true; + return true;
+ return false; + return false;
+ } + }
@ -1825,7 +1825,7 @@ index 0000000000000000000000000000000000000000..1a55b5498c18d2403eab21fe9149242f
+ return; + return;
+ } + }
+ const browserContext = pageNetwork._target.browserContext(); + const browserContext = pageNetwork._target.browserContext();
+ if (browserContext && browserContext.options.onlineOverride === 'offline') { + if (browserContext && browserContext.settings.onlineOverride === 'offline') {
+ interceptor._abort(Cr.NS_ERROR_OFFLINE); + interceptor._abort(Cr.NS_ERROR_OFFLINE);
+ return; + return;
+ } + }
@ -2181,7 +2181,7 @@ index 0000000000000000000000000000000000000000..1a55b5498c18d2403eab21fe9149242f
+ if (authInfo.flags & Ci.nsIAuthInformation.PREVIOUS_FAILED) + if (authInfo.flags & Ci.nsIAuthInformation.PREVIOUS_FAILED)
+ return false; + return false;
+ const browserContext = this._pageNetwork._target.browserContext(); + const browserContext = this._pageNetwork._target.browserContext();
+ const credentials = browserContext ? browserContext.options.httpCredentials : undefined; + const credentials = browserContext ? browserContext.httpCredentials : undefined;
+ if (!credentials) + if (!credentials)
+ return false; + return false;
+ authInfo.username = credentials.username; + authInfo.username = credentials.username;
@ -2402,10 +2402,10 @@ index 0000000000000000000000000000000000000000..ba34976ad05e7f5f1a99777f76ac08b1
+this.SimpleChannel = SimpleChannel; +this.SimpleChannel = SimpleChannel;
diff --git a/juggler/TargetRegistry.js b/juggler/TargetRegistry.js diff --git a/juggler/TargetRegistry.js b/juggler/TargetRegistry.js
new file mode 100644 new file mode 100644
index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a176348cd8 index 0000000000000000000000000000000000000000..ffa7a3eb7db0508bce20f59535fee808a3ee2859
--- /dev/null --- /dev/null
+++ b/juggler/TargetRegistry.js +++ b/juggler/TargetRegistry.js
@@ -0,0 +1,654 @@ @@ -0,0 +1,648 @@
+const {EventEmitter} = ChromeUtils.import('resource://gre/modules/EventEmitter.jsm'); +const {EventEmitter} = ChromeUtils.import('resource://gre/modules/EventEmitter.jsm');
+const {Helper} = ChromeUtils.import('chrome://juggler/content/Helper.js'); +const {Helper} = ChromeUtils.import('chrome://juggler/content/Helper.js');
+const {SimpleChannel} = ChromeUtils.import('chrome://juggler/content/SimpleChannel.js'); +const {SimpleChannel} = ChromeUtils.import('chrome://juggler/content/SimpleChannel.js');
@ -2460,7 +2460,7 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ return false; + return false;
+ +
+ const browserContext = pageTarget.browserContext(); + const browserContext = pageTarget.browserContext();
+ const options = browserContext.options.downloadOptions; + const options = browserContext.downloadOptions;
+ if (!options) + if (!options)
+ return false; + return false;
+ +
@ -2583,7 +2583,9 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ this.emit(TargetRegistry.Events.TargetCreated, readyData); + this.emit(TargetRegistry.Events.TargetCreated, readyData);
+ sessions.forEach(session => target._initSession(session)); + sessions.forEach(session => target._initSession(session));
+ return { + return {
+ browserContextOptions: browserContext ? browserContext.options : {}, + scriptsToEvaluateOnNewDocument: browserContext ? browserContext.scriptsToEvaluateOnNewDocument : [],
+ bindings: browserContext ? browserContext.bindings : [],
+ settings: browserContext ? browserContext.settings : {},
+ sessionIds: sessions.map(session => session.sessionId()), + sessionIds: sessions.map(session => session.sessionId()),
+ }; + };
+ }, + },
@ -2593,8 +2595,8 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ const tab = event.target; + const tab = event.target;
+ const userContextId = tab.userContextId; + const userContextId = tab.userContextId;
+ const browserContext = this._userContextIdToBrowserContext.get(userContextId); + const browserContext = this._userContextIdToBrowserContext.get(userContextId);
+ if (browserContext && browserContext.options.viewport) + if (browserContext && browserContext.settings.defaultViewport)
+ setViewportSizeForBrowser(browserContext.options.viewport.viewportSize, tab.linkedBrowser); + setViewportSizeForBrowser(browserContext.settings.defaultViewport.viewportSize, tab.linkedBrowser);
+ }; + };
+ +
+ const onTabCloseListener = event => { + const onTabCloseListener = event => {
@ -2646,8 +2648,8 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ return this._defaultContext; + return this._defaultContext;
+ } + }
+ +
+ createBrowserContext(options) { + createBrowserContext(removeOnDetach) {
+ return new BrowserContext(this, helper.generateId(), options); + return new BrowserContext(this, helper.generateId(), removeOnDetach);
+ } + }
+ +
+ browserContextForId(browserContextId) { + browserContextForId(browserContextId) {
@ -2694,7 +2696,7 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ }); + });
+ } + }
+ window.gBrowser.selectedTab = tab; + window.gBrowser.selectedTab = tab;
+ if (browserContext.options.timezoneId) { + if (browserContext.settings.timezoneId) {
+ if (await target.hasFailedToOverrideTimezone()) + if (await target.hasFailedToOverrideTimezone())
+ throw new Error('Failed to override timezone'); + throw new Error('Failed to override timezone');
+ } + }
@ -2818,16 +2820,8 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ await this._channel.connect('').send('addBinding', { name, script }).catch(e => void e); + await this._channel.connect('').send('addBinding', { name, script }).catch(e => void e);
+ } + }
+ +
+ async setGeolocationOverride(geolocation) { + async applyContextSetting(name, value) {
+ await this._channel.connect('').send('setGeolocationOverride', geolocation).catch(e => void e); + await this._channel.connect('').send('applyContextSetting', { name, value }).catch(e => void e);
+ }
+
+ async setOnlineOverride(override) {
+ await this._channel.connect('').send('setOnlineOverride', override).catch(e => void e);
+ }
+
+ async setColorScheme(colorScheme) {
+ await this._channel.connect('').send('setColorScheme', colorScheme).catch(e => void e);
+ } + }
+ +
+ async hasFailedToOverrideTimezone() { + async hasFailedToOverrideTimezone() {
@ -2845,7 +2839,7 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+} +}
+ +
+class BrowserContext { +class BrowserContext {
+ constructor(registry, browserContextId, options) { + constructor(registry, browserContextId, removeOnDetach) {
+ this._registry = registry; + this._registry = registry;
+ this.browserContextId = browserContextId; + this.browserContextId = browserContextId;
+ // Default context has userContextId === 0, but we pass undefined to many APIs just in case. + // Default context has userContextId === 0, but we pass undefined to many APIs just in case.
@ -2859,22 +2853,16 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ this._permissions = new Map(); + this._permissions = new Map();
+ this._registry._browserContextIdToBrowserContext.set(this.browserContextId, this); + this._registry._browserContextIdToBrowserContext.set(this.browserContextId, this);
+ this._registry._userContextIdToBrowserContext.set(this.userContextId, this); + this._registry._userContextIdToBrowserContext.set(this.userContextId, this);
+ this.options = options || {}; + this.removeOnDetach = removeOnDetach;
+ this.options.scriptsToEvaluateOnNewDocument = []; + this.extraHTTPHeaders = undefined;
+ this.options.bindings = []; + this.httpCredentials = undefined;
+ this.requestInterceptionEnabled = undefined;
+ this.ignoreHTTPSErrors = undefined;
+ this.downloadOptions = undefined;
+ this.scriptsToEvaluateOnNewDocument = [];
+ this.bindings = [];
+ this.settings = {};
+ this.pages = new Set(); + this.pages = new Set();
+
+ if (this.options.ignoreHTTPSErrors) {
+ Preferences.set("network.stricttransportsecurity.preloadlist", false);
+ Preferences.set("security.cert_pinning.enforcement_level", 0);
+
+ const certOverrideService = Cc[
+ "@mozilla.org/security/certoverride;1"
+ ].getService(Ci.nsICertOverrideService);
+ certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(
+ true, this.userContextId
+ );
+ }
+ } + }
+ +
+ async destroy() { + async destroy() {
@ -2896,29 +2884,35 @@ index 0000000000000000000000000000000000000000..97221bb293315abe2ecbb954aebd17a1
+ this._registry._userContextIdToBrowserContext.delete(this.userContextId); + this._registry._userContextIdToBrowserContext.delete(this.userContextId);
+ } + }
+ +
+ setIgnoreHTTPSErrors(ignoreHTTPSErrors) {
+ if (this.ignoreHTTPSErrors === ignoreHTTPSErrors)
+ return;
+ this.ignoreHTTPSErrors = ignoreHTTPSErrors;
+ const certOverrideService = Cc[
+ "@mozilla.org/security/certoverride;1"
+ ].getService(Ci.nsICertOverrideService);
+ if (ignoreHTTPSErrors) {
+ Preferences.set("network.stricttransportsecurity.preloadlist", false);
+ Preferences.set("security.cert_pinning.enforcement_level", 0);
+ certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(true, this.userContextId);
+ } else {
+ certOverrideService.setDisableAllSecurityChecksAndLetAttackersInterceptMyData(false, this.userContextId);
+ }
+ }
+
+ async addScriptToEvaluateOnNewDocument(script) { + async addScriptToEvaluateOnNewDocument(script) {
+ this.options.scriptsToEvaluateOnNewDocument.push(script); + this.scriptsToEvaluateOnNewDocument.push(script);
+ await Promise.all(Array.from(this.pages).map(page => page.addScriptToEvaluateOnNewDocument(script))); + await Promise.all(Array.from(this.pages).map(page => page.addScriptToEvaluateOnNewDocument(script)));
+ } + }
+ +
+ async addBinding(name, script) { + async addBinding(name, script) {
+ this.options.bindings.push({ name, script }); + this.bindings.push({ name, script });
+ await Promise.all(Array.from(this.pages).map(page => page.addBinding(name, script))); + await Promise.all(Array.from(this.pages).map(page => page.addBinding(name, script)));
+ } + }
+ +
+ async setGeolocationOverride(geolocation) { + async applySetting(name, value) {
+ this.options.geolocation = geolocation; + this.settings[name] = value;
+ await Promise.all(Array.from(this.pages).map(page => page.setGeolocationOverride(geolocation))); + await Promise.all(Array.from(this.pages).map(page => page.applyContextSetting(name, value)));
+ }
+
+ async setOnlineOverride(override) {
+ this.options.onlineOverride = override;
+ await Promise.all(Array.from(this.pages).map(page => page.setOnlineOverride(override)));
+ }
+
+ async setColorScheme(colorScheme) {
+ this.options.colorScheme = colorScheme;
+ await Promise.all(Array.from(this.pages).map(page => page.setColorScheme(colorScheme)));
+ } + }
+ +
+ async grantPermissions(origin, permissions) { + async grantPermissions(origin, permissions) {
@ -5420,10 +5414,10 @@ index 0000000000000000000000000000000000000000..3a386425d3796d0a6786dea193b3402d
+ +
diff --git a/juggler/content/main.js b/juggler/content/main.js diff --git a/juggler/content/main.js b/juggler/content/main.js
new file mode 100644 new file mode 100644
index 0000000000000000000000000000000000000000..848b8daab8655df61ba2aaebc1abf02ffdc94b6d index 0000000000000000000000000000000000000000..ef33a19f8fd4f8abefac1470aa7c79b66d822860
--- /dev/null --- /dev/null
+++ b/juggler/content/main.js +++ b/juggler/content/main.js
@@ -0,0 +1,165 @@ @@ -0,0 +1,174 @@
+const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm"); +const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const {Helper} = ChromeUtils.import('chrome://juggler/content/Helper.js'); +const {Helper} = ChromeUtils.import('chrome://juggler/content/Helper.js');
+const {FrameTree} = ChromeUtils.import('chrome://juggler/content/content/FrameTree.js'); +const {FrameTree} = ChromeUtils.import('chrome://juggler/content/content/FrameTree.js');
@ -5453,7 +5447,10 @@ index 0000000000000000000000000000000000000000..848b8daab8655df61ba2aaebc1abf02f
+ handler.dispose(); + handler.dispose();
+} +}
+ +
+function setGeolocationOverrideInDocShell(geolocation) { +let failedToOverrideTimezone = false;
+
+const applySetting = {
+ geolocation: (geolocation) => {
+ if (geolocation) { + if (geolocation) {
+ docShell.setGeolocationOverride({ + docShell.setGeolocationOverride({
+ coords: { + coords: {
@ -5471,59 +5468,73 @@ index 0000000000000000000000000000000000000000..848b8daab8655df61ba2aaebc1abf02f
+ } else { + } else {
+ docShell.setGeolocationOverride(null); + docShell.setGeolocationOverride(null);
+ } + }
+} + },
+ +
+function setOnlineOverrideInDocShell(override) { + onlineOverride: (onlineOverride) => {
+ if (!override) { + if (!onlineOverride) {
+ docShell.onlineOverride = Ci.nsIDocShell.ONLINE_OVERRIDE_NONE; + docShell.onlineOverride = Ci.nsIDocShell.ONLINE_OVERRIDE_NONE;
+ return; + return;
+ } + }
+ docShell.onlineOverride = override === 'online' ? + docShell.onlineOverride = onlineOverride === 'online' ?
+ Ci.nsIDocShell.ONLINE_OVERRIDE_ONLINE : Ci.nsIDocShell.ONLINE_OVERRIDE_OFFLINE; + Ci.nsIDocShell.ONLINE_OVERRIDE_ONLINE : Ci.nsIDocShell.ONLINE_OVERRIDE_OFFLINE;
+} + },
+
+ userAgent: (userAgent) => {
+ docShell.browsingContext.customUserAgent = userAgent;
+ },
+
+ bypassCSP: (bypassCSP) => {
+ docShell.bypassCSPEnabled = bypassCSP;
+ },
+
+ timezoneId: (timezoneId) => {
+ failedToOverrideTimezone = !docShell.overrideTimezone(timezoneId);
+ },
+
+ locale: (locale) => {
+ docShell.languageOverride = locale;
+ },
+
+ javaScriptDisabled: (javaScriptDisabled) => {
+ docShell.allowJavascript = !javaScriptDisabled;
+ },
+
+ hasTouch: (hasTouch) => {
+ docShell.touchEventsOverride = hasTouch ? Ci.nsIDocShell.TOUCHEVENTS_OVERRIDE_ENABLED : Ci.nsIDocShell.TOUCHEVENTS_OVERRIDE_NONE;
+ },
+
+ colorScheme: (colorScheme) => {
+ frameTree.setColorScheme(colorScheme);
+ },
+
+ defaultViewport: (viewport) => {
+ docShell.contentViewer.overrideDPPX = viewport.deviceScaleFactor || this._initialDPPX;
+ docShell.deviceSizeIsPageSize = true;
+ },
+};
+ +
+function initialize() { +function initialize() {
+ const loadContext = docShell.QueryInterface(Ci.nsILoadContext); + const loadContext = docShell.QueryInterface(Ci.nsILoadContext);
+ const userContextId = loadContext.originAttributes.userContextId; + const userContextId = loadContext.originAttributes.userContextId;
+ +
+ let response = sendSyncMessage('juggler:content-ready', { userContextId })[0]; + const response = sendSyncMessage('juggler:content-ready', { userContextId })[0];
+ if (!response) + const {
+ response = { sessionIds: [], browserContextOptions: {} }; + sessionIds = [],
+ + scriptsToEvaluateOnNewDocument = [],
+ const { sessionIds, browserContextOptions } = response; + bindings = [],
+ const { userAgent, bypassCSP, javaScriptDisabled, viewport, scriptsToEvaluateOnNewDocument, bindings, locale, timezoneId, geolocation, onlineOverride, colorScheme } = browserContextOptions; + settings = {}
+ + } = response || {};
+ let failedToOverrideTimezone = false;
+ if (timezoneId)
+ failedToOverrideTimezone = !docShell.overrideTimezone(timezoneId);
+ if (userAgent !== undefined)
+ docShell.browsingContext.customUserAgent = userAgent;
+ if (bypassCSP !== undefined)
+ docShell.bypassCSPEnabled = bypassCSP;
+ if (javaScriptDisabled !== undefined)
+ docShell.allowJavascript = !javaScriptDisabled;
+ if (locale !== undefined)
+ docShell.languageOverride = locale;
+ if (geolocation !== undefined)
+ setGeolocationOverrideInDocShell(geolocation);
+ if (onlineOverride !== undefined)
+ setOnlineOverrideInDocShell(onlineOverride);
+ if (viewport !== undefined) {
+ docShell.contentViewer.overrideDPPX = viewport.deviceScaleFactor || this._initialDPPX;
+ docShell.touchEventsOverride = viewport.hasTouch ? Ci.nsIDocShell.TOUCHEVENTS_OVERRIDE_ENABLED : Ci.nsIDocShell.TOUCHEVENTS_OVERRIDE_NONE;
+ docShell.deviceSizeIsPageSize = true;
+ scrollbarManager.setFloatingScrollbars(viewport.isMobile);
+ }
+ +
+ // Enforce focused state for all top level documents. + // Enforce focused state for all top level documents.
+ docShell.overrideHasFocus = true; + docShell.overrideHasFocus = true;
+
+ frameTree = new FrameTree(docShell); + frameTree = new FrameTree(docShell);
+ if (colorScheme !== undefined) + for (const [name, value] of Object.entries(settings)) {
+ frameTree.setColorScheme(colorScheme); + if (value !== undefined)
+ for (const script of scriptsToEvaluateOnNewDocument || []) + applySetting[name](value);
+ }
+ for (const script of scriptsToEvaluateOnNewDocument)
+ frameTree.addScriptToEvaluateOnNewDocument(script); + frameTree.addScriptToEvaluateOnNewDocument(script);
+ for (const { name, script } of bindings || []) + for (const { name, script } of bindings)
+ frameTree.addBinding(name, script); + frameTree.addBinding(name, script);
+ networkMonitor = new NetworkMonitor(docShell, frameTree); + networkMonitor = new NetworkMonitor(docShell, frameTree);
+ +
@ -5545,20 +5556,12 @@ index 0000000000000000000000000000000000000000..848b8daab8655df61ba2aaebc1abf02f
+ frameTree.addScriptToEvaluateOnNewDocument(script); + frameTree.addScriptToEvaluateOnNewDocument(script);
+ }, + },
+ +
+ addBinding(name, script) { + addBinding({name, script}) {
+ frameTree.addBinding(name, script); + frameTree.addBinding(name, script);
+ }, + },
+ +
+ setGeolocationOverride(geolocation) { + applyContextSetting({name, value}) {
+ setGeolocationOverrideInDocShell(geolocation); + applySetting[name](value);
+ },
+
+ setOnlineOverride(override) {
+ setOnlineOverrideInDocShell(override);
+ },
+
+ setColorScheme(colorScheme) {
+ frameTree.setColorScheme(colorScheme);
+ }, + },
+ +
+ ensurePermissions() { + ensurePermissions() {
@ -5668,10 +5671,10 @@ index 0000000000000000000000000000000000000000..bf37558bccc48f4d90eadc971c1eb3e4
+this.AccessibilityHandler = AccessibilityHandler; +this.AccessibilityHandler = AccessibilityHandler;
diff --git a/juggler/protocol/BrowserHandler.js b/juggler/protocol/BrowserHandler.js diff --git a/juggler/protocol/BrowserHandler.js b/juggler/protocol/BrowserHandler.js
new file mode 100644 new file mode 100644
index 0000000000000000000000000000000000000000..21ea3ef1451d02b36f884cf3c6ef3df81bd1a9b9 index 0000000000000000000000000000000000000000..1d304e2996c62df07d823b4cffd1eb309cba29ab
--- /dev/null --- /dev/null
+++ b/juggler/protocol/BrowserHandler.js +++ b/juggler/protocol/BrowserHandler.js
@@ -0,0 +1,199 @@ @@ -0,0 +1,239 @@
+"use strict"; +"use strict";
+ +
+const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm"); +const {Services} = ChromeUtils.import("resource://gre/modules/Services.jsm");
@ -5719,10 +5722,10 @@ index 0000000000000000000000000000000000000000..21ea3ef1451d02b36f884cf3c6ef3df8
+ ]; + ];
+ } + }
+ +
+ async createBrowserContext(options) { + async createBrowserContext({removeOnDetach}) {
+ if (!this._enabled) + if (!this._enabled)
+ throw new Error('Browser domain is not enabled'); + throw new Error('Browser domain is not enabled');
+ const browserContext = this._targetRegistry.createBrowserContext(options); + const browserContext = this._targetRegistry.createBrowserContext(removeOnDetach);
+ this._createdBrowserContextIds.add(browserContext.browserContextId); + this._createdBrowserContextIds.add(browserContext.browserContextId);
+ return {browserContextId: browserContext.browserContextId}; + return {browserContextId: browserContext.browserContextId};
+ } + }
@ -5743,7 +5746,7 @@ index 0000000000000000000000000000000000000000..21ea3ef1451d02b36f884cf3c6ef3df8
+ this._attachedSessions.clear(); + this._attachedSessions.clear();
+ for (const browserContextId of this._createdBrowserContextIds) { + for (const browserContextId of this._createdBrowserContextIds) {
+ const browserContext = this._targetRegistry.browserContextForId(browserContextId); + const browserContext = this._targetRegistry.browserContextForId(browserContextId);
+ if (browserContext.options.removeOnDetach) + if (browserContext.removeOnDetach)
+ browserContext.destroy(); + browserContext.destroy();
+ } + }
+ this._createdBrowserContextIds.clear(); + this._createdBrowserContextIds.clear();
@ -5814,27 +5817,63 @@ index 0000000000000000000000000000000000000000..21ea3ef1451d02b36f884cf3c6ef3df8
+ } + }
+ +
+ setExtraHTTPHeaders({browserContextId, headers}) { + setExtraHTTPHeaders({browserContextId, headers}) {
+ this._targetRegistry.browserContextForId(browserContextId).options.extraHTTPHeaders = headers; + this._targetRegistry.browserContextForId(browserContextId).extraHTTPHeaders = headers;
+ } + }
+ +
+ setHTTPCredentials({browserContextId, credentials}) { + setHTTPCredentials({browserContextId, credentials}) {
+ this._targetRegistry.browserContextForId(browserContextId).options.httpCredentials = credentials; + this._targetRegistry.browserContextForId(browserContextId).httpCredentials = nullToUndefined(credentials);
+ } + }
+ +
+ setRequestInterception({browserContextId, enabled}) { + setRequestInterception({browserContextId, enabled}) {
+ this._targetRegistry.browserContextForId(browserContextId).options.requestInterceptionEnabled = enabled; + this._targetRegistry.browserContextForId(browserContextId).requestInterceptionEnabled = enabled;
+ }
+
+ setIgnoreHTTPSErrors({browserContextId, ignoreHTTPSErrors}) {
+ this._targetRegistry.browserContextForId(browserContextId).setIgnoreHTTPSErrors(nullToUndefined(ignoreHTTPSErrors));
+ }
+
+ setDownloadOptions({browserContextId, downloadOptions}) {
+ this._targetRegistry.browserContextForId(browserContextId).downloadOptions = nullToUndefined(downloadOptions);
+ } + }
+ +
+ async setGeolocationOverride({browserContextId, geolocation}) { + async setGeolocationOverride({browserContextId, geolocation}) {
+ await this._targetRegistry.browserContextForId(browserContextId).setGeolocationOverride(geolocation); + await this._targetRegistry.browserContextForId(browserContextId).applySetting('geolocation', nullToUndefined(geolocation));
+ } + }
+ +
+ async setOnlineOverride({browserContextId, override}) { + async setOnlineOverride({browserContextId, override}) {
+ await this._targetRegistry.browserContextForId(browserContextId).setOnlineOverride(override); + await this._targetRegistry.browserContextForId(browserContextId).applySetting('onlineOverride', nullToUndefined(override));
+ } + }
+ +
+ async setColorScheme({browserContextId, colorScheme}) { + async setColorScheme({browserContextId, colorScheme}) {
+ await this._targetRegistry.browserContextForId(browserContextId).setColorScheme(colorScheme); + await this._targetRegistry.browserContextForId(browserContextId).applySetting('colorScheme', nullToUndefined(colorScheme));
+ }
+
+ async setUserAgentOverride({browserContextId, userAgent}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('userAgent', nullToUndefined(userAgent));
+ }
+
+ async setBypassCSP({browserContextId, bypassCSP}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('bypassCSP', nullToUndefined(bypassCSP));
+ }
+
+ async setJavaScriptDisabled({browserContextId, javaScriptDisabled}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('javaScriptDisabled', nullToUndefined(javaScriptDisabled));
+ }
+
+ async setLocaleOverride({browserContextId, locale}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('locale', nullToUndefined(locale));
+ }
+
+ async setTimezoneOverride({browserContextId, timezoneId}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('timezoneId', nullToUndefined(timezoneId));
+ }
+
+ async setTouchOverride({browserContextId, hasTouch}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('hasTouch', nullToUndefined(hasTouch));
+ }
+
+ async setDefaultViewport({browserContextId, viewport}) {
+ await this._targetRegistry.browserContextForId(browserContextId).applySetting('defaultViewport', nullToUndefined(viewport));
+ } + }
+ +
+ async addScriptToEvaluateOnNewDocument({browserContextId, script}) { + async addScriptToEvaluateOnNewDocument({browserContextId, script}) {
@ -5869,6 +5908,10 @@ index 0000000000000000000000000000000000000000..21ea3ef1451d02b36f884cf3c6ef3df8
+ } + }
+} +}
+ +
+function nullToUndefined(value) {
+ return value === null ? undefined : value;
+}
+
+var EXPORTED_SYMBOLS = ['BrowserHandler']; +var EXPORTED_SYMBOLS = ['BrowserHandler'];
+this.BrowserHandler = BrowserHandler; +this.BrowserHandler = BrowserHandler;
diff --git a/juggler/protocol/Dispatcher.js b/juggler/protocol/Dispatcher.js diff --git a/juggler/protocol/Dispatcher.js b/juggler/protocol/Dispatcher.js
@ -6678,10 +6721,10 @@ index 0000000000000000000000000000000000000000..78b6601b91d0b7fcda61114e6846aa07
+this.EXPORTED_SYMBOLS = ['t', 'checkScheme']; +this.EXPORTED_SYMBOLS = ['t', 'checkScheme'];
diff --git a/juggler/protocol/Protocol.js b/juggler/protocol/Protocol.js diff --git a/juggler/protocol/Protocol.js b/juggler/protocol/Protocol.js
new file mode 100644 new file mode 100644
index 0000000000000000000000000000000000000000..76445a317969f569f080bbec116c59a37587ef84 index 0000000000000000000000000000000000000000..e6bb9a8d5b553531a2ee22e27e693dd0569bda22
--- /dev/null --- /dev/null
+++ b/juggler/protocol/Protocol.js +++ b/juggler/protocol/Protocol.js
@@ -0,0 +1,801 @@ @@ -0,0 +1,845 @@
+const {t, checkScheme} = ChromeUtils.import('chrome://juggler/content/protocol/PrimitiveTypes.js'); +const {t, checkScheme} = ChromeUtils.import('chrome://juggler/content/protocol/PrimitiveTypes.js');
+ +
+// Protocol-specific types. +// Protocol-specific types.
@ -6752,8 +6795,6 @@ index 0000000000000000000000000000000000000000..76445a317969f569f080bbec116c59a3
+pageTypes.Viewport = { +pageTypes.Viewport = {
+ viewportSize: pageTypes.Size, + viewportSize: pageTypes.Size,
+ deviceScaleFactor: t.Number, + deviceScaleFactor: t.Number,
+ isMobile: t.Boolean,
+ hasTouch: t.Boolean,
+}; +};
+ +
+pageTypes.DOMQuad = { +pageTypes.DOMQuad = {
@ -6910,14 +6951,6 @@ index 0000000000000000000000000000000000000000..76445a317969f569f080bbec116c59a3
+ 'createBrowserContext': { + 'createBrowserContext': {
+ params: { + params: {
+ removeOnDetach: t.Optional(t.Boolean), + removeOnDetach: t.Optional(t.Boolean),
+ userAgent: t.Optional(t.String),
+ bypassCSP: t.Optional(t.Boolean),
+ ignoreHTTPSErrors: t.Optional(t.Boolean),
+ javaScriptDisabled: t.Optional(t.Boolean),
+ viewport: t.Optional(pageTypes.Viewport),
+ locale: t.Optional(t.String),
+ timezoneId: t.Optional(t.String),
+ downloadOptions: t.Optional(browserTypes.DownloadOptions),
+ }, + },
+ returns: { + returns: {
+ browserContextId: t.String, + browserContextId: t.String,
@ -6967,6 +7000,60 @@ index 0000000000000000000000000000000000000000..76445a317969f569f080bbec116c59a3
+ geolocation: t.Nullable(browserTypes.Geolocation), + geolocation: t.Nullable(browserTypes.Geolocation),
+ } + }
+ }, + },
+ 'setUserAgentOverride': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ userAgent: t.Nullable(t.String),
+ }
+ },
+ 'setBypassCSP': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ bypassCSP: t.Nullable(t.Boolean),
+ }
+ },
+ 'setIgnoreHTTPSErrors': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ ignoreHTTPSErrors: t.Nullable(t.Boolean),
+ }
+ },
+ 'setJavaScriptDisabled': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ javaScriptDisabled: t.Nullable(t.Boolean),
+ }
+ },
+ 'setLocaleOverride': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ locale: t.Nullable(t.String),
+ }
+ },
+ 'setTimezoneOverride': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ timezoneId: t.Nullable(t.String),
+ }
+ },
+ 'setDownloadOptions': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ downloadOptions: t.Nullable(browserTypes.DownloadOptions),
+ }
+ },
+ 'setTouchOverride': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ hasTouch: t.Nullable(t.Boolean),
+ }
+ },
+ 'setDefaultViewport': {
+ params: {
+ browserContextId: t.Optional(t.String),
+ viewport: t.Nullable(pageTypes.Viewport),
+ }
+ },
+ 'addScriptToEvaluateOnNewDocument': { + 'addScriptToEvaluateOnNewDocument': {
+ params: { + params: {
+ browserContextId: t.Optional(t.String), + browserContextId: t.Optional(t.String),
@ -7014,13 +7101,13 @@ index 0000000000000000000000000000000000000000..76445a317969f569f080bbec116c59a3
+ 'setOnlineOverride': { + 'setOnlineOverride': {
+ params: { + params: {
+ browserContextId: t.Optional(t.String), + browserContextId: t.Optional(t.String),
+ override: t.Optional(t.Enum(['online', 'offline'])), + override: t.Nullable(t.Enum(['online', 'offline'])),
+ } + }
+ }, + },
+ 'setColorScheme': { + 'setColorScheme': {
+ params: { + params: {
+ browserContextId: t.Optional(t.String), + browserContextId: t.Optional(t.String),
+ colorScheme: t.Optional(t.Enum(['dark', 'light', 'no-preference'])), + colorScheme: t.Nullable(t.Enum(['dark', 'light', 'no-preference'])),
+ }, + },
+ }, + },
+ }, + },