From f34f947867ed07ee02da57ae3a26c8090b4cb192 Mon Sep 17 00:00:00 2001 From: Victor Sanni Date: Mon, 2 Nov 2026 10:04:01 -0800 Subject: [PATCH 1/3] Connect the accessibility override controls to the app Adds ViewMetricsOverrideClient, a client for ext.flutter.viewMetricsOverride, and connects the text scale, bold text, screen reader and high contrast controls of the Accessibility page to it. --- .../accessibility_controller.dart | 124 ++++++-- .../screens/accessibility/overrides_pane.dart | 155 +++++++--- .../src/service/service_registrations.dart | 3 + .../service/view_metrics_override_client.dart | 269 ++++++++++++++++ .../accessibility_controller_test.dart | 47 ++- .../accessibility_screen_test.dart | 107 ++++++- .../view_metrics_override_client_test.dart | 286 ++++++++++++++++++ .../utils/view_metrics_override_utils.dart | 149 +++++++++ .../lib/src/mocks/fake_isolate_manager.dart | 6 + .../mocks/fake_service_extension_manager.dart | 10 + .../src/mocks/fake_vm_service_wrapper.dart | 8 +- 11 files changed, 1092 insertions(+), 72 deletions(-) create mode 100644 packages/devtools_app/lib/src/service/view_metrics_override_client.dart create mode 100644 packages/devtools_app/test/service/view_metrics_override_client_test.dart create mode 100644 packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart diff --git a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart index 679bdccd399..d1a34602078 100644 --- a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart +++ b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart @@ -12,6 +12,7 @@ import 'package:logging/logging.dart'; import '../../service/service_extensions.dart' as extensions; import '../../service/service_registrations.dart' as registrations; +import '../../service/view_metrics_override_client.dart'; import '../../shared/framework/screen.dart'; import '../../shared/framework/screen_controllers.dart'; import '../../shared/globals.dart'; @@ -46,15 +47,12 @@ class AccessibilityController extends DevToolsScreenController void init() { super.init(); _initServiceExtensionStates(); + _initViewMetricsOverrides(); _initSemanticsTree(); } void _initListeners() { addAutoDisposeListener(brightness, _onBrightnessChanged); - addAutoDisposeListener(textScale, _onTextScaleChanged); - addAutoDisposeListener(boldText, _onBoldTextChanged); - addAutoDisposeListener(screenReader, _onScreenReaderChanged); - addAutoDisposeListener(highContrast, _onHighContrastChanged); addAutoDisposeListener(semanticsRoots, _onSemanticsRootsChanged); } @@ -123,21 +121,78 @@ class AccessibilityController extends DevToolsScreenController ); } - void _onTextScaleChanged() { - // TODO(hannah-hyj): Implement VM service extension call for text scale override. - } + // The metrics of `ext.flutter.viewMetricsOverride` that the overrides pane + // controls. Brightness stays on `ext.flutter.brightnessOverride`. + static const _textScalingMetric = 'textScaling'; + static const _boldTextMetric = 'boldText'; + static const _accessibleNavigationMetric = 'accessibleNavigation'; + static const _highContrastMetric = 'highContrast'; + + /// The client that overrides the text scale, bold text, screen reader and + /// high contrast settings of the app, or null before [init]. + ViewMetricsOverrideClient? _viewMetricsOverrideClient; + + void _initViewMetricsOverrides() { + final client = _viewMetricsOverrideClient = ViewMetricsOverrideClient(); + void updateFromApp() { + final overrides = client.overrides.value; + _overridesAvailable.value = client.available.value; + _textScale.value = _textScaleFactor(overrides[_textScalingMetric]); + _boldText.value = overrides[_boldTextMetric] == true; + _screenReader.value = overrides[_accessibleNavigationMetric] == true; + _highContrast.value = overrides[_highContrastMetric] == true; + } - void _onBoldTextChanged() { - // TODO(hannah-hyj): Implement VM service extension call for bold text override. + updateFromApp(); + addAutoDisposeListener(client.available, updateFromApp); + addAutoDisposeListener(client.overrides, updateFromApp); } - void _onScreenReaderChanged() { - // TODO(hannah-hyj): Implement VM service extension call for screen reader / semantics debugger. - // e.g. using 'ext.flutter.showSemanticsDebugger'. + /// Overrides the text scale factor of the app with [factor], or stops + /// overriding it if [factor] is null. + /// + /// The override scales every font size linearly by [factor]. + Future setTextScale(double? factor) => _setOverride( + _textScalingMetric, + factor == null + ? null + : [ + [1, factor], + ], + ); + + /// Makes the app use bold text, or the bold text setting of the platform + /// again if [enabled] is false. + Future setBoldText(bool enabled) => + _setFlagOverride(_boldTextMetric, enabled); + + /// Makes the app behave as though a screen reader is on, or follow the + /// platform again if [enabled] is false. + Future setScreenReader(bool enabled) => + _setFlagOverride(_accessibleNavigationMetric, enabled); + + /// Makes the app use high contrast, or the high contrast setting of the + /// platform again if [enabled] is false. + Future setHighContrast(bool enabled) => + _setFlagOverride(_highContrastMetric, enabled); + + // Turning an override off stops overriding the flag rather than overriding + // it to false, so that the app goes back to the setting of the platform. + Future _setFlagOverride(String metric, bool enabled) => + _setOverride(metric, enabled ? true : null); + + Future _setOverride(String metric, Object? value) async { + await _viewMetricsOverrideClient?.updateOverrides({metric: value}); } - void _onHighContrastChanged() { - // TODO(hannah-hyj): Implement VM service extension call for high contrast override. + /// Returns the ratio of the first point of [textScaling], which is the text + /// scale factor that the app reports, or null if text scale is not + /// overridden. + static double? _textScaleFactor(Object? textScaling) { + if (textScaling case [[final num unscaled, final num scaled], ...]) { + return scaled / unscaled; + } + return null; } @override @@ -147,10 +202,33 @@ class AccessibilityController extends DevToolsScreenController final brightness = ValueNotifier( BrightnessOverride.system, ); - final textScale = ValueNotifier(1.0); - final boldText = ValueNotifier(false); - final screenReader = ValueNotifier(false); - final highContrast = ValueNotifier(false); + + /// Whether the connected app supports the text scale, bold text, screen + /// reader and high contrast overrides. + /// + /// See [ViewMetricsOverrideClient.available] for the apps that do. + ValueListenable get overridesAvailable => _overridesAvailable; + final _overridesAvailable = ValueNotifier(false); + + /// The text scale factor that the app is overridden to, or null if the app + /// uses the text scale that the platform reports. + ValueListenable get textScale => _textScale; + final _textScale = ValueNotifier(null); + + /// Whether the app is overridden to use bold text. + ValueListenable get boldText => _boldText; + final _boldText = ValueNotifier(false); + + /// Whether the app is overridden to behave as though a screen reader is on. + /// + /// This overrides `AccessibilityFeatures.accessibleNavigation`, which + /// changes how widgets behave. It does not start a screen reader. + ValueListenable get screenReader => _screenReader; + final _screenReader = ValueNotifier(false); + + /// Whether the app is overridden to use high contrast. + ValueListenable get highContrast => _highContrast; + final _highContrast = ValueNotifier(false); final semanticsRoots = ValueNotifier>([]); final selectedSemanticsNode = ValueNotifier(null); @@ -321,11 +399,13 @@ class AccessibilityController extends DevToolsScreenController @override void dispose() { unawaited(_disposeSemanticsOnApp()); + _viewMetricsOverrideClient?.dispose(); brightness.dispose(); - textScale.dispose(); - boldText.dispose(); - screenReader.dispose(); - highContrast.dispose(); + _overridesAvailable.dispose(); + _textScale.dispose(); + _boldText.dispose(); + _screenReader.dispose(); + _highContrast.dispose(); semanticsRoots.dispose(); selectedSemanticsNode.dispose(); semanticsTreeLoading.dispose(); diff --git a/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart b/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart index 9e2555ac122..bfdaf070cb4 100644 --- a/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart +++ b/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart @@ -2,7 +2,10 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file or at https://developers.google.com/open-source/licenses/bsd. +import 'dart:async'; + import 'package:devtools_app_shared/ui.dart'; +import 'package:flutter/foundation.dart'; import 'package:material_ui/material_ui.dart'; import '../../shared/globals.dart'; @@ -38,25 +41,7 @@ class AccessibilityOverridesPane extends StatelessWidget { const SizedBox(height: denseSpacing), _BrightnessOverride(controller: controller), const SizedBox(height: defaultSpacing), - _TextScaleOverride(controller: controller), - const SizedBox(height: defaultSpacing), - _SwitchOverride( - label: 'Bold Text', - description: 'Forces all text in the application to be bold.', - notifier: controller.boldText, - ), - const SizedBox(height: defaultSpacing), - _SwitchOverride( - label: 'Screen Reader Debugger', - description: 'Debug and test screen reader layouts.', - notifier: controller.screenReader, - ), - const SizedBox(height: defaultSpacing), - _SwitchOverride( - label: 'High Contrast', - description: 'Increases the contrast of text and icons.', - notifier: controller.highContrast, - ), + _ViewMetricsOverrides(controller: controller), ], ), ), @@ -128,46 +113,134 @@ class _BrightnessOverride extends StatelessWidget { } } -class _TextScaleOverride extends StatelessWidget { - const _TextScaleOverride({required this.controller}); +/// The controls of `ext.flutter.viewMetricsOverride`, which are disabled with +/// a tooltip while the app does not support it. +class _ViewMetricsOverrides extends StatelessWidget { + const _ViewMetricsOverrides({required this.controller}); final AccessibilityController controller; + static const _unavailableMessage = + 'Unavailable because the connected app is a profile build, or uses a ' + 'Flutter version that does not support these overrides.'; + + @override + Widget build(BuildContext context) { + return ValueListenableBuilder( + valueListenable: controller.overridesAvailable, + builder: (context, available, _) { + final overrides = Column( + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + _TextScaleOverride(controller: controller, enabled: available), + const SizedBox(height: defaultSpacing), + _SwitchOverride( + label: 'Bold Text', + description: 'Forces all text in the application to be bold.', + value: controller.boldText, + onChanged: available ? controller.setBoldText : null, + ), + const SizedBox(height: defaultSpacing), + _SwitchOverride( + label: 'Screen Reader Debugger', + description: 'Debug and test screen reader layouts.', + value: controller.screenReader, + onChanged: available ? controller.setScreenReader : null, + ), + const SizedBox(height: defaultSpacing), + _SwitchOverride( + label: 'High Contrast', + description: 'Increases the contrast of text and icons.', + value: controller.highContrast, + onChanged: available ? controller.setHighContrast : null, + ), + ], + ); + if (available) return overrides; + return DevToolsTooltip(message: _unavailableMessage, child: overrides); + }, + ); + } +} + +class _TextScaleOverride extends StatefulWidget { + const _TextScaleOverride({required this.controller, required this.enabled}); + + final AccessibilityController controller; + + /// Whether the text scale can be changed. + final bool enabled; + + @override + State<_TextScaleOverride> createState() => _TextScaleOverrideState(); +} + +class _TextScaleOverrideState extends State<_TextScaleOverride> { static const _minTextScale = 0.5; static const _maxTextScale = 3.0; static const _textScaleDivisions = 25; + /// The text scale that the slider shows while the user moves it, until the + /// app answers the override. + double? _sliderTextScale; + + Future _overrideTextScale(double textScale) async { + await widget.controller.setTextScale(textScale); + if (mounted && _sliderTextScale == textScale) { + setState(() => _sliderTextScale = null); + } + } + @override Widget build(BuildContext context) { final theme = Theme.of(context); - return ValueListenableBuilder( - valueListenable: controller.textScale, - builder: (context, value, _) { + final enabled = widget.enabled; + return ValueListenableBuilder( + valueListenable: widget.controller.textScale, + builder: (context, appTextScale, _) { + final textScale = _sliderTextScale ?? appTextScale; return Column( crossAxisAlignment: CrossAxisAlignment.start, children: [ Row( - mainAxisAlignment: MainAxisAlignment.spaceBetween, children: [ - const _AccessibilityPanelLabel( - label: 'Text Scale', - description: 'Scale the system font size.', + const Expanded( + child: _AccessibilityPanelLabel( + label: 'Text Scale', + description: 'Scale the system font size.', + ), ), Text( - '${value.toStringAsFixed(2)}x', + // 1.0 is an override too, so the text scale of the platform + // is shown by name rather than as a factor. + textScale == null + ? 'System default' + : '${textScale.toStringAsFixed(2)}x', style: theme.boldTextStyle, ), + const SizedBox(width: denseSpacing), + DevToolsButton.iconOnly( + icon: Icons.restart_alt, + outlined: false, + tooltip: 'Use the system text scale', + onPressed: enabled && appTextScale != null + ? () => unawaited(widget.controller.setTextScale(null)) + : null, + ), ], ), const SizedBox(height: densePadding), Slider( - value: value, + value: (textScale ?? 1.0).clamp(_minTextScale, _maxTextScale), min: _minTextScale, max: _maxTextScale, divisions: _textScaleDivisions, - onChanged: (newValue) { - controller.textScale.value = newValue; - }, + onChanged: enabled + ? (value) => setState(() => _sliderTextScale = value) + : null, + onChangeEnd: enabled + ? (value) => unawaited(_overrideTextScale(value)) + : null, ), ], ); @@ -180,12 +253,18 @@ class _SwitchOverride extends StatelessWidget { const _SwitchOverride({ required this.label, required this.description, - required this.notifier, + required this.value, + required this.onChanged, }); final String label; final String description; - final ValueNotifier notifier; + + /// Whether the app has this override on. + final ValueListenable value; + + /// Called when the user toggles the switch, or null to disable the switch. + final ValueChanged? onChanged; @override Widget build(BuildContext context) { @@ -197,7 +276,11 @@ class _SwitchOverride extends StatelessWidget { description: description, ), ), - NotifierSwitch(notifier: notifier), + ValueListenableBuilder( + valueListenable: value, + builder: (context, isOn, _) => + DevToolsSwitch(value: isOn, onChanged: onChanged), + ), ], ); } diff --git a/packages/devtools_app/lib/src/service/service_registrations.dart b/packages/devtools_app/lib/src/service/service_registrations.dart index 52c049f7983..a2c8596eff7 100644 --- a/packages/devtools_app/lib/src/service/service_registrations.dart +++ b/packages/devtools_app/lib/src/service/service_registrations.dart @@ -70,3 +70,6 @@ const getIssuesAndSemanticsTree = /// Service extension to dispose semantics on the connected app. const disposeSemantics = 'ext.flutter.accessibility.disposeSemantics'; + +/// Service extension to override the view metrics of the connected app. +const viewMetricsOverride = 'ext.flutter.viewMetricsOverride'; diff --git a/packages/devtools_app/lib/src/service/view_metrics_override_client.dart b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart new file mode 100644 index 00000000000..23e92a8485e --- /dev/null +++ b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart @@ -0,0 +1,269 @@ +// Copyright 2026 The Flutter Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file or at https://developers.google.com/open-source/licenses/bsd. + +import 'dart:async'; +import 'dart:convert'; + +import 'package:collection/collection.dart'; +import 'package:devtools_app_shared/service.dart'; +import 'package:devtools_app_shared/utils.dart'; +import 'package:flutter/foundation.dart'; +import 'package:logging/logging.dart'; +import 'package:vm_service/vm_service.dart'; + +import '../shared/globals.dart'; +import 'service_registrations.dart' as registrations; + +final _log = Logger('view_metrics_override_client'); + +/// A client for the `ext.flutter.viewMetricsOverride` service extension, which +/// makes a debug Flutter app behave as though the platform reported different +/// view metrics, such as a larger text scale or bold text. +/// +/// The app keeps the overrides in a registry keyed by view ID. Every reply of +/// the extension, and every `Flutter.ServiceExtensionStateChanged` event that +/// it posts, carries the whole registry. This client takes [overrides] from +/// the latest of them, so a call that fails leaves [overrides] as the app last +/// reported it. +/// +/// The extension cannot list view IDs yet, so this client only acts on the +/// implicit view, whose ID is 0. +/// +/// The registry lives in the main isolate of the app, so a hot restart empties +/// it. When the extension is registered again on the new isolate, this client +/// reads the registry and restores the metrics that it set, with the values +/// that they had before the restart. +/// +/// See `FoundationServiceExtensions.viewMetricsOverride` in +/// `package:flutter/foundation.dart` for the protocol. +class ViewMetricsOverrideClient extends DisposableController + with AutoDisposeControllerMixin { + ViewMetricsOverrideClient() { + final serviceManager = serviceConnection.serviceManager; + addAutoDisposeListener( + serviceManager.isolateManager.mainIsolate, + _onMainIsolateChanged, + ); + final service = serviceManager.service; + if (service != null) { + autoDisposeStreamSubscription( + service.onExtensionEvent.listen(_onExtensionEvent), + ); + } + _onMainIsolateChanged(); + } + + /// The ID of the implicit view, as a key of the registry. + static const _implicitViewId = '0'; + + /// Whether the main isolate of the connected app has registered the + /// extension, which only debug builds of recent Flutter versions do. + ValueListenable get available => _available; + final _available = ValueNotifier(false); + + /// The overrides that the app has for the implicit view, as it last reported + /// them, such as `{'boldText': true}`. + /// + /// The map has the JSON format of `DebugViewMetricsOverride` in + /// `package:flutter/foundation.dart`. It is empty until the app first + /// reports its overrides. + ValueListenable> get overrides => _overrides; + final _overrides = ValueNotifier>(const {}); + + /// Whether the current main isolate has reported its overrides. + bool _overridesReported = false; + + /// The metrics that this client has changed, which it sets again after a hot + /// restart if the app still overrides them. + final _ownMetrics = {}; + + /// The metrics to set again once the extension is registered on the new + /// main isolate, with the values that they had on the previous one. + Map _metricsToRestore = const {}; + + /// The number of times that the main isolate has changed, so that the calls + /// meant for an isolate that is gone are dropped, and their replies ignored. + int _isolateGeneration = 0; + + /// The [ServiceExtensionManager.hasServiceExtension] listenable of the + /// extension for the current main isolate. + /// + /// [ServiceExtensionManager] stops updating the listenables that it returned + /// once the main isolate exits, so this is looked up again for every main + /// isolate. + ValueListenable? _hasExtension; + + /// Completes when the last call that this client queued for the current + /// main isolate is done. + /// + /// The calls run one at a time, so that replies apply in the order the calls + /// were made, and every write starts from the reply to the call before it. + Future _lastCall = Future.value(); + + /// Overrides the metrics in [metrics] for the implicit view, and keeps the + /// other [overrides] that the view has. + /// + /// The keys and values of [metrics] have the format of [overrides]. A null + /// value stops overriding the metric, so that the app uses the value that + /// the platform reports. + /// + /// A change that another client makes after this client last heard from the + /// app, and before the app receives this call, is lost. + /// + /// Does nothing while the extension is not [available]. The returned future + /// does not complete if a hot restart interrupts the call. + Future updateOverrides(Map metrics) => _queue(() { + _ownMetrics.addAll(metrics.keys); + return _write(metrics); + }); + + /// Runs [call] once the calls queued before it for the current main isolate + /// are done, unless the main isolate has changed or the extension is not + /// [available] by then. + Future _queue(Future Function() call) { + final isolateGeneration = _isolateGeneration; + return _lastCall = _lastCall.then((_) async { + if (disposed || + isolateGeneration != _isolateGeneration || + !_available.value) { + return; + } + await call(); + }); + } + + Future _read() => _call(const {}); + + Future _write(Map metrics) async { + final isolateGeneration = _isolateGeneration; + // A write that does not start from the overrides of the app could remove + // the overrides that other clients set, so read them first if needed. + if (!_overridesReported) await _read(); + if (!_overridesReported || isolateGeneration != _isolateGeneration) return; + final viewOverrides = {..._overrides.value, ...metrics} + ..removeWhere((_, value) => value == null); + await _call({ + 'viewId': _implicitViewId, + 'overrides': jsonEncode(viewOverrides), + }); + } + + /// Calls the extension with [parameters], and takes [overrides] from the + /// reply. + Future _call(Map parameters) async { + final isolateGeneration = _isolateGeneration; + try { + final response = await serviceConnection.serviceManager + .callServiceExtensionOnMainIsolate( + registrations.viewMetricsOverride, + args: parameters, + ); + if (disposed || isolateGeneration != _isolateGeneration) return; + _takeOverridesFrom(response.json?['overrides']); + } catch (e, st) { + _log.warning( + 'Failed to call ${registrations.viewMetricsOverride}: $e', + e, + st, + ); + } + } + + /// Takes [overrides] from [registry], which is the `overrides` of a reply or + /// the `value` of an event. + void _takeOverridesFrom(Object? registry) { + final viewOverrides = registry is Map + ? registry[_implicitViewId] ?? const {} + : null; + if (viewOverrides is! Map) { + _log.warning( + 'Unexpected overrides from ${registrations.viewMetricsOverride}: ' + '$registry', + ); + return; + } + _overridesReported = true; + // Replies, and events about other views, often carry unchanged overrides + // for this view, so notify only when they differ. + if (!const DeepCollectionEquality().equals( + viewOverrides, + _overrides.value, + )) { + _overrides.value = Map.unmodifiable(viewOverrides); + } + } + + void _onExtensionEvent(Event event) { + if (event.extensionKind != FlutterEvent.serviceExtensionStateChanged) { + return; + } + final data = event.extensionData?.data; + if (data == null || + data['extension'] != registrations.viewMetricsOverride) { + return; + } + // An isolate that a hot restart replaced can still post an event, which + // describes a registry that is gone. + final mainIsolate = + serviceConnection.serviceManager.isolateManager.mainIsolate.value; + if (mainIsolate == null || event.isolate?.id != mainIsolate.id) return; + // Unlike the other extensions, this one posts its state as a JSON object, + // which ServiceExtensionManager would turn into a string. + _takeOverridesFrom(data['value']); + } + + void _onMainIsolateChanged() { + _isolateGeneration++; + // The VM service never answers a call that is in flight when its isolate + // exits, so the calls for the new main isolate do not wait for older ones. + _lastCall = Future.value(); + // A hot restart replaces the main isolate, and the registry with it, so + // remember the values of the metrics that this client set. + final viewOverrides = _overrides.value; + _metricsToRestore = { + ..._metricsToRestore, + for (final metric in _ownMetrics) + if (viewOverrides.containsKey(metric)) metric: viewOverrides[metric], + }; + _overridesReported = false; + + final serviceManager = serviceConnection.serviceManager; + cancelListener(_onAvailabilityChanged); + // ServiceExtensionManager can report the extensions of a new isolate + // before it becomes the main isolate, so wait for a main isolate. + _hasExtension = serviceManager.isolateManager.mainIsolate.value == null + ? null + : serviceManager.serviceExtensionManager.hasServiceExtension( + registrations.viewMetricsOverride, + ); + addAutoDisposeListener(_hasExtension, _onAvailabilityChanged); + _onAvailabilityChanged(); + } + + void _onAvailabilityChanged() { + final available = _hasExtension?.value ?? false; + if (available == _available.value) return; + _available.value = available; + if (!available) return; + unawaited(_queue(_read)); + unawaited(_queue(_restoreMetrics)); + } + + Future _restoreMetrics() async { + final metrics = _metricsToRestore; + if (metrics.isEmpty) return; + final isolateGeneration = _isolateGeneration; + await _write(metrics); + // If the main isolate changed during the write, the new one needs the + // metrics too. + if (isolateGeneration == _isolateGeneration) _metricsToRestore = const {}; + } + + @override + void dispose() { + _available.dispose(); + _overrides.dispose(); + super.dispose(); + } +} diff --git a/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart b/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart index 2575cb09fd3..7a04ef4d44e 100644 --- a/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart +++ b/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart @@ -17,12 +17,16 @@ import 'package:flutter_test/flutter_test.dart'; import 'package:mockito/mockito.dart'; import 'package:vm_service/vm_service.dart'; +import '../../test_infra/utils/view_metrics_override_utils.dart'; + void main() { group('AccessibilityController', () { late AccessibilityController controller; + late FakeViewMetricsOverrideExtension fakeExtension; setUp(() { - final fakeServiceConnection = FakeServiceConnectionManager(); + final fakeServiceConnection = ViewMetricsOverrideServiceConnection(); + fakeExtension = fakeServiceConnection.extension; when( fakeServiceConnection.serviceManager.connectedApp!.isFlutterWebAppNow, ).thenReturn(false); @@ -60,7 +64,8 @@ void main() { uninitializedController.brightness.value, BrightnessOverride.system, ); - expect(uninitializedController.textScale.value, 1.0); + expect(uninitializedController.overridesAvailable.value, isFalse); + expect(uninitializedController.textScale.value, isNull); expect(uninitializedController.boldText.value, isFalse); expect(uninitializedController.screenReader.value, isFalse); expect(uninitializedController.highContrast.value, isFalse); @@ -525,6 +530,44 @@ void main() { isTrue, ); }); + + group('view metrics overrides', () { + test('show the overrides of the app once it supports them', () async { + fakeExtension.registry['0'] = { + 'textScaling': [ + [8, 16], + [100, 100], + ], + 'boldText': true, + 'accessibleNavigation': true, + 'highContrast': false, + }; + expect(controller.overridesAvailable.value, isFalse); + + await fakeExtension.register(); + await pumpEventQueue(); + + expect(controller.overridesAvailable.value, isTrue); + // Like the app, the page reports the ratio of the first point. + expect(controller.textScale.value, 2.0); + expect(controller.boldText.value, isTrue); + expect(controller.screenReader.value, isTrue); + expect(controller.highContrast.value, isFalse); + }); + + test('1.0 is a text scale override', () async { + await fakeExtension.register(); + await pumpEventQueue(); + + await controller.setTextScale(1.0); + expect(fakeExtension.registry['0'], { + 'textScaling': [ + [1, 1.0], + ], + }); + expect(controller.textScale.value, 1.0); + }); + }); }); } diff --git a/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart b/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart index e1c14e9ce40..266bf50906a 100644 --- a/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart +++ b/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart @@ -10,15 +10,17 @@ import 'dart:ui' show SemanticsFlag; import 'package:devtools_app/devtools_app.dart'; import 'package:devtools_app_shared/ui.dart'; import 'package:devtools_app_shared/utils.dart'; -import 'package:devtools_test/devtools_test.dart'; import 'package:devtools_test/helpers.dart'; import 'package:flutter_test/flutter_test.dart'; import 'package:material_ui/material_ui.dart'; import 'package:mockito/mockito.dart'; +import '../../test_infra/utils/view_metrics_override_utils.dart'; + void main() { late AccessibilityScreen screen; late AccessibilityController controller; + late FakeViewMetricsOverrideExtension fakeExtension; const windowSize = Size(1000.0, 1000.0); group('Accessibility Screen', () { @@ -32,7 +34,8 @@ void main() { } setUp(() { - final fakeServiceConnection = FakeServiceConnectionManager(); + final fakeServiceConnection = ViewMetricsOverrideServiceConnection(); + fakeExtension = fakeServiceConnection.extension; when( fakeServiceConnection.serviceManager.connectedApp!.isFlutterWebAppNow, ).thenReturn(false); @@ -111,7 +114,7 @@ void main() { // Text Scale controls expect(find.text('Text Scale'), findsOneWidget); expect(find.text('Scale the system font size.'), findsOneWidget); - expect(find.text('1.00x'), findsOneWidget); + expect(find.text('System default'), findsOneWidget); expect(find.byType(Slider), findsOneWidget); // Switches @@ -134,20 +137,21 @@ void main() { }, ); + Finder findSwitchFor(String label) { + return find.descendant( + of: find.ancestor(of: find.text(label), matching: find.byType(Row)), + matching: find.byType(Switch), + ); + } + testWidgetsWithWindowSize( - 'interacting with override controls updates controller state', + 'interacting with override controls updates the app and the controller', windowSize, (WidgetTester tester) async { await pumpAccessibilityScreen(tester); + await fakeExtension.register(); await tester.pumpAndSettle(); - Finder findSwitchFor(String label) { - return find.descendant( - of: find.ancestor(of: find.text(label), matching: find.byType(Row)), - matching: find.byType(Switch), - ); - } - // 1. Test Brightness Dropdown expect(controller.brightness.value, BrightnessOverride.system); await tester.tap( @@ -184,6 +188,87 @@ void main() { await tester.tap(highContrastSwitch); await tester.pumpAndSettle(); expect(controller.highContrast.value, isTrue); + + // Brightness does not go through ext.flutter.viewMetricsOverride. + expect(fakeExtension.registry, { + '0': { + 'boldText': true, + 'accessibleNavigation': true, + 'highContrast': true, + }, + }); + + // Turning a switch off lets the app use the setting of the platform. + await tester.tap(boldTextSwitch); + await tester.pumpAndSettle(); + expect(controller.boldText.value, isFalse); + expect(fakeExtension.registry['0'], { + 'accessibleNavigation': true, + 'highContrast': true, + }); + }, + ); + + testWidgetsWithWindowSize( + 'disables the overrides and explains why while the app does not support them', + windowSize, + (WidgetTester tester) async { + await pumpAccessibilityScreen(tester); + await tester.pumpAndSettle(); + + final unavailableTooltip = find.byWidgetPredicate( + (widget) => + widget is Tooltip && + (widget.message ?? '').contains('profile build'), + ); + for (final element in find.byType(Switch).evaluate()) { + expect((element.widget as Switch).onChanged, isNull); + } + expect(tester.widget(find.byType(Slider)).onChanged, isNull); + expect(unavailableTooltip, findsOneWidget); + + // The controls are enabled once the app registers the extension. + await fakeExtension.register(); + await tester.pumpAndSettle(); + expect( + tester.widget(findSwitchFor('Bold Text')).onChanged, + isNotNull, + ); + expect(tester.widget(find.byType(Slider)).onChanged, isNotNull); + expect(unavailableTooltip, findsNothing); + }, + ); + + testWidgetsWithWindowSize( + 'text scale shows the override of the app, and the slider and reset change it', + windowSize, + (WidgetTester tester) async { + fakeExtension.registry['0'] = { + 'textScaling': [ + [1.0, 4.0], + ], + }; + await pumpAccessibilityScreen(tester); + await fakeExtension.register(); + await tester.pumpAndSettle(); + + // The slider stays within its range. + expect(find.text('4.00x'), findsOneWidget); + expect(tester.widget(find.byType(Slider)).value, 3.0); + + await tester.drag(find.byType(Slider), const Offset(-1000, 0)); + await tester.pumpAndSettle(); + expect(find.text('0.50x'), findsOneWidget); + expect(fakeExtension.registry['0'], { + 'textScaling': [ + [1, 0.5], + ], + }); + + await tester.tap(find.byIcon(Icons.restart_alt)); + await tester.pumpAndSettle(); + expect(find.text('System default'), findsOneWidget); + expect(fakeExtension.registry, isEmpty); }, ); diff --git a/packages/devtools_app/test/service/view_metrics_override_client_test.dart b/packages/devtools_app/test/service/view_metrics_override_client_test.dart new file mode 100644 index 00000000000..ccde094d442 --- /dev/null +++ b/packages/devtools_app/test/service/view_metrics_override_client_test.dart @@ -0,0 +1,286 @@ +// Copyright 2026 The Flutter Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file or at https://developers.google.com/open-source/licenses/bsd. + +@TestOn('vm') +library; + +import 'dart:async'; +import 'dart:convert'; + +import 'package:devtools_app/devtools_app.dart'; +import 'package:devtools_app/src/service/view_metrics_override_client.dart'; +import 'package:devtools_app_shared/service.dart' show FlutterEvent; +import 'package:devtools_app_shared/utils.dart'; +import 'package:devtools_test/devtools_test.dart'; +import 'package:flutter_test/flutter_test.dart'; +import 'package:vm_service/vm_service.dart'; + +import '../test_infra/utils/view_metrics_override_utils.dart'; + +void main() { + group('ViewMetricsOverrideClient', () { + late ViewMetricsOverrideServiceConnection connection; + late FakeViewMetricsOverrideExtension extension; + late ViewMetricsOverrideClient client; + + void emitExtensionEvent(Event event) { + (connection.serviceManager.service as FakeVmServiceWrapper) + .emitExtensionEvent(event); + } + + Event stateChangedEvent({ + required String extensionName, + required Object? value, + IsolateRef? isolate, + }) { + return Event( + kind: EventKind.kExtension, + extensionKind: FlutterEvent.serviceExtensionStateChanged, + extensionData: ExtensionData.parse({ + 'extension': extensionName, + 'value': value, + }), + isolate: + isolate ?? + connection.serviceManager.isolateManager.mainIsolate.value, + timestamp: 0, + ); + } + + setUp(() { + connection = ViewMetricsOverrideServiceConnection(); + extension = connection.extension; + setGlobal(ServiceConnectionManager, connection); + client = ViewMetricsOverrideClient(); + }); + + tearDown(() { + client.dispose(); + }); + + test('is not available until the extension is registered', () async { + expect(client.available.value, isFalse); + + await client.updateOverrides({'boldText': true}); + + expect(extension.calls, isEmpty); + }); + + test('reads the registry once the extension is registered', () async { + extension.registry['0'] = {'platformBrightness': 'dark'}; + extension.registry['1'] = {'boldText': true}; + + await extension.register(); + await pumpEventQueue(); + + expect(client.available.value, isTrue); + expect(extension.calls, [{}]); + expect(client.overrides.value, {'platformBrightness': 'dark'}); + + // A client created once the extension is registered reads it too. + final otherClient = ViewMetricsOverrideClient(); + addTearDown(otherClient.dispose); + await pumpEventQueue(); + expect(otherClient.available.value, isTrue); + expect(otherClient.overrides.value, {'platformBrightness': 'dark'}); + }); + + test('updateOverrides keeps the metrics that other clients set', () async { + extension.registry['0'] = { + 'platformBrightness': 'dark', + 'boldText': true, + }; + await extension.register(); + await pumpEventQueue(); + + await client.updateOverrides({'highContrast': true, 'boldText': null}); + + expect(extension.registry, { + '0': {'platformBrightness': 'dark', 'highContrast': true}, + }); + expect(client.overrides.value, { + 'platformBrightness': 'dark', + 'highContrast': true, + }); + }); + + test('follows the changes that other clients make', () async { + await extension.register(); + await pumpEventQueue(); + var notifications = 0; + client.overrides.addListener(() => notifications++); + + extension.callFromOtherClient({ + 'viewId': '0', + 'overrides': jsonEncode({ + 'textScaling': [ + [1, 2], + ], + }), + }); + await pumpEventQueue(); + expect(client.overrides.value, { + 'textScaling': [ + [1, 2], + ], + }); + expect(notifications, 1); + + // A change to another view does not change the overrides of view 0. + extension.callFromOtherClient({ + 'viewId': '1', + 'overrides': jsonEncode({'boldText': true}), + }); + await pumpEventQueue(); + expect(notifications, 1); + + // A write starts from the latest event, without reading first. + await client.updateOverrides({'boldText': true}); + expect(extension.calls, [ + {}, + {'viewId': '0', 'overrides': anything}, + ]); + expect(extension.registry['0'], { + 'textScaling': [ + [1, 2], + ], + 'boldText': true, + }); + }); + + test('ignores events of other extensions and of other isolates', () async { + extension.registry['0'] = {'boldText': true}; + await extension.register(); + await pumpEventQueue(); + + emitExtensionEvent( + stateChangedEvent( + extensionName: 'ext.flutter.brightnessOverride', + value: {}, + ), + ); + emitExtensionEvent( + stateChangedEvent( + extensionName: viewMetricsOverride, + value: {}, + isolate: IsolateRef(id: 'exited_isolate'), + ), + ); + await pumpEventQueue(); + + expect(client.overrides.value, {'boldText': true}); + }); + + test('failed calls keep the overrides and the restore', () async { + final error = RPCError( + viewMetricsOverride, + RPCErrorKind.kServerError.code, + 'Failed', + ); + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({'boldText': true}); + + extension.nextCallError = error; + await client.updateOverrides({'highContrast': true}); + expect(extension.registry, { + '0': {'boldText': true}, + }); + expect(client.overrides.value, {'boldText': true}); + + // The first read after the hot restart fails, so the restore reads again. + extension.nextCallError = error; + await extension.hotRestart(); + await pumpEventQueue(); + expect(extension.registry, { + '0': {'boldText': true}, + }); + }); + + test('writes run one at a time, each from the reply before it', () async { + await extension.register(); + await pumpEventQueue(); + + await Future.wait([ + client.updateOverrides({'boldText': true}), + client.updateOverrides({'highContrast': true}), + ]); + + expect(extension.registry['0'], {'boldText': true, 'highContrast': true}); + }); + + test('sets its metrics again after a hot restart', () async { + extension.registry['0'] = {'platformBrightness': 'dark'}; + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({ + 'boldText': true, + 'textScaling': [ + [1, 2], + ], + }); + await client.updateOverrides({'textScaling': null}); + extension.callFromOtherClient({ + 'viewId': '0', + 'overrides': jsonEncode({ + 'platformBrightness': 'dark', + 'boldText': false, + }), + }); + await pumpEventQueue(); + + extension.calls.clear(); + await extension.hotRestart(); + await pumpEventQueue(); + + expect(extension.calls, [ + {}, + {'viewId': '0', 'overrides': anything}, + ]); + // Only the metrics that this client set and that the app still had are + // set again, with the values that they had. The metrics of other clients + // are theirs to set again. + expect(extension.registry, { + '0': {'boldText': false}, + }); + expect(client.overrides.value, {'boldText': false}); + }); + + test( + 'does not wait for calls that an exited isolate never answers', + () async { + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({'boldText': true}); + extension.calls.clear(); + await extension.hotRestart(); + // Let the new isolate be read, and the restore be sent. + for (var i = 0; i < 5 && extension.calls.length < 2; i++) { + await Future.delayed(Duration.zero); + } + expect(extension.calls, [ + {}, + {'viewId': '0', 'overrides': '{"boldText":true}'}, + ]); + expect(extension.registry, isEmpty); + + // The app restarts again before it answers the restore, while a write + // waits for the restore in the queue. + unawaited(client.updateOverrides({'highContrast': true})); + extension.calls.clear(); + await extension.hotRestart(); + await pumpEventQueue(); + + // The write is dropped, and the new isolate gets the restore. + expect(extension.calls, [ + {}, + {'viewId': '0', 'overrides': '{"boldText":true}'}, + ]); + expect(extension.registry, { + '0': {'boldText': true}, + }); + }, + ); + }); +} diff --git a/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart b/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart new file mode 100644 index 00000000000..fb3fa06527f --- /dev/null +++ b/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart @@ -0,0 +1,149 @@ +// Copyright 2026 The Flutter Authors +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file or at https://developers.google.com/open-source/licenses/bsd. + +import 'dart:async'; +import 'dart:convert'; + +import 'package:collection/collection.dart'; +import 'package:devtools_app/devtools_app.dart'; +import 'package:devtools_app_shared/service.dart' show FlutterEvent; +import 'package:devtools_test/devtools_test.dart'; +import 'package:vm_service/vm_service.dart'; + +/// A [FakeServiceConnectionManager] whose main isolate serves the +/// `ext.flutter.viewMetricsOverride` service extension through [extension]. +class ViewMetricsOverrideServiceConnection + extends FakeServiceConnectionManager { + @override + FakeServiceManager get serviceManager => _serviceManager; + final _serviceManager = _ViewMetricsOverrideServiceManager(); + + /// The fake extension that [serviceManager] calls. + FakeViewMetricsOverrideExtension get extension => _serviceManager.extension; +} + +// ignore: subtype_of_sealed_class, fake for testing. +class _ViewMetricsOverrideServiceManager extends FakeServiceManager { + late final extension = FakeViewMetricsOverrideExtension._(this); + + @override + Future callServiceExtensionOnMainIsolate( + String method, { + Map? args, + }) async { + if (method != viewMetricsOverride) { + return super.callServiceExtensionOnMainIsolate(method, args: args); + } + final parameters = Map.from(args ?? const {}); + extension.calls.add(parameters); + final isolate = isolateManager.mainIsolate.value; + // Like the VM service, reply after the caller has moved on, and never + // reply to a call whose isolate exits first. + await Future.delayed(Duration.zero); + if (isolateManager.mainIsolate.value != isolate) { + return Completer().future; + } + final error = extension.nextCallError; + extension.nextCallError = null; + if (error != null) throw error; + return extension._handle(parameters); + } +} + +/// A fake of the `ext.flutter.viewMetricsOverride` service extension of a +/// debug Flutter app. +/// +/// Like the app, it replies with the registry, and posts it in a +/// `Flutter.ServiceExtensionStateChanged` event when a call changes it. It +/// does not validate the parameters. +class FakeViewMetricsOverrideExtension { + FakeViewMetricsOverrideExtension._(this._serviceManager); + + final FakeServiceManager _serviceManager; + + /// The registry of the app, keyed by view ID. + final registry = >{}; + + /// The parameters of the calls that DevTools made, in order. + final calls = >[]; + + /// An error that the next call from DevTools throws instead of being + /// handled, such as an [RPCError]. + Object? nextCallError; + + int _restarts = 0; + + /// Registers the extension, as the binding of a debug Flutter app does, and + /// sends the first frame. + Future register() async { + final extensionManager = _serviceManager.serviceExtensionManager; + await extensionManager.fakeAddServiceExtension(viewMetricsOverride); + await extensionManager.fakeFrame(); + } + + /// Calls the extension as another client of the app would, such as an MCP + /// server. + void callFromOtherClient(Map parameters) { + _handle(parameters); + } + + /// Hot restarts the app, which replaces the main isolate and empties the + /// registry. + /// + /// As a real app can, the new isolate registers the extension before it + /// becomes the main isolate. + Future hotRestart() async { + final isolateManager = _serviceManager.isolateManager as FakeIsolateManager; + // ServiceExtensionManager starts listening to the main isolate when the VM + // service opens, so it reacts to the old isolate exiting before others. + _serviceManager.serviceExtensionManager.fakeMainIsolateClosed(); + isolateManager.setMainIsolate(null); + registry.clear(); + await register(); + _restarts++; + isolateManager.setMainIsolate( + IsolateRef(id: 'restarted_isolate_$_restarts', name: 'main'), + ); + } + + Response _handle(Map parameters) { + final viewId = parameters['viewId']; + final overrides = parameters['overrides']; + if (viewId != null && overrides != null) { + final previous = registry[viewId]; + final next = jsonDecode(overrides) as Map; + if (next.isEmpty) { + registry.remove(viewId); + } else { + registry[viewId] = next; + } + if (!const DeepCollectionEquality().equals(previous, registry[viewId])) { + _postStateChangedEvent(); + } + } + return Response.parse({ + 'type': '_extensionType', + 'method': viewMetricsOverride, + 'overrides': _encodedRegistry, + })!; + } + + /// The registry as the app serializes it into a reply or an event. + Object? get _encodedRegistry => jsonDecode(jsonEncode(registry)); + + void _postStateChangedEvent() { + (_serviceManager.service as FakeVmServiceWrapper).emitExtensionEvent( + Event( + kind: EventKind.kExtension, + extensionKind: FlutterEvent.serviceExtensionStateChanged, + extensionData: ExtensionData.parse({ + 'extension': viewMetricsOverride, + 'value': _encodedRegistry, + }), + isolate: _serviceManager.isolateManager.mainIsolate.value, + timestamp: 0, + ), + ); + } +} diff --git a/packages/devtools_test/lib/src/mocks/fake_isolate_manager.dart b/packages/devtools_test/lib/src/mocks/fake_isolate_manager.dart index 5e9823fdd07..09c5688a78a 100644 --- a/packages/devtools_test/lib/src/mocks/fake_isolate_manager.dart +++ b/packages/devtools_test/lib/src/mocks/fake_isolate_manager.dart @@ -46,6 +46,12 @@ base class FakeIsolateManager extends Fake with TestIsolateManager { _isolateCreatedController.add(isolate); } + /// Changes the main isolate, as [IsolateManager] does during a hot restart. + @visibleForTesting + void setMainIsolate(IsolateRef? isolate) { + _mainIsolate.value = isolate; + } + @override ValueNotifier> get isolates { return _isolates ??= ValueNotifier([?_selectedIsolate.value]); diff --git a/packages/devtools_test/lib/src/mocks/fake_service_extension_manager.dart b/packages/devtools_test/lib/src/mocks/fake_service_extension_manager.dart index fc47c3adacd..b518859f91f 100644 --- a/packages/devtools_test/lib/src/mocks/fake_service_extension_manager.dart +++ b/packages/devtools_test/lib/src/mocks/fake_service_extension_manager.dart @@ -194,6 +194,16 @@ base class FakeServiceExtensionManager extends Fake } } + /// Hook for tests to simulate the main isolate exiting, as it does during a + /// hot restart. + /// + /// Like [ServiceExtensionManager], this also stops updating the listenables + /// that [hasServiceExtension] returned. + void fakeMainIsolateClosed() { + vmServiceClosed(); + _serviceExtensionAvailable.clear(); + } + /// Sets the state for a service extension and makes the call to the VMService. @override Future setServiceExtensionState( diff --git a/packages/devtools_test/lib/src/mocks/fake_vm_service_wrapper.dart b/packages/devtools_test/lib/src/mocks/fake_vm_service_wrapper.dart index c687bb6d4cb..726c2a40361 100644 --- a/packages/devtools_test/lib/src/mocks/fake_vm_service_wrapper.dart +++ b/packages/devtools_test/lib/src/mocks/fake_vm_service_wrapper.dart @@ -85,6 +85,7 @@ class FakeVmServiceWrapper extends Fake implements VmServiceWrapper { final ClassList? _classList; late final Map? _reverseResolvedUriMap; final _gcEventStream = StreamController.broadcast(); + final _extensionEventStream = StreamController.broadcast(); final _flags = >{ 'flags': [ @@ -533,7 +534,12 @@ class FakeVmServiceWrapper extends Fake implements VmServiceWrapper { Stream get onLoggingEventWithHistorySafe => const Stream.empty(); @override - Stream get onExtensionEvent => const Stream.empty(); + Stream get onExtensionEvent => _extensionEventStream.stream; + + /// Posts [event] to [onExtensionEvent]. + void emitExtensionEvent(Event event) { + _extensionEventStream.sink.add(event); + } @override Stream get onExtensionEventWithHistorySafe => const Stream.empty(); From 2274ba05a2f88fb913e102883852a611af03d091 Mon Sep 17 00:00:00 2001 From: Victor Sanni Date: Tue, 17 Nov 2026 10:53:45 -0800 Subject: [PATCH 2/3] Fix edge cases of the view metrics override client A call that throws no longer keeps the calls after it from running, and the future of a call that a hot restart interrupts now completes. A metric that DevTools stops overriding is no longer set again after a hot restart, and a restore that fails is tried again after the next one. The page ignores text scaling tables without a valid first point, and setTextScale asserts that its factor is finite and not negative. The text scale label now reads "System Default", like the brightness dropdown next to it. --- .../accessibility_controller.dart | 30 +++-- .../screens/accessibility/overrides_pane.dart | 15 ++- .../service/view_metrics_override_client.dart | 105 +++++++++++++----- .../accessibility_controller_test.dart | 17 +++ .../accessibility_screen_test.dart | 16 ++- .../view_metrics_override_client_test.dart | 104 +++++++++++++++-- 6 files changed, 235 insertions(+), 52 deletions(-) diff --git a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart index d1a34602078..e0d6fdd198e 100644 --- a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart +++ b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart @@ -151,15 +151,22 @@ class AccessibilityController extends DevToolsScreenController /// Overrides the text scale factor of the app with [factor], or stops /// overriding it if [factor] is null. /// - /// The override scales every font size linearly by [factor]. - Future setTextScale(double? factor) => _setOverride( - _textScalingMetric, - factor == null - ? null - : [ - [1, factor], - ], - ); + /// The override scales every font size linearly by [factor], which has to be + /// finite and not negative. + Future setTextScale(double? factor) { + assert( + factor == null || (factor.isFinite && factor >= 0), + 'The text scale factor must be finite and not negative, got $factor.', + ); + return _setOverride( + _textScalingMetric, + factor == null + ? null + : [ + [1, factor], + ], + ); + } /// Makes the app use bold text, or the bold text setting of the platform /// again if [enabled] is false. @@ -188,9 +195,12 @@ class AccessibilityController extends DevToolsScreenController /// Returns the ratio of the first point of [textScaling], which is the text /// scale factor that the app reports, or null if text scale is not /// overridden. + /// + /// Like the app, this only accepts a first point whose unscaled size is + /// greater than zero, and whose scaled size is not negative. static double? _textScaleFactor(Object? textScaling) { if (textScaling case [[final num unscaled, final num scaled], ...]) { - return scaled / unscaled; + if (unscaled > 0 && scaled >= 0) return scaled / unscaled; } return null; } diff --git a/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart b/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart index bfdaf070cb4..a58c5ee7c17 100644 --- a/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart +++ b/packages/devtools_app/lib/src/screens/accessibility/overrides_pane.dart @@ -179,15 +179,20 @@ class _TextScaleOverrideState extends State<_TextScaleOverride> { static const _minTextScale = 0.5; static const _maxTextScale = 3.0; static const _textScaleDivisions = 25; + static const _systemTextScaleLabel = 'System Default'; + static const _resetTooltip = 'Use the system text scale'; /// The text scale that the slider shows while the user moves it, until the /// app answers the override. double? _sliderTextScale; Future _overrideTextScale(double textScale) async { - await widget.controller.setTextScale(textScale); - if (mounted && _sliderTextScale == textScale) { - setState(() => _sliderTextScale = null); + try { + await widget.controller.setTextScale(textScale); + } finally { + if (mounted && _sliderTextScale == textScale) { + setState(() => _sliderTextScale = null); + } } } @@ -214,7 +219,7 @@ class _TextScaleOverrideState extends State<_TextScaleOverride> { // 1.0 is an override too, so the text scale of the platform // is shown by name rather than as a factor. textScale == null - ? 'System default' + ? _systemTextScaleLabel : '${textScale.toStringAsFixed(2)}x', style: theme.boldTextStyle, ), @@ -222,7 +227,7 @@ class _TextScaleOverrideState extends State<_TextScaleOverride> { DevToolsButton.iconOnly( icon: Icons.restart_alt, outlined: false, - tooltip: 'Use the system text scale', + tooltip: _resetTooltip, onPressed: enabled && appTextScale != null ? () => unawaited(widget.controller.setTextScale(null)) : null, diff --git a/packages/devtools_app/lib/src/service/view_metrics_override_client.dart b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart index 23e92a8485e..bbc113d29c6 100644 --- a/packages/devtools_app/lib/src/service/view_metrics_override_client.dart +++ b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart @@ -32,13 +32,18 @@ final _log = Logger('view_metrics_override_client'); /// /// The registry lives in the main isolate of the app, so a hot restart empties /// it. When the extension is registered again on the new isolate, this client -/// reads the registry and restores the metrics that it set, with the values -/// that they had before the restart. +/// reads the registry and restores the metrics that it overrides, with the +/// values that they had before the restart. /// /// See `FoundationServiceExtensions.viewMetricsOverride` in /// `package:flutter/foundation.dart` for the protocol. class ViewMetricsOverrideClient extends DisposableController with AutoDisposeControllerMixin { + /// Creates a client for the app that DevTools is connected to. + /// + /// The client listens to the extension events of the VM service connection + /// that is open when it is created, so, like a screen controller, it has to + /// be created again for a new connection. ViewMetricsOverrideClient() { final serviceManager = serviceConnection.serviceManager; addAutoDisposeListener( @@ -74,12 +79,15 @@ class ViewMetricsOverrideClient extends DisposableController /// Whether the current main isolate has reported its overrides. bool _overridesReported = false; - /// The metrics that this client has changed, which it sets again after a hot + /// The metrics that this client overrides, which it sets again after a hot /// restart if the app still overrides them. final _ownMetrics = {}; /// The metrics to set again once the extension is registered on the new /// main isolate, with the values that they had on the previous one. + /// + /// They are kept until a restore succeeds, so that a restore that fails is + /// tried again on the next main isolate. Map _metricsToRestore = const {}; /// The number of times that the main isolate has changed, so that the calls @@ -101,49 +109,87 @@ class ViewMetricsOverrideClient extends DisposableController /// were made, and every write starts from the reply to the call before it. Future _lastCall = Future.value(); + /// Completes at the next change of the main isolate, or when this client is + /// disposed. + /// + /// The VM service never answers a call that is in flight when its isolate + /// exits, so the futures that [_queue] returns also complete when this does. + Completer _nextMainIsolateChange = Completer(); + /// Overrides the metrics in [metrics] for the implicit view, and keeps the /// other [overrides] that the view has. /// /// The keys and values of [metrics] have the format of [overrides]. A null /// value stops overriding the metric, so that the app uses the value that - /// the platform reports. + /// the platform reports, and this client no longer sets it again after a hot + /// restart. /// /// A change that another client makes after this client last heard from the /// app, and before the app receives this call, is lost. /// - /// Does nothing while the extension is not [available]. The returned future - /// does not complete if a hot restart interrupts the call. + /// Does nothing while the extension is not [available]. A call that fails is + /// logged, and leaves [overrides] as the app last reported them. The + /// returned future completes once the app answers, or once a hot restart + /// interrupts the call. Future updateOverrides(Map metrics) => _queue(() { - _ownMetrics.addAll(metrics.keys); + for (final MapEntry(key: metric, :value) in metrics.entries) { + if (value == null) { + _ownMetrics.remove(metric); + } else { + _ownMetrics.add(metric); + } + } + // These values replace the ones that a pending restore would set. + _metricsToRestore = Map.of(_metricsToRestore) + ..removeWhere((metric, _) => metrics.containsKey(metric)); return _write(metrics); }); /// Runs [call] once the calls queued before it for the current main isolate /// are done, unless the main isolate has changed or the extension is not /// [available] by then. + /// + /// A call that throws is logged, so that the calls after it still run. The + /// returned future completes when [call] is done, or at the next change of + /// the main isolate, whichever comes first. Future _queue(Future Function() call) { final isolateGeneration = _isolateGeneration; - return _lastCall = _lastCall.then((_) async { + _lastCall = _lastCall.then((_) async { if (disposed || isolateGeneration != _isolateGeneration || !_available.value) { return; } - await call(); + try { + await call(); + } catch (e, st) { + _log.warning( + 'Failed to call ${registrations.viewMetricsOverride}: $e', + e, + st, + ); + } }); + return Future.any([_lastCall, _nextMainIsolateChange.future]); } - Future _read() => _call(const {}); + /// Reads the overrides of the app, and returns whether the app reported + /// them. + Future _read() => _call(const {}); - Future _write(Map metrics) async { + /// Writes [metrics] over the overrides that the app last reported, and + /// returns whether the app applied them and reported its overrides. + Future _write(Map metrics) async { final isolateGeneration = _isolateGeneration; // A write that does not start from the overrides of the app could remove // the overrides that other clients set, so read them first if needed. if (!_overridesReported) await _read(); - if (!_overridesReported || isolateGeneration != _isolateGeneration) return; + if (!_overridesReported || isolateGeneration != _isolateGeneration) { + return false; + } final viewOverrides = {..._overrides.value, ...metrics} ..removeWhere((_, value) => value == null); - await _call({ + return _call({ 'viewId': _implicitViewId, 'overrides': jsonEncode(viewOverrides), }); @@ -151,7 +197,10 @@ class ViewMetricsOverrideClient extends DisposableController /// Calls the extension with [parameters], and takes [overrides] from the /// reply. - Future _call(Map parameters) async { + /// + /// Returns whether the reply is for the current main isolate, and has the + /// expected format. + Future _call(Map parameters) async { final isolateGeneration = _isolateGeneration; try { final response = await serviceConnection.serviceManager @@ -159,20 +208,23 @@ class ViewMetricsOverrideClient extends DisposableController registrations.viewMetricsOverride, args: parameters, ); - if (disposed || isolateGeneration != _isolateGeneration) return; - _takeOverridesFrom(response.json?['overrides']); + if (disposed || isolateGeneration != _isolateGeneration) return false; + return _takeOverridesFrom(response.json?['overrides']); } catch (e, st) { _log.warning( 'Failed to call ${registrations.viewMetricsOverride}: $e', e, st, ); + return false; } } /// Takes [overrides] from [registry], which is the `overrides` of a reply or /// the `value` of an event. - void _takeOverridesFrom(Object? registry) { + /// + /// Returns whether [registry] has the expected format. + bool _takeOverridesFrom(Object? registry) { final viewOverrides = registry is Map ? registry[_implicitViewId] ?? const {} : null; @@ -181,7 +233,7 @@ class ViewMetricsOverrideClient extends DisposableController 'Unexpected overrides from ${registrations.viewMetricsOverride}: ' '$registry', ); - return; + return false; } _overridesReported = true; // Replies, and events about other views, often carry unchanged overrides @@ -192,6 +244,7 @@ class ViewMetricsOverrideClient extends DisposableController )) { _overrides.value = Map.unmodifiable(viewOverrides); } + return true; } void _onExtensionEvent(Event event) { @@ -216,10 +269,13 @@ class ViewMetricsOverrideClient extends DisposableController void _onMainIsolateChanged() { _isolateGeneration++; // The VM service never answers a call that is in flight when its isolate - // exits, so the calls for the new main isolate do not wait for older ones. + // exits, so the calls for the new main isolate do not wait for older ones, + // and neither do the callers of the older ones. _lastCall = Future.value(); + _nextMainIsolateChange.complete(); + _nextMainIsolateChange = Completer(); // A hot restart replaces the main isolate, and the registry with it, so - // remember the values of the metrics that this client set. + // remember the values of the metrics that this client overrides. final viewOverrides = _overrides.value; _metricsToRestore = { ..._metricsToRestore, @@ -253,15 +309,14 @@ class ViewMetricsOverrideClient extends DisposableController Future _restoreMetrics() async { final metrics = _metricsToRestore; if (metrics.isEmpty) return; - final isolateGeneration = _isolateGeneration; - await _write(metrics); - // If the main isolate changed during the write, the new one needs the - // metrics too. - if (isolateGeneration == _isolateGeneration) _metricsToRestore = const {}; + // If the write fails, or the main isolate changes during it, the next main + // isolate needs the metrics too. + if (await _write(metrics)) _metricsToRestore = const {}; } @override void dispose() { + _nextMainIsolateChange.complete(); _available.dispose(); _overrides.dispose(); super.dispose(); diff --git a/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart b/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart index 7a04ef4d44e..4e10f7b43cd 100644 --- a/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart +++ b/packages/devtools_app/test/screens/accessibility/accessibility_controller_test.dart @@ -567,6 +567,23 @@ void main() { }); expect(controller.textScale.value, 1.0); }); + + test('ignore a text scaling table without a valid first point', () async { + fakeExtension.registry['0'] = { + 'textScaling': [ + [0, 16], + ], + }; + await fakeExtension.register(); + await pumpEventQueue(); + + expect(controller.textScale.value, isNull); + }); + + test('setTextScale asserts a finite, non-negative factor', () { + expect(() => controller.setTextScale(double.nan), throwsAssertionError); + expect(() => controller.setTextScale(-1.0), throwsAssertionError); + }); }); }); } diff --git a/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart b/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart index 266bf50906a..b946d07ca10 100644 --- a/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart +++ b/packages/devtools_app/test/screens/accessibility/accessibility_screen_test.dart @@ -33,6 +33,18 @@ void main() { ); } + /// Finds [text] in the row of the text scale override, because the + /// brightness dropdown can show the same text. + Finder findInTextScaleRow(String text) { + return find.descendant( + of: find.ancestor( + of: find.text('Text Scale'), + matching: find.byType(Row), + ), + matching: find.text(text), + ); + } + setUp(() { final fakeServiceConnection = ViewMetricsOverrideServiceConnection(); fakeExtension = fakeServiceConnection.extension; @@ -114,7 +126,7 @@ void main() { // Text Scale controls expect(find.text('Text Scale'), findsOneWidget); expect(find.text('Scale the system font size.'), findsOneWidget); - expect(find.text('System default'), findsOneWidget); + expect(findInTextScaleRow('System Default'), findsOneWidget); expect(find.byType(Slider), findsOneWidget); // Switches @@ -267,7 +279,7 @@ void main() { await tester.tap(find.byIcon(Icons.restart_alt)); await tester.pumpAndSettle(); - expect(find.text('System default'), findsOneWidget); + expect(findInTextScaleRow('System Default'), findsOneWidget); expect(fakeExtension.registry, isEmpty); }, ); diff --git a/packages/devtools_app/test/service/view_metrics_override_client_test.dart b/packages/devtools_app/test/service/view_metrics_override_client_test.dart index ccde094d442..01663725363 100644 --- a/packages/devtools_app/test/service/view_metrics_override_client_test.dart +++ b/packages/devtools_app/test/service/view_metrics_override_client_test.dart @@ -48,6 +48,12 @@ void main() { ); } + final callFailure = RPCError( + viewMetricsOverride, + RPCErrorKind.kServerError.code, + 'Failed', + ); + setUp(() { connection = ViewMetricsOverrideServiceConnection(); extension = connection.extension; @@ -173,16 +179,11 @@ void main() { }); test('failed calls keep the overrides and the restore', () async { - final error = RPCError( - viewMetricsOverride, - RPCErrorKind.kServerError.code, - 'Failed', - ); await extension.register(); await pumpEventQueue(); await client.updateOverrides({'boldText': true}); - extension.nextCallError = error; + extension.nextCallError = callFailure; await client.updateOverrides({'highContrast': true}); expect(extension.registry, { '0': {'boldText': true}, @@ -190,7 +191,7 @@ void main() { expect(client.overrides.value, {'boldText': true}); // The first read after the hot restart fails, so the restore reads again. - extension.nextCallError = error; + extension.nextCallError = callFailure; await extension.hotRestart(); await pumpEventQueue(); expect(extension.registry, { @@ -198,6 +199,24 @@ void main() { }); }); + test( + 'a write reads the registry first if the app has not reported it', + () async { + extension.registry['0'] = {'platformBrightness': 'dark'}; + // The read that follows the registration fails. + extension.nextCallError = callFailure; + await extension.register(); + await pumpEventQueue(); + expect(client.overrides.value, isEmpty); + + await client.updateOverrides({'boldText': true}); + + expect(extension.registry, { + '0': {'platformBrightness': 'dark', 'boldText': true}, + }); + }, + ); + test('writes run one at a time, each from the reply before it', () async { await extension.register(); await pumpEventQueue(); @@ -210,6 +229,19 @@ void main() { expect(extension.registry['0'], {'boldText': true, 'highContrast': true}); }); + test('a call that throws does not stop the calls after it', () async { + await extension.register(); + await pumpEventQueue(); + + // JSON cannot encode NaN, so this write throws before it is sent. + await client.updateOverrides({'textScaling': double.nan}); + await client.updateOverrides({'boldText': true}); + + expect(extension.registry, { + '0': {'boldText': true}, + }); + }); + test('sets its metrics again after a hot restart', () async { extension.registry['0'] = {'platformBrightness': 'dark'}; await extension.register(); @@ -226,6 +258,9 @@ void main() { 'overrides': jsonEncode({ 'platformBrightness': 'dark', 'boldText': false, + 'textScaling': [ + [1, 3], + ], }), }); await pumpEventQueue(); @@ -238,9 +273,10 @@ void main() { {}, {'viewId': '0', 'overrides': anything}, ]); - // Only the metrics that this client set and that the app still had are - // set again, with the values that they had. The metrics of other clients - // are theirs to set again. + // Only the metrics that this client overrides and that the app still had + // are set again, with the values that they had. The metrics of other + // clients, including the ones that this client stopped overriding, are + // theirs to set again. expect(extension.registry, { '0': {'boldText': false}, }); @@ -282,5 +318,53 @@ void main() { }); }, ); + + test('completes a call that a hot restart interrupts', () async { + await extension.register(); + await pumpEventQueue(); + var completed = false; + unawaited( + client + .updateOverrides({'boldText': true}) + .then((_) => completed = true), + ); + // The app restarts after the write is sent, and before it answers. + for (var i = 0; i < 5 && extension.calls.length < 2; i++) { + await Future.microtask(() {}); + } + expect(extension.calls, hasLength(2)); + await extension.hotRestart(); + await pumpEventQueue(); + + expect(completed, isTrue); + }); + + test( + 'sets its metrics again after the next hot restart if a restore fails', + () async { + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({'boldText': true, 'highContrast': true}); + extension.calls.clear(); + await extension.hotRestart(); + // Let the new isolate be read, and fail the restore that follows. + for (var i = 0; i < 5 && extension.calls.length < 2; i++) { + await Future.delayed(Duration.zero); + } + expect(extension.calls, hasLength(2)); + extension.nextCallError = callFailure; + await pumpEventQueue(); + expect(extension.registry, isEmpty); + + // A metric that this client stops overriding is not restored anymore. + await client.updateOverrides({'highContrast': null}); + await extension.hotRestart(); + await pumpEventQueue(); + + expect(extension.registry, { + '0': {'boldText': true}, + }); + }, + ); }); } From acdb58a7376979b46a03a678fd6818e835bd77b0 Mon Sep 17 00:00:00 2001 From: Victor Sanni Date: Tue, 17 Nov 2026 15:27:17 -0800 Subject: [PATCH 3/3] Restore what the page shows after a hot restart After a hot restart, the client now restores the text scale, bold text, screen reader and high contrast overrides that the app had, whoever set them, rather than only the ones that this client set. So the page shows the same overrides after the restart, also after DevTools reloads. The fake extension parses writes with DebugViewMetricsOverride.fromJson, like the app, and can hold calls until a test releases them, so the tests of a hot restart during a call no longer poll. The client docs also say to create one client per connection. --- .../accessibility_controller.dart | 14 +- .../service/view_metrics_override_client.dart | 34 ++--- .../view_metrics_override_client_test.dart | 135 +++++++++++------- .../utils/view_metrics_override_utils.dart | 86 +++++++++-- 4 files changed, 184 insertions(+), 85 deletions(-) diff --git a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart index e0d6fdd198e..9ff848c4d31 100644 --- a/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart +++ b/packages/devtools_app/lib/src/screens/accessibility/accessibility_controller.dart @@ -128,12 +128,24 @@ class AccessibilityController extends DevToolsScreenController static const _accessibleNavigationMetric = 'accessibleNavigation'; static const _highContrastMetric = 'highContrast'; + /// The metrics that the overrides pane shows, which the client sets again + /// after a hot restart, so that the pane shows the same overrides as before + /// the restart. + static const _paneMetrics = { + _textScalingMetric, + _boldTextMetric, + _accessibleNavigationMetric, + _highContrastMetric, + }; + /// The client that overrides the text scale, bold text, screen reader and /// high contrast settings of the app, or null before [init]. ViewMetricsOverrideClient? _viewMetricsOverrideClient; void _initViewMetricsOverrides() { - final client = _viewMetricsOverrideClient = ViewMetricsOverrideClient(); + final client = _viewMetricsOverrideClient = ViewMetricsOverrideClient( + restoredMetrics: _paneMetrics, + ); void updateFromApp() { final overrides = client.overrides.value; _overridesAvailable.value = client.available.value; diff --git a/packages/devtools_app/lib/src/service/view_metrics_override_client.dart b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart index bbc113d29c6..640ed0d8761 100644 --- a/packages/devtools_app/lib/src/service/view_metrics_override_client.dart +++ b/packages/devtools_app/lib/src/service/view_metrics_override_client.dart @@ -32,8 +32,8 @@ final _log = Logger('view_metrics_override_client'); /// /// The registry lives in the main isolate of the app, so a hot restart empties /// it. When the extension is registered again on the new isolate, this client -/// reads the registry and restores the metrics that it overrides, with the -/// values that they had before the restart. +/// reads the registry and restores the [restoredMetrics] that the app had +/// before the restart, with the values that they had, whoever set them. /// /// See `FoundationServiceExtensions.viewMetricsOverride` in /// `package:flutter/foundation.dart` for the protocol. @@ -43,8 +43,10 @@ class ViewMetricsOverrideClient extends DisposableController /// /// The client listens to the extension events of the VM service connection /// that is open when it is created, so, like a screen controller, it has to - /// be created again for a new connection. - ViewMetricsOverrideClient() { + /// be created again for a new connection. Create only one client per + /// connection: like two tools, two clients can overwrite each other's + /// changes. + ViewMetricsOverrideClient({required this.restoredMetrics}) { final serviceManager = serviceConnection.serviceManager; addAutoDisposeListener( serviceManager.isolateManager.mainIsolate, @@ -59,6 +61,12 @@ class ViewMetricsOverrideClient extends DisposableController _onMainIsolateChanged(); } + /// The metrics that this client sets again after a hot restart if the app + /// had them, whoever set them, such as the metrics that a page shows. + /// + /// The other metrics are left to the tools that set them. + final Set restoredMetrics; + /// The ID of the implicit view, as a key of the registry. static const _implicitViewId = '0'; @@ -79,10 +87,6 @@ class ViewMetricsOverrideClient extends DisposableController /// Whether the current main isolate has reported its overrides. bool _overridesReported = false; - /// The metrics that this client overrides, which it sets again after a hot - /// restart if the app still overrides them. - final _ownMetrics = {}; - /// The metrics to set again once the extension is registered on the new /// main isolate, with the values that they had on the previous one. /// @@ -121,8 +125,7 @@ class ViewMetricsOverrideClient extends DisposableController /// /// The keys and values of [metrics] have the format of [overrides]. A null /// value stops overriding the metric, so that the app uses the value that - /// the platform reports, and this client no longer sets it again after a hot - /// restart. + /// the platform reports. /// /// A change that another client makes after this client last heard from the /// app, and before the app receives this call, is lost. @@ -132,13 +135,6 @@ class ViewMetricsOverrideClient extends DisposableController /// returned future completes once the app answers, or once a hot restart /// interrupts the call. Future updateOverrides(Map metrics) => _queue(() { - for (final MapEntry(key: metric, :value) in metrics.entries) { - if (value == null) { - _ownMetrics.remove(metric); - } else { - _ownMetrics.add(metric); - } - } // These values replace the ones that a pending restore would set. _metricsToRestore = Map.of(_metricsToRestore) ..removeWhere((metric, _) => metrics.containsKey(metric)); @@ -275,11 +271,11 @@ class ViewMetricsOverrideClient extends DisposableController _nextMainIsolateChange.complete(); _nextMainIsolateChange = Completer(); // A hot restart replaces the main isolate, and the registry with it, so - // remember the values of the metrics that this client overrides. + // remember the values that the app had for the metrics to restore. final viewOverrides = _overrides.value; _metricsToRestore = { ..._metricsToRestore, - for (final metric in _ownMetrics) + for (final metric in restoredMetrics) if (viewOverrides.containsKey(metric)) metric: viewOverrides[metric], }; _overridesReported = false; diff --git a/packages/devtools_app/test/service/view_metrics_override_client_test.dart b/packages/devtools_app/test/service/view_metrics_override_client_test.dart index 01663725363..cb245a78529 100644 --- a/packages/devtools_app/test/service/view_metrics_override_client_test.dart +++ b/packages/devtools_app/test/service/view_metrics_override_client_test.dart @@ -54,11 +54,19 @@ void main() { 'Failed', ); + // The metrics that the accessibility page shows. + const restoredMetrics = { + 'textScaling', + 'boldText', + 'accessibleNavigation', + 'highContrast', + }; + setUp(() { connection = ViewMetricsOverrideServiceConnection(); extension = connection.extension; setGlobal(ServiceConnectionManager, connection); - client = ViewMetricsOverrideClient(); + client = ViewMetricsOverrideClient(restoredMetrics: restoredMetrics); }); tearDown(() { @@ -85,11 +93,11 @@ void main() { expect(client.overrides.value, {'platformBrightness': 'dark'}); // A client created once the extension is registered reads it too. - final otherClient = ViewMetricsOverrideClient(); - addTearDown(otherClient.dispose); + client.dispose(); + client = ViewMetricsOverrideClient(restoredMetrics: restoredMetrics); await pumpEventQueue(); - expect(otherClient.available.value, isTrue); - expect(otherClient.overrides.value, {'platformBrightness': 'dark'}); + expect(client.available.value, isTrue); + expect(client.overrides.value, {'platformBrightness': 'dark'}); }); test('updateOverrides keeps the metrics that other clients set', () async { @@ -242,17 +250,18 @@ void main() { }); }); - test('sets its metrics again after a hot restart', () async { + test('restores the metrics that the app had after a hot restart', () async { extension.registry['0'] = {'platformBrightness': 'dark'}; await extension.register(); await pumpEventQueue(); await client.updateOverrides({ 'boldText': true, + 'highContrast': true, 'textScaling': [ [1, 2], ], }); - await client.updateOverrides({'textScaling': null}); + await client.updateOverrides({'highContrast': null, 'textScaling': null}); extension.callFromOtherClient({ 'viewId': '0', 'overrides': jsonEncode({ @@ -273,14 +282,34 @@ void main() { {}, {'viewId': '0', 'overrides': anything}, ]); - // Only the metrics that this client overrides and that the app still had - // are set again, with the values that they had. The metrics of other - // clients, including the ones that this client stopped overriding, are - // theirs to set again. + // The metrics in restoredMetrics that the app had are set again, with + // the values that the app had, whoever set them. The other metrics are + // left to the tools that set them. + const restored = { + 'boldText': false, + 'textScaling': [ + [1, 3], + ], + }; + expect(extension.registry, {'0': restored}); + expect(client.overrides.value, restored); + }); + + test('a new client restores the metrics that the app had', () async { + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({'boldText': true}); + + // DevTools reloads, which creates a new client. + client.dispose(); + client = ViewMetricsOverrideClient(restoredMetrics: restoredMetrics); + await pumpEventQueue(); + await extension.hotRestart(); + await pumpEventQueue(); + expect(extension.registry, { - '0': {'boldText': false}, + '0': {'boldText': true}, }); - expect(client.overrides.value, {'boldText': false}); }); test( @@ -289,21 +318,22 @@ void main() { await extension.register(); await pumpEventQueue(); await client.updateOverrides({'boldText': true}); - extension.calls.clear(); + extension.holdCalls = true; await extension.hotRestart(); - // Let the new isolate be read, and the restore be sent. - for (var i = 0; i < 5 && extension.calls.length < 2; i++) { - await Future.delayed(Duration.zero); - } - expect(extension.calls, [ - {}, - {'viewId': '0', 'overrides': '{"boldText":true}'}, - ]); - expect(extension.registry, isEmpty); + await pumpEventQueue(); + // Answer the read of the new isolate, and hold the restore. + extension.releaseCall(); + await pumpEventQueue(); + expect(extension.heldCallCount, 1); + expect(extension.calls.last, { + 'viewId': '0', + 'overrides': '{"boldText":true}', + }); // The app restarts again before it answers the restore, while a write // waits for the restore in the queue. unawaited(client.updateOverrides({'highContrast': true})); + extension.holdCalls = false; extension.calls.clear(); await extension.hotRestart(); await pumpEventQueue(); @@ -322,49 +352,48 @@ void main() { test('completes a call that a hot restart interrupts', () async { await extension.register(); await pumpEventQueue(); + extension.holdCalls = true; var completed = false; unawaited( client .updateOverrides({'boldText': true}) .then((_) => completed = true), ); - // The app restarts after the write is sent, and before it answers. - for (var i = 0; i < 5 && extension.calls.length < 2; i++) { - await Future.microtask(() {}); - } - expect(extension.calls, hasLength(2)); + await pumpEventQueue(); + expect(extension.heldCallCount, 1); + expect(completed, isFalse); + + // The app restarts before it answers the write. await extension.hotRestart(); await pumpEventQueue(); expect(completed, isTrue); }); - test( - 'sets its metrics again after the next hot restart if a restore fails', - () async { - await extension.register(); - await pumpEventQueue(); - await client.updateOverrides({'boldText': true, 'highContrast': true}); - extension.calls.clear(); - await extension.hotRestart(); - // Let the new isolate be read, and fail the restore that follows. - for (var i = 0; i < 5 && extension.calls.length < 2; i++) { - await Future.delayed(Duration.zero); - } - expect(extension.calls, hasLength(2)); - extension.nextCallError = callFailure; - await pumpEventQueue(); - expect(extension.registry, isEmpty); + test('tries a failed restore again after the next hot restart', () async { + await extension.register(); + await pumpEventQueue(); + await client.updateOverrides({'boldText': true, 'highContrast': true}); + extension.holdCalls = true; + await extension.hotRestart(); + await pumpEventQueue(); + // Answer the read of the new isolate, and fail the restore. + extension.releaseCall(); + await pumpEventQueue(); + expect(extension.calls.last, {'viewId': '0', 'overrides': anything}); + extension.releaseCall(error: callFailure); + await pumpEventQueue(); + expect(extension.registry, isEmpty); - // A metric that this client stops overriding is not restored anymore. - await client.updateOverrides({'highContrast': null}); - await extension.hotRestart(); - await pumpEventQueue(); + // A metric that this client stops overriding is not restored anymore. + extension.holdCalls = false; + await client.updateOverrides({'highContrast': null}); + await extension.hotRestart(); + await pumpEventQueue(); - expect(extension.registry, { - '0': {'boldText': true}, - }); - }, - ); + expect(extension.registry, { + '0': {'boldText': true}, + }); + }); }); } diff --git a/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart b/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart index fb3fa06527f..28ce0b3a325 100644 --- a/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart +++ b/packages/devtools_app/test/test_infra/utils/view_metrics_override_utils.dart @@ -9,7 +9,8 @@ import 'package:collection/collection.dart'; import 'package:devtools_app/devtools_app.dart'; import 'package:devtools_app_shared/service.dart' show FlutterEvent; import 'package:devtools_test/devtools_test.dart'; -import 'package:vm_service/vm_service.dart'; +import 'package:flutter/foundation.dart' show DebugViewMetricsOverride; +import 'package:vm_service/vm_service.dart' hide Error; /// A [FakeServiceConnectionManager] whose main isolate serves the /// `ext.flutter.viewMetricsOverride` service extension through [extension]. @@ -38,31 +39,40 @@ class _ViewMetricsOverrideServiceManager extends FakeServiceManager { final parameters = Map.from(args ?? const {}); extension.calls.add(parameters); final isolate = isolateManager.mainIsolate.value; - // Like the VM service, reply after the caller has moved on, and never - // reply to a call whose isolate exits first. - await Future.delayed(Duration.zero); + final releaseError = await extension._waitToHandleCall(); + // Like the VM service, never reply to a call whose isolate exits first. if (isolateManager.mainIsolate.value != isolate) { return Completer().future; } - final error = extension.nextCallError; - extension.nextCallError = null; + final error = releaseError ?? extension._takeNextCallError(); if (error != null) throw error; - return extension._handle(parameters); + try { + return extension._handle(parameters); + } on FormatException catch (e, st) { + // The app answers a call that the extension rejects with an error. + Error.throwWithStackTrace( + RPCError(method, RPCErrorKind.kServerError.code, e.message), + st, + ); + } } } /// A fake of the `ext.flutter.viewMetricsOverride` service extension of a /// debug Flutter app. /// -/// Like the app, it replies with the registry, and posts it in a -/// `Flutter.ServiceExtensionStateChanged` event when a call changes it. It -/// does not validate the parameters. +/// Like the app, it parses the overrides of a call with +/// [DebugViewMetricsOverride.fromJson], so a call that the app would reject +/// fails. It replies with the registry, and posts it in a +/// `Flutter.ServiceExtensionStateChanged` event when a call changes it. class FakeViewMetricsOverrideExtension { FakeViewMetricsOverrideExtension._(this._serviceManager); final FakeServiceManager _serviceManager; /// The registry of the app, keyed by view ID. + /// + /// A test can fill it directly, without the checks that calls go through. final registry = >{}; /// The parameters of the calls that DevTools made, in order. @@ -72,8 +82,24 @@ class FakeViewMetricsOverrideExtension { /// handled, such as an [RPCError]. Object? nextCallError; + /// Whether the app holds the calls from DevTools until [releaseCall], so + /// that a test can act while a call is in flight. + /// + /// Otherwise, the app handles a call once the caller has moved on. + bool holdCalls = false; + + /// The number of calls from DevTools that the app holds. + int get heldCallCount => _heldCalls.length; + final _heldCalls = >[]; + int _restarts = 0; + /// Lets the app handle the oldest call that it holds, or makes that call + /// throw [error] instead. + void releaseCall({Object? error}) { + _heldCalls.removeAt(0).complete(error); + } + /// Registers the extension, as the binding of a debug Flutter app does, and /// sends the first frame. Future register() async { @@ -84,6 +110,8 @@ class FakeViewMetricsOverrideExtension { /// Calls the extension as another client of the app would, such as an MCP /// server. + /// + /// Throws a [FormatException] if the app would reject the call. void callFromOtherClient(Map parameters) { _handle(parameters); } @@ -92,9 +120,11 @@ class FakeViewMetricsOverrideExtension { /// registry. /// /// As a real app can, the new isolate registers the extension before it - /// becomes the main isolate. + /// becomes the main isolate. Like the VM service, the app never answers the + /// calls that it holds. Future hotRestart() async { final isolateManager = _serviceManager.isolateManager as FakeIsolateManager; + _heldCalls.clear(); // ServiceExtensionManager starts listening to the main isolate when the VM // service opens, so it reacts to the old isolate exiting before others. _serviceManager.serviceExtensionManager.fakeMainIsolateClosed(); @@ -107,12 +137,31 @@ class FakeViewMetricsOverrideExtension { ); } + /// Waits until the app handles a call from DevTools, and returns the error + /// that the call throws instead, if any. + Future _waitToHandleCall() async { + if (!holdCalls) { + // Like the VM service, reply after the caller has moved on. + await Future.delayed(Duration.zero); + return null; + } + final release = Completer(); + _heldCalls.add(release); + return release.future; + } + + Object? _takeNextCallError() { + final error = nextCallError; + nextCallError = null; + return error; + } + Response _handle(Map parameters) { final viewId = parameters['viewId']; final overrides = parameters['overrides']; if (viewId != null && overrides != null) { final previous = registry[viewId]; - final next = jsonDecode(overrides) as Map; + final next = _parse(overrides); if (next.isEmpty) { registry.remove(viewId); } else { @@ -129,6 +178,19 @@ class FakeViewMetricsOverrideExtension { })!; } + /// Parses [overrides] as the app does, and returns the overrides that the + /// app keeps, in the format of its replies. + /// + /// Throws a [FormatException] if the app would reject [overrides]. + static Map _parse(String overrides) { + return switch (jsonDecode(overrides)) { + final Map json => DebugViewMetricsOverride.fromJson( + json, + ).toJson(), + _ => throw const FormatException('The overrides must be a JSON object.'), + }; + } + /// The registry as the app serializes it into a reply or an event. Object? get _encodedRegistry => jsonDecode(jsonEncode(registry));