tor-browser

ContentAnalysis.sys.mjs (39677B)

---

/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
/* vim: set ts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// @ts-check

/**
* Contains elements of the Content Analysis UI, which are integrated into
* various browser behaviors (uploading, downloading, printing, etc) that
* require content analysis to be done.
* The content analysis itself is done by the clients of this script, who
* use nsIContentAnalysis to talk to the external CA system.
*/

import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";

const lazy = {};
let internalContentAnalysisService = undefined;

ChromeUtils.defineESModuleGetters(lazy, {
 BrowserWindowTracker: "resource:///modules/BrowserWindowTracker.sys.mjs",
 clearTimeout: "resource://gre/modules/Timer.sys.mjs",
 PanelMultiView:
   "moz-src:///browser/components/customizableui/PanelMultiView.sys.mjs",
 setTimeout: "resource://gre/modules/Timer.sys.mjs",
});

XPCOMUtils.defineLazyPreferenceGetter(
 lazy,
 "silentNotifications",
 "browser.contentanalysis.silent_notifications",
 false
);

XPCOMUtils.defineLazyPreferenceGetter(
 lazy,
 "agentName",
 "browser.contentanalysis.agent_name",
 "A DLP agent"
);

XPCOMUtils.defineLazyPreferenceGetter(
 lazy,
 "showBlockedResult",
 "browser.contentanalysis.show_blocked_result",
 true
);

