// 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"),
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,
DisabledByLocalSettings
};
// A mapping of arc::mojom::WakefulnessMode
enum WakefulnessMode {
Unknown,
Asleep,
Awake,
Dreaming,
Dozing
};
callback WakefulnessModeCallback = void (WakefulnessMode mode);
// 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,
Pinned,
TrustedPinned,
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,
PreparingForLaunch,
PreLaunched,
Starting,
Running,
WaitingForMojoDisconnected,
WaitingForProcessTerminated
};
// 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.
// DEPRECATED: please use isEnabled.
// TODO(crbug.com/40286020): Remove this field after tests are fixed.
LacrosMode mode;
// True iff Lacros is enabled for the current user session's primary user.
boolean isEnabled;
};
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 perceivedFps;
double commitDeviation;
double presentDeviation;
double renderQuality;
double janksPerMinute;
double janksPercentage;
};
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 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);
dictionary OverdrawData {
// Average overdraw as percentage of the display size grouped by
// `bucketSizeInSeconds` arg of `startOverdrawTracking` call.
double[] averageOverdraws;
};
callback StopOverdrawTrackingCallback = void (OverdrawData 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;
// The timestamps of the janks during this animation in milllisecond.
long[] jankTimestamps;
// The durations of the janks during this animation in millisecond.
long[] jankDurations;
};
// 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.
double 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);
// Response callback to report if a field trial exists and has been activated.
callback IsFieldTrialActiveCallback = void(boolean active);
// Request data containing the mock responses from
// overrideOrcaResponseForTesting.
dictionary OrcaResponseArray {
DOMString[] responses;
};
callback OverrideOrcaResponseForTestingCallback = void(boolean success);
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.
static void loginStatus(LoginStatusCallback callback);
// Waits for the post login animation to be complete and then triggers the
// callback.
static void waitForLoginAnimationEnd(VoidCallback callback);
// Locks the screen.
static void lockScreen();
// Get info about installed extensions.
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.
static void getAllEnterprisePolicies(
AllEnterprisePoliciesCallback callback);
// Refreshes the Enterprise Policies.
static void refreshEnterprisePolicies(
VoidCallback callback);
// Refreshes the remote commands.
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.
static void getVisibleNotifications(
NotificationArrayCallback callback);
// Remove all notifications.
static void removeAllNotifications(
VoidCallback callback);
// Get ARC start time in ticks.
static void getArcStartTime(
ArcStartTimeCallback callback);
// Get state of the ARC session.
static void getArcState(
ArcStateCallback callback);
// Get state of the Play Store.
static void getPlayStoreState(
PlayStoreStateCallback callback);
// Get list of available printers
static void getPrinterList(
PrinterArrayCallback callback);
// Returns true if requested app is shown in Chrome.
static void isAppShown(
DOMString appId,
IsAppShownCallback callback);
// Returns true if ARC is provisioned.
// [deprecated="Use getArcState()"]
static void isArcProvisioned(
IsArcProvisionedCallback callback);
// Gets various information about the state of lacros on the system.
static void getLacrosInfo(
GetLacrosInfoCallback callback);
// Gets information about the requested ARC app.
static void getArcApp(
DOMString appId,
GetArcAppCallback callback);
// Gets counts of how many ARC apps have been killed, by priority.
static void getArcAppKills(
GetArcAppKillsCallback callback);
// Gets information about requested ARC package.
static void getArcPackage(
DOMString packageName,
GetArcPackageCallback callback);
// Waits for system web apps to complete the installation.
static void waitForSystemWebAppsInstall(
VoidCallback callback);
// Gets all the default pinned shelf app IDs, these may not be installed.
static void getDefaultPinnedAppIds(
GetDefaultPinnedAppIdsCallback callback);
// Returns the number of system web apps that should be installed.
static void getRegisteredSystemWebApps(
GetRegisteredSystemWebAppsCallback callback);
// Returns whether the system web app is currently open or not.
static void isSystemWebAppOpen(
DOMString appId,
IsSystemWebAppOpenCallback callback);
// Launches an application from the launcher with the given appId.
static void launchApp(
DOMString appId,
VoidCallback callback);
// Launches an system web app from the launcher with the given app name and
// url.
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. MyFiles).
// If the supplied path is a file (and it exists) it will open Files app
// to the parent folder instead.
static void launchFilesAppToPath(
DOMString absolutePath,
VoidCallback callback);
// Closes an application the given appId in case it was running.
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.
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.
static void stopArc(VoidCallback callback);
// Enable/disable the Play Store.
// |enabled|: if set, enable the Play Store.
// |callback|: Called when the operation has completed.
static void setPlayStoreEnabled(
boolean enabled,
VoidCallback callback);
// Get text from ui::Clipboard.
// |callback|: Called with result.
static void getClipboardTextData(
DOMStringCallback callback);
// Set text in ui::Clipbaord.
// |callback|: Called when operation is complete.
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.
static void runCrostiniInstaller(VoidCallback callback);
// Run the crostini uninstaller GUI to remove the default crostini
// vm / container. The callback is invoked upon completion.
static void runCrostiniUninstaller(
VoidCallback callback);
// Enable/disable Crostini in preferences.
// |enabled|: Enable Crostini.
// |callback|: Called when the operation has completed.
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.
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.
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.
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.
static void installBorealis(VoidCallback callback);
// Register a component with ComponentManagerAsh.
// |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.
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.
static void takeScreenshotForDisplay(
DOMString display_id,
TakeScreenshotCallback 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.
static void loadSmartDimComponent(VoidCallback callback);
// Enables/disables the Google Assistant.
// |callback|: Called when the operation has completed.
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.
static void enableAssistantAndWaitForReady(
VoidCallback callback);
// Sends a text query via Google Assistant.
// |callback|: Called when response has been received.
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.
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.
static void isArcPackageListInitialRefreshed(
IsArcPackageListInitialRefreshedCallback callback);
// Set value for the specified user pref in the pref tree.
static void setAllowedPref(
DOMString pref_name,
any value,
VoidCallback callback);
// Clears value for the specified user pref in the pref tree.
static void clearAllowedPref(
DOMString pref_name,
VoidCallback callback);
// DEPRECATED: use SetAllowedPref instead, see crbug/1262034
// Set value for the specified user pref in the pref tree.
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.
static void setCrostiniAppScaled(
DOMString appId,
boolean scaled,
VoidCallback callback);
// Get the primary display scale factor.
// |callback| is invoked with the scale factor.
static void getPrimaryDisplayScaleFactor(
GetPrimaryDisplayScaleFactorCallback callback);
// Get the tablet mode enabled status.
// |callback| is invoked with the tablet mode enablement status.
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.
static void setTabletModeEnabled(
boolean enabled,
SetTabletModeEnabledCallback callback);
// Get the list of all installed applications
static void getAllInstalledApps(
GetAllInstalledAppsCallback callback);
// Get the list of all shelf items
static void getShelfItems(
GetShelfItemsCallback callback);
// Get the launcher search box search state.
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".
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.
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.
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.
static void setShelfAlignment(
DOMString displayId,
ShelfAlignmentType alignment,
VoidCallback callback);
// Create a pin on shelf for the app specified by |appId|.
// Deprecated. Use setShelfIconPin() instead.
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.
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.
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.
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.
static void arcAppTracingStart(VoidCallback callback);
// Stop ARC performance tracing if it was started and analyze results.
// |callback|: callback to deliver tracing results.
static void arcAppTracingStopAndAnalyze(
ArcAppTracingCallback callback);
// Swap the windows in the split view.
// |callback|: Called when the operation has completed.
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.
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.
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.
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.
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.
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.
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.
static void installPWAForCurrentURL(
long timeout_ms,
InstallPWAForCurrentURLCallback callback);
// Activates shortcut.
// |accelerator|: the accelerator to activate.
// |callback|: called when the operation has completed.
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.
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|.
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.
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.
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.
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.
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.
static void getDeskCount(
GetDeskCountCallback callback);
// Fetches info about the open desks at the time of the call.
// `callback`: callback that is passed desks information.
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.
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.
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.
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.
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.
static void setMetricsEnabled(
boolean enabled,
VoidCallback callback);
// Sends ARC touch mode enabled or disabled.
// |enable|: whether enabled touch mode.
// |callback|: called when action performed.
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()"]
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.
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.
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.
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.
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.
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.
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).
static void disableAutomation(VoidCallback callback);
// Starts to ui::ThroughputTracker data collection for tracked animations.
static void startThroughputTrackerDataCollection(
VoidCallback callback);
// Stops ui::ThroughputTracker data collection and reports the collected
// data since the start or the last GetThroughtputTrackerData call.
static void stopThroughputTrackerDataCollection(
StopThroughputTrackerDataCollectionCallback callback);
// Reports the currently collected animation data.
static void getThroughputTrackerData(
GetThroughtputTrackerDataCallback callback);
// Gets the smoothness of a display. If the display id is not specified,
// the primary display is used.
static void getDisplaySmoothness(
optional DOMString displayId,
GetDisplaySmoothnessCallback callback);
// Resets the holding space by removing all items and clearing the prefs.
static void resetHoldingSpace(
optional ResetHoldingSpaceOptions options,
VoidCallback callback);
// Starts collection of ui::LoginEventRecorder data.
static void startLoginEventRecorderDataCollection(
VoidCallback callback);
// Stops ui::LoginEventRecorder data collection and reports all the
// collected data.
static void getLoginEventRecorderLoginEvents(
GetLoginEventRecorderLoginEventsCallback callback);
// Adds login event to test LoginEventRecorderDataCollection API.
static void addLoginEventForTesting(
VoidCallback callback);
// Force auto theme mode in dark mode or light mode for testing.
static void forceAutoThemeMode(boolean darkModeEnabled, VoidCallback callback);
// Fetches an access token from Chrome.
static void getAccessToken(
GetAccessTokenParams accessTokenParams,
GetAccessTokenCallback callback);
// Returns whether the current input method is ready to accept key events.
static void isInputMethodReadyForTesting(
IsInputMethodReadyForTestingCallback callback);
// Creates a temporary directory visible under the Fusebox mount point.
static void makeFuseboxTempDir(
MakeFuseboxTempDirCallback callback);
// Removes a temporary directory visible under the Fusebox mount point. The
// fuseboxFilePath argument was returned by the MakeFuseboxTempDirCallback.
static void removeFuseboxTempDir(
DOMString fuseboxFilePath,
RemoveFuseboxTempDirCallback callback);
// Remove the specified component extension.
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.
static void startFrameCounting(
long bucketSizeInSeconds,
VoidCallback callback);
// Ends frame counting in viz and return the collected data.
static void stopFrameCounting(
StopFrameCountingCallback callback);
// Starts overdraw tracking for the display associated with
// `displayId` in viz. `bucketSizeInSeconds` decides the bucket size
// of the overdraw records.
// If it is X seconds, each record is the average overdraw of the
// frames presented on the display in X seconds.
static void startOverdrawTracking(
long bucketSizeInSeconds,
optional DOMString displayId,
VoidCallback callback
);
// Ends overdraw tracking in viz and return the collected data.
static void stopOverdrawTracking(
optional DOMString displayId,
StopOverdrawTrackingCallback callback
);
// Install a bruschetta VM.
static void installBruschetta(
DOMString vm_name, VoidCallback callback);
// Delete a bruschetta VM.
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.
static void isFeatureEnabled(
DOMString feature_name, IsFeatureEnabledCallback callback);
// Returns keyboard layout used for current input method.
static void getCurrentInputMethodDescriptor(
GetCurrentInputMethodDescriptorCallback callback);
// Overrides the response from Orca Provider and returns the boolean value
// that indicates if the overriding is successful or not.
static void overrideOrcaResponseForTesting(
OrcaResponseArray array,
OverrideOrcaResponseForTestingCallback callback);
// ARC set interactive enable/disable state.
// |enabled|: Enable ARC interactive.
// |callback|: Called when the operation sent to ARC by mojo.
static void setArcInteractiveState(
boolean enabled, VoidCallback callback);
// Returns whether a field trial exists and has been activated.
static void isFieldTrialActive(
DOMString trial_name,
DOMString group_name,
IsFieldTrialActiveCallback callback);
// ARC get wakefulness mode.
static void getArcWakefulnessMode(
WakefulnessModeCallback callback);
// Sets the default device language.
// A restart is required for this change to take effect.
// |value|: the locale of the language.
static void setDeviceLanguage(DOMString locale, VoidCallback callback);
};
interface Events {
// Fired when the data in ui::Clipboard is changed.
static void onClipboardDataChanged();
};
};
Codebase Browser
chromium