Run continuation asynchronously in context of events

[nvborisenko]

This PR make Playwright events waiter more friendly with sync-over-async pattern.

Issue

This piece of code demonstrates deadlock. Real code, you can run it (I ran it in NUnit).

await page.RunAndWaitForResponseAsync(async () =>
{
    await page.GotoAsync("https://linked.in");
}, new Regex(".*google.*"));

//await Task.Yield();

Task.Run(async () => await page.Locator(".nav__logo-link").ClickAsync()).GetAwaiter().GetResult();

Here GetAwaiter().GetResult() is blocked. We understand that it is anti-pattern, sync-over-async. To fix it we can add await Task.Yield(). But what if Playwright can be more friendly for dummy users like me?

Solution?

This PR allows tasks continuations asynchronously. Now the code above just works.

[nvborisenko]

Apologies for the inquiry, but after a month without activity, I'm concerned I may have done something improperly. @mxschmitt, if you happen to know the cause, I would be very grateful for a hint. Thank you.

[Skn0tt]

Hi Nikolay, sorry for not taking a look earlier. I'll ask our colleague Dima for a review, but it'll take a little longer due to holidays.

[Skn0tt]

I did some digging on the ramifications of this options, and it seems like a safe change for us. The only negative implication is a slight overhead since the continuation now needs to wait for the scheduler, but that microsecond impact is neglegible given we're dealing with slow browsers.

My understanding of DotNet's async scheduling is limited, so please take another look @dgozman.

[nvborisenko]

It is absolutely safe, moreover it is recommended for libraries to prevent deadlocks I demonstrated in the original issue.

[dgozman]

The fix looks good to me. Let's add a test though, to avoid regressing this behavior.

[nvborisenko]

Honestly, I am not sure how to test it properly. Please advise.

[dgozman]

Honestly, I am not sure how to test it properly. Please advise.

Add a test next to this one that follows your repro code from this issue. I'd recommend to use this test page, so that you can wait for **/style.css response.

[nvborisenko]

@microsoft-github-policy-service agree

[nvborisenko]

Added test, verified locally - it blocks in main branch, and green in this branch. Please review again.

[nvborisenko]

CI is unstable with the message Target page, context or browser has been closed. I hope it is not related to this PR.

[dgozman]

Thank you for the PR!

[Skn0tt]

Hmm, CI is still failing after trying again. @nvborisenko, could you merge in main to see if this is also true on Playwright 1.58? Maybe it was fixed upstream.

[nvborisenko]

Stabilized CI build. Actually original simple changes/improvements revealed hidden race conditions. Then I made some changes to "fix" it, but I am afraid some of these "improvements" might be unnecessary (I don't fully understand what I did).

I will try to identify whether my changes are actually necessary to clean up this PR at least. Thank you for your support.

[Skn0tt]

Thanks for looking into it! I'll mark this as "request changes" to prevent anybody from accidentally merging while we haven't re-reviewed it.

[nvborisenko]

Current status: I blame tests are flaky only those who depend on external website. I think my initial commit should be enough. My next step is to ignore all "external" tests and see whether CI is stable.

[nvborisenko]

@Skn0tt @dgozman there are no changes required, everything is minimal and even better. Tests are flaky by design. I walked through the history and observed flakiness even on green builds:
https://github.com/microsoft/playwright-dotnet/actions/runs/23795732235/job/69342390543

WARNING: Test Microsoft.Playwright.Tests.BrowserContextEventsTests.DialogEventShouldWork needed 3 retries and passed
  Passed DialogEventShouldWork [30 s]

Why it is happening... Let's see concrete example

        var task = Page.EvaluateAsync(@"() => {
            window.open('javascript:prompt(""hey?"")');
        }");

        var dialog = await WaitForContextDialog(Page.Context);

So the flow is evaluate -> prompt opened -> start awaiting. This is misuse, I would say bad. The correct flow should: start awaiting -> evaluate -> prompt opened.

We can easy verify it, the following code always fails:

        var task = Page.EvaluateAsync(@"() => {
            window.open('javascript:prompt(""hey?"")');
        }");

        await Task.Delay(100); // 100 ms between actual event and awaiter

        var dialog = await WaitForContextDialog(Page.Context);

My changes made the "open window" shorter, what is very good in terms of performance. But now, I also improved this area to minimize race condition: register the events handler as soon as possible and then do unnecessary stuff. So it helped stabilize the CI. Anyway correct API is RunAndWait*.

So I am promoting the changes in this PR to be merged. Please let me know what is needed.