export const ContentAnalysis = {
 _SHOW_NOTIFICATIONS: true,

 _SHOW_DIALOGS: false,

 _SLOW_DLP_NOTIFICATION_BLOCKING_TIMEOUT_MS: 250,

 _SLOW_DLP_NOTIFICATION_NONBLOCKING_TIMEOUT_MS: 3 * 1000,

 _RESULT_NOTIFICATION_TIMEOUT_MS: 5 * 60 * 1000, // 5 min

 _RESULT_NOTIFICATION_FAST_TIMEOUT_MS: 60 * 1000, // 1 min

 PROMPTID_PREFIX: "ContentAnalysisSlowDialog-",

 isInitialized: false,

 /**
  * @typedef {object} NotificationInfo - information about the busy dialog itself that is showing
  * @property {*} [close] - Method to close the native notification
  * @property {BrowsingContext} [dialogBrowsingContext] - browsing context where the
  *                                                       confirm() dialog is shown
  */

 /**
  * @typedef {object} BusyDialogInfo - information about a busy dialog that is either showing or will
  *                                    will be shown after a delay.
  * @property {string} userActionId - The userActionId of the request
  * @property {Set<string>} requestTokenSet - The set of requestTokens associated with the userActionId
  * @property {*} [timer] - Result of a setTimeout() call that can be used to cancel the showing of the busy
  *                         dialog if it has not been displayed yet.
  * @property {NotificationInfo} [notification] - Information about the busy dialog that is being shown.
  */

 /**
  * @type {Map<string, BusyDialogInfo>}
  *
  * Maps string UserActionId to info about the busy dialog.
  */
 userActionToBusyDialogMap: new Map(),

 /**
  * @typedef {object} ResourceNameOrOperationType
  * @property {string} [name] - the name of the resource
  * @property {number} [operationType] - the type of operation
  */

 /**
  * @typedef {object} RequestInfo
  * @property {CanonicalBrowsingContext?} browsingContext - browsing context where the request was sent from
  * @property {ResourceNameOrOperationType} resourceNameOrOperationType - name of the operation
  */

 /**
  * @type {Map<string, RequestInfo>}
  */
 requestTokenToRequestInfo: new Map(),

 /**
  * @type {Set<string>}
  */
 warnDialogRequestTokens: new Set(),

 /**
  * The nsIContentAnalysis to use instead of lazy.gContentAnalysis. Should
  * only be used for tests.
  *
  * @type {nsIContentAnalysis?}
  */
 mockContentAnalysisForTest: undefined,

 /**
  * The nsIContentAnalysis to use. Nothing else in this file should
  * use lazy.gContentAnalysis.
  *
  * @returns {nsIContentAnalysis}
  */
 get contentAnalysis() {
   if (this.mockContentAnalysisForTest) {
     return this.mockContentAnalysisForTest;
   }
   if (!internalContentAnalysisService) {
     internalContentAnalysisService = Cc[
       "@mozilla.org/contentanalysis;1"
     ].getService(Ci.nsIContentAnalysis);
   }
   return internalContentAnalysisService;
 },

 /**
  * Sets the nsIContentAnalysis to use. Should only be used for tests.
  *
  * @param {nsIContentAnalysis?} contentAnalysis
  */
 setMockContentAnalysisForTest(contentAnalysis) {
   this.mockContentAnalysisForTest = contentAnalysis;
 },

 /**
  * Registers for various messages/events that will indicate the
  * need for communicating something to the user.
  *
  * @param {Window} window - The window to monitor
  */
 initialize(window) {
   if (!this.contentAnalysis.isActive) {
     this.uninitialize();
     return;
   }
   let doc = window.document;
   if (!this.isInitialized) {
     this.isInitialized = true;
     this.initializeObservers();

     ChromeUtils.defineLazyGetter(this, "l10n", function () {
       return new Localization(
         ["branding/brand.ftl", "toolkit/contentanalysis/contentanalysis.ftl"],
         true
       );
     });
   }

   // Do this even if initialized so the icon shows up on new windows, not just the
   // first one.
   for (let indicator of doc.getElementsByClassName(
     "content-analysis-indicator"
   )) {
     doc.l10n.setAttributes(indicator, "content-analysis-indicator-tooltip", {
       agentName: lazy.agentName,
     });
   }
   doc.documentElement.setAttribute("contentanalysisactive", "true");
 },

 async uninitialize() {
   if (this.isInitialized) {
     this.isInitialized = false;
     this.requestTokenToRequestInfo.clear();
     this.userActionToBusyDialogMap.clear();
     this.uninitializeObservers();
   }
 },

 /**
  * Register UI for CA events.
  */
 initializeObservers() {
   Services.obs.addObserver(this, "dlp-request-made");
   Services.obs.addObserver(this, "dlp-response");
   Services.obs.addObserver(this, "quit-application");
   Services.obs.addObserver(this, "quit-application-granted");
   Services.obs.addObserver(this, "quit-application-requested");
 },

 /**
  * Unregister UI for CA events.
  */
 uninitializeObservers() {
   Services.obs.removeObserver(this, "dlp-request-made");
   Services.obs.removeObserver(this, "dlp-response");
   Services.obs.removeObserver(this, "quit-application");
   Services.obs.removeObserver(this, "quit-application-granted");
   Services.obs.removeObserver(this, "quit-application-requested");
 },

 // nsIObserver
 async observe(aSubj, aTopic, _aData) {
   switch (aTopic) {
     case "quit-application-requested": {
       if (aSubj.data) {
         // something has already cancelled the quit operation,
         // so we don't need to do anything.
         return;
       }
       let pendingRequestInfos = this._getAllSlowCARequestInfos();
       let requestDescriptions = Array.from(
         pendingRequestInfos.flatMap(info =>
           info
             ? [
                 this._getResourceNameFromNameOrOperationType(
                   info.resourceNameOrOperationType
                 ),
               ]
             : []
         )
       );
       if (!requestDescriptions.length) {
         return;
       }
       let messageBody = this.l10n.formatValueSync(
         "contentanalysis-inprogress-quit-message"
       );
       messageBody = messageBody + "\n\n";
       messageBody += requestDescriptions.join("\n");
       let buttonSelected = Services.prompt.confirmEx(
         null,
         this.l10n.formatValueSync("contentanalysis-inprogress-quit-title"),
         messageBody,
         Ci.nsIPromptService.BUTTON_POS_0 *
           Ci.nsIPromptService.BUTTON_TITLE_IS_STRING +
           Ci.nsIPromptService.BUTTON_POS_1 *
             Ci.nsIPromptService.BUTTON_TITLE_CANCEL +
           Ci.nsIPromptService.BUTTON_POS_0_DEFAULT,
         this.l10n.formatValueSync(
           "contentanalysis-inprogress-quit-yesbutton"
         ),
         null,
         null,
         null,
         { value: false }
       );
       if (buttonSelected === 1) {
         // Cancel the quit operation
         aSubj.data = true;
       } else {
         // Ideally we would wait until "quit-application" to cancel outstanding
         // DLP requests, but the "DLP busy" or "DLP blocked" dialog can block the
         // main thread, thus preventing the "quit-application" from being sent,
         // which causes a shutdownhang. (bug 1899703)
         this.contentAnalysis.cancelAllRequests(true);
       }
       break;
     }
     // Note that we do this in quit-application-granted instead of quit-application
     // because otherwise we can get a shutdownhang if WARN dialogs are showing and
     // the user quits via keyboard or the hamburger menu (bug 1959966)
     case "quit-application-granted": {
       // We're quitting, so respond false to all WARN dialogs.
       let requestTokensToCancel = this.warnDialogRequestTokens;
       // Clear this first so the handler showing the dialog will know not
       // to call respondToWarnDialog() again.
       this.warnDialogRequestTokens = new Set();
       for (let warnDialogRequestToken of requestTokensToCancel) {
         this.contentAnalysis.respondToWarnDialog(
           warnDialogRequestToken,
           false
         );
       }
       break;
     }
     case "quit-application": {
       this.uninitialize();
       break;
     }
     case "dlp-request-made":
       {
         const request = aSubj.QueryInterface(Ci.nsIContentAnalysisRequest);
         if (!request) {
           console.error(
             "Showing in-browser Content Analysis notification but no request was passed"
           );
           return;
         }
         let browsingContext = request.windowGlobalParent?.browsingContext;
         if (
           !browsingContext &&
           request.operationTypeForDisplay !==
             Ci.nsIContentAnalysisRequest.eDownload
         ) {
           throw new Error(
             "Got dlp-request-made message but couldn't find a browsingContext!"
           );
         }

         // Start timer that, when it expires,
         // presents a "slow CA check" message.
         let resourceNameOrOperationType =
           this._getResourceNameOrOperationTypeFromRequest(request, false);
         this.requestTokenToRequestInfo.set(request.requestToken, {
           browsingContext,
           resourceNameOrOperationType,
         });
         this._queueSlowCAMessage(
           request,
           resourceNameOrOperationType,
           browsingContext
         );
       }
       break;
     case "dlp-response": {
       const response = aSubj.QueryInterface(Ci.nsIContentAnalysisResponse);
       // Cancels timer or slow message UI,
       // if present, and possibly presents the CA verdict.
       if (!response) {
         throw new Error(
           "Got dlp-response message but no response object was passed"
         );
       }

       let windowAndResourceNameOrOperationType =
         this.requestTokenToRequestInfo.get(response.requestToken);
       if (!windowAndResourceNameOrOperationType) {
         // We may get multiple responses, for example, if we are blocked or
         // canceled after receiving our verdict because we were part of a
         // multipart transaction.  Just ignore that.
         console.warn(
           `Got dlp-response message with unknown token ${response.requestToken} | action: ${response.action}`
         );
         return;
       }
       this.requestTokenToRequestInfo.delete(response.requestToken);
       this._removeSlowCAMessage(response.userActionId, response.requestToken);
       if (
         windowAndResourceNameOrOperationType.resourceNameOrOperationType
           ?.operationType === Ci.nsIContentAnalysisRequest.eDownload
       ) {
         // Don't show warn/block/error dialogs for downloads; they're shown
         // inside the downloads panel.
         return;
       }
       const responseResult =
         response?.action ?? Ci.nsIContentAnalysisResponse.eUnspecified;
       // Don't show dialog if this is a cached response
       if (!response?.isCachedResponse) {
         await this._showCAResult(
           windowAndResourceNameOrOperationType.resourceNameOrOperationType,
           windowAndResourceNameOrOperationType.browsingContext,
           response.requestToken,
           response.userActionId,
           responseResult,
           response.isSyntheticResponse,
           response.cancelError
         );
       }
       break;
     }
   }
 },

 /**
  * Shows the panel that indicates that DLP is active.
  *
  * @param {Element} element The toolbarbutton the user has clicked on
  * @param {*} panelUI Maintains state for the main menu panel
  */
 async showPanel(element, panelUI) {
   element.ownerDocument.l10n.setAttributes(
     lazy.PanelMultiView.getViewNode(
       element.ownerDocument,
       "content-analysis-panel-description"
     ),
     "content-analysis-panel-text-styled",
     { agentName: lazy.agentName }
   );
   panelUI.showSubView("content-analysis-panel", element);
 },

 /**
  * Closes a busy dialog
  *
  * @param {BusyDialogInfo?} caView - the busy dialog to close
  */
 _disconnectFromView(caView) {
   if (!caView) {
     return;
   }
   if (caView.timer) {
     lazy.clearTimeout(caView.timer);
   } else if (caView.notification) {
     if (caView.notification.close) {
       // native notification
       caView.notification.close();
     } else if (caView.notification.dialogBrowsingContext) {
       // in-browser notification
       let browser =
         caView.notification.dialogBrowsingContext.top.embedderElement;
       // If we're showing a dialog in the sidebar, the dialog is managed
       // by the embedderElement.
       let isSidebar =
         browser?.ownerGlobal?.browsingContext?.embedderElement?.id ==
         "sidebar";
       if (isSidebar) {
         browser = browser.ownerGlobal.browsingContext.embedderElement;
       }
       // browser will be null if the tab was closed
       let win = browser?.ownerGlobal;
       if (win) {
         let dialogBox = win.gBrowser.getTabDialogBox(browser);
         // Just close the dialog associated with this CA request.
         dialogBox.getTabDialogManager().abortDialogs(dialog => {
           return (
             dialog.promptID == this.PROMPTID_PREFIX + caView.userActionId
           );
         });
       }
     } else {
       console.error(
         "Unexpected content analysis notification - can't close it!"
       );
     }
   }
 },

 /**
  * Shows either a dialog or native notification or both, depending on the values of
  * _SHOW_DIALOGS and _SHOW_NOTIFICATIONS.
  *
  * @param {string} aMessage - Message to show
  * @param {CanonicalBrowsingContext?} aBrowsingContext - BrowsingContext to show the dialog in. If
  *                            null, the top browsing context will be used for native notifications.
  * @param {number} aTimeout - timeout for closing the native notification. 0 indicates it is
  *                            not automatically closed.
  * @returns {NotificationInfo?} - information about the native notification, if it has been shown.
  */
 _showMessage(aMessage, aBrowsingContext, aTimeout = 0) {
   if (this._SHOW_DIALOGS) {
     Services.prompt.asyncAlert(
       aBrowsingContext,
       Ci.nsIPrompt.MODAL_TYPE_WINDOW,
       this.l10n.formatValueSync("contentanalysis-alert-title"),
       aMessage
     );
   }

   if (this._SHOW_NOTIFICATIONS) {
     // Downloading as a "save as" operation does not provide a browsing context,
     // so use the the top window in that case.
     let topWindow =
       aBrowsingContext?.topChromeWindow ??
       aBrowsingContext?.embedderWindowGlobal.browsingContext
         .topChromeWindow ??
       lazy.BrowserWindowTracker.getTopWindow({
         allowFromInactiveWorkspace: true,
       });
     if (!topWindow) {
       console.error(
         "Unable to get window to show Content Analysis notification for."
       );
       return null;
     }
     const notification = new topWindow.Notification(
       this.l10n.formatValueSync("contentanalysis-notification-title"),
       { body: aMessage, silent: lazy.silentNotifications }
     );

     if (aTimeout != 0) {
       lazy.setTimeout(() => {
         notification.close();
       }, aTimeout);
     }
     return notification;
   }

   return null;
 },

 /**
  * Whether the notification should block browser interaction.
  *
  * @param {nsIContentAnalysisRequest.AnalysisType} aAnalysisType The type of DLP analysis being done.
  * @returns {boolean}
  */
 _shouldShowBlockingNotification(aAnalysisType) {
   return !(
     aAnalysisType == Ci.nsIContentAnalysisRequest.eFileDownloaded ||
     aAnalysisType == Ci.nsIContentAnalysisRequest.ePrint
   );
 },

 /**
  * This function also transforms the nameOrOperationType so we won't have to
  * look it up again.
  *
  * @param {ResourceNameOrOperationType} nameOrOperationType
  * @returns {string}
  */
 _getResourceNameFromNameOrOperationType(nameOrOperationType) {
   if (!nameOrOperationType.name) {
     let l10nId = undefined;
     switch (nameOrOperationType.operationType) {
       case Ci.nsIContentAnalysisRequest.eClipboard:
         l10nId = "contentanalysis-operationtype-clipboard";
         break;
       case Ci.nsIContentAnalysisRequest.eDroppedText:
         l10nId = "contentanalysis-operationtype-dropped-text";
         break;
       case Ci.nsIContentAnalysisRequest.eOperationPrint:
         l10nId = "contentanalysis-operationtype-print";
         break;
     }
     if (!l10nId) {
       console.error(
         "Unknown operationTypeForDisplay: " +
           nameOrOperationType.operationType
       );
       return "";
     }
     nameOrOperationType.name = this.l10n.formatValueSync(l10nId);
   }
   return nameOrOperationType.name;
 },

 /**
  * Gets a name or operation type from a request
  *
  * @param {nsIContentAnalysisRequest} aRequest The nsIContentAnalysisRequest
  * @param {boolean} aStandalone Whether the message is going to be used on its own
  *                              line. This is used to add more context to the message
  *                              if a file is being uploaded or downloaded rather than
  *                              just the name of the file.
  * @returns {ResourceNameOrOperationType}
  */
 _getResourceNameOrOperationTypeFromRequest(aRequest, aStandalone) {
   /**
    * @type {ResourceNameOrOperationType}
    */
   let nameOrOperationType = {
     operationType: aRequest.operationTypeForDisplay,
   };
   if (
     aRequest.operationTypeForDisplay == Ci.nsIContentAnalysisRequest.eUpload
   ) {
     if (aStandalone) {
       nameOrOperationType.name = this.l10n.formatValueSync(
         "contentanalysis-upload-description",
         { filename: aRequest.fileNameForDisplay }
       );
     } else {
       nameOrOperationType.name = aRequest.fileNameForDisplay;
     }
   } else if (
     aRequest.operationTypeForDisplay == Ci.nsIContentAnalysisRequest.eDownload
   ) {
     if (aStandalone) {
       nameOrOperationType.name = this.l10n.formatValueSync(
         "contentanalysis-download-description",
         { filename: aRequest.fileNameForDisplay }
       );
     } else {
       nameOrOperationType.name = aRequest.fileNameForDisplay;
     }
   }
   return nameOrOperationType;
 },

 /**
  * Sets up an "operation is in progress" dialog to be shown after a delay,
  * unless one is already showing for this userActionId.
  *
  * @param {nsIContentAnalysisRequest} aRequest
  * @param {ResourceNameOrOperationType} aResourceNameOrOperationType
  * @param {CanonicalBrowsingContext?} aBrowsingContext
  */
 _queueSlowCAMessage(
   aRequest,
   aResourceNameOrOperationType,
   aBrowsingContext
 ) {
   let entry = this.userActionToBusyDialogMap.get(aRequest.userActionId);
   if (entry) {
     // Don't show busy dialog if another request is already doing so.
     entry.requestTokenSet.add(aRequest.requestToken);
     return;
   }

   const analysisType = aRequest.analysisType;
   // For operations that block browser interaction, show the "slow content analysis"
   // dialog faster
   let slowTimeoutMs = this._shouldShowBlockingNotification(analysisType)
     ? this._SLOW_DLP_NOTIFICATION_BLOCKING_TIMEOUT_MS
     : this._SLOW_DLP_NOTIFICATION_NONBLOCKING_TIMEOUT_MS;

   entry = {
     requestTokenSet: new Set([aRequest.requestToken]),
     userActionId: aRequest.userActionId,
   };
   this.userActionToBusyDialogMap.set(aRequest.userActionId, entry);
   entry.timer = lazy.setTimeout(() => {
     entry.timer = null;
     entry.notification = this._showSlowCAMessage(
       analysisType,
       aRequest,
       this._getSlowDialogMessage(
         aResourceNameOrOperationType,
         aRequest.userActionRequestsCount
       ),
       aBrowsingContext
     );
   }, slowTimeoutMs);
 },

 /**
  * Removes the Slow CA message, if it is showing
  *
  * @param {string} aUserActionId The user action ID to remove
  * @param {string} aRequestToken The request token to remove
  */
 _removeSlowCAMessage(aUserActionId, aRequestToken) {
   let entry = this.userActionToBusyDialogMap.get(aUserActionId);
   if (!entry) {
     console.error(
       `Couldn't find slow dialog for user action ${aUserActionId}`
     );
     return;
   }
   if (!entry.requestTokenSet.delete(aRequestToken)) {
     console.warn(
       `Couldn't find request ${aRequestToken} in slow dialog object for user action ${aUserActionId}.  Shutting down?`
     );
     return;
   }
   if (entry.requestTokenSet.size) {
     // Continue showing the busy dialog since other requests are still pending.
     return;
   }
   this.userActionToBusyDialogMap.delete(aUserActionId);
   this._disconnectFromView(entry);
 },

 /**
  * Gets all the requests that are still in progress.
  *
  * @returns {IteratorObject<RequestInfo>} Information about the requests that are still in progress
  */
 _getAllSlowCARequestInfos() {
   return this.userActionToBusyDialogMap
     .values()
     .flatMap(val => val.requestTokenSet)
     .map(requestToken => this.requestTokenToRequestInfo.get(requestToken));
 },

 /**
  * Show a message to the user to indicate that a CA request is taking
  * a long time.
  *
  * @param {nsIContentAnalysisRequest.AnalysisType} aOperation The operation
  * @param {nsIContentAnalysisRequest} aRequest The request that is taking a long time
  * @param {string} aBodyMessage Message to show in the body of the alert
  * @param {CanonicalBrowsingContext?} aBrowsingContext BrowsingContext to show the alert in
  */
 _showSlowCAMessage(aOperation, aRequest, aBodyMessage, aBrowsingContext) {
   if (!this._shouldShowBlockingNotification(aOperation)) {
     return this._showMessage(aBodyMessage, aBrowsingContext);
   }

   if (!aRequest) {
     throw new Error(
       "Showing in-browser Content Analysis notification but no request was passed"
     );
   }

   return this._showSlowCABlockingMessage(
     aBrowsingContext,
     aRequest.userActionId,
     aRequest.requestToken,
     aBodyMessage
   );
 },

 /**
  * Gets the dialog message to show for the Slow CA dialog.
  *
  * @param {ResourceNameOrOperationType} aResourceNameOrOperationType
  * @param {number} aNumRequests
  * @returns {string}
  */
 _getSlowDialogMessage(aResourceNameOrOperationType, aNumRequests) {
   if (aResourceNameOrOperationType.name) {
     let label =
       aNumRequests > 1
         ? "contentanalysis-slow-agent-dialog-body-file-and-more"
         : "contentanalysis-slow-agent-dialog-body-file";

     return this.l10n.formatValueSync(label, {
       agent: lazy.agentName,
       filename: aResourceNameOrOperationType.name,
       count: aNumRequests - 1,
     });
   }
   let l10nId = undefined;
   switch (aResourceNameOrOperationType.operationType) {
     case Ci.nsIContentAnalysisRequest.eClipboard:
       l10nId = "contentanalysis-slow-agent-dialog-body-clipboard";
       break;
     case Ci.nsIContentAnalysisRequest.eDroppedText:
       l10nId = "contentanalysis-slow-agent-dialog-body-dropped-text";
       break;
     case Ci.nsIContentAnalysisRequest.eOperationPrint:
       l10nId = "contentanalysis-slow-agent-dialog-body-print";
       break;
   }
   if (!l10nId) {
     console.error(
       "Unknown operationTypeForDisplay: ",
       aResourceNameOrOperationType
     );
     return "";
   }
   return this.l10n.formatValueSync(l10nId, { agent: lazy.agentName });
 },

 /**
  * Gets the dialog message to show when the request has an error.
  *
  * @param {ResourceNameOrOperationType} aResourceNameOrOperationType
  * @returns {string}
  */
 _getErrorDialogMessage(aResourceNameOrOperationType) {
   if (aResourceNameOrOperationType.name) {
     return this.l10n.formatValueSync(
       "contentanalysis-error-message-upload-file",
       { filename: aResourceNameOrOperationType.name }
     );
   }
   let l10nId = undefined;
   switch (aResourceNameOrOperationType.operationType) {
     case Ci.nsIContentAnalysisRequest.eClipboard:
       l10nId = "contentanalysis-error-message-clipboard";
       break;
     case Ci.nsIContentAnalysisRequest.eDroppedText:
       l10nId = "contentanalysis-error-message-dropped-text";
       break;
     case Ci.nsIContentAnalysisRequest.eOperationPrint:
       l10nId = "contentanalysis-error-message-print";
       break;
   }
   if (!l10nId) {
     console.error(
       "Unknown operationTypeForDisplay: ",
       aResourceNameOrOperationType
     );
     return "";
   }
   return this.l10n.formatValueSync(l10nId);
 },

 /**
  * Show the Slow CA blocking dialog.
  *
  * @param {BrowsingContext} aBrowsingContext
  * @param {string} aUserActionId
  * @param {string} aRequestToken
  * @param {string} aBodyMessage
  * @returns {NotificationInfo}
  */
 _showSlowCABlockingMessage(
   aBrowsingContext,
   aUserActionId,
   aRequestToken,
   aBodyMessage
 ) {
   // Note that TabDialogManager maintains a list of displaying dialogs, and so
   // we can pop up multiple of these and the first one will keep displaying until
   // it is closed, at which point the next one will display, etc.
   let promise = Services.prompt.asyncConfirmEx(
     aBrowsingContext,
     Ci.nsIPromptService.MODAL_TYPE_TAB,
     this.l10n.formatValueSync("contentanalysis-slow-agent-dialog-header"),
     aBodyMessage,
     Ci.nsIPromptService.BUTTON_POS_0 *
       Ci.nsIPromptService.BUTTON_TITLE_CANCEL +
       Ci.nsIPromptService.BUTTON_POS_1_DEFAULT +
       Ci.nsIPromptService.SHOW_SPINNER,
     null,
     null,
     null,
     null,
     false,
     { promptID: this.PROMPTID_PREFIX + aUserActionId }
   );
   promise
     .catch(() => {
       // need a catch clause to avoid an unhandled JS exception
       // when we programmatically close the dialog or close the tab.
     })
     .finally(() => {
       // This is also called if the tab/window is closed while a request is
       // in progress, in which case we need to cancel all related requests.
       //
       // If aUserActionId is still in userActionToBusyDialogMap,
       // this means the dialog wasn't closed by _disconnectFromView(),
       // so cancel the operation.
       if (this.userActionToBusyDialogMap.has(aUserActionId)) {
         this.contentAnalysis.cancelAllRequestsAssociatedWithUserAction(
           aUserActionId
         );
       }
       // Do this after checking userActionToBusyDialogMap, since
       // _removeSlowCAMessage() will remove the entry from
       // userActionToBusyDialogMap.
       if (this.requestTokenToRequestInfo.delete(aRequestToken)) {
         // I think this is needed to clean up when the tab/window
         // is closed.
         this._removeSlowCAMessage(aUserActionId, aRequestToken);
       }
     });
   return {
     dialogBrowsingContext: aBrowsingContext,
   };
 },

 /**
  * Show a message to the user to indicate the result of a CA request.
  *
  * @param {ResourceNameOrOperationType} aResourceNameOrOperationType
  * @param {CanonicalBrowsingContext} aBrowsingContext
  * @param {string} aRequestToken
  * @param {string} aUserActionId
  * @param {number} aCAResult
  * @param {boolean} aIsSyntheticResponse
  * @param {number} aRequestCancelError
  * @returns {Promise<NotificationInfo?>} a notification object (if shown)
  */
 async _showCAResult(
   aResourceNameOrOperationType,
   aBrowsingContext,
   aRequestToken,
   aUserActionId,
   aCAResult,
   aIsSyntheticResponse,
   aRequestCancelError
 ) {
   let message = null;
   let timeoutMs = 0;

   switch (aCAResult) {
     case Ci.nsIContentAnalysisResponse.eAllow:
       // We don't need to show anything
       return null;
     case Ci.nsIContentAnalysisResponse.eReportOnly:
       message = await this.l10n.formatValue(
         "contentanalysis-genericresponse-message",
         {
           content: this._getResourceNameFromNameOrOperationType(
             aResourceNameOrOperationType
           ),
           response: "REPORT_ONLY",
         }
       );
       timeoutMs = this._RESULT_NOTIFICATION_FAST_TIMEOUT_MS;
       break;
     case Ci.nsIContentAnalysisResponse.eWarn: {
       let allow = false;
       try {
         this.warnDialogRequestTokens.add(aRequestToken);
         const result = await Services.prompt.asyncConfirmEx(
           aBrowsingContext,
           Ci.nsIPromptService.MODAL_TYPE_TAB,
           await this.l10n.formatValue("contentanalysis-warndialogtitle"),
           await this._warnDialogText(aResourceNameOrOperationType),
           Ci.nsIPromptService.BUTTON_POS_0 *
             Ci.nsIPromptService.BUTTON_TITLE_IS_STRING +
             Ci.nsIPromptService.BUTTON_POS_1 *
               Ci.nsIPromptService.BUTTON_TITLE_IS_STRING +
             Ci.nsIPromptService.BUTTON_POS_2_DEFAULT,
           await this.l10n.formatValue(
             "contentanalysis-warndialog-response-allow"
           ),
           await this.l10n.formatValue(
             "contentanalysis-warndialog-response-deny"
           ),
           null,
           null,
           false
         );
         allow = result.get("buttonNumClicked") === 0;
       } catch {
         // This can happen if the dialog is closed programmatically, for
         // example if the tab is moved to a new window.
         // In this case just pretend the user clicked deny, as this
         // emulates the behavior of cancelling when
         // the request is still active.
         allow = false;
       }
       // Note that the shutdown code in the "quit-application" handler
       // may have cleared out warnDialogRequestTokens and responded
       // to the request already, so don't call respondToWarnDialog()
       // if aRequestToken is not in warnDialogRequestTokens.
       if (this.warnDialogRequestTokens.delete(aRequestToken)) {
         this.contentAnalysis.respondToWarnDialog(aRequestToken, allow);
       }
       return null;
     }
     case Ci.nsIContentAnalysisResponse.eBlock: {
       if (!aIsSyntheticResponse && !lazy.showBlockedResult) {
         // Don't show anything
         return null;
       }
       let titleId = undefined;
       let body = undefined;
       if (aResourceNameOrOperationType.name) {
         titleId =
           aResourceNameOrOperationType.operationType ==
           Ci.nsIContentAnalysisRequest.eUpload
             ? "contentanalysis-block-dialog-title-upload-file"
             : "contentanalysis-block-dialog-title-download-file";
         body = this.l10n.formatValueSync(
           aResourceNameOrOperationType.operationType ==
             Ci.nsIContentAnalysisRequest.eUpload
             ? "contentanalysis-block-dialog-body-upload-file"
             : "contentanalysis-block-dialog-body-download-file",
           { filename: aResourceNameOrOperationType.name }
         );
       } else {
         let bodyId = undefined;
         let bodyHasContent = false;
         switch (aResourceNameOrOperationType.operationType) {
           case Ci.nsIContentAnalysisRequest.eClipboard: {
             // Unlike the cases below, this can be shown when the DLP
             // agent is not available.  We use a different message for that.
             const caInfo = await this.contentAnalysis.getDiagnosticInfo();
             titleId = "contentanalysis-block-dialog-title-clipboard";
             bodyId = caInfo.connectedToAgent
               ? "contentanalysis-block-dialog-body-clipboard"
               : "contentanalysis-no-agent-connected-message-content";
             bodyHasContent = true;
             break;
           }
           case Ci.nsIContentAnalysisRequest.eDroppedText:
             titleId = "contentanalysis-block-dialog-title-dropped-text";
             bodyId = "contentanalysis-block-dialog-body-dropped-text";
             break;
           case Ci.nsIContentAnalysisRequest.eOperationPrint:
             titleId = "contentanalysis-block-dialog-title-print";
             bodyId = "contentanalysis-block-dialog-body-print";
             break;
         }
         if (!titleId || !bodyId) {
           console.error(
             "Unknown operationTypeForDisplay: ",
             aResourceNameOrOperationType
           );
           return null;
         }
         if (bodyHasContent) {
           body = this.l10n.formatValueSync(bodyId, {
             agent: lazy.agentName,
             content: "",
           });
         } else {
           body = this.l10n.formatValueSync(bodyId);
         }
       }
       let alertBrowsingContext = aBrowsingContext;
       if (aBrowsingContext.embedderElement?.getAttribute("printpreview")) {
         // If we're in a print preview dialog, things are tricky.
         // The window itself is about to close (because of the thrown NS_ERROR_CONTENT_BLOCKED),
         // so using an async call would just immediately make the dialog disappear. (bug 1899714)
         // Using a blocking version can cause a hang if the window is resizing while
         // we show the dialog. (bug 1900798)
         // So instead, try to find the browser that this print preview dialog is on top of
         // and show the dialog there.
         let printPreviewBrowser = aBrowsingContext.embedderElement;
         let win = printPreviewBrowser.ownerGlobal;
         for (let browser of win.gBrowser.browsers) {
           if (
             win.PrintUtils.getPreviewBrowser(browser)?.browserId ===
             printPreviewBrowser.browserId
           ) {
             alertBrowsingContext = browser.browsingContext;
             break;
           }
         }
       }
       await Services.prompt.asyncAlert(
         alertBrowsingContext,
         Ci.nsIPromptService.MODAL_TYPE_TAB,
         this.l10n.formatValueSync(titleId),
         body
       );
       return null;
     }
     case Ci.nsIContentAnalysisResponse.eUnspecified:
       message = await this.l10n.formatValue(
         "contentanalysis-unspecified-error-message-content",
         {
           agent: lazy.agentName,
           content: this._getErrorDialogMessage(aResourceNameOrOperationType),
         }
       );
       timeoutMs = this._RESULT_NOTIFICATION_TIMEOUT_MS;
       break;
     case Ci.nsIContentAnalysisResponse.eCanceled:
       {
         let messageId;
         switch (aRequestCancelError) {
           case Ci.nsIContentAnalysisResponse.eUserInitiated:
             console.error(
               "Got unexpected cancel response with eUserInitiated"
             );
             return null;
           case Ci.nsIContentAnalysisResponse.eOtherRequestInGroupCancelled:
             return null;
           case Ci.nsIContentAnalysisResponse.eNoAgent:
             messageId = "contentanalysis-no-agent-connected-message-content";
             break;
           case Ci.nsIContentAnalysisResponse.eInvalidAgentSignature:
             messageId =
               "contentanalysis-invalid-agent-signature-message-content";
             break;
           case Ci.nsIContentAnalysisResponse.eErrorOther:
             messageId = "contentanalysis-unspecified-error-message-content";
             break;
           case Ci.nsIContentAnalysisResponse.eShutdown:
             // we're shutting down, no need to show a dialog
             return null;
           case Ci.nsIContentAnalysisResponse.eTimeout:
             // We only show this if the default action was to block.
             messageId = "contentanalysis-timeout-block-error-message-content";
             break;
           default:
             console.error(
               "Unexpected CA cancelError value: " + aRequestCancelError
             );
             messageId = "contentanalysis-unspecified-error-message-content";
             break;
         }
         // We got an error with this request, so close any dialogs for any other request
         // with the same user action id and also remove their data so we don't show
         // any dialogs they might later try to show.
         const busyDialogInfo =
           this.userActionToBusyDialogMap.get(aUserActionId);
         if (busyDialogInfo) {
           busyDialogInfo.requestTokenSet.forEach(requestToken => {
             this.requestTokenToRequestInfo.delete(requestToken);
             this._removeSlowCAMessage(aUserActionId, requestToken);
           });
         }
         message = await this.l10n.formatValue(messageId, {
           agent: lazy.agentName,
           content: this._getErrorDialogMessage(aResourceNameOrOperationType),
           contentName: this._getResourceNameFromNameOrOperationType(
             aResourceNameOrOperationType
           ),
         });
         timeoutMs = this._RESULT_NOTIFICATION_TIMEOUT_MS;
       }
       break;
     default:
       throw new Error("Unexpected CA result value: " + aCAResult);
   }

   if (!message) {
     console.error(
       "_showCAResult did not get a message populated for result value " +
         aCAResult
     );
     return null;
   }

   return this._showMessage(message, aBrowsingContext, timeoutMs);
 },

 /**
  * Returns the correct text for warn dialog contents.
  *
  * @param {ResourceNameOrOperationType} aResourceNameOrOperationType
  */
 async _warnDialogText(aResourceNameOrOperationType) {
   const caInfo = await this.contentAnalysis.getDiagnosticInfo();
   if (caInfo.connectedToAgent) {
     return await this.l10n.formatValue("contentanalysis-warndialogtext", {
       content: this._getResourceNameFromNameOrOperationType(
         aResourceNameOrOperationType
       ),
     });
   }
   return await this.l10n.formatValue(
     "contentanalysis-no-agent-connected-message-content",
     { agent: lazy.agentName, content: "" }
   );
 },
};