@checkly/playwright-core 1.42.17 → 1.47.11

package/lib/server/trace/viewer/traceViewer.js

@@ -3,8 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.installRootRedirect = installRootRedirect;
 exports.openTraceInBrowser = openTraceInBrowser;
 exports.openTraceViewerApp = openTraceViewerApp;
+exports.runTraceInBrowser = runTraceInBrowser;
+exports.runTraceViewerApp = runTraceViewerApp;
+exports.startTraceViewerServer = startTraceViewerServer;
 var _path = _interopRequireDefault(require("path"));
 var _fs = _interopRequireDefault(require("fs"));
 var _httpServer = require("../../../utils/httpServer");
@@ -31,17 +35,15 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * limitations under the License.
  */
 
-async function startTraceViewerServer(traceUrls, options) {
+function validateTraceUrls(traceUrls) {
   for (const traceUrl of traceUrls) {
     let traceFile = traceUrl;
     // If .json is requested, we'll synthesize it.
     if (traceUrl.endsWith('.json')) traceFile = traceUrl.substring(0, traceUrl.length - '.json'.length);
-    if (!traceUrl.startsWith('http://') && !traceUrl.startsWith('https://') && !_fs.default.existsSync(traceFile) && !_fs.default.existsSync(traceFile + '.trace')) {
-      // eslint-disable-next-line no-console
-      console.error(`Trace file ${traceUrl} does not exist!`);
-      (0, _utils.gracefullyProcessExitDoNotHang)(1);
-    }
+    if (!traceUrl.startsWith('http://') && !traceUrl.startsWith('https://') && !_fs.default.existsSync(traceFile) && !_fs.default.existsSync(traceFile + '.trace')) throw new Error(`Trace file ${traceUrl} does not exist!`);
   }
+}
+async function startTraceViewerServer(options) {
   const server = new _httpServer.HttpServer();
   server.routePrefix('/trace', (request, response) => {
     const url = new URL('http://localhost' + request.url);
@@ -68,67 +70,57 @@ async function startTraceViewerServer(traceUrls, options) {
     const absolutePath = _path.default.join(__dirname, '..', '..', '..', 'vite', 'traceViewer', ...relativePath.split('/'));
     return server.serveFile(request, response, absolutePath);
   });
-  const params = traceUrls.map(t => `trace=${encodeURIComponent(t)}`);
   const transport = (options === null || options === void 0 ? void 0 : options.transport) || (options !== null && options !== void 0 && options.isServer ? new StdinServer() : undefined);
-  if (transport) {
-    const guid = (0, _utils.createGuid)();
-    params.push('ws=' + guid);
-    const wss = new _utilsBundle.wsServer({
-      server: server.server(),
-      path: '/' + guid
-    });
-    wss.on('connection', ws => {
-      transport.sendEvent = (method, params) => ws.send(JSON.stringify({
-        method,
-        params
-      }));
-      transport.close = () => ws.close();
-      ws.on('message', async message => {
-        const {
-          id,
-          method,
-          params
-        } = JSON.parse(message);
-        const result = await transport.dispatch(method, params);
-        ws.send(JSON.stringify({
-          id,
-          result
-        }));
-      });
-      ws.on('close', () => transport.onclose());
-      ws.on('error', () => transport.onclose());
-    });
-  }
-  if (options !== null && options !== void 0 && options.isServer) params.push('isServer');
-  if ((0, _utils.isUnderTest)()) params.push('isUnderTest=true');
+  if (transport) server.createWebSocket(transport);
   const {
     host,
     port
   } = options || {};
-  const url = await server.start({
+  await server.start({
     preferredPort: port,
     host
   });
-  const {
-    app
-  } = options || {};
-  const searchQuery = params.length ? '?' + params.join('&') : '';
-  const urlPath = `/trace/${app || 'index.html'}${searchQuery}`;
-  server.routePath('/', (request, response) => {
+  return server;
+}
+async function installRootRedirect(server, traceUrls, options) {
+  const params = new URLSearchParams();
+  for (const traceUrl of traceUrls) params.append('trace', traceUrl);
+  if (server.wsGuid()) params.append('ws', server.wsGuid());
+  if (options !== null && options !== void 0 && options.isServer) params.append('isServer', '');
+  if ((0, _utils.isUnderTest)()) params.append('isUnderTest', 'true');
+  for (const arg of options.args || []) params.append('arg', arg);
+  if (options.grep) params.append('grep', options.grep);
+  if (options.grepInvert) params.append('grepInvert', options.grepInvert);
+  for (const project of options.project || []) params.append('project', project);
+  if (options.workers) params.append('workers', String(options.workers));
+  if (options.timeout) params.append('timeout', String(options.timeout));
+  if (options.headed) params.append('headed', '');
+  if (options.outputDir) params.append('outputDir', options.outputDir);
+  if (options.updateSnapshots) params.append('updateSnapshots', options.updateSnapshots);
+  for (const reporter of options.reporter || []) params.append('reporter', reporter);
+  const urlPath = `./trace/${options.webApp || 'index.html'}?${params.toString()}`;
+  server.routePath('/', (_, response) => {
     response.statusCode = 302;
-    response.setHeader('Location', urlPath + request.url.substring(1));
+    response.setHeader('Location', urlPath);
     response.end();
     return true;
   });
-  return {
-    server,
-    url
-  };
 }
-async function openTraceViewerApp(traceUrls, browserName, options) {
-  const {
-    url
-  } = await startTraceViewerServer(traceUrls, options);
+async function runTraceViewerApp(traceUrls, browserName, options, exitOnClose) {
+  validateTraceUrls(traceUrls);
+  const server = await startTraceViewerServer(options);
+  await installRootRedirect(server, traceUrls, options);
+  const page = await openTraceViewerApp(server.urlPrefix('precise'), browserName, options);
+  if (exitOnClose) page.on('close', () => (0, _utils.gracefullyProcessExitDoNotHang)(0));
+  return page;
+}
+async function runTraceInBrowser(traceUrls, options) {
+  validateTraceUrls(traceUrls);
+  const server = await startTraceViewerServer(options);
+  await installRootRedirect(server, traceUrls, options);
+  await openTraceInBrowser(server.urlPrefix('human-readable'));
+}
+async function openTraceViewerApp(url, browserName, options) {
   const traceViewerPlaywright = (0, _playwright.createPlaywright)({
     sdkLanguage: 'javascript',
     isInternalPlaywright: true
@@ -147,7 +139,7 @@ async function openTraceViewerApp(traceUrls, browserName, options) {
     persistentContextOptions: {
       ...(options === null || options === void 0 ? void 0 : options.persistentContextOptions),
       useWebSocket: (0, _utils.isUnderTest)(),
-      headless: options === null || options === void 0 ? void 0 : options.headless
+      headless: !!(options !== null && options !== void 0 && options.headless)
     }
   });
   const controller = new _progress.ProgressController((0, _instrumentation.serverSideCallMetadata)(), context._browser);
@@ -162,10 +154,7 @@ async function openTraceViewerApp(traceUrls, browserName, options) {
   await page.mainFrame().goto((0, _instrumentation.serverSideCallMetadata)(), url);
   return page;
 }
-async function openTraceInBrowser(traceUrls, options) {
-  const {
-    url
-  } = await startTraceViewerServer(traceUrls, options);
+async function openTraceInBrowser(url) {
   // eslint-disable-next-line no-console
   console.log('\nListening on ' + url);
   if (!(0, _utils.isUnderTest)()) await (0, _utilsBundle.open)(url.replace('0.0.0.0', 'localhost')).catch(() => {});
@@ -184,19 +173,17 @@ class StdinServer {
     process.stdin.on('close', () => (0, _utils.gracefullyProcessExitDoNotHang)(0));
   }
   async dispatch(method, params) {
-    if (method === 'ready') {
+    if (method === 'initialize') {
       if (this._traceUrl) this._loadTrace(this._traceUrl);
     }
   }
-  onclose() {
-    (0, _utils.gracefullyProcessExitDoNotHang)(0);
-  }
-  _loadTrace(url) {
+  onclose() {}
+  _loadTrace(traceUrl) {
     var _this$sendEvent;
-    this._traceUrl = url;
+    this._traceUrl = traceUrl;
     clearTimeout(this._pollTimer);
-    (_this$sendEvent = this.sendEvent) === null || _this$sendEvent === void 0 || _this$sendEvent.call(this, 'loadTrace', {
-      url
+    (_this$sendEvent = this.sendEvent) === null || _this$sendEvent === void 0 || _this$sendEvent.call(this, 'loadTraceRequested', {
+      traceUrl
     });
   }
   _pollLoadTrace(url) {

package/lib/server/transport.js

@@ -155,7 +155,7 @@ class WebSocketTransport {
     this._ws.addEventListener('close', event => {
       var _this$_progress3;
       (_this$_progress3 = this._progress) === null || _this$_progress3 === void 0 || _this$_progress3.log(`<ws disconnected> ${logUrl} code=${event.code} reason=${event.reason}`);
-      if (this.onclose) this.onclose.call(null);
+      if (this.onclose) this.onclose.call(null, event.reason);
     });
     // Prevent Error: read ECONNRESET.
     this._ws.addEventListener('error', error => {

package/lib/server/webkit/webkit.js

@@ -31,28 +31,28 @@ class WebKit extends _browserType.BrowserType {
   constructor(parent) {
     super(parent, 'webkit');
   }
-  _connectToTransport(transport, options) {
+  connectToTransport(transport, options) {
     return _wkBrowser.WKBrowser.connect(this.attribution.playwright, transport, options);
   }
-  _amendEnvironment(env, userDataDir, executable, browserArguments) {
+  amendEnvironment(env, userDataDir, executable, browserArguments) {
     return {
       ...env,
       CURL_COOKIE_JAR_PATH: _path.default.join(userDataDir, 'cookiejar.db')
     };
   }
-  _doRewriteStartupLog(error) {
+  doRewriteStartupLog(error) {
     if (!error.logs) return error;
     if (error.logs.includes('cannot open display')) error.logs = '\n' + (0, _utils.wrapInASCIIBox)(_browserType.kNoXServerRunningError, 1);
     return error;
   }
-  _attemptToGracefullyCloseBrowser(transport) {
+  attemptToGracefullyCloseBrowser(transport) {
     transport.send({
       method: 'Playwright.close',
       params: {},
       id: _wkConnection.kBrowserCloseMessageId
     });
   }
-  _defaultArgs(options, isPersistent, userDataDir) {
+  defaultArgs(options, isPersistent, userDataDir) {
     const {
       args = [],
       proxy,

package/lib/server/webkit/wkBrowser.js

@@ -7,7 +7,6 @@ exports.WKBrowserContext = exports.WKBrowser = void 0;
 var _browser = require("../browser");
 var _browserContext = require("../browserContext");
 var _utils = require("../../utils");
-var _eventsHelper = require("../../utils/eventsHelper");
 var network = _interopRequireWildcard(require("../network"));
 var _wkConnection = require("./wkConnection");
 var _wkPage = require("./wkPage");
@@ -31,8 +30,8 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  * limitations under the License.
  */
 
-const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.4 Safari/605.1.15';
-const BROWSER_VERSION = '17.4';
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.0 Safari/605.1.15';
+const BROWSER_VERSION = '18.0';
 class WKBrowser extends _browser.Browser {
   static async connect(parent, transport, options) {
     const browser = new WKBrowser(parent, transport, options);
@@ -53,10 +52,17 @@ class WKBrowser extends _browser.Browser {
     this._browserSession = void 0;
     this._contexts = new Map();
     this._wkPages = new Map();
-    this._eventListeners = void 0;
     this._connection = new _wkConnection.WKConnection(transport, this._onDisconnect.bind(this), options.protocolLogger, options.browserLogsCollector);
     this._browserSession = this._connection.browserSession;
-    this._eventListeners = [_eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.pageProxyCreated', this._onPageProxyCreated.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.pageProxyDestroyed', this._onPageProxyDestroyed.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.provisionalLoadFailed', event => this._onProvisionalLoadFailed(event)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.windowOpen', event => this._onWindowOpen(event)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.downloadCreated', this._onDownloadCreated.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.downloadFilenameSuggested', this._onDownloadFilenameSuggested.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.downloadFinished', this._onDownloadFinished.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, 'Playwright.screencastFinished', this._onScreencastFinished.bind(this)), _eventsHelper.eventsHelper.addEventListener(this._browserSession, _wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this))];
+    this._browserSession.on('Playwright.pageProxyCreated', this._onPageProxyCreated.bind(this));
+    this._browserSession.on('Playwright.pageProxyDestroyed', this._onPageProxyDestroyed.bind(this));
+    this._browserSession.on('Playwright.provisionalLoadFailed', event => this._onProvisionalLoadFailed(event));
+    this._browserSession.on('Playwright.windowOpen', event => this._onWindowOpen(event));
+    this._browserSession.on('Playwright.downloadCreated', this._onDownloadCreated.bind(this));
+    this._browserSession.on('Playwright.downloadFilenameSuggested', this._onDownloadFilenameSuggested.bind(this));
+    this._browserSession.on('Playwright.downloadFinished', this._onDownloadFinished.bind(this));
+    this._browserSession.on('Playwright.screencastFinished', this._onScreencastFinished.bind(this));
+    this._browserSession.on(_wkConnection.kPageProxyMessageReceived, this._onPageProxyMessageReceived.bind(this));
   }
   _onDisconnect() {
     for (const wkPage of this._wkPages.values()) wkPage.didClose();
@@ -240,7 +246,7 @@ class WKBrowserContext extends _browserContext.BrowserContext {
       browserContextId: this._browserContextId
     });
   }
-  async clearCookies() {
+  async doClearCookies() {
     await this._browser._browserSession.send('Playwright.deleteAllCookies', {
       browserContextId: this._browserContextId
     });
@@ -279,18 +285,12 @@ class WKBrowserContext extends _browserContext.BrowserContext {
     this._options.httpCredentials = httpCredentials;
     for (const page of this.pages()) await page._delegate.updateHttpCredentials();
   }
-  async doAddInitScript(source) {
+  async doAddInitScript(initScript) {
     for (const page of this.pages()) await page._delegate._updateBootstrapScript();
   }
-  async doRemoveInitScripts() {
+  async doRemoveNonInternalInitScripts() {
     for (const page of this.pages()) await page._delegate._updateBootstrapScript();
   }
-  async doExposeBinding(binding) {
-    for (const page of this.pages()) await page._delegate.exposeBinding(binding);
-  }
-  async doRemoveExposedBindings() {
-    for (const page of this.pages()) await page._delegate.removeExposedBindings();
-  }
   async doUpdateRequestInterception() {
     for (const page of this.pages()) await page._delegate.updateRequestInterception();
   }

package/lib/server/webkit/wkConnection.js

@@ -32,7 +32,7 @@ const kBrowserCloseMessageId = exports.kBrowserCloseMessageId = -9999;
 
 // We emulate kPageProxyMessageReceived message to unify it with Browser.pageProxyCreated
 // and Browser.pageProxyDestroyed for easier management.
-const kPageProxyMessageReceived = exports.kPageProxyMessageReceived = 'kPageProxyMessageReceived';
+const kPageProxyMessageReceived = exports.kPageProxyMessageReceived = Symbol('kPageProxyMessageReceived');
 class WKConnection {
   constructor(transport, onDisconnect, protocolLogger, browserLogsCollector) {
     this._transport = void 0;
@@ -77,11 +77,11 @@ class WKConnection {
     }
     this.browserSession.dispatchMessage(message);
   }
-  _onClose() {
+  _onClose(reason) {
     this._closed = true;
     this._transport.onmessage = undefined;
     this._transport.onclose = undefined;
-    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs());
+    this._browserDisconnectedLogs = _helper.helper.formatBrowserLogs(this._browserLogsCollector.recentLogs(), reason);
     this.browserSession.dispose();
     this._onDisconnect();
   }

package/lib/server/webkit/wkInterceptableRequest.js

@@ -44,8 +44,8 @@ const errorReasons = {
 class WKInterceptableRequest {
   constructor(session, frame, event, redirectedFrom, documentId) {
     this._session = void 0;
-    this.request = void 0;
     this._requestId = void 0;
+    this.request = void 0;
     this._timestamp = void 0;
     this._wallTime = void 0;
     this._session = session;
@@ -57,6 +57,10 @@ class WKInterceptableRequest {
     if (event.request.postData) postDataBuffer = Buffer.from(event.request.postData, 'base64');
     this.request = new network.Request(frame._page._browserContext, frame, null, (redirectedFrom === null || redirectedFrom === void 0 ? void 0 : redirectedFrom.request) || null, documentId, event.request.url, resourceType, event.request.method, postDataBuffer, (0, _utils.headersObjectToArray)(event.request.headers));
   }
+  adoptRequestFromNewProcess(newSession, requestId) {
+    this._session = newSession;
+    this._requestId = requestId;
+  }
   createResponse(responsePayload) {
     const getResponseBody = async () => {
       const response = await this._session.send('Network.getResponseBody', {
@@ -75,7 +79,7 @@ class WKInterceptableRequest {
       requestStart: timingPayload ? wkMillisToRoundishMillis(timingPayload.requestStart) : -1,
       responseStart: timingPayload ? wkMillisToRoundishMillis(timingPayload.responseStart) : -1
     };
-    const setCookieSeparator = process.platform === 'darwin' ? ',' : '\n';
+    const setCookieSeparator = process.platform === 'darwin' ? ',' : 'playwright-set-cookie-separator';
     const response = new network.Response(this.request, responsePayload.status, responsePayload.statusText, (0, _utils.headersObjectToArray)(responsePayload.headers, ',', setCookieSeparator), timing, getResponseBody, responsePayload.source === 'service-worker');
 
     // No raw response headers in WebKit, use "provisional" ones.
@@ -125,14 +129,14 @@ class WKRouteImpl {
     await this._session.sendMayFail('Network.interceptRequestWithResponse', {
       requestId: this._requestId,
       status: response.status,
-      statusText: network.STATUS_TEXTS[String(response.status)],
+      statusText: network.statusText(response.status),
       mimeType,
       headers,
       base64Encoded: response.isBase64,
       content: response.body
     });
   }
-  async continue(request, overrides) {
+  async continue(overrides) {
     // In certain cases, protocol will return error if the request was already canceled
     // or the page was closed. We should tolerate these errors.
     await this._session.sendMayFail('Network.interceptWithRequest', {

package/lib/server/webkit/wkPage.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.WKPage = void 0;
 var _path = _interopRequireDefault(require("path"));
+var _os = _interopRequireDefault(require("os"));
 var _utilsBundle = require("../../utilsBundle");
 var _stackTrace = require("../../utils/stackTrace");
 var _utils = require("../../utils");
@@ -159,7 +160,9 @@ class WKPage {
     resourceTreeHandler(frameTree);
     const promises = [
     // Resource tree should be received before first execution context.
-    session.send('Runtime.enable'), session.send('Page.createUserWorld', {
+    session.send('Runtime.enable'), session.send('Runtime.addBinding', {
+      name: _page.PageBinding.kPlaywrightBinding
+    }), session.send('Page.createUserWorld', {
       name: UTILITY_WORLD_NAME
     }).catch(_ => {}),
     // Worlds are per-process
@@ -185,9 +188,6 @@ class WKPage {
     if (contextOptions.userAgent) promises.push(this.updateUserAgent());
     const emulatedMedia = this._page.emulatedMedia();
     if (emulatedMedia.media || emulatedMedia.colorScheme || emulatedMedia.reducedMotion || emulatedMedia.forcedColors) promises.push(WKPage._setEmulateMedia(session, emulatedMedia.media, emulatedMedia.colorScheme, emulatedMedia.reducedMotion, emulatedMedia.forcedColors));
-    for (const binding of this._page.allBindings()) promises.push(session.send('Runtime.addBinding', {
-      name: binding.name
-    }));
     const bootstrapScript = this._calculateBootstrapScript();
     if (bootstrapScript.length) promises.push(session.send('Page.setBootstrapScript', {
       source: bootstrapScript
@@ -269,6 +269,7 @@ class WKPage {
       crashed
     } = event;
     if (this._provisionalPage && this._provisionalPage._session.sessionId === targetId) {
+      this._maybeCancelCoopNavigationRequest(this._provisionalPage);
       this._provisionalPage._session.dispose();
       this._provisionalPage.dispose();
       this._provisionalPage = null;
@@ -460,11 +461,11 @@ class WKPage {
     const frame = this._page._frameManager.frame(contextPayload.frameId);
     if (!frame) return;
     const delegate = new _wkExecutionContext.WKExecutionContext(this._session, contextPayload.id);
-    let worldName = null;
-    if (contextPayload.type === 'normal') worldName = 'main';else if (contextPayload.type === 'user' && contextPayload.name === UTILITY_WORLD_NAME) worldName = 'utility';
+    let worldName;
+    if (contextPayload.type === 'normal') worldName = 'main';else if (contextPayload.type === 'user' && contextPayload.name === UTILITY_WORLD_NAME) worldName = 'utility';else return;
     const context = new dom.FrameExecutionContext(delegate, frame, worldName);
     context[contextDelegateSymbol] = delegate;
-    if (worldName) frame._contextCreated(worldName, context);
+    frame._contextCreated(worldName, context);
     this._contextIdToContext.set(contextPayload.id, context);
   }
   async _onBindingCalled(contextId, argument) {
@@ -685,7 +686,11 @@ class WKPage {
     })];
     if (options.isMobile) {
       const angle = viewportSize.width > viewportSize.height ? 90 : 0;
-      promises.push(this._session.send('Page.setOrientationOverride', {
+      // Special handling for macOS 12.
+      const useLegacySetOrientationOverrideMethod = _os.default.platform() === 'darwin' && parseInt(_os.default.release().split('.')[0], 10) <= 21;
+      if (useLegacySetOrientationOverrideMethod) promises.push(this._session.send('Page.setOrientationOverride', {
+        angle
+      }));else promises.push(this._pageProxySession.send('Emulation.setOrientationOverride', {
         angle
       }));
     }
@@ -741,20 +746,10 @@ class WKPage {
       throw error;
     });
   }
-  async exposeBinding(binding) {
-    this._session.send('Runtime.addBinding', {
-      name: binding.name
-    });
-    await this._updateBootstrapScript();
-    await Promise.all(this._page.frames().map(frame => frame.evaluateExpression(binding.source).catch(e => {})));
-  }
-  async removeExposedBindings() {
-    await this._updateBootstrapScript();
-  }
-  async addInitScript(script) {
+  async addInitScript(initScript) {
     await this._updateBootstrapScript();
   }
-  async removeInitScripts() {
+  async removeNonInternalInitScripts() {
     await this._updateBootstrapScript();
   }
   _calculateBootstrapScript() {
@@ -766,9 +761,7 @@ class WKPage {
     }
     scripts.push('if (!window.safari) window.safari = { pushNotification: { toString() { return "[object SafariRemoteNotification]"; } } };');
     scripts.push('if (!window.GestureEvent) window.GestureEvent = function GestureEvent() {};');
-    for (const binding of this._page.allBindings()) scripts.push(binding.source);
-    scripts.push(...this._browserContext.initScripts);
-    scripts.push(...this._page.initScripts);
+    scripts.push(...this._page.allInitScripts().map(script => script.source));
     return scripts.join(';\n');
   }
   async _updateBootstrapScript() {
@@ -944,7 +937,7 @@ class WKPage {
       files: protocolFiles
     });
   }
-  async setInputFilePaths(progress, handle, paths) {
+  async setInputFilePaths(handle, paths) {
     const pageProxyId = this._pageProxySession.sessionId;
     const objectId = handle._objectId;
     await Promise.all([this._pageProxySession.connection.browserSession.send('Playwright.grantFileReadAccess', {
@@ -979,6 +972,31 @@ class WKPage {
     if (!result || result.object.subtype === 'null') throw new Error('Frame has been detached.');
     return context.createHandle(result.object);
   }
+  _maybeCancelCoopNavigationRequest(provisionalPage) {
+    const navigationRequest = provisionalPage.coopNavigationRequest();
+    for (const [requestId, request] of this._requestIdToRequest) {
+      if (request.request === navigationRequest) {
+        // Make sure the request completes if the provisional navigation is canceled.
+        this._onLoadingFailed(provisionalPage._session, {
+          requestId: requestId,
+          errorText: 'Provisiolal navigation canceled.',
+          timestamp: request._timestamp,
+          canceled: true
+        });
+        return;
+      }
+    }
+  }
+  _adoptRequestFromNewProcess(navigationRequest, newSession, newRequestId) {
+    for (const [requestId, request] of this._requestIdToRequest) {
+      if (request.request === navigationRequest) {
+        this._requestIdToRequest.delete(requestId);
+        request.adoptRequestFromNewProcess(newSession, newRequestId);
+        this._requestIdToRequest.set(newRequestId, request);
+        return;
+      }
+    }
+  }
   _onRequestWillBeSent(session, event) {
     if (event.request.url.startsWith('data:')) return;
 
@@ -991,7 +1009,7 @@ class WKPage {
       const request = this._requestIdToRequest.get(event.requestId);
       // If we connect late to the target, we could have missed the requestWillBeSent event.
       if (request) {
-        this._handleRequestRedirect(request, event.redirectResponse, event.timestamp);
+        this._handleRequestRedirect(request, event.requestId, event.redirectResponse, event.timestamp);
         redirectedFrom = request;
       }
     }
@@ -1006,7 +1024,7 @@ class WKPage {
     const request = new _wkInterceptableRequest.WKInterceptableRequest(session, frame, event, redirectedFrom, documentId);
     let route;
     if (intercepted) {
-      route = new _wkInterceptableRequest.WKRouteImpl(session, request._requestId);
+      route = new _wkInterceptableRequest.WKRouteImpl(session, event.requestId);
       // There is no point in waiting for the raw headers in Network.responseReceived when intercepting.
       // Use provisional headers as raw headers, so that client can call allHeaders() from the route handler.
       request.request.setRawRequestHeaders(null);
@@ -1014,14 +1032,14 @@ class WKPage {
     this._requestIdToRequest.set(event.requestId, request);
     this._page._frameManager.requestStarted(request.request, route);
   }
-  _handleRequestRedirect(request, responsePayload, timestamp) {
+  _handleRequestRedirect(request, requestId, responsePayload, timestamp) {
     const response = request.createResponse(responsePayload);
     response._securityDetailsFinished();
     response._serverAddrFinished();
     response.setResponseHeadersSize(null);
     response.setEncodedBodySize(null);
     response._requestFinished(responsePayload.timing ? _helper.helper.secondsToRoundishMillis(timestamp - request._timestamp) : -1);
-    this._requestIdToRequest.delete(request._requestId);
+    this._requestIdToRequest.delete(requestId);
     this._page._frameManager.requestReceivedResponse(response);
     this._page._frameManager.reportRequestFinished(request.request, response);
   }
@@ -1049,7 +1067,7 @@ class WKPage {
     const request = this._requestIdToRequest.get(event.requestId);
     // FileUpload sends a response without a matching request.
     if (!request) return;
-    this._requestIdToResponseReceivedPayloadEvent.set(request._requestId, event);
+    this._requestIdToResponseReceivedPayloadEvent.set(event.requestId, event);
     const response = request.createResponse(event.response);
     this._page._frameManager.requestReceivedResponse(response);
     if (response.status() === 204) {
@@ -1071,7 +1089,7 @@ class WKPage {
     const response = request.request._existingResponse();
     if (response) {
       var _event$metrics, _event$metrics2, _responseReceivedPayl, _responseReceivedPayl2, _responseReceivedPayl3, _event$metrics3, _event$metrics$respon, _event$metrics4, _event$metrics$respon2, _event$metrics5;
-      const responseReceivedPayload = this._requestIdToResponseReceivedPayloadEvent.get(request._requestId);
+      const responseReceivedPayload = this._requestIdToResponseReceivedPayloadEvent.get(event.requestId);
       response._serverAddrFinished(parseRemoteAddress(event === null || event === void 0 || (_event$metrics = event.metrics) === null || _event$metrics === void 0 ? void 0 : _event$metrics.remoteAddress));
       response._securityDetailsFinished({
         protocol: isLoadedSecurely(response.url(), response.timing()) ? (_event$metrics2 = event.metrics) === null || _event$metrics2 === void 0 || (_event$metrics2 = _event$metrics2.securityConnection) === null || _event$metrics2 === void 0 ? void 0 : _event$metrics2.protocol : undefined,
@@ -1087,8 +1105,8 @@ class WKPage {
       // Use provisional headers if we didn't have the response with raw headers.
       request.request.setRawRequestHeaders(null);
     }
-    this._requestIdToResponseReceivedPayloadEvent.delete(request._requestId);
-    this._requestIdToRequest.delete(request._requestId);
+    this._requestIdToResponseReceivedPayloadEvent.delete(event.requestId);
+    this._requestIdToRequest.delete(event.requestId);
     this._page._frameManager.reportRequestFinished(request.request, response);
   }
   _onLoadingFailed(session, event) {
@@ -1114,12 +1132,12 @@ class WKPage {
       // Use provisional headers if we didn't have the response with raw headers.
       request.request.setRawRequestHeaders(null);
     }
-    this._requestIdToRequest.delete(request._requestId);
+    this._requestIdToRequest.delete(event.requestId);
     request.request._setFailureText(event.errorText);
     this._page._frameManager.requestFailed(request.request, event.errorText.includes('cancelled'));
   }
   async _grantPermissions(origin, permissions) {
-    const webPermissionToProtocol = new Map([['geolocation', 'geolocation'], ['clipboard-read', 'clipboard-read']]);
+    const webPermissionToProtocol = new Map([['geolocation', 'geolocation'], ['notifications', 'notifications'], ['clipboard-read', 'clipboard-read']]);
     const filtered = permissions.map(permission => {
       const protocolPermission = webPermissionToProtocol.get(permission);
       if (!protocolPermission) throw new Error('Unknown permission: ' + permission);

package/lib/server/webkit/wkProvisionalPage.js

@@ -24,13 +24,25 @@ var _utils = require("../../utils");
 
 class WKProvisionalPage {
   constructor(session, page) {
+    var _page$_page$mainFrame;
     this._session = void 0;
     this._wkPage = void 0;
+    this._coopNavigationRequest = void 0;
     this._sessionListeners = [];
     this._mainFrameId = null;
     this.initializationPromise = void 0;
     this._session = session;
     this._wkPage = page;
+    // Cross-Origin-Opener-Policy (COOP) request starts in one process and once response headers
+    // have been received, continues in another.
+    //
+    // Network.requestWillBeSent and requestIntercepted (if intercepting) from the original web process
+    // will always come before a provisional page is created based on the response COOP headers.
+    // Thereafter we'll receive targetCreated (provisional) and later on in some order loadingFailed from the
+    // original process and requestWillBeSent from the provisional one. We should ignore loadingFailed
+    // as the original request continues in the provisional process. But if the provisional load is later
+    // canceled we should dispatch loadingFailed to the client.
+    this._coopNavigationRequest = (_page$_page$mainFrame = page._page.mainFrame().pendingDocument()) === null || _page$_page$mainFrame === void 0 ? void 0 : _page$_page$mainFrame.request;
     const overrideFrameId = handler => {
       return payload => {
         // Pretend that the events happened in the same process.
@@ -39,11 +51,14 @@ class WKProvisionalPage {
       };
     };
     const wkPage = this._wkPage;
-    this._sessionListeners = [_eventsHelper.eventsHelper.addEventListener(session, 'Network.requestWillBeSent', overrideFrameId(e => wkPage._onRequestWillBeSent(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.requestIntercepted', overrideFrameId(e => wkPage._onRequestIntercepted(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.responseReceived', overrideFrameId(e => wkPage._onResponseReceived(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFinished', overrideFrameId(e => wkPage._onLoadingFinished(e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFailed', overrideFrameId(e => wkPage._onLoadingFailed(session, e)))];
+    this._sessionListeners = [_eventsHelper.eventsHelper.addEventListener(session, 'Network.requestWillBeSent', overrideFrameId(e => this._onRequestWillBeSent(e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.requestIntercepted', overrideFrameId(e => wkPage._onRequestIntercepted(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.responseReceived', overrideFrameId(e => wkPage._onResponseReceived(session, e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFinished', overrideFrameId(e => this._onLoadingFinished(e))), _eventsHelper.eventsHelper.addEventListener(session, 'Network.loadingFailed', overrideFrameId(e => this._onLoadingFailed(e)))];
     this.initializationPromise = this._wkPage._initializeSession(session, true, ({
       frameTree
     }) => this._handleFrameTree(frameTree));
   }
+  coopNavigationRequest() {
+    return this._coopNavigationRequest;
+  }
   dispose() {
     _eventsHelper.eventsHelper.removeEventListeners(this._sessionListeners);
   }
@@ -51,6 +66,26 @@ class WKProvisionalPage {
     (0, _utils.assert)(this._mainFrameId);
     this._wkPage._onFrameAttached(this._mainFrameId, null);
   }
+  _onRequestWillBeSent(event) {
+    if (this._coopNavigationRequest && this._coopNavigationRequest.url() === event.request.url) {
+      // If it's a continuation of the main frame navigation request after COOP headers were received,
+      // take over original request, and replace its request id with the new one.
+      this._wkPage._adoptRequestFromNewProcess(this._coopNavigationRequest, this._session, event.requestId);
+      // Simply ignore this event as it has already been dispatched from the original process
+      // and there will ne no requestIntercepted event from the provisional process as it resumes
+      // existing network load (that has already received reponse headers).
+      return;
+    }
+    this._wkPage._onRequestWillBeSent(this._session, event);
+  }
+  _onLoadingFinished(event) {
+    this._coopNavigationRequest = undefined;
+    this._wkPage._onLoadingFinished(event);
+  }
+  _onLoadingFailed(event) {
+    this._coopNavigationRequest = undefined;
+    this._wkPage._onLoadingFailed(this._session, event);
+  }
   _handleFrameTree(frameTree) {
     (0, _utils.assert)(!frameTree.frame.parentId);
     this._mainFrameId = frameTree.frame.id;