| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // API for integration testing. To be used on test images with a test component |
| // extension. |
| [platforms=("chromeos"), |
| modernised_enums, |
| implemented_in="chrome/browser/ash/extensions/autotest_private/autotest_private_api.h"] |
| namespace autotestPrivate { |
| |
| enum ShelfAlignmentType { |
| // BottomLocked not supported by shelf_prefs. |
| Bottom, Left, Right |
| }; |
| |
| // A mapping of ash::ShelfItemType. |
| enum ShelfItemType { |
| PinnedApp, |
| BrowserShortcut, |
| App, |
| UnpinnedBrowserShortcut, |
| Dialog |
| }; |
| |
| // A mapping of ash::ShelfItemStatus. |
| enum ShelfItemStatus { |
| Closed, |
| Running, |
| Attention |
| }; |
| |
| // A mapping of apps::mojom::Type |
| enum AppType { |
| Arc, |
| BuiltIn, |
| Crostini, |
| Extension, |
| Web, |
| MacOS, |
| PluginVm, |
| StandaloneBrowser, |
| Remote, |
| Borealis, |
| Bruschetta |
| }; |
| |
| // A mapping of apps::mojom::InstallSource |
| enum AppInstallSource { |
| Unknown, |
| System, |
| Policy, |
| Oem, |
| Default, |
| Sync, |
| User, |
| SubApp, |
| Kiosk, |
| CommandLine |
| }; |
| |
| // A mapping of apps::mojom::Readiness |
| enum AppReadiness { |
| Ready, |
| DisabledByBlacklist, |
| DisabledByPolicy, |
| DisabledByUser, |
| Terminated, |
| UninstalledByUser, |
| Removed, |
| UninstalledByMigration |
| }; |
| |
| // A subset of Window State types in ash::WindowStateType. We may add more |
| // into the set in the future. |
| enum WindowStateType { |
| Normal, |
| Minimized, |
| Maximized, |
| Fullscreen, |
| PrimarySnapped, |
| SecondarySnapped, |
| PIP, |
| Floated |
| }; |
| |
| // A subset of WM event types in ash::WMEventType. We may add more in the |
| // set in the future. |
| enum WMEventType { |
| WMEventNormal, |
| WMEventMaximize, |
| WMEventMinimize, |
| WMEventFullscreen, |
| WMEventSnapPrimary, |
| WMEventSnapSecondary, |
| WMEventFloat |
| }; |
| |
| // Display orientation type. |
| enum RotationType { |
| // RotateAny is the auto-rotation status (not locked to a rotation) for |
| // tablet mode. Not working in clamshell mode. |
| RotateAny, |
| Rotate0, |
| Rotate90, |
| Rotate180, |
| Rotate270 |
| }; |
| |
| enum LauncherStateType { |
| Closed, |
| FullscreenAllApps, |
| FullscreenSearch |
| }; |
| |
| enum OverviewStateType { |
| Shown, |
| Hidden |
| }; |
| |
| enum MouseButton { |
| Left, |
| Middle, |
| Right, |
| Back, |
| Forward |
| }; |
| |
| // A paramter used in setArcAppWindowState() function. |
| dictionary WindowStateChangeDict { |
| // The WM event to change the ARC window state. |
| WMEventType eventType; |
| |
| // If the initial state is already same as the expected state, should we |
| // treat this case as a failure? Default value is false. |
| boolean? failIfNoChange; |
| }; |
| |
| dictionary LoginStatusDict { |
| // Are we logged in? |
| boolean isLoggedIn; |
| // Is the logged-in user the owner? |
| boolean isOwner; |
| // Is the screen locked? |
| boolean isScreenLocked; |
| // Is the wallpaper blur layer still animating in? |
| boolean isLockscreenWallpaperAnimating; |
| // Is the screen ready for password? |
| boolean isReadyForPassword; |
| // Are the avatar images loaded for all users? |
| boolean areAllUserImagesLoaded; |
| |
| // Is the logged-in user a regular user? Set only if `isLoggedIn`. |
| boolean? isRegularUser; |
| // Are we logged into the guest account? Set only if `isLoggedIn`. |
| boolean? isGuest; |
| // Are we logged into kiosk-app mode? Set only if `isLoggedIn`. |
| boolean? isKiosk; |
| |
| // User email. Set only if `isLoggedIn`. |
| DOMString? email; |
| // User display email. Set only if `isLoggedIn`. |
| DOMString? displayEmail; |
| // User display name. Set only if `isLoggedIn`. |
| DOMString? displayName; |
| // User image: 'file', 'profile' or a number. Set only if `isLoggedIn`. |
| DOMString? userImage; |
| // Whether the user has a valid oauth2 token. Only set for gaia user. |
| boolean? hasValidOauth2Token; |
| }; |
| callback LoginStatusCallback = void (LoginStatusDict status); |
| |
| // |all_policies| will be the full list of policies as returned by the |
| // DictionaryPolicyConversions.ToValue function. |
| callback AllEnterprisePoliciesCallback = void (any all_policies); |
| |
| dictionary ExtensionInfoDict { |
| DOMString id; |
| DOMString version; |
| DOMString name; |
| DOMString publicKey; |
| DOMString description; |
| DOMString backgroundUrl; |
| DOMString optionsUrl; |
| |
| DOMString[] hostPermissions; |
| DOMString[] effectiveHostPermissions; |
| DOMString[] apiPermissions; |
| |
| boolean isComponent; |
| boolean isInternal; |
| boolean isUserInstalled; |
| boolean isEnabled; |
| boolean allowedInIncognito; |
| boolean hasPageAction; |
| }; |
| dictionary ExtensionsInfoArray { |
| ExtensionInfoDict[] extensions; |
| }; |
| callback ExtensionsInfoCallback = void (ExtensionsInfoArray info); |
| |
| dictionary Notification { |
| DOMString id; |
| DOMString type; |
| DOMString title; |
| DOMString message; |
| long priority; |
| long progress; |
| }; |
| callback NotificationArrayCallback = void (Notification[] notifications); |
| |
| dictionary Printer { |
| DOMString printerName; |
| DOMString? printerId; |
| DOMString? printerType; |
| DOMString? printerDesc; |
| DOMString? printerMakeAndModel; |
| DOMString? printerUri; |
| DOMString? printerPpd; |
| }; |
| callback PrinterArrayCallback = void (Printer[] printers); |
| |
| callback ArcStartTimeCallback = void (double startTicks); |
| |
| dictionary ArcState { |
| // Whether the ARC is provisioned. |
| boolean provisioned; |
| // Whether ARC Terms of Service needs to be shown. |
| boolean tosNeeded; |
| // ARC pre-start time (mini-ARC) or 0 if not pre-started. |
| double preStartTime; |
| // ARC start time or 0 if not started. |
| double startTime; |
| }; |
| callback ArcStateCallback = void (ArcState result); |
| |
| dictionary PlayStoreState { |
| // Whether the Play Store allowed for the current user. |
| boolean allowed; |
| // Whether the Play Store currently enabled. |
| boolean? enabled; |
| // Whether the Play Store managed by policy. |
| boolean? managed; |
| }; |
| callback PlayStoreStateCallback = void (PlayStoreState result); |
| |
| dictionary AssistantQueryResponse { |
| // Text response returned from server. |
| DOMString? text; |
| // HTML response returned from server. |
| DOMString? htmlResponse; |
| // Open URL response returned from server. |
| DOMString? openUrl; |
| // Open Android app response returned from server. |
| DOMString? openAppResponse; |
| }; |
| dictionary AssistantQueryStatus { |
| // Indicates whether this might be a voice interaction. |
| boolean isMicOpen; |
| // Query text sent to Assistant. In the event of a voice interaction, |
| // this field will be same as the speech recognition final result. |
| DOMString queryText; |
| // Response for the current query. |
| AssistantQueryResponse queryResponse; |
| }; |
| callback AssistantQueryStatusCallback = void (AssistantQueryStatus status); |
| |
| callback IsAppShownCallback = void (boolean appShown); |
| |
| callback IsArcProvisionedCallback = void (boolean arcProvisioned); |
| |
| callback IsArcPackageListInitialRefreshedCallback = void (boolean refreshed); |
| |
| // A mapping of crosapi::BrowserManager::State |
| enum LacrosState { |
| NotInitialized, |
| Reloading, |
| Mounting, |
| Unavailable, |
| Stopped, |
| CreatingLogFile, |
| PreLaunched, |
| Starting, |
| Running, |
| Terminating |
| }; |
| |
| // A mapping of crosapi::browser_util::LacrosMode |
| enum LacrosMode { |
| Disabled, |
| Only |
| }; |
| |
| dictionary LacrosInfo { |
| // The state of lacros. |
| LacrosState state; |
| // True iff keepalive is enabled for lacros. |
| boolean isKeepAlive; |
| // Path to lacros-chrome directory. Note that this may change over time if |
| // omaha is used. This also may be empty if lacros is not running. |
| DOMString lacrosPath; |
| // Specifies the mode Lacros is currently running. |
| // For a full list of supported mode, see LacrosMode enum definition. |
| LacrosMode mode; |
| }; |
| |
| callback GetLacrosInfoCallback = void (LacrosInfo info); |
| |
| dictionary ArcAppDict { |
| DOMString name; |
| DOMString packageName; |
| DOMString activity; |
| DOMString intentUri; |
| DOMString iconResourceId; |
| double lastLaunchTime; |
| double installTime; |
| boolean sticky; |
| boolean notificationsEnabled; |
| boolean ready; |
| boolean suspended; |
| boolean showInLauncher; |
| boolean shortcut; |
| boolean launchable; |
| }; |
| callback GetArcAppCallback = void (ArcAppDict package); |
| |
| dictionary ArcAppKillsDict { |
| double oom; |
| double lmkdForeground; |
| double lmkdPerceptible; |
| double lmkdCached; |
| double pressureForeground; |
| double pressurePerceptible; |
| double pressureCached; |
| }; |
| callback GetArcAppKillsCallback = void (ArcAppKillsDict counts); |
| |
| dictionary ArcPackageDict { |
| DOMString packageName; |
| long packageVersion; |
| DOMString lastBackupAndroidId; |
| double lastBackupTime; |
| boolean shouldSync; |
| boolean vpnProvider; |
| }; |
| callback GetArcPackageCallback = void (ArcPackageDict package); |
| |
| dictionary Location { |
| double x; |
| double y; |
| }; |
| |
| dictionary Bounds { |
| double left; |
| double top; |
| double width; |
| double height; |
| }; |
| |
| dictionary ArcAppTracingInfo { |
| boolean success; |
| double fps; |
| double commitDeviation; |
| double renderQuality; |
| }; |
| |
| callback TakeScreenshotCallback = void (DOMString base64Png); |
| |
| callback GetPrimaryDisplayScaleFactorCallback = void (double scaleFactor); |
| |
| callback IsTabletModeEnabledCallback = void (boolean enabled); |
| |
| callback SetTabletModeEnabledCallback = void(boolean enabled); |
| |
| callback SetShelfIconPinCallback = void(DOMString[] results); |
| |
| callback SetOverviewModeStateCallback = void(boolean finished); |
| |
| enum ThemeStyle { |
| TonalSpot, |
| Vibrant, |
| Expressive, |
| Spritz, |
| Rainbow, |
| FruitSalad |
| }; |
| |
| callback SendArcOverlayColorCallback = void (boolean result); |
| |
| callback ArcAppTracingCallback = void(ArcAppTracingInfo info); |
| |
| callback WaitForDisplayRotationCallback = void (boolean success); |
| |
| callback InstallPWAForCurrentURLCallback = void (DOMString appId); |
| |
| dictionary App { |
| DOMString appId; |
| DOMString name; |
| DOMString shortName; |
| DOMString publisherId; |
| AppType? type; |
| AppInstallSource? installSource; |
| AppReadiness? readiness; |
| DOMString[] additionalSearchTerms; |
| boolean? showInLauncher; |
| boolean? showInSearch; |
| }; |
| |
| dictionary SystemWebApp { |
| // App's internal name. This isn't user-visible and should only be used |
| // for logging. |
| DOMString internalName; |
| |
| // App's install URL. This is a placeholder for installation pipeline, |
| // not used for anything else. |
| DOMString url; |
| |
| // App's visible name. This is defined in the Web App manifest, and shown |
| // in Shelf and Launcher. This matches App's name attribute (see above). |
| DOMString name; |
| |
| // App's default start_url. This is the default URL that the App will be |
| // launched to. |
| DOMString startUrl; |
| }; |
| |
| callback GetAllInstalledAppsCallback = void (App[] apps); |
| |
| dictionary CryptohomeRecoveryDataDict { |
| DOMString reauthProofToken; |
| DOMString refreshToken; |
| }; |
| |
| callback GetCryptohomeRecoveryDataCallback = void ( |
| CryptohomeRecoveryDataDict dict); |
| |
| dictionary ShelfItem { |
| DOMString appId; |
| DOMString launchId; |
| DOMString title; |
| ShelfItemType? type; |
| ShelfItemStatus status; |
| boolean showsTooltip; |
| boolean pinnedByPolicy; |
| boolean pinStateForcedByType; |
| boolean hasNotification; |
| }; |
| |
| // A mapping of ash::AppType. |
| enum AppWindowType { |
| Browser, |
| ChromeApp, |
| ArcApp, |
| CrostiniApp, |
| SystemApp, |
| ExtensionApp, |
| Lacros |
| }; |
| |
| // A mapping of HotseatState in ash/public/cpp/shelf_types.h. |
| enum HotseatState { |
| Hidden, |
| ShownClamShell, |
| ShownHomeLauncher, |
| Extended |
| }; |
| |
| // The frame mode of a window. None if the window is framesless. |
| enum FrameMode { |
| Normal, |
| Immersive |
| }; |
| |
| dictionary OverviewInfo { |
| // Bounds in screen of an OverviewItem. |
| Bounds bounds; |
| // Whether an OverviewItem is being dragged in overview. |
| boolean isDragged; |
| }; |
| |
| // Used to update an app's shelf pin state. |
| dictionary ShelfIconPinUpdateParam { |
| // The identifier of the target app. |
| DOMString appId; |
| |
| // The target pin state for the app. |
| boolean pinned; |
| }; |
| |
| dictionary AppWindowInfo { |
| // The identifier of the window. This shouldn't change across the time. |
| long id; |
| |
| // The name of the window object -- typically internal class name of the |
| // window (like 'BrowserFrame'). |
| DOMString name; |
| |
| AppWindowType windowType; |
| WindowStateType stateType; |
| |
| // The bounds of the window, in the coordinate of the root window (i.e. |
| // relative to the display where this window resides). |
| Bounds boundsInRoot; |
| |
| // The identifier of the display where this window resides. |
| DOMString displayId; |
| |
| boolean isVisible; |
| boolean canFocus; |
| |
| // The title of the window; this can be seen in the window caption, or in |
| // the overview mode. Typically, this provides the title of the webpage or |
| // the title supplied by the application. |
| DOMString title; |
| |
| // Whether some animation is ongoing on the window or not. |
| boolean isAnimating; |
| |
| // The final bounds of the window when the animation completes. This should |
| // be same as |boundsInRoot| when |isAnimating| is false. |
| Bounds targetBounds; |
| |
| // Whether or not the window is going to be visible after the animation |
| // completes. This should be same as |isVisible| when |isAnimating| is |
| // false. |
| boolean targetVisibility; |
| |
| // WM Releated states |
| boolean isActive; |
| boolean hasFocus; |
| boolean onActiveDesk; |
| boolean hasCapture; |
| boolean canResize; |
| |
| // Stacking order of the window in relation to its siblings. 0 indicates |
| // that the window is topmost. -1 if stacking info is not available |
| long stackingOrder; |
| |
| // Window frame info |
| FrameMode frameMode; |
| boolean isFrameVisible; |
| long captionHeight; |
| // The bitset of the enabled caption buttons. See |
| // ui/views/window/caption_button_types.h. |
| long captionButtonEnabledStatus; |
| // The bitset of the caption buttons which are visible on the frame. |
| long captionButtonVisibleStatus; |
| |
| DOMString? arcPackageName; |
| |
| OverviewInfo? overviewInfo; |
| |
| // The identifier of the app associated with the window that was launched |
| // from full restore. This should be same as |appId| when the window was |
| // restored from full restore, otherwise null. |
| DOMString? fullRestoreWindowAppId; |
| |
| // The identifier of the app associated with the window. |
| DOMString? appId; |
| }; |
| |
| dictionary Accelerator { |
| DOMString keyCode; |
| boolean shift; |
| boolean control; |
| boolean alt; |
| boolean search; |
| boolean pressed; |
| }; |
| |
| // Mapped to ScrollableShelfState in ash/public/cpp/shelf_ui_info.h. |
| // [deprecated="Use ShelfState"] |
| dictionary ScrollableShelfState { |
| double? scrollDistance; |
| }; |
| |
| // Mapped to ShelfState in ash/public/cpp/shelf_ui_info.h. |
| dictionary ShelfState { |
| double? scrollDistance; |
| }; |
| |
| // Mapped to ScrollableShelfInfo in ash/public/cpp/shelf_ui_info.h. |
| // |targetMainAxisOffset| is set when ShelfState used in query |
| // specifies the scroll distance. |
| dictionary ScrollableShelfInfo { |
| double mainAxisOffset; |
| double pageOffset; |
| double? targetMainAxisOffset; |
| Bounds leftArrowBounds; |
| Bounds rightArrowBounds; |
| boolean isAnimating; |
| boolean iconsUnderAnimation; |
| boolean isOverflow; |
| Bounds[] iconsBoundsInScreen; |
| boolean isShelfWidgetAnimating; |
| }; |
| |
| // Mapped to HotseatSwipeDescriptor in ash/public/cpp/shelf_ui_info.h. |
| dictionary HotseatSwipeDescriptor { |
| Location swipeStartLocation; |
| Location swipeEndLocation; |
| }; |
| |
| // Mapped to HotseatInfo in ash/public/cpp/shelf_ui_info.h. |
| dictionary HotseatInfo { |
| HotseatSwipeDescriptor swipeUp; |
| HotseatState state; |
| boolean isAnimating; |
| // Whether the shelf is hidden with auto-hide enabled. |
| boolean isAutoHidden; |
| }; |
| |
| // The ui information of shelf components, including hotseat and |
| // scrollable shelf. |
| dictionary ShelfUIInfo { |
| HotseatInfo hotseatInfo; |
| ScrollableShelfInfo scrollableShelfInfo; |
| }; |
| |
| // Information about all desks. |
| dictionary DesksInfo { |
| long activeDeskIndex; |
| long numDesks; |
| boolean isAnimating; |
| DOMString[] deskContainers; |
| }; |
| |
| // Information about launcher's search box. |
| dictionary LauncherSearchBoxState { |
| DOMString ghostText; |
| }; |
| |
| callback GetShelfItemsCallback = void (ShelfItem[] items); |
| |
| callback GetDefaultPinnedAppIdsCallback = void (DOMString[] items); |
| |
| callback GetShelfAutoHideBehaviorCallback = void (DOMString behavior); |
| |
| callback GetLauncherSearchBoxStateCallback = void ( |
| LauncherSearchBoxState state); |
| |
| callback GetShelfAlignmentCallback = void (ShelfAlignmentType alignment); |
| |
| callback WindowStateCallback = void (WindowStateType currentType); |
| |
| callback VoidCallback = void (); |
| |
| callback DOMStringCallback = void (DOMString data); |
| |
| callback GetAppWindowListCallback = void (AppWindowInfo[] window_list); |
| |
| callback AcceleratorCallback = void (boolean success); |
| |
| callback DesksCallback = void (boolean success); |
| |
| callback GetDeskCountCallback = void (long count); |
| |
| callback GetDesksInfoCallback = void (DesksInfo desks); |
| |
| callback GetScrollableShelfInfoForStateCallback = void ( |
| ScrollableShelfInfo info); |
| |
| callback GetShelfUIInfoForStateCallback = void (ShelfUIInfo info); |
| |
| // Frame counting record for one frame sink/compositor. |
| dictionary FrameCountingPerSinkData { |
| // Type of the frame sink. This corresponds to CompositorFrameSinkType. |
| DOMString sinkType; |
| // Whether the frame sink is the root. |
| boolean isRoot; |
| // Debug label of the frame sink. |
| DOMString debugLabel; |
| |
| // Number of presented frames grouped using `bucketSizeInSeconds` arg in |
| // startFrameCounting call. It would be fps if the `bucketSizeInSeconds` is |
| // 1s. |
| long[] presentedFrames; |
| }; |
| |
| callback StopFrameCountingCallback = void (FrameCountingPerSinkData[] data); |
| |
| // Result of calling setWindowBounds, which returns the actual bounds and |
| // display the window was set to. This may be different than the requested |
| // bounds and display, for example if the window is showing an ARC app and |
| // Android modifies the bounds request. Further, this result may never be |
| // returned in some situations (e.g. Android ignoring a bounds request), |
| // causing a timeout. |
| dictionary SetWindowBoundsResult { |
| // Bounds of the window. |
| Bounds bounds; |
| // Display ID of the display the window is on. |
| DOMString displayId; |
| }; |
| callback WindowBoundsCallback = void (SetWindowBoundsResult result); |
| |
| // Collected DisplaySmoothness data between startSmoothnessTracking and |
| // stopSmoothnessTracking calls. |
| dictionary DisplaySmoothnessData { |
| // Number of frames expected to be shown for this animation. |
| long framesExpected; |
| // Number of frames actually shown for this animation. |
| long framesProduced; |
| // Number of janks during this animation. A jank is counted when the current |
| // frame latency is larger than previous ones. |
| long jankCount; |
| // Display throughput percentage at fixed intervals. |
| long[] throughput; |
| }; |
| |
| // Callback invoked to report the smoothness after StopSmoothnessTracking is |
| // called. |
| callback StopSmoothnessTrackingCallback = void |
| (DisplaySmoothnessData data); |
| |
| // Collected ui::ThroughputTracker data for one animation. It is based on |
| // cc::FrameSequenceMetrics::ThroughputData. |
| dictionary ThroughputTrackerAnimationData { |
| // Animation start time in milliseconds, relative to when |
| // `startThroughputTrackerDataCollection` is called. |
| long startOffsetMs; |
| // Animation stop time in milliseconds, relative to when |
| // `startThroughputTrackerDataCollection` is called. |
| long stopOffsetMs; |
| // Number of frames expected to be shown for this animation. |
| long framesExpected; |
| // Number of frames actually shown for this animation. |
| long framesProduced; |
| // Number of janks during this animation. A jank is counted when the current |
| // frame latency is larger than previous ones. |
| long jankCount; |
| }; |
| |
| // Callback invoked to report the collection ui::ThroughputTracker data |
| // after stopThroughputTrackerDataCollection is called. |
| callback StopThroughputTrackerDataCollectionCallback = void |
| (ThroughputTrackerAnimationData[] data); |
| |
| // Callback invoked to report the currently collected ui::ThroughputTracker |
| // animation data. Note that the data reported is removed to avoid reporting |
| // duplicated data. |
| callback GetThroughtputTrackerDataCallback = void |
| (ThroughputTrackerAnimationData[] data); |
| |
| // Callback invoked to report the number of system web apps that should be |
| // installed. |
| callback GetRegisteredSystemWebAppsCallback = void |
| (SystemWebApp[] systemWebApps); |
| |
| callback IsSystemWebAppOpenCallback = void (boolean isOpen); |
| |
| // Callback invoked to return the smoothness percentage after |
| // getDisplaySmoothness is called. |
| callback GetDisplaySmoothnessCallback = void (long smoothness); |
| |
| // Options for resetting the holding space. |
| dictionary ResetHoldingSpaceOptions { |
| // Whether to call `ash::holding_space_prefs::MarkTimeOfFirstAdd()` after |
| // reset. Used to show the holding space tray in tests, since it's otherwise |
| // hidden after OOBE. |
| boolean markTimeOfFirstAdd; |
| }; |
| |
| callback CouldAllowCrostiniCallback = void (boolean canBeAllowed); |
| |
| // Collected ash::LoginEventRecorder data. |
| dictionary LoginEventRecorderData { |
| // Event name |
| DOMString name; |
| // Number of frames actually shown for this animation. |
| long microsecnods_since_unix_epoch; |
| }; |
| |
| // Callback invoked to report the collection ui::LoginEventRecorder data |
| // after getLoginEventRecorderLoginEvents is called. |
| callback GetLoginEventRecorderLoginEventsCallback = void |
| (LoginEventRecorderData[] data); |
| |
| // Request parameters for <code>getAccessToken</code>. |
| dictionary GetAccessTokenParams { |
| // An email associated with the account to get a token for. |
| DOMString email; |
| // A list of OAuth scopes to request. |
| DOMString[] scopes; |
| // An optional timeout in milliseconds for the request. |
| // Default: 90 seconds |
| long? timeoutMs; |
| }; |
| |
| // Response data for <code>getAccessToken</code>. |
| dictionary GetAccessTokenData { |
| // The access token |
| DOMString accessToken; |
| // The time the access token will expire as a unix timestamp in |
| // milliseconds. |
| DOMString expirationTimeUnixMs; |
| }; |
| |
| // Reponse callback for <code>getAccessToken</code>. |
| callback GetAccessTokenCallback = void(GetAccessTokenData data); |
| |
| // Callback invoked to report whether the current input method is ready to |
| // accept key events from the test. |
| callback IsInputMethodReadyForTestingCallback = void |
| (boolean isReady); |
| |
| // Response data for <code>makeFuseboxTempDir</code>. |
| dictionary MakeFuseboxTempDirData { |
| DOMString fuseboxFilePath; |
| DOMString underlyingFilePath; |
| }; |
| |
| // Callback invoked when the temporary directory was made. |
| callback MakeFuseboxTempDirCallback = void(MakeFuseboxTempDirData data); |
| |
| // Callback invoked when the temporary directory was removed. |
| callback RemoveFuseboxTempDirCallback = void(); |
| |
| callback IsFeatureEnabledCallback = void(boolean enabled); |
| |
| // Response data for <code>getCurrentInputMethodDescriptor</code>. |
| // Add more fields from ash/input_method/InputMethodDescriptor as needed. |
| dictionary GetCurrentInputMethodDescriptorData { |
| DOMString keyboardLayout; |
| }; |
| |
| // Response callback for current input method keyboard layout. |
| callback GetCurrentInputMethodDescriptorCallback = void |
| (GetCurrentInputMethodDescriptorData data); |
| |
| interface Functions { |
| // Must be called to allow autotestPrivateAPI events to be fired. |
| static void initializeEvents(); |
| |
| // Logout of a user session. |
| static void logout(); |
| |
| // Restart the browser. |
| static void restart(); |
| |
| // Shutdown the browser. |
| // |force|: if set, ignore ongoing downloads and onunbeforeunload handlers. |
| static void shutdown(boolean force); |
| |
| // Get login status. |
| [supportsPromises] static void loginStatus(LoginStatusCallback callback); |
| |
| // Locks the screen. |
| static void lockScreen(); |
| |
| // Get info about installed extensions. |
| [supportsPromises] static void getExtensionsInfo( |
| ExtensionsInfoCallback callback); |
| |
| // Get state of the policies. |
| // Will contain device policies and policies from the active profile. |
| // The policy values are formatted as they would be for exporting in |
| // chrome://policy. |
| [supportsPromises] static void getAllEnterprisePolicies( |
| AllEnterprisePoliciesCallback callback); |
| |
| // Refreshes the Enterprise Policies. |
| [supportsPromises] static void refreshEnterprisePolicies( |
| VoidCallback callback); |
| |
| // Refreshes the remote commands. |
| [supportsPromises] static void refreshRemoteCommands(VoidCallback callback); |
| |
| // Simulates a memory access bug for asan testing. |
| static void simulateAsanMemoryBug(); |
| |
| // Set the touchpad pointer sensitivity setting. |
| // |value|: the pointer sensitivity setting index. |
| static void setTouchpadSensitivity(long value); |
| |
| // Turn on/off tap-to-click for the touchpad. |
| // |enabled|: if set, enable tap-to-click. |
| static void setTapToClick(boolean enabled); |
| |
| // Turn on/off three finger click for the touchpad. |
| // |enabled|: if set, enable three finger click. |
| static void setThreeFingerClick(boolean enabled); |
| |
| // Turn on/off tap dragging for the touchpad. |
| // |enabled|: if set, enable tap dragging. |
| static void setTapDragging(boolean enabled); |
| |
| // Turn on/off Australian scrolling for devices other than wheel mouse. |
| // |enabled|: if set, enable Australian scrolling. |
| static void setNaturalScroll(boolean enabled); |
| |
| // Set the mouse pointer sensitivity setting. |
| // |value|: the pointer sensitivity setting index. |
| static void setMouseSensitivity(long value); |
| |
| // Swap the primary mouse button for left click. |
| // |right|: if set, swap the primary mouse button. |
| static void setPrimaryButtonRight(boolean right); |
| |
| // Turn on/off reverse scrolling for mice. |
| // |enabled|: if set, enable reverse scrolling. |
| static void setMouseReverseScroll(boolean enabled); |
| |
| // Get visible notifications on the system. |
| [supportsPromises] static void getVisibleNotifications( |
| NotificationArrayCallback callback); |
| |
| // Remove all notifications. |
| [supportsPromises] static void removeAllNotifications( |
| VoidCallback callback); |
| |
| // Get ARC start time in ticks. |
| [supportsPromises] static void getArcStartTime( |
| ArcStartTimeCallback callback); |
| |
| // Get state of the ARC session. |
| [supportsPromises] static void getArcState( |
| ArcStateCallback callback); |
| |
| // Get state of the Play Store. |
| [supportsPromises] static void getPlayStoreState( |
| PlayStoreStateCallback callback); |
| |
| // Get list of available printers |
| [supportsPromises] static void getPrinterList( |
| PrinterArrayCallback callback); |
| |
| // Returns true if requested app is shown in Chrome. |
| [supportsPromises] static void isAppShown(DOMString appId, |
| IsAppShownCallback callback); |
| |
| // Returns true if ARC is provisioned. |
| // [deprecated="Use getArcState()"] |
| [supportsPromises] static void isArcProvisioned( |
| IsArcProvisionedCallback callback); |
| |
| // Gets various information about the state of lacros on the system. |
| [supportsPromises] static void getLacrosInfo( |
| GetLacrosInfoCallback callback); |
| |
| // Gets information about the requested ARC app. |
| [supportsPromises] static void getArcApp(DOMString appId, |
| GetArcAppCallback callback); |
| |
| // Gets counts of how many ARC apps have been killed, by priority. |
| [supportsPromises] static void getArcAppKills( |
| GetArcAppKillsCallback callback); |
| |
| // Gets information about requested ARC package. |
| [supportsPromises] static void getArcPackage( |
| DOMString packageName, |
| GetArcPackageCallback callback); |
| |
| // Gets the data needed for Cryptohome Recovery. |
| [supportsPromises] static void getCryptohomeRecoveryData( |
| GetCryptohomeRecoveryDataCallback callback); |
| |
| // Waits for system web apps to complete the installation. |
| [supportsPromises] static void waitForSystemWebAppsInstall( |
| VoidCallback callback); |
| |
| // Gets all the default pinned shelf app IDs, these may not be installed. |
| [supportsPromises] static void getDefaultPinnedAppIds( |
| GetDefaultPinnedAppIdsCallback callback); |
| |
| // Returns the number of system web apps that should be installed. |
| [supportsPromises] static void getRegisteredSystemWebApps( |
| GetRegisteredSystemWebAppsCallback callback); |
| |
| // Returns whether the system web app is currently open or not. |
| [supportsPromises] static void isSystemWebAppOpen( |
| DOMString appId, |
| IsSystemWebAppOpenCallback callback); |
| |
| // Launches an application from the launcher with the given appId. |
| [supportsPromises] static void launchApp(DOMString appId, |
| VoidCallback callback); |
| |
| // Launches an system web app from the launcher with the given app name and |
| // url. |
| [supportsPromises] static void launchSystemWebApp(DOMString appName, |
| DOMString url, |
| VoidCallback callback); |
| |
| // Launches Files app directly to absolutePath, if the path does not |
| // exist, it will launch to the default opening location (i.e. My files). |
| // If the supplied path is a file (and it exists) it will open Files app |
| // to the parent folder instead. |
| [supportsPromises] static void launchFilesAppToPath( |
| DOMString absolutePath, |
| VoidCallback callback); |
| |
| // Closes an application the given appId in case it was running. |
| [supportsPromises] static void closeApp(DOMString appId, |
| VoidCallback callback); |
| |
| // Update printer. Printer with empty ID is considered new. |
| static void updatePrinter(Printer printer); |
| |
| // Remove printer. |
| static void removePrinter(DOMString printerId); |
| |
| // Start ARC directly, note this differs from |setPlayStoreEnabled|. It is |
| // used to restart ARC in tests. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void startArc(VoidCallback callback); |
| |
| // Stop ARC directly, note this differs from |setPlayStoreEnabled|. It is |
| // used to restart ARC in tests. Note, this preserves ARC data. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void stopArc(VoidCallback callback); |
| |
| // Enable/disable the Play Store. |
| // |enabled|: if set, enable the Play Store. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setPlayStoreEnabled(boolean enabled, |
| VoidCallback callback); |
| |
| // Get text from ui::Clipboard. |
| // |callback|: Called with result. |
| [supportsPromises] static void getClipboardTextData( |
| DOMStringCallback callback); |
| |
| // Set text in ui::Clipbaord. |
| // |callback|: Called when operation is complete. |
| [supportsPromises] static void setClipboardTextData(DOMString data, |
| VoidCallback callback); |
| |
| // Run the crostini installer GUI to install the default crostini |
| // vm / container and create sshfs mount. The installer launches the |
| // crostini terminal app on completion. The installer expects that |
| // crostini is not already installed. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void runCrostiniInstaller(VoidCallback callback); |
| |
| // Run the crostini uninstaller GUI to remove the default crostini |
| // vm / container. The callback is invoked upon completion. |
| [supportsPromises] static void runCrostiniUninstaller( |
| VoidCallback callback); |
| |
| // Enable/disable Crostini in preferences. |
| // |enabled|: Enable Crostini. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setCrostiniEnabled(boolean enabled, |
| VoidCallback callback); |
| |
| // Export the crostini container. |
| // |path|: The path in Downloads to save the export. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void exportCrostini(DOMString path, |
| VoidCallback callback); |
| |
| // Import the crostini container. |
| // |path|: The path in Downloads to read the import. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void importCrostini(DOMString path, |
| VoidCallback callback); |
| |
| // Returns whether crostini could ever be allowed. |
| // |callback|: Called with a boolean indicating if crostini can ever be |
| // allowed in the current profile. |
| [supportsPromises] static void couldAllowCrostini( |
| CouldAllowCrostiniCallback callback); |
| |
| // Sets mock Plugin VM policy. |
| // |imageUrl|: URL to the image to install. |
| // |imageHash|: Hash for the provided image. |
| // |licenseKey|: License key for Plugin VM. |
| static void setPluginVMPolicy(DOMString imageUrl, |
| DOMString imageHash, |
| DOMString licenseKey); |
| |
| // Shows the Plugin VM installer. Does not start installation. |
| static void showPluginVMInstaller(); |
| |
| // Installs Borealis without showing the normal installer UI. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void installBorealis(VoidCallback callback); |
| |
| // Register a component with CrOSComponentManager. |
| // |name|: The name of the component. |
| // |path|: Path to the component. |
| static void registerComponent(DOMString name, DOMString path); |
| |
| // Takes a screenshot and returns the data in base64 encoded PNG format. |
| [supportsPromises] static void takeScreenshot( |
| TakeScreenshotCallback callback); |
| |
| // Tasks a screenshot for a display. |
| // |display_id|: the display id of the display. |
| // |callback|: called when the operation has completed. |
| [supportsPromises] static void takeScreenshotForDisplay( |
| DOMString display_id, |
| TakeScreenshotCallback callback); |
| |
| // Makes a basic request to ML Service, triggering 1. ML Service |
| // daemon startup, and 2. the initial D-Bus -> Mojo IPC bootstrap. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void bootstrapMachineLearningService( |
| VoidCallback callback); |
| |
| // Triggers an on-demand update of smart dim component and checks whether |
| // it's successfully loaded by smart dim ml_agent. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void loadSmartDimComponent(VoidCallback callback); |
| |
| // Enables/disables the Google Assistant. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setAssistantEnabled(boolean enabled, |
| long timeout_ms, |
| VoidCallback callback); |
| |
| // Bring up the Assistant service, and wait for the ready signal. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void enableAssistantAndWaitForReady( |
| VoidCallback callback); |
| |
| // Sends a text query via Google Assistant. |
| // |callback|: Called when response has been received. |
| [supportsPromises] static void sendAssistantTextQuery( |
| DOMString query, |
| long timeout_ms, |
| AssistantQueryStatusCallback callback); |
| |
| // Invokes |callback| once the current text/voice interaction is completed. |
| // Responds with the the query status if any valid response was caught |
| // before the timeout. This API should be called before sending the query. |
| // To use it for testing a voice query via OKG in Autotest, for example, |
| // you can do: |
| // |
| // // Enable hotword setting for Assistant. |
| // assistant_util.enable_hotword(); |
| // |
| // // Call this API with your callback function. |
| // chrome.autotestPrivate.waitForAssistantQueryStatus(timeout_s, |
| // function(status) {...}); |
| // |
| // then start Assistant via OKG and send voice query before timeout. |
| // |
| // TODO(meilinw@): disable warmer welcome to avoid an unintended early |
| // return of this API when launching Assistant via hotkey. |
| // TODO(meilinw@): update the comment above to use Tast instead after |
| // adding API to enable hotword in Tast. |
| [supportsPromises] static void waitForAssistantQueryStatus( |
| long timeout_s, |
| AssistantQueryStatusCallback callback); |
| |
| // Whether the local list of installed ARC packages has been refreshed for |
| // the first time after user login. |
| [supportsPromises] static void isArcPackageListInitialRefreshed( |
| IsArcPackageListInitialRefreshedCallback callback); |
| |
| // Set value for the specified user pref in the pref tree. |
| [supportsPromises] static void setAllowedPref(DOMString pref_name, |
| any value, |
| VoidCallback callback); |
| |
| // DEPRECATED: use SetAllowedPref instead, see crbug/1262034 |
| // Set value for the specified user pref in the pref tree. |
| [supportsPromises] static void setWhitelistedPref(DOMString pref_name, |
| any value, |
| VoidCallback callback); |
| |
| // Enable/disable a Crostini app's "scaled" property. |
| // |appId|: The Crostini application ID. |
| // |scaled|: The app is "scaled" when shown, which means it uses low display |
| // density. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setCrostiniAppScaled(DOMString appId, |
| boolean scaled, |
| VoidCallback callback); |
| |
| // Get the primary display scale factor. |
| // |callback| is invoked with the scale factor. |
| [supportsPromises] static void getPrimaryDisplayScaleFactor( |
| GetPrimaryDisplayScaleFactorCallback callback); |
| |
| // Get the tablet mode enabled status. |
| // |callback| is invoked with the tablet mode enablement status. |
| [supportsPromises] static void isTabletModeEnabled( |
| IsTabletModeEnabledCallback callback); |
| |
| // Enable/disable tablet mode. After calling this function, it won't be |
| // possible to physically switch to/from tablet mode since that |
| // functionality will be disabled. |
| // |enabled|: if set, enable tablet mode. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setTabletModeEnabled( |
| boolean enabled, |
| SetTabletModeEnabledCallback callback); |
| |
| // Get the list of all installed applications |
| [supportsPromises] static void getAllInstalledApps( |
| GetAllInstalledAppsCallback callback); |
| |
| // Get the list of all shelf items |
| [supportsPromises] static void getShelfItems( |
| GetShelfItemsCallback callback); |
| |
| // Get the launcher search box search state. |
| [supportsPromises] static void getLauncherSearchBoxState( |
| GetLauncherSearchBoxStateCallback callback); |
| |
| // Get the shelf auto hide behavior. |
| // |displayId|: display that contains the shelf. |
| // |callback| is invoked with the shelf auto hide behavior. Possible |
| // behavior values are: "always", "never" or "hidden". |
| [supportsPromises] static void getShelfAutoHideBehavior( |
| DOMString displayId, |
| GetShelfAutoHideBehaviorCallback callback); |
| |
| // Set the shelf auto hide behavior. |
| // |displayId|: display that contains the shelf. |
| // |behavior|: an enum of "always", "never" or "hidden". |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setShelfAutoHideBehavior( |
| DOMString displayId, |
| DOMString behavior, |
| VoidCallback callback); |
| |
| // Get the shelf alignment. |
| // |displayId|: display that contains the shelf. |
| // |callback| is invoked with the shelf alignment type. |
| [supportsPromises] static void getShelfAlignment( |
| DOMString displayId, |
| GetShelfAlignmentCallback callback); |
| |
| // Set the shelf alignment. |
| // |displayId|: display that contains the shelf. |
| // |alignment|: the type of alignment to set. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setShelfAlignment( |
| DOMString displayId, |
| ShelfAlignmentType alignment, |
| VoidCallback callback); |
| |
| // Create a pin on shelf for the app specified by |appId|. |
| // Deprecated. Use setShelfIconPin() instead. |
| [supportsPromises] static void pinShelfIcon(DOMString appId, |
| VoidCallback callback); |
| |
| // Update pin states of the shelf apps based on |updateParams|. Return a |
| // list of app ids whose pin state changed. Pin states will not be changed |
| // if the method fails. |
| [supportsPromises] static void setShelfIconPin( |
| ShelfIconPinUpdateParam[] updateParams, |
| optional SetShelfIconPinCallback callback); |
| |
| // Enter or exit the overview mode. |
| // |start|: whether entering to or exiting from the overview mode. |
| // |callback|: called after the overview mode switch finishes. |
| [supportsPromises] static void setOverviewModeState( |
| boolean start, |
| SetOverviewModeStateCallback callback); |
| |
| // Show virtual keyboard of the current input method if it's available. |
| static void showVirtualKeyboardIfEnabled(); |
| |
| // Sends the overlay color and theme to Android and changes the Android system color and theme to these values. |
| // |color|: the int color of the system ui. |
| // |theme|: the theme of the system ui. |
| // |callback|: callback to deliver sendArcOverlayColor result. |
| [supportsPromises] static void sendArcOverlayColor( |
| long color, ThemeStyle theme, SendArcOverlayColorCallback callback); |
| |
| // Start ARC performance tracing for the active ARC app window. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void arcAppTracingStart(VoidCallback callback); |
| |
| // Stop ARC performance tracing if it was started and analyze results. |
| // |callback|: callback to deliver tracing results. |
| [supportsPromises] static void arcAppTracingStopAndAnalyze( |
| ArcAppTracingCallback callback); |
| |
| // Swap the windows in the split view. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void swapWindowsInSplitView( |
| VoidCallback callback); |
| |
| // Set ARC app window focused. |
| // |packageName|: the package name of the ARC app window. |
| // |callback|: called when the operation has completed. |
| [supportsPromises] static void setArcAppWindowFocus(DOMString packageName, |
| VoidCallback callback); |
| |
| // Invokes the callback when the display rotation animation is finished, or |
| // invokes it immediately if it is not animating. The callback argument |
| // is true if the display's rotation is same as |rotation|, or false otherwise. |
| // |displayId|: display that contains the shelf. |
| // |rotation|: the target rotation. |
| // |callback|: called when the operation has completed. |
| [supportsPromises] static void waitForDisplayRotation( |
| DOMString displayId, |
| RotationType rotation, |
| WaitForDisplayRotationCallback callback); |
| |
| // Get information on all application windows. Callback will be called |
| // with the list of |AppWindowInfo| dictionary. |
| // |callback|: called with window list. |
| [supportsPromises] static void getAppWindowList( |
| GetAppWindowListCallback callback); |
| |
| // Send WM event to change the app window's window state. |
| // |id|: the id of the window |
| // |change|: WM event type to send to the app window. |
| // |wait|: whether the method should wait for the window state to change before returning. |
| // |callback|: called when the window state is changed if |wait| is true. |
| // Otherwise, called right after the WM event is sent. |
| [supportsPromises] static void setAppWindowState( |
| long id, |
| WindowStateChangeDict change, |
| optional boolean wait, |
| WindowStateCallback callback); |
| |
| // Activate app window given by "id". |
| // |id|: the id of the window |
| // |callback|: called when the window is requested to activate. |
| [supportsPromises] static void activateAppWindow(long id, |
| VoidCallback callback); |
| |
| // Closes an app window given by "id". |
| // |id|: the id of the window |
| // |callback|: called when the window is requested to close. |
| [supportsPromises] static void closeAppWindow(long id, |
| VoidCallback callback); |
| |
| // Installs the Progressive Web App (PWA) that is in the current URL. |
| // |timeout_ms|: Timeout in milliseconds for the operation to complete. |
| // |callback|: called when the operation has completed. Passes the app Id |
| // of the recently installed PWA as argument. |
| [supportsPromises] static void installPWAForCurrentURL( |
| long timeout_ms, |
| InstallPWAForCurrentURLCallback callback); |
| |
| // Activates shortcut. |
| // |accelerator|: the accelerator to activate. |
| // |callback|: called when the operation has completed. |
| [supportsPromises] static void activateAccelerator( |
| Accelerator accelerator, |
| AcceleratorCallback callback); |
| |
| // Wwait until the launcher is transitionto the |launcherState|, if it's not |
| // in that state. |
| // |launcherState|: the target launcher state. |
| // |callback|: called when the operation has completed. |
| [supportsPromises] static void waitForLauncherState( |
| LauncherStateType launcherState, |
| VoidCallback callback); |
| |
| // Wait until overview has transitioned to |overviewState|, if it is not in |
| // that state. |
| // |overviewState|: the target overview state. |
| // |callback|: called when overview has reached |overviewState|. |
| [supportsPromises] static void waitForOverviewState( |
| OverviewStateType overviewState, |
| VoidCallback callback); |
| |
| // Creates a new desk if the maximum number of desks has not been reached. |
| // |callback|: called to indicate success or failure. |
| [supportsPromises] static void createNewDesk(DesksCallback callback); |
| |
| // Activates the desk at the given |index| triggering the activate-desk |
| // animation. |
| // |index|: the zero-based index of the desk desired to be activated. |
| // |callback|: called indicating success when the animation completes, or |
| // failure when the desk at |index| is already the active desk. |
| [supportsPromises] static void activateDeskAtIndex(long index, |
| DesksCallback callback); |
| |
| // Removes the currently active desk and triggers the remove-desk animation. |
| // |callback|: called indicating success when the animation completes, or |
| // failure if the currently active desk is the last available desk which |
| // cannot be removed. |
| [supportsPromises] static void removeActiveDesk(DesksCallback callback); |
| |
| // Activates the desk at the given |index| by chaining multiple |
| // activate-desk animations. |
| // |index|: the zero-based index of the desk desired to be activated. |
| // |callback|: called indicating success when the animation completes, or |
| // failure when the desk at |index| is already the active desk. |
| [supportsPromises] static void activateAdjacentDesksToTargetIndex( |
| long index, |
| DesksCallback callback); |
| |
| // Fetches the number of open desks in the `DesksController` at the time of |
| // call. |
| // `callback`: callback that is passed the number of open desks. |
| [supportsPromises] static void getDeskCount( |
| GetDeskCountCallback callback |
| ); |
| |
| // Fetches info about the open desks at the time of the call. |
| // `callback`: callback that is passed desks information. |
| [supportsPromises] static void getDesksInfo( |
| GetDesksInfoCallback callback |
| ); |
| |
| // Create mouse events to cause a mouse click. |
| // |button|: the mouse button for the click event. |
| // |callback|: called after the mouse click finishes. |
| [supportsPromises] static void mouseClick(MouseButton button, |
| VoidCallback callback); |
| |
| // Create a mouse event to cause mouse pressing. The mouse button stays |
| // in the pressed state. |
| // |button|: the mouse button to be pressed. |
| // |callback|: called after the mouse pressed event is handled. |
| [supportsPromises] static void mousePress(MouseButton button, |
| VoidCallback callback); |
| |
| // Create a mouse event to release a mouse button. This does nothing and |
| // returns immediately if the specified button is not pressed. |
| // |button|: the mouse button to be released. |
| // |callback|: called after the mouse is released. |
| [supportsPromises] static void mouseRelease(MouseButton button, |
| VoidCallback callback); |
| |
| // Create mouse events to move a mouse cursor to the location. This can |
| // cause a dragging if a button is pressed. It starts from the last mouse |
| // location. |
| // |location|: the target location (in screen coordinate). |
| // |duration_in_ms|: the duration (in milliseconds) for the mouse movement. |
| // The mouse will move linearly. 0 means moving immediately. |
| // |callback|: called after the mouse move finishes. |
| [supportsPromises] static void mouseMove(Location location, |
| double duration_in_ms, |
| VoidCallback callback); |
| |
| // Enable/disable metrics reporting in preferences. |
| // |enabled|: Enable metrics reporting. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void setMetricsEnabled(boolean enabled, |
| VoidCallback callback); |
| |
| // Sends ARC touch mode enabled or disabled. |
| // |enable|: whether enabled touch mode. |
| // |callback|: called when action performed. |
| [supportsPromises] static void setArcTouchMode(boolean enabled, |
| VoidCallback callback); |
| |
| // Fetches ui information of scrollable shelf view for the given shelf |
| // state. This function does not change scrollable shelf. |
| // [deprecated="Use getShelfUIInfoForState()"] |
| [supportsPromises] static void getScrollableShelfInfoForState( |
| ScrollableShelfState state, |
| GetScrollableShelfInfoForStateCallback callback); |
| |
| // Fetches UI information of shelf (including scrollable shelf and hotseat) |
| // for the given shelf state. This function does not change any shelf |
| // component. |
| [supportsPromises] static void getShelfUIInfoForState( |
| ShelfState state, |
| GetShelfUIInfoForStateCallback callback); |
| |
| // Sends a WM event to change a window's bounds and/or the display it is on. |
| // |id|: the id of the window. |
| // |bounds|: bounds the window should be set to. |
| // |displayId|: id of display to move the window to. |
| // |callback|: called when the window bounds are changed. |
| [supportsPromises] static void setWindowBounds( |
| long id, |
| Bounds bounds, |
| DOMString displayId, |
| WindowBoundsCallback callback); |
| |
| // Starts smoothness tracking for a display. If the display id is not |
| // specified, the primary display is used. Otherwise, the display specified |
| // by the display id is used. If `throughputIntervalMs` is not specified, |
| // default 5 seconds interval is used to collect throughput data. |
| [supportsPromises] static void startSmoothnessTracking( |
| optional DOMString displayId, |
| optional long throughputIntervalMs, |
| VoidCallback callback); |
| |
| // Stops smoothness tracking for a display and report the smoothness. If |
| // the display id is not specified, the primary display is used. Otherwise, |
| // the display specified by the display id is used. |
| [supportsPromises] static void stopSmoothnessTracking( |
| optional DOMString displayId, |
| StopSmoothnessTrackingCallback callback); |
| |
| // When neccesary, disables showing the dialog when Switch Access is disabled. |
| static void disableSwitchAccessDialog(); |
| |
| // Waits for the completion of photo transition animation in ambient mode. |
| // |numCompletions|: number of completions of the animation. |
| // |timeout|: the timeout in seconds. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void waitForAmbientPhotoAnimation( |
| long numCompletions, |
| long timeout, |
| VoidCallback callback); |
| |
| // Waits for ambient video to successfully start playback. |
| // |timeout|: the timeout in seconds. |
| // |callback|: Called when the operation has completed. |
| [supportsPromises] static void waitForAmbientVideo( |
| long timeout, |
| VoidCallback callback); |
| |
| // Disables the automation feature. Note that the event handlers and caches |
| // of automation nodes still remain in the test extension and so the next |
| // automation.getDesktop will miss initialization. The caller should ensure |
| // invalidation of those information (i.e. reloading the entire background |
| // page). |
| [supportsPromises] static void disableAutomation(VoidCallback callback); |
| |
| // Starts to ui::ThroughputTracker data collection for tracked animations. |
| [supportsPromises] static void startThroughputTrackerDataCollection( |
| VoidCallback callback); |
| |
| // Stops ui::ThroughputTracker data collection and reports the collected |
| // data since the start or the last GetThroughtputTrackerData call. |
| [supportsPromises] static void stopThroughputTrackerDataCollection( |
| StopThroughputTrackerDataCollectionCallback callback); |
| |
| // Reports the currently collected animation data. |
| [supportsPromises] static void getThroughputTrackerData( |
| GetThroughtputTrackerDataCallback callback); |
| |
| // Gets the smoothness of a display. If the display id is not specified, |
| // the primary display is used. |
| [supportsPromises] static void getDisplaySmoothness( |
| optional DOMString displayId, |
| GetDisplaySmoothnessCallback callback); |
| |
| // Resets the holding space by removing all items and clearing the prefs. |
| [supportsPromises] static void resetHoldingSpace( |
| optional ResetHoldingSpaceOptions options, |
| VoidCallback callback); |
| |
| // Starts collection of ui::LoginEventRecorder data. |
| [supportsPromises] static void startLoginEventRecorderDataCollection( |
| VoidCallback callback); |
| |
| // Stops ui::LoginEventRecorder data collection and reports all the |
| // collected data. |
| [supportsPromises] static void getLoginEventRecorderLoginEvents( |
| GetLoginEventRecorderLoginEventsCallback callback); |
| |
| // Adds login event to test LoginEventRecorderDataCollection API. |
| [supportsPromises] static void addLoginEventForTesting( |
| VoidCallback callback); |
| |
| // Force auto theme mode in dark mode or light mode for testing. |
| [supportsPromises] static void forceAutoThemeMode(boolean darkModeEnabled, VoidCallback callback); |
| |
| // Fetches an access token from Chrome. |
| [supportsPromises] static void getAccessToken( |
| GetAccessTokenParams accessTokenParams, |
| GetAccessTokenCallback callback); |
| |
| // Returns whether the current input method is ready to accept key events. |
| [supportsPromises] static void isInputMethodReadyForTesting( |
| IsInputMethodReadyForTestingCallback callback); |
| |
| // Creates a temporary directory visible under the Fusebox mount point. |
| [supportsPromises] static void makeFuseboxTempDir( |
| MakeFuseboxTempDirCallback callback); |
| |
| // Removes a temporary directory visible under the Fusebox mount point. The |
| // fuseboxFilePath argument was returned by the MakeFuseboxTempDirCallback. |
| [supportsPromises] static void removeFuseboxTempDir( |
| DOMString fuseboxFilePath, |
| RemoveFuseboxTempDirCallback callback); |
| |
| // Remove the specified component extension. |
| [supportsPromises] static void removeComponentExtension( |
| DOMString extensionId, VoidCallback callback); |
| |
| // Starts frame counting in viz. `bucketSizeInSeconds` decides the bucket |
| // size of the frame count records. If it is X seconds, each record is |
| // the number of presented frames in X seconds. |
| [supportsPromises] static void startFrameCounting(long bucketSizeInSeconds, |
| VoidCallback callback); |
| |
| // Ends frame counting in viz and return the collected data. |
| [supportsPromises] static void stopFrameCounting( |
| StopFrameCountingCallback callback); |
| |
| // Install a bruschetta VM. |
| [supportsPromises] static void installBruschetta( |
| DOMString vm_name, VoidCallback callback); |
| |
| // Delete a bruschetta VM. |
| [supportsPromises] static void removeBruschetta( |
| DOMString vm_name, VoidCallback callback); |
| |
| // Returns whether a base::Feature is enabled. The state may change because |
| // a Chrome uprev into ChromeOS changed the default feature state. |
| [supportsPromises] static void isFeatureEnabled( |
| DOMString feature_name, IsFeatureEnabledCallback callback); |
| |
| // Returns keyboard layout used for current input method. |
| [supportsPromises] static void getCurrentInputMethodDescriptor( |
| GetCurrentInputMethodDescriptorCallback callback); |
| |
| // ARC set interactive enable/disable state. |
| // |enabled|: Enable ARC interactive. |
| // |callback|: Called when the operation sent to ARC by mojo. |
| [supportsPromises] static void setArcInteractiveState( |
| boolean enabled, VoidCallback callback); |
| }; |
| |
| interface Events { |
| // Fired when the data in ui::Clipboard is changed. |
| static void onClipboardDataChanged(); |
| }; |
| }; |
