Una verifica indipendente di 654076d ha trovato tre punti deboli.
- «Pagina iniziale» guardava il permesso di guida una volta sola, prima di
aspettare fino a 15 s la fine della sessione e 15 s il turno della pagina
(che poi prendeva comunque). Se nel frattempo Alberto chiudeva la finestra,
Febe navigava senza permesso e fuori dal Governatore (regole 7 e 8). Ora la
pressione vale finché dura il permesso di chi l'ha premuta: la finestra di
Windows passa un gettone che si annulla con il suo permesso, la vista remota
quello della propria vita. Con il turno della pagina in mano la connessione
guarda di nuovo che Alberto guidi ancora; senza turno rinuncia invece di
prendere la pagina a un passo della ricerca. L'attesa del turno è
BrowserConnectionService.PageTurnWait (15 s, le prove la accorciano).
- Nella vista remota «Pagina iniziale» aspettava dentro il ciclo di ricezione:
la vista restava ferma fino a mezzo minuto e poi riversava clic e tasti sulla
pagina nuova. Ora la pressione corre a parte, una per volta, e intanto clic,
tasti, «Indietro» e «Ricarica» si scartano.
- Repaint chiedeva un ridisegno sincrono (RDW_UPDATENOW) a finestre figlie del
processo del browser di WebView2: uno bloccato avrebbe fermato il thread
dell'interfaccia. Ora si chiede solo di ridisegnare.
Prove nuove, che senza le correzioni non passano: la pressione dimenticata se
Alberto lascia il browser, quella che finisce con il permesso di chi l'ha
premuta, la pagina mai tolta a un passo della ricerca, la vista che non si
blocca e scarta l'input; su Windows con WebView2 vero, il gettone che si
annulla quando la finestra si chiude. PROTOCOLLO.md, la guida e decisioni.md
dicono il comportamento nuovo.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
328 lines
11 KiB
C#
328 lines
11 KiB
C#
using System.Collections.Concurrent;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
using Febe.App;
|
|
using Febe.Browser.Cdp;
|
|
using Febe.Browser.Hosting;
|
|
using Febe.Core.Abstractions;
|
|
using Febe.Desktop.Core;
|
|
using Febe.Web.Native;
|
|
|
|
namespace Febe.Tests.Desktop.Support;
|
|
|
|
/// <summary>The Windows-only part of the desktop, faked: what the platform asks of it is recorded.</summary>
|
|
internal sealed class FakeDesktopShell : IDesktopShell
|
|
{
|
|
public FakeNativeShell NativeShell { get; } = new();
|
|
|
|
public INativeShell Native => NativeShell;
|
|
|
|
/// <summary>The WebView2 runtime this «Windows» has (null: missing).</summary>
|
|
public string? RuntimeVersion { get; set; } = "141.0.3537.71";
|
|
|
|
/// <summary>Where «Edge» is (null: not installed).</summary>
|
|
public string? EdgePath { get; set; }
|
|
|
|
/// <summary>The browsers created, with the settings the platform gave them.</summary>
|
|
public ConcurrentQueue<(WebView2BrowserSettings Settings, FakeBrowser Browser)> Created { get; } = new();
|
|
|
|
public ConcurrentQueue<string> ProcessWindows { get; } = new();
|
|
|
|
/// <summary>Called with each browser as it is created, before Febe uses it (to set up the fake page).</summary>
|
|
public Action<FakeBrowser>? OnCreated { get; set; }
|
|
|
|
public string? WebView2Version() => RuntimeVersion;
|
|
|
|
public IFebeBrowser CreateWebView2Browser(WebView2BrowserSettings settings, FebePlatformContext context)
|
|
{
|
|
var browser = new FakeBrowser(settings.ProfileDirectory, settings.Width, settings.Height, context);
|
|
OnCreated?.Invoke(browser);
|
|
Created.Enqueue((settings, browser));
|
|
return browser;
|
|
}
|
|
|
|
public string? FindEdge() => EdgePath;
|
|
|
|
public Task ShowProcessWindowAsync(int processId, CancellationToken ct)
|
|
{
|
|
ProcessWindows.Enqueue("mostra " + processId);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task HideProcessWindowAsync(int processId, CancellationToken ct)
|
|
{
|
|
ProcessWindows.Enqueue("nascondi " + processId);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>The processes the platform asked to tie to Febe's life (Edge), by id.</summary>
|
|
public ConcurrentQueue<int> TiedToFebe { get; } = new();
|
|
|
|
/// <summary>What «Windows» answers when a process is tied to Febe.</summary>
|
|
public bool TieSucceeds { get; set; } = true;
|
|
|
|
public bool EndWithFebe(System.Diagnostics.Process process)
|
|
{
|
|
TiedToFebe.Enqueue(process.Id);
|
|
return TieSucceeds;
|
|
}
|
|
}
|
|
|
|
/// <summary>Folder picker, explorer, default browser, notifications (the Windows alerts) and autostart, faked.</summary>
|
|
internal sealed class FakeNativeShell : INativeShell
|
|
{
|
|
public bool CanPickFolder => true;
|
|
|
|
public bool CanShowInFolder => true;
|
|
|
|
public bool CanOpenUrl => true;
|
|
|
|
public bool CanNotify => true;
|
|
|
|
public bool SupportsAutostart => true;
|
|
|
|
public bool Autostart { get; private set; }
|
|
|
|
public string? FolderToPick { get; set; }
|
|
|
|
public ConcurrentQueue<string> Shown { get; } = new();
|
|
|
|
public ConcurrentQueue<Uri> Opened { get; } = new();
|
|
|
|
public ConcurrentQueue<(string Title, string Message)> Notified { get; } = new();
|
|
|
|
public Task<string?> PickFolderAsync(string title, string? initialFolder, CancellationToken ct) => Task.FromResult(FolderToPick);
|
|
|
|
public Task<bool> ShowInFolderAsync(string fullPath, CancellationToken ct)
|
|
{
|
|
Shown.Enqueue(fullPath);
|
|
return Task.FromResult(true);
|
|
}
|
|
|
|
public Task<bool> OpenUrlAsync(Uri address, CancellationToken ct)
|
|
{
|
|
Opened.Enqueue(address);
|
|
return Task.FromResult(true);
|
|
}
|
|
|
|
public Task NotifyAsync(string title, string message, CancellationToken ct)
|
|
{
|
|
Notified.Enqueue((title, message));
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<bool> GetAutostartAsync(CancellationToken ct) => Task.FromResult(Autostart);
|
|
|
|
public Task SetAutostartAsync(bool enabled, CancellationToken ct)
|
|
{
|
|
Autostart = enabled;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// The window «Browser di Febe», faked: a CDP session that answers like a browser on a blank page, a session cookie
|
|
/// that exists once «Alberto» has logged in, and a record of every time the window came to the front or went away.
|
|
/// </summary>
|
|
internal sealed class FakeBrowser : IFebeBrowser
|
|
{
|
|
private readonly FebePlatformContext _context;
|
|
private IDisposable? _lease;
|
|
|
|
public FakeBrowser(string profileDirectory, int width, int height, FebePlatformContext context)
|
|
{
|
|
ProfileDirectory = profileDirectory;
|
|
WindowWidth = width;
|
|
WindowHeight = height;
|
|
_context = context;
|
|
}
|
|
|
|
public FakeCdp FakeCdp { get; } = new();
|
|
|
|
public ICdpSession Cdp => FakeCdp;
|
|
|
|
public UserDrivingGate UserDriving { get; } = new();
|
|
|
|
public bool UserIsDriving => UserDriving.IsDriving;
|
|
|
|
public bool IsAvailable { get; private set; }
|
|
|
|
public string? LastError => null;
|
|
|
|
public string ProfileDirectory { get; }
|
|
|
|
public int WindowWidth { get; }
|
|
|
|
public int WindowHeight { get; }
|
|
|
|
public int Shown { get; private set; }
|
|
|
|
public int Hidden { get; private set; }
|
|
|
|
public int EmptiedProfiles { get; private set; }
|
|
|
|
public bool Disposed { get; private set; }
|
|
|
|
public Task RunAsync(CancellationToken ct)
|
|
{
|
|
Directory.CreateDirectory(ProfileDirectory);
|
|
IsAvailable = true;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task<NavigationResult> RestAsync(CancellationToken ct) => FakeCdp.NavigateAsync(CdpPageExtensions.RestUrl, ct);
|
|
|
|
/// <summary>Like the real window: in front, Alberto is driving.</summary>
|
|
public Task ShowToUserAsync(CancellationToken ct)
|
|
{
|
|
Shown++;
|
|
_lease ??= UserDriving.Begin();
|
|
_context.Tracker.MarkUsed(_context.Clock.Now);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task HideFromUserAsync(CancellationToken ct)
|
|
{
|
|
Hidden++;
|
|
_lease?.Dispose();
|
|
_lease = null;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
/// <summary>The next «Scollega» finds a file held by another process (Windows) and cannot delete the profile.</summary>
|
|
public bool ProfileLocked { get; set; }
|
|
|
|
public Task RestartWithEmptyProfileAsync(CancellationToken ct)
|
|
{
|
|
if (ProfileLocked)
|
|
{
|
|
throw new IOException("Il file Cookies è in uso da un altro processo.");
|
|
}
|
|
|
|
if (Directory.Exists(ProfileDirectory))
|
|
{
|
|
Directory.Delete(ProfileDirectory, recursive: true);
|
|
}
|
|
|
|
Directory.CreateDirectory(ProfileDirectory);
|
|
FakeCdp.LoggedIn = false;
|
|
EmptiedProfiles++;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public ValueTask DisposeAsync()
|
|
{
|
|
Disposed = true;
|
|
IsAvailable = false;
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// A CDP session answering like a page: frame tree, navigation (with its <c>Page.frameNavigated</c> event, as the
|
|
/// collection pipeline hears it), the session cookie (name only).
|
|
/// </summary>
|
|
internal sealed class FakeCdp : ICdpSession
|
|
{
|
|
private readonly Lock _gate = new();
|
|
private readonly Dictionary<string, List<Action<JsonElement>>> _handlers = new(StringComparer.Ordinal);
|
|
|
|
public bool LoggedIn { get; set; }
|
|
|
|
/// <summary>
|
|
/// Like the test site, which sets its session cookie on any visit: a navigation to an address starting with this
|
|
/// logs in, and the page reports itself loaded. Null: only the test logs in.
|
|
/// </summary>
|
|
public string? LogsInOnVisit { get; set; }
|
|
|
|
public string Url { get; private set; } = "about:blank";
|
|
|
|
public ConcurrentQueue<string> Methods { get; } = new();
|
|
|
|
/// <summary>Every address a <c>Page.navigate</c> asked for, in order.</summary>
|
|
public ConcurrentQueue<string> Visited { get; } = new();
|
|
|
|
/// <summary>The main frame moved to <paramref name="url"/> by itself (a redirect of the site), not by a command.</summary>
|
|
public void Navigated(string url)
|
|
{
|
|
Url = url;
|
|
Raise("Page.frameNavigated", new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = url } });
|
|
}
|
|
|
|
public Task<JsonElement> SendAsync(string method, object? parameters = null, CancellationToken ct = default)
|
|
{
|
|
CdpCommandPolicy.EnsureAllowed(method);
|
|
Methods.Enqueue(method);
|
|
JsonNode result = method switch
|
|
{
|
|
"Page.getFrameTree" => new JsonObject { ["frameTree"] = new JsonObject { ["frame"] = new JsonObject { ["id"] = "F1", ["url"] = Url } } },
|
|
"Page.navigate" => Navigate(parameters),
|
|
// The session cookie of Instagram, and the test site's one.
|
|
"Network.getCookies" => new JsonObject { ["cookies"] = LoggedIn ? new JsonArray(new JsonObject { ["name"] = "sessionid" }, new JsonObject { ["name"] = "sessione_prova" }) : new JsonArray() },
|
|
"Runtime.evaluate" when LogsInOnVisit is not null => new JsonObject { ["result"] = new JsonObject { ["type"] = "string", ["value"] = "complete" } },
|
|
_ => new JsonObject(),
|
|
};
|
|
return Task.FromResult(JsonDocument.Parse(result.ToJsonString()).RootElement.Clone());
|
|
}
|
|
|
|
public IDisposable On(string eventName, Action<JsonElement> handler)
|
|
{
|
|
lock (_gate)
|
|
{
|
|
if (!_handlers.TryGetValue(eventName, out var list))
|
|
{
|
|
_handlers[eventName] = list = [];
|
|
}
|
|
|
|
list.Add(handler);
|
|
}
|
|
|
|
return new Removal(() =>
|
|
{
|
|
lock (_gate)
|
|
{
|
|
_handlers[eventName].Remove(handler);
|
|
}
|
|
});
|
|
}
|
|
|
|
private JsonObject Navigate(object? parameters)
|
|
{
|
|
var url = (parameters as JsonObject)?["url"]?.GetValue<string>();
|
|
if (url is not null)
|
|
{
|
|
Visited.Enqueue(url);
|
|
if (LogsInOnVisit is { } site && url.StartsWith(site, StringComparison.Ordinal))
|
|
{
|
|
LoggedIn = true;
|
|
}
|
|
|
|
Navigated(url);
|
|
}
|
|
|
|
return new JsonObject { ["frameId"] = "F1" };
|
|
}
|
|
|
|
private void Raise(string eventName, JsonObject parameters)
|
|
{
|
|
Action<JsonElement>[] handlers;
|
|
lock (_gate)
|
|
{
|
|
handlers = _handlers.TryGetValue(eventName, out var list) ? [.. list] : [];
|
|
}
|
|
|
|
var element = JsonDocument.Parse(parameters.ToJsonString()).RootElement.Clone();
|
|
foreach (var handler in handlers)
|
|
{
|
|
handler(element);
|
|
}
|
|
}
|
|
|
|
private sealed class Removal(Action remove) : IDisposable
|
|
{
|
|
private Action? _remove = remove;
|
|
|
|
public void Dispose() => Interlocked.Exchange(ref _remove, null)?.Invoke();
|
|
}
|
|
}
|