extensions/api/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 {
    App,
    PinnedApp,
    BrowserShortcut,
    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,
    Lacros,
    Remote,
    Borealis
  };

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

  // A mapping of apps::mojom::Readiness
  enum AppReadiness {
    Ready,
    DisabledByBlacklist,
    DisabledByPolicy,
    DisabledByUser,
    Terminated,
    UninstalledByUser
  };

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

  // 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?
    boolean isRegularUser;
    // Are we logged into the guest account?
    boolean isGuest;
    // Are we logged into kiosk-app mode?
    boolean isKiosk;

    DOMString email;
    DOMString displayEmail;
    // User image: 'file', 'profile' or a number.
    DOMString userImage;
  };
  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 startTime);

  dictionary ArcState {
    // Whether the ARC is provisioned.
    boolean provisioned;
    // Whether ARC Terms of Service needs to be shown.
    boolean tosNeeded;
  };
  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, usually accompanied with
    // fallback text.
    DOMString? htmlResponse;
    // Text messages used as the "fallback" for HTML card rendering.
    // Generally the fallback text is similar to transcribed TTS,
    // e.g. "It's exactly 6 o'clock." or "Turning bluetooth off.".
    DOMString? htmlFallback;
  };
  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);

  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 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 SetOverviewModeStateCallback = void(boolean finished);

  callback ArcAppTracingCallback = void(ArcAppTracingInfo info);

  callback WaitForDisplayRotationCallback = void (boolean success);

  callback InstallPWAForCurrentURLCallback = void (DOMString appId);

  dictionary App {
    DOMString appId;
    DOMString name;
    DOMString shortName;
    AppType? type;
    AppInstallSource? installSource;
    AppReadiness? readiness;
    DOMString[] additionalSearchTerms;
    boolean? showInLauncher;
    boolean? showInSearch;
  };

  dictionary SystemApp {
    DOMString internalName;
    DOMString url;
  };

  callback GetAllInstalledAppsCallback = void (App[] apps);

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

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

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

  // The ui information of shelf components, including hotseat and
  // scrollable shelf.
  dictionary ShelfUIInfo {
    HotseatInfo hotseatInfo;
    ScrollableShelfInfo scrollableShelfInfo;
  };

  callback GetShelfItemsCallback = void (ShelfItem[] 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 GetScrollableShelfInfoForStateCallback = void (
      ScrollableShelfInfo info);

  callback GetShelfUIInfoForStateCallback = void (ShelfUIInfo info);

  dictionary TraceConfig {
    // The recording mode of the trace. Possible options are:
    // "record-until-full", "record-continuously", "record-as-much-as-possible",
    // and "trace-to-console".
    DOMString? record_mode;
    // Stop trace after capturing |trace_buffer_size_in_events| events.
    long? trace_buffer_size_in_events;
    // Stop trace after capturing |trace_buffer_size_in_kb| kilobytes worth of
    // events.
    long? trace_buffer_size_in_kb;
    // Determines whether systrace events should be included in the trace.
    boolean? enable_systrace;
    // Enables argument filter.
    boolean? enable_argument_filter;
    // A list of categories that should be included in the trace.
    DOMString[]? included_categories;
    // A list of categories that should be excluded from the the trace.
    DOMString[]? excluded_categories;
    // A list of processes from which events should be included in the trace. If
    // this parameter is empty or missing, traces from all processes are
    // included.
    DOMString[]? included_process_ids;
    // A list of Systrace events that will be included in the trace.
    DOMString[]? enable_systrace_events;
  };

  // Defines a callback that will be run when the trace is complete. The parameter
  // |data| contains the result of the trace in Trace Event JSON format.
  callback TraceCompleteCallback = void (DOMString 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 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 smoothness after StopSmoothnessTracking is
  // called.
  callback StopSmoothnessTrackingCallback = void
      (ThroughputTrackerAnimationData data);

  // 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
      (SystemApp[] systemApps);

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

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

    // 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.
    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 information about the requested ARC app.
    static void getArcApp(DOMString appId, GetArcAppCallback 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);

    // Returns the number of system web apps that should be installed.
    static void getRegisteredSystemWebApps(
        GetRegisteredSystemWebAppsCallback callback);

    // Launches ARC app with optional intent. Returns true if ARC is active,
    // app exists and launch request is passed to Android.
    static void launchArcApp(DOMString appId, DOMString intent,
                             LaunchArcAppCallback 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);

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

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

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

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

    // 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.
    static void bootstrapMachineLearningService(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 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 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|.
    static void pinShelfIcon(DOMString appId, VoidCallback 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();

    // 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.
    // |callback|: called when the window state is changed.
    static void setAppWindowState(long id,
                                  WindowStateChangeDict change,
                                  WindowStateCallback callback);

    // Closes an app window given by "id".
    // |id|: the id of the window
    // |callback|: called when the window state 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);

    // 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. It does not support the move or drag across display boundaries.
    // |location|: the target location (in display's 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);

    // Starts Chrome tracing.
    // |config|: the tracing configuration.
    // |callback|: called when tracing has started.
    static void startTracing(TraceConfig config, VoidCallback callback);

    // Stops Chrome tracing.
    // |completeCallback|: called when tracing is complete, with results as a
    //     parameter.
    static void stopTracing(TraceCompleteCallback completeCallback);

    // 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.
    static void startSmoothnessTracking(optional DOMString displayId,
                                        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);

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

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