autotest_private.idl

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// 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/chromeos/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
  };

  // A mapping of apps::mojom::InstallSource
  enum AppInstallSource {
    Unknown,
    System,
    Policy,
    Oem,
    Default,
    Sync,
    User,
    SubApp
  };

  // 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,
    LeftSnapped,
    RightSnapped,
    PIP
  };

  // 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,
    WMEventSnapLeft,
    WMEventSnapRight
  };

  // 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,
    Peeking,
    Half,
    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 screen ready for password?
    boolean isReadyForPassword;

    // 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);

  callback IsLacrosPrimaryBrowserCallback = void (boolean primary);

  // A mapping of crosapi::BrowserManager::State
  enum LacrosState {
    NotInitialized,
    Mounting,
    Unavailable,
    Stopped,
    CreatingLogFile,
    Starting,
    Running,
    Terminating
  };

  // A mapping of crosapi::browser_util::LacrosMode
  enum LacrosMode {
    Disabled,
    SideBySide,
    Primary,
    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 lacrosMode;
  };

  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 system;
    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 LaunchArcAppCallback = void (boolean appLaunched);

  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 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;

    // 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;

    DOMString? fullRestoreWindowAppId;
  };

  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;
  };

  callback GetShelfItemsCallback = void (ShelfItem[] items);

  callback GetDefaultPinnedAppIdsCallback = void (DOMString[] items);

  callback GetShelfAutoHideBehaviorCallback = void (DOMString behavior);

  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 GetScrollableShelfInfoForStateCallback = void (
      ScrollableShelfInfo info);

  callback GetShelfUIInfoForStateCallback = void (ShelfUIInfo info);

  // 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 {
    // 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 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 chromeos::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);

  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);

    // 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);

    // Returns true if Lacros is the primary browser. This includes the case
    // where Lacros is the only browser.
    // NOTE: Because the answer depends on the policy, this function should
    // be used only after profile initialization.
    [supportsPromises] static void isLacrosPrimaryBrowser(
        IsLacrosPrimaryBrowserCallback 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 ARC app with optional intent. Returns true if ARC is active,
    // app exists and launch request is passed to Android.
    [supportsPromises] static void launchArcApp(
        DOMString appId,
        DOMString intent,
        LaunchArcAppCallback 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 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
    );

    // 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);

    // 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.
    [supportsPromises] static void stopThroughputTrackerDataCollection(
        StopThroughputTrackerDataCollectionCallback 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.
    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.
    [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);
  };

  interface Events {
    // Fired when the data in ui::Clipboard is changed.
    static void onClipboardDataChanged();
  };
};