[pull] main from microsoft:main

docs/src/api/class-screencast.md

@@ -22,8 +22,8 @@ await page.screencast.stop();
 ```js
 // Capture frames
 await page.screencast.start({
-  onFrame: ({ data, viewportWidth, viewportHeight }) => {
-    console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight})`);
+  onFrame: ({ data, timestamp, viewportWidth, viewportHeight }) => {
+    console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight}) at ${timestamp}`);
   },
   size: { width: 800, height: 600 },
 });
@@ -36,6 +36,7 @@ await page.screencast.stop();
 - `onFrame` <[function]\([Object]\): [Promise]>
   * alias: ScreencastFrame
   - `data` <[Buffer]> JPEG-encoded frame data.
+  - `timestamp` <[float]> The timestamp of when the frame was presented by the browser, in milliseconds since the Unix epoch.
   - `viewportWidth` <[int]> Width of the page viewport at the time the frame was captured.
   - `viewportHeight` <[int]> Height of the page viewport at the time the frame was captured.
 
@@ -55,7 +56,6 @@ The quality of the image, between 0-100.
 
 ### option: Screencast.start.size
 * since: v1.59
-* langs: js
 - `size` ?<[Object]>
   * alias-csharp: ScreencastSize
   - `width` <[int]> Max frame width in pixels.

packages/playwright-client/types/types.d.ts

@@ -16706,8 +16706,8 @@ export interface Screencast {
    * ```js
    * // Capture frames
    * await page.screencast.start({
-   *   onFrame: ({ data, viewportWidth, viewportHeight }) => {
-   *     console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight})`);
+   *   onFrame: ({ data, timestamp, viewportWidth, viewportHeight }) => {
+   *     console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight}) at ${timestamp}`);
    *   },
    *   size: { width: 800, height: 600 },
    * });
