diff --git a/docs/decisioni.md b/docs/decisioni.md index e1b0270..d2301f8 100644 --- a/docs/decisioni.md +++ b/docs/decisioni.md @@ -235,3 +235,4 @@ Ogni scelta tecnica presa strada facendo, con data e motivo (specifica §15). | 2026-10-20 | La finestra dell'interfaccia apre gli indirizzi esterni nel browser predefinito dopo che il gestore di WebView2 è tornato (in coda sul dispatcher) | La shell di Windows può far girare un ciclo di messaggi suo e WebView2 non regge di essere richiamato dentro i propri gestori | | 2026-10-20 | Le prove per Windows hanno un `CompressedClock` e un fuso «mezzogiorno» propri, copie di quelli della suite per Linux; `Febe.Desktop` concede gli `internal` a `Febe.Tests.Windows` e `WebView2Host` espone la sua finestra come `internal` (da leggere sul thread dell'interfaccia) | Un progetto di prove non può dipendere dall'altro; la finestra serve alle prove del primo piano e del fuori vista | | 2026-10-20 | Un solo WebView alla volta in `WebView2Host`: l'avvio, dentro la sezione esclusiva, non fa nulla se un WebView è già collegato, chiude prima i resti di uno morto, e se fallisce chiude da sé ciò che ha creato (il ciclo dei tentativi non chiude più niente da fuori); la ripartenza dopo un arresto del processo usa lo stesso avvio; chiudere un WebView ne cambia la generazione, così i suoi eventi tardivi non contano | Revisione del ramo: un «Scollega» durante i tentativi del primo avvio faceva partire il browser, poi il tentativo in attesa ne apriva un secondo nella stessa finestra senza chiudere il primo. Il processo orfano teneva il profilo: il «Scollega» dopo aspettava 20 s e non cancellava la sessione di Instagram, l'uscita aspettava 15 s a vuoto | +| 2026-10-20 | All'uscita il primo avvio e il ciclo di ripartenza di `WebView2Browser` smettono subito di aspettare WebView2: `WebView2Host.StartAsync` onora il suo token (un avvio non ancora cominciato non comincia, uno in corso finisce da sé e l'arresto chiude ciò che lascia, anche se arriva dopo i 30 s); `WebView2Browser.DisposeAsync` aspetta il ciclo al più 30 s. «Scollega», una volta cominciato, va fino in fondo e resta coperto dai 30 s dell'arresto | Revisione del ramo: il limite di 30 s copriva solo un «Scollega» in corso. `FebeApp` aspetta `RunAsync` prima di chiudere il browser, e `RunAsync` e il ciclo aspettavano WebView2 senza limite; interrompere «Scollega» a metà lascerebbe invece fermo il motore | diff --git a/src/Febe.Desktop/Browser/WebView2Browser.cs b/src/Febe.Desktop/Browser/WebView2Browser.cs index 14e1631..36c8405 100644 --- a/src/Febe.Desktop/Browser/WebView2Browser.cs +++ b/src/Febe.Desktop/Browser/WebView2Browser.cs @@ -25,6 +25,9 @@ internal sealed class WebView2Browser : IFebeBrowser { private static readonly TimeSpan[] Retry = [TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(15), TimeSpan.FromSeconds(30), TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(5)]; + /// How long stopping waits for the restart loop to end before closing WebView2 anyway. + private static readonly TimeSpan StopWait = TimeSpan.FromSeconds(30); + private readonly WebView2BrowserSettings _settings; private readonly FebePlatformContext _context; private readonly IClock _wallClock; @@ -133,8 +136,9 @@ internal sealed class WebView2Browser : IFebeBrowser } /// - /// Stops the retries, waits for a restart in progress, then closes WebView2 and its window. _lifetime stays - /// undisposed on purpose: a late caller may still read its (cancelled) token. + /// Stops the retries, waits for the restart loop to notice (it stops waiting for WebView2 as soon as + /// _lifetime is cancelled; at most in any case), then closes WebView2 and its window. + /// _lifetime stays undisposed on purpose: a late caller may still read its (cancelled) token. /// public async ValueTask DisposeAsync() { @@ -147,7 +151,14 @@ internal sealed class WebView2Browser : IFebeBrowser if (restarting is not null) { - await restarting.ConfigureAwait(false); + try + { + await restarting.WaitAsync(StopWait).ConfigureAwait(false); + } + catch (TimeoutException) + { + _context.Log.Warn("browser", "WebView2: la ripartenza del browser non si è fermata in tempo; Febe si chiude lo stesso."); + } } await Host.DisposeAsync().ConfigureAwait(false); diff --git a/src/Febe.Desktop/Browser/WebView2Host.cs b/src/Febe.Desktop/Browser/WebView2Host.cs index 3cdffad..51db2fc 100644 --- a/src/Febe.Desktop/Browser/WebView2Host.cs +++ b/src/Febe.Desktop/Browser/WebView2Host.cs @@ -123,13 +123,20 @@ internal sealed class WebView2Host : IBrowserHost /// /// Creates the window (once), the environment and the controller, and attaches the CDP session — unless a WebView /// is already running, because another way in started it («Scollega», the start after a crash): then it does nothing - /// and the start counts as done. A failed start leaves nothing open. + /// and the start counts as done. A failed start leaves nothing open. When is cancelled (Febe + /// is exiting) the caller stops waiting at once, even while WebView2 has not answered: a start not yet begun does not + /// begin, one under way on the UI thread ends by itself, and stopping closes what it leaves. /// public Task StartAsync(BrowserOptions options, CancellationToken ct) { ArgumentNullException.ThrowIfNull(options); _options = options; - return OnUiAsync(() => ExclusiveAsync(StartCoreAsync)); + var start = OnUiAsync(() => ExclusiveAsync(() => + { + ct.ThrowIfCancellationRequested(); + return StartCoreAsync(); + })); + return UntilCancelledAsync(start, ct); } public Task ShowToUserAsync() => OnUiAsync(() => @@ -170,7 +177,9 @@ internal sealed class WebView2Host : IBrowserHost /// — «Scollega» deletes the profile there — and starts it again. /// stays the same object. The browser starts again even when fails with an /// or ; that error is thrown afterwards. A failed - /// start throws its own error and, like a failed , leaves nothing open. + /// start throws its own error and, like a failed , leaves nothing open. Once begun it goes + /// to the end whatever says (the profile with the Instagram session must go, and the engine + /// starts again after it); stopping waits for it at most . /// public Task RestartAsync(Func? whileStopped, CancellationToken ct) => OnUiAsync(() => ExclusiveAsync(async () => { @@ -253,6 +262,10 @@ internal sealed class WebView2Host : IBrowserHost { throw new InvalidOperationException("Il processo del browser WebView2 si è chiuso durante l'avvio."); } + + // Stopping gave up waiting for this start (WebView2 took longer than StopWait) and closed what there was: + // what this start created goes too. + ObjectDisposedException.ThrowIf(_closing, this); } catch (Exception ex) when (ex is not OutOfMemoryException) { @@ -566,6 +579,27 @@ internal sealed class WebView2Host : IBrowserHost } } + /// + /// Waits for until is cancelled. Then the caller goes on and the work + /// is left to end by itself; its outcome is observed here, so a late error is never an unobserved task. + /// + private static async Task UntilCancelledAsync(Task work, CancellationToken ct) + { + try + { + await work.WaitAsync(ct).ConfigureAwait(false); + } + catch (OperationCanceledException) when (ct.IsCancellationRequested) + { + _ = work.ContinueWith( + static done => _ = done.Exception, + CancellationToken.None, + TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously, + TaskScheduler.Default); + throw; + } + } + /// /// Runs on the UI thread — at once when already there — and returns its task: an exception /// is always in the task, never thrown to the caller. diff --git a/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs b/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs index 5b09e71..155254e 100644 --- a/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs +++ b/tests/Febe.Tests.Windows/WebView2LifecycleTests.cs @@ -186,6 +186,60 @@ public sealed class WebView2LifecycleTests Assert.HasCount(2, bed.Lines.Lines.Where(l => l.Contains("ERRORE", StringComparison.Ordinal)), "only the two failed starts: " + bed.Lines.Text); } + /// + /// «Esci» while the start does not complete (review of 20 October 2026): the composition awaits + /// before it closes the browser, so RunAsync must stop + /// waiting as soon as it is cancelled. Here the UI thread is kept busy, as when WebView2 does not answer. + /// + [TestMethod] + [Timeout(120_000, CooperativeCancellation = true)] + public async Task OnExitTheStartStopsWaitingForAUiThreadThatDoesNotAnswer() + { + var ct = TestContext.CancellationToken; + await using var bed = await BrowserBed.CreateAsync("uscita"); + var released = false; + var busy = bed.Ui.Dispatcher.InvokeAsync(() => + { + // Thread.Sleep does not pump: nothing else runs on the UI thread meanwhile. + var until = DateTime.UtcNow.AddSeconds(60); + while (!Volatile.Read(ref released) && DateTime.UtcNow < until) + { + Thread.Sleep(20); + } + }); + + using var lifetime = CancellationTokenSource.CreateLinkedTokenSource(ct); + var run = Task.Run(() => bed.Browser.RunAsync(lifetime.Token), ct); + await Task.Delay(500, ct); + Assert.IsFalse(run.IsCompleted, "the start waits for the UI thread"); + + // «Esci»: FebeApp cancels its lifetime, then waits for RunAsync. + var watch = Stopwatch.StartNew(); + await lifetime.CancelAsync(); + try + { + await run.WaitAsync(TimeSpan.FromSeconds(10), ct); + } + finally + { + Volatile.Write(ref released, true); + await busy.Task; + } + + TestContext.WriteLine($"RunAsync è tornato {watch.Elapsed.TotalSeconds:0.0} s dopo la cancellazione."); + Assert.IsLessThan(3, watch.Elapsed.TotalSeconds, "RunAsync stops waiting at once"); + Assert.IsFalse(bed.Browser.IsAvailable); + + // The start that was waiting for the UI thread does not begin after the exit, and stopping is quick. + watch.Restart(); + await bed.Browser.DisposeAsync(); + Assert.IsLessThan(10, watch.Elapsed.TotalSeconds); + Assert.IsNull(await bed.OnUiAsync(() => bed.Browser.Host.Window), "no window was created after the exit"); + Assert.AreEqual(0, bed.Browser.Host.BrowserProcessId, "no browser process was started after the exit"); + Assert.IsFalse(bed.Lines.Any("ERRORE"), bed.Lines.Text); + Assert.IsFalse(bed.Lines.Any("Browser di Febe pronto"), bed.Lines.Text); + } + [TestMethod] [Timeout(180_000, CooperativeCancellation = true)] public async Task WhenItsBrowserProcessDiesTheBrowserStartsAgainByItself()