@@ -16718,7 +16718,7 @@ export interface Screencast {
    * @param options
    */
   start(options?: {
-    onFrame?: (frame: { data: Buffer, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
+    onFrame?: (frame: { data: Buffer, timestamp: number, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
     path?: string;
     size?: {
       width: number;

packages/playwright-core/src/client/screencast.ts

@@ -24,17 +24,17 @@ export class Screencast implements api.Screencast {
   private _page: Page;
   private _started = false;
   private _savePath: string | undefined;
-  private _onFrame: ((frame: { data: Buffer, viewportWidth: number, viewportHeight: number }) => Promise<any>) | null = null;
+  private _onFrame: ((frame: { data: Buffer, timestamp: number, viewportWidth: number, viewportHeight: number }) => Promise<any>) | null = null;
   private _artifact: Artifact | undefined;
 
   constructor(page: Page) {
     this._page = page;
-    this._page._channel.on('screencastFrame', ({ data, viewportWidth, viewportHeight }) => {
-      void this._onFrame?.({ data, viewportWidth, viewportHeight });
+    this._page._channel.on('screencastFrame', ({ data, timestamp, viewportWidth, viewportHeight }) => {
+      void this._onFrame?.({ data, timestamp, viewportWidth, viewportHeight });
     });
   }
 
-  async start(options: { onFrame?: (frame: { data: Buffer, viewportWidth: number, viewportHeight: number }) => Promise<any>|any, path?: string, size?: { width: number, height: number }, quality?: number } = {}): Promise<DisposableStub> {
+  async start(options: { onFrame?: (frame: { data: Buffer, timestamp: number, viewportWidth: number, viewportHeight: number }) => Promise<any>|any, path?: string, size?: { width: number, height: number }, quality?: number } = {}): Promise<DisposableStub> {
     if (this._started)
       throw new Error('Screencast is already started');
     this._started = true;

packages/playwright-core/src/protocol/validator.ts

@@ -2299,6 +2299,7 @@ scheme.PageRouteEvent = tObject({
 });
 scheme.PageScreencastFrameEvent = tObject({
   data: tBinary,
+  timestamp: tFloat,
   viewportWidth: tInt,
   viewportHeight: tInt,
 });

packages/playwright-core/src/server/dispatchers/pageDispatcher.ts

@@ -398,7 +398,7 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
     if (params.sendFrames) {
       this._screencastClient = {
         onFrame: (frame: ScreencastFrame) => {
-          this._dispatchEvent('screencastFrame', { data: frame.buffer, viewportWidth: frame.viewportWidth, viewportHeight: frame.viewportHeight });
+          this._dispatchEvent('screencastFrame', { data: frame.buffer, timestamp: frame.frameSwapWallTime, viewportWidth: frame.viewportWidth, viewportHeight: frame.viewportHeight });
         },
         dispose: () => {},
         size: params.size,

packages/playwright-core/src/server/har/harTracer.ts

@@ -321,15 +321,15 @@ export class HarTracer {
     // In WebKit security details and server ip are reported in Network.loadingFinished, so we populate
     // it here to not hang in case of long chunked responses, see https://github.com/microsoft/playwright/issues/21182.
     if (!this._options.omitServerIP) {
-      this._addBarrier(page || request.serviceWorker(), response.serverAddr(nullProgress).then(server => {
+      this._addBarrier(page || request.serviceWorker(), response.internalServerAddr().then(server => {
         if (server?.ipAddress)
           harEntry.serverIPAddress = server.ipAddress;
         if (server?.port)
           harEntry._serverPort = server.port;
       }));
     }
     if (!this._options.omitSecurityDetails) {
-      this._addBarrier(page || request.serviceWorker(), response.securityDetails(nullProgress).then(details => {
+      this._addBarrier(page || request.serviceWorker(), response.internalSecurityDetails().then(details => {
         if (details)
           harEntry._securityDetails = details;
       }));
@@ -374,7 +374,7 @@ export class HarTracer {
     });
     this._addBarrier(page || request.serviceWorker(), promise);
 
-    this._addBarrier(page || request.serviceWorker(), response.httpVersion(nullProgress).then(httpVersion => {
+    this._addBarrier(page || request.serviceWorker(), response.internalHttpVersion().then(httpVersion => {
       harEntry.request.httpVersion = httpVersion;
       harEntry.response.httpVersion = httpVersion;
     }));
@@ -385,7 +385,7 @@ export class HarTracer {
     this._computeHarEntryTotalTime(harEntry);
 
     if (!this._options.omitSizes) {
-      this._addBarrier(page || request.serviceWorker(), response.sizes(nullProgress).then(sizes => {
+      this._addBarrier(page || request.serviceWorker(), response.internalSizes().then(sizes => {
         harEntry.response.bodySize = sizes.responseBodySize;
         harEntry.response.headersSize = sizes.responseHeadersSize;
         harEntry.response._transferSize = sizes.transferSize;
@@ -595,13 +595,13 @@ export class HarTracer {
     }
 
     this._recordRequestOverrides(harEntry, request);
-    this._addBarrier(page || request.serviceWorker(), request.rawRequestHeaders(nullProgress).then(headers => {
+    this._addBarrier(page || request.serviceWorker(), request.internalRawRequestHeaders().then(headers => {
       this._recordRequestHeadersAndCookies(harEntry, headers);
     }));
     // Record available headers including redirect location in case the tracing is stopped before
     // response extra info is received (in Chromium).
     this._recordResponseHeaders(harEntry, response.headers());
-    this._addBarrier(page || request.serviceWorker(), response.rawResponseHeaders(nullProgress).then(headers => {
+    this._addBarrier(page || request.serviceWorker(), response.internalRawResponseHeaders().then(headers => {
       this._recordResponseHeaders(harEntry, headers);
     }));
   }

packages/playwright-core/src/server/network.ts

@@ -228,7 +228,7 @@ export class Request extends SdkObject {
   }
 
   async rawRequestHeaders(progress: Progress): Promise<HeadersArray> {
-    return await this.raceWithPageClosure(progress, this._rawRequestHeaders());
+    return await this.raceWithPageClosure(progress, this.internalRawRequestHeaders());
   }
 
   async response(progress: Progress): Promise<Response | null> {
@@ -280,7 +280,7 @@ export class Request extends SdkObject {
       this._rawRequestHeadersPromise.resolve(headers || this._headers);
   }
 
-  private async _rawRequestHeaders(): Promise<HeadersArray> {
+  async internalRawRequestHeaders(): Promise<HeadersArray> {
     return this._overrides?.headers || this._rawRequestHeadersPromise;
   }
 
@@ -336,7 +336,7 @@ export class Request extends SdkObject {
   }
 
   async _requestHeadersSize(): Promise<number> {
-    return requestHeadersSize(await this._rawRequestHeaders(), this.url(), this.method());
+    return requestHeadersSize(await this.internalRawRequestHeaders(), this.url(), this.method());
   }
 }
 
@@ -553,19 +553,19 @@ export class Response extends SdkObject {
   }
 
   async serverAddr(progress: Progress): Promise<RemoteAddr | null> {
-    return (await this._request.raceWithPageClosure(progress, this._serverAddrPromise)) || null;
+    return await this._request.raceWithPageClosure(progress, this.internalServerAddr());
   }
 
   async rawResponseHeaders(progress: Progress): Promise<NameValue[]> {
-    return await this._request.raceWithPageClosure(progress, this._rawResponseHeadersPromise);
+    return await this._request.raceWithPageClosure(progress, this.internalRawResponseHeaders());
   }
 
   async httpVersion(progress: Progress): Promise<string> {
-    return await this._request.raceWithPageClosure(progress, this._httpVersion());
+    return await this._request.raceWithPageClosure(progress, this.internalHttpVersion());
   }
 
   async sizes(progress: Progress): Promise<ResourceSizes> {
-    return await this._request.raceWithPageClosure(progress, this._sizes());
+    return await this._request.raceWithPageClosure(progress, this.internalSizes());
   }
 
   _serverAddrFinished(addr?: RemoteAddr) {
@@ -634,6 +634,14 @@ export class Response extends SdkObject {
     return await this._securityDetailsPromise || null;
   }
 
+  async internalServerAddr(): Promise<RemoteAddr | null> {
+    return await this._serverAddrPromise || null;
+  }
+
+  async internalRawResponseHeaders(): Promise<HeadersArray> {
+    return await this._rawResponseHeadersPromise;
+  }
+
   internalBody(): Promise<Buffer> {
     if (!this._contentPromise) {
       this._contentPromise = this._finishedPromise.then(async () => {
@@ -661,7 +669,7 @@ export class Response extends SdkObject {
     return this._request.frame();
   }
 
-  private async _httpVersion(): Promise<string> {
+  async internalHttpVersion(): Promise<string> {
     const httpVersion = await this._httpVersionPromise || null;
     if (!httpVersion)
       return 'HTTP/1.1';
@@ -685,7 +693,7 @@ export class Response extends SdkObject {
     return responseHeadersSize(await this._rawResponseHeadersPromise, this.statusText());
   }
 
-  private async _sizes(): Promise<ResourceSizes> {
+  async internalSizes(): Promise<ResourceSizes> {
     const requestHeadersSize = await this._request._requestHeadersSize();
     const responseHeadersSize = await this.responseHeadersSize();
 

packages/playwright-core/types/types.d.ts

@@ -16706,8 +16706,8 @@ export interface Screencast {
    * ```js
    * // Capture frames
    * await page.screencast.start({
-   *   onFrame: ({ data, viewportWidth, viewportHeight }) => {
-   *     console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight})`);
+   *   onFrame: ({ data, timestamp, viewportWidth, viewportHeight }) => {
+   *     console.log(`frame size: ${data.length} (${viewportWidth}x${viewportHeight}) at ${timestamp}`);
    *   },
    *   size: { width: 800, height: 600 },
    * });
@@ -16718,7 +16718,7 @@ export interface Screencast {
    * @param options
    */
   start(options?: {
-    onFrame?: (frame: { data: Buffer, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
+    onFrame?: (frame: { data: Buffer, timestamp: number, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
     path?: string;
     size?: {
       width: number;

packages/protocol/spec/page.yml

@@ -718,6 +718,7 @@ Page:
     screencastFrame:
       parameters:
         data: binary
+        timestamp: float
         viewportWidth: int
         viewportHeight: int
 

packages/protocol/src/channels.d.ts

@@ -4140,6 +4140,7 @@ export type PageRouteEvent = {
 };
 export type PageScreencastFrameEvent = {
   data: Binary,
+  timestamp: number,
   viewportWidth: number,
   viewportHeight: number,
 };

tests/library/browsercontext-basic.spec.ts

@@ -69,8 +69,7 @@ it('should be able to click across browser contexts', async function({ browser }
   await page2.close();
 });
 
-it('should be able to hover across browser contexts in parallel', async function({ browser, browserName, isBidi }) {
-  it.fixme(browserName === 'firefox' && !isBidi);
+it('should be able to hover across browser contexts in parallel', async function({ browser }) {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/40562' });
 
   const html = `

tests/library/screencast.spec.ts

@@ -57,9 +57,9 @@ test('onFrame receives viewport size', async ({ browser, server, trace }) => {
   const context = await browser.newContext({ viewport: { width: 1000, height: 400 } });
   const page = await context.newPage();
 
-  const frames: { viewportWidth: number, viewportHeight: number }[] = [];
+  const frames: { timestamp: number, viewportWidth: number, viewportHeight: number }[] = [];
   await page.screencast.start({
-    onFrame: ({ viewportWidth, viewportHeight }) => frames.push({ viewportWidth, viewportHeight }),
+    onFrame: ({ timestamp, viewportWidth, viewportHeight }) => frames.push({ timestamp, viewportWidth, viewportHeight }),
     size: { width: 500, height: 400 },
   });
   await page.goto(server.EMPTY_PAGE);
@@ -70,6 +70,7 @@ test('onFrame receives viewport size', async ({ browser, server, trace }) => {
   for (const frame of frames) {
     expect(frame.viewportWidth).toBe(1000);
     expect(frame.viewportHeight).toBe(400);
+    expect(typeof frame.timestamp).toBe('number');
   }
 
   await context.close();

utils/generate_types/overrides.d.ts

@@ -255,7 +255,7 @@ export interface WebSocketRoute {
 
 export interface Screencast {
   start(options?: {
-    onFrame?: (frame: { data: Buffer, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
+    onFrame?: (frame: { data: Buffer, timestamp: number, viewportWidth: number, viewportHeight: number }) => Promise<any>|any;
     path?: string;
     size?: {
       width: number;