Source: js/permission_manager.js

  1. /* global Service, applications, ManifestHelper, Tagged */
  2. 'use strict';
  3. (function(exports) {
  4.   /**
  5.    * Handle Web API permissions such as geolocation, getUserMedia
  6.    * @class PermissionManager
  7.    * @requires Applications
  8.    */
  9.   function PermissionManager() {
  10.   }
  12.   PermissionManager.prototype = {
  14.     currentOrigin: undefined,
  15.     permissionType: undefined,
  16.     currentPermissions: undefined,
  17.     currentChoices: {}, //select choices
  18.     isFullscreenRequest: false,
  19.     isVideo: false,
  20.     isAudio: false,
  21.     /**
  22.      * special dialog for camera selection while in app mode and
  23.      * permission is granted
  24.      */
  25.     isCamSelector: false,
  26.     responseStatus: undefined,
  27.     /**
  28.      * A queue of pending requests.
  29.      */
  30.     pending: [],
  32.     /**
  33.      * The ID of the request currently visible on the screen. This has the value
  34.      * "undefined" when there is no request visible on the screen.
  35.      */
  36.     currentRequestId: undefined,
  38.     /**
  39.      * start the PermissionManager to init variables and listeners
  40.      * @memberof PermissionManager.prototype
  41.      */
  42.     start: function pm_start() {
  43.       // Div over in which the permission UI resides.
  44.       this.overlay = document.getElementById('permission-screen');
  45.       this.dialog = document.getElementById('permission-dialog');
  46.       this.title = document.getElementById('permission-title');
  47.       this.message = document.getElementById('permission-message');
  48.       this.moreInfo = document.getElementById('permission-more-info');
  49.       this.moreInfoLink = document.getElementById('permission-more-info-link');
  50.       this.hideInfoLink = document.getElementById('permission-hide-info-link');
  51.       this.moreInfoBox = document.getElementById('permission-more-info-box');
  53.       // "Yes"/"No" buttons on the permission UI.
  54.       this.buttons = document.getElementById('permission-buttons');
  55.       this.yes = document.getElementById('permission-yes');
  56.       this.no = document.getElementById('permission-no');
  58.       // Remember the choice checkbox
  59.       this.remember = document.getElementById('permission-remember-checkbox');
  60.       this.rememberSection =
  61.         document.getElementById('permission-remember-section');
  62.       this.deviceSelector =
  63.         document.getElementById('permission-device-selector');
  64.       this.devices = document.getElementById('permission-devices');
  66.       var self = this;
  67.       this.rememberSection.addEventListener('click',
  68.         function onLabelClick() {
  69.         self.remember.checked = !self.remember.checked;
  70.       });
  72.       window.addEventListener('mozChromeEvent', this);
  73.       window.addEventListener('attentionopening', this);
  74.       window.addEventListener('attentionopened', this);
  75.       window.addEventListener('lockscreen-appopened', this);
  76.       window.addEventListener('screenchange', this);
  78.       /* On home/holdhome pressed, discard permission request.
  79.        * XXX: We should make permission dialog be embededd in appWindow
  80.        * Gaia bug is https://bugzilla.mozilla.org/show_bug.cgi?id=853711
  81.        * Gecko bug is https://bugzilla.mozilla.org/show_bug.cgi?id=852013
  82.        */
  83.       this.discardPermissionRequest = this.discardPermissionRequest.bind(this);
  84.       window.addEventListener('home', this.discardPermissionRequest);
  85.       window.addEventListener('holdhome', this.discardPermissionRequest);
  87.       /* If an application that is currently running needs to get killed for
  88.        * whatever reason we want to discard it's request for permissions.
  89.        */
  90.       window.addEventListener('appterminated', (function(evt) {
  91.         if (evt.detail.origin == this.currentOrigin) {
  92.           this.discardPermissionRequest();
  93.         }
  94.       }).bind(this));
  96.       // Ensure that the focus is not stolen by the permission overlay, as
  97.       // it may appears on top of a <select> element, and just cancel it.
  98.       this.overlay.addEventListener('mousedown', function onMouseDown(evt) {
  99.         evt.preventDefault();
  100.       });
  101.     },
  103.     /**
  104.      * Returns the view for each device option.
  105.      * @memberof PermissionManager.prototype
  106.      */
  107.     deviceOptionView: function({id, checked, label}) {
  108.       return Tagged.escapeHTML `<label class="device-list deviceEnable">
  109.           <input class="input-enable" id="${id}" type="checkbox" ${checked}>
  110.           <span></span>
  111.         </label>
  112.         <span class="device-item" data-l10n-id="${label}"></span>`;
  113.     },
  115.     /**
  116.      * Request all strings to show
  117.      * @memberof PermissionManager.prototype
  118.      */
  119.     getStrings: function getStrings(detail) {
  120.       // If we are in fullscreen, the strings are slightly different.
  121.       if (this.isFullscreenRequest) {
  122.         var fullscreenMessage = {
  123.           id: 'fullscreen-request',
  124.           args: {
  125.             'origin': detail.fullscreenorigin
  126.           }};
  127.         return {
  128.           message: fullscreenMessage,
  129.           moreInfoText: null
  130.         };
  131.       }
  133.       // If it's a regular request (non-fullscreen), we review
  134.       // the permission and create the strings accordingly
  135.       var permissionID = 'perm-' + this.permissionType.replace(':', '-');
  136.       var app = applications.getByManifestURL(detail.manifestURL);
  137.       var message = '';
  138.       if (detail.isApp) {
  139.         var appName = new ManifestHelper(app.manifest).name;
  140.         message = {
  141.           id: permissionID + '-appRequest',
  142.           args: {
  143.             'app': appName
  144.           }};
  145.       } else {
  146.         message = {
  147.           id: permissionID + '-webRequest',
  148.           args: {
  149.             'site': detail.origin
  150.           }};
  151.       }
  153.       var moreInfoText = permissionID + '-more-info';
  154.       return {
  155.         message : message,
  156.         moreInfoText: moreInfoText
  157.       };
  158.     },
  160.     /**
  161.      * stop the PermissionManager to reset variables and listeners
  162.      * @memberof PermissionManager.prototype
  163.      */
  164.     stop: function pm_stop() {
  165.       this.currentOrigin = null;
  166.       this.permissionType = null;
  167.       this.currentPermissions = null;
  168.       this.currentChoices = {};
  169.       this.fullscreenRequest = null;
  170.       this.isVideo = false;
  171.       this.isAudio = false;
  172.       this.isCamSelector = false;
  174.       this.responseStatus = null;
  175.       this.pending = [];
  176.       this.currentRequestId = null;
  178.       this.overlay = null;
  179.       this.dialog = null;
  180.       this.title = null;
  181.       this.message = null;
  182.       this.moreInfo = null;
  183.       this.moreInfoLink = null;
  184.       this.moreInfoBox = null;
  186.       this.remember = null;
  187.       this.rememberSection = null;
  188.       this.deviceSelector = null;
  189.       this.devices = null;
  191.       this.buttons = null;
  192.       this.yes = null;
  193.       this.no = null;
  195.       window.removeEventListener('mozChromeEvent', this);
  196.       window.removeEventListener('attentionopening', this);
  197.       window.removeEventListener('attentionopened', this);
  198.       window.removeEventListener('lockscreen-appopened', this);
  199.       window.removeEventListener('screenchange', this);
  200.       window.removeEventListener('home', this.discardPermissionRequest);
  201.       window.removeEventListener('holdhome', this.discardPermissionRequest);
  202.     },
  204.     /**
  205.      * Reset current values
  206.      * @memberof PermissionManager.prototype
  207.      */
  208.     cleanDialog: function pm_cleanDialog() {
  209.       delete this.overlay.dataset.type;
  210.       this.permissionType = undefined;
  211.       this.currentPermissions = undefined;
  212.       this.currentChoices = {};
  213.       this.isVideo = false;
  214.       this.isAudio = false;
  215.       this.isCamSelector = false;
  217.       //handled in showPermissionPrompt
  218.       if (this.message.classList.contains('hidden')) {
  219.         this.message.classList.remove('hidden');
  220.       }
  221.       if (!this.moreInfoBox.classList.contains('hidden')) {
  222.         this.moreInfoBox.classList.add('hidden');
  223.       }
  224.       this.devices.innerHTML = '';
  225.       if (!this.deviceSelector.classList.contains('hidden')) {
  226.         this.deviceSelector.classList.add('hidden');
  227.       }
  228.       this.buttons.dataset.items = 2;
  229.       this.no.style.display = 'inline';
  230.     },
  232.     /**
  233.      * Queue or show the permission prompt
  234.      * @memberof PermissionManager.prototype
  235.      */
  236.     queuePrompt: function(detail) {
  237.       this.pending.push(detail);
  238.     },
  240.     /**
  241.      * Event handler interface for mozChromeEvent.
  242.      * @memberof PermissionManager.prototype
  243.      * @param {DOMEvent} evt The event.
  244.      */
  245.     handleEvent: function pm_handleEvent(evt) {
  246.       var detail = evt.detail;
  247.       switch (detail.type) {
  248.         case 'permission-prompt':
  249.           if (!!this.currentRequestId) {
  250.             this.queuePrompt(detail);
  251.             return;
  252.           }
  253.           this.handlePermissionPrompt(detail);
  254.           break;
  255.         case 'cancel-permission-prompt':
  256.           this.discardPermissionRequest();
  257.           break;
  258.         case 'fullscreenoriginchange':
  259.           delete this.overlay.dataset.type;
  260.           this.cleanDialog();
  261.           this.handleFullscreenOriginChange(detail);
  262.           break;
  263.       }
  265.       switch (evt.type) {
  266.         case 'attentionopened':
  267.         case 'attentionopening':
  268.           if (this.currentOrigin !== evt.detail.origin) {
  269.             this.discardPermissionRequest();
  270.           }
  271.           break;
  272.         case 'lockscreen-appopened':
  273.           if (this.currentRequestId == 'fullscreen') {
  274.             this.discardPermissionRequest();
  275.           }
  276.           break;
  277.         case 'screenchange':
  278.           if (Service.query('locked') && !detail.screenEnabled) {
  279.             this.discardPermissionRequest();
  280.           }
  281.           break;
  282.       }
  283.     },
  285.     /**
  286.      * Handle getUserMedia device select options
  287.      * @memberof PermissionManager.prototype
  288.      * @param {DOMEvent} evt The event.
  289.      */
  290.     optionClickhandler: function pm_optionClickhandler(evt) {
  291.       var link = evt.target;
  292.       if (!link) {
  293.         return;
  294.       }
  295.       if (link.classList.contains('input-enable')) {
  296.         if (link.checked) {
  297.           this.currentChoices['video-capture'] = link.id;
  298.         }
  299.         var items = this.devices.querySelectorAll('input[type="checkbox"]');
  300.         // Uncheck unselected option, allow 1 selection at same time
  301.         for (var i = 0; i < items.length; i++) {
  302.           if (items[i].id !== link.id) {
  303.             items[i].checked = false;
  304.             items[i].disabled = false; // Not allow to uncheck last option
  305.           } else {
  306.             link.disabled = true;
  307.           }
  308.         }
  309.       }
  310.     },
  312.     /**
  313.      * Show the request for the new domain
  314.      * @memberof PermissionManager.prototype
  315.      * @param {Object} detail The event detail object.
  316.      */
  317.     handleFullscreenOriginChange:
  318.       function pm_handleFullscreenOriginChange(detail) {
  319.       // If there's already a fullscreen request visible, cancel it,
  320.       // we'll show the request for the new domain.
  321.       if (this.isFullscreenRequest) {
  322.         this.cancelRequest(this.currentRequestId);
  323.         this.isFullscreenRequest = false;
  324.       }
  325.       if (detail.fullscreenorigin !==
  326.           Service.query('getTopMostWindow').origin) {
  327.         this.isFullscreenRequest = true;
  328.         detail.id = 'fullscreen';
  329.         this.showPermissionPrompt(
  330.           detail,
  331.           function foo() {},
  332.           function() {
  333.             document.mozCancelFullScreen();
  334.           }
  335.         );
  336.       }
  337.     },
  339.     /**
  340.      * Prepare for permission prompt
  341.      * @memberof PermissionManager.prototype
  342.      * @param {Object} detail The event detail object.
  343.      */
  344.     handlePermissionPrompt: function pm_handlePermissionPrompt(detail) {
  345.       // Clean dialog if was rendered before
  346.       this.cleanDialog();
  347.       this.isFullscreenRequest = false;
  348.       this.currentOrigin = detail.origin;
  349.       this.currentRequestId = detail.id;
  351.       if (detail.permissions) {
  352.         if ('video-capture' in detail.permissions) {
  353.           this.isVideo = true;
  355.           // video selector is only for app
  356.           if (detail.isApp && detail.isGranted &&
  357.             detail.permissions['video-capture'].length > 1) {
  358.             this.isCamSelector = true;
  359.           }
  360.         }
  361.         if ('audio-capture' in detail.permissions) {
  362.           this.isAudio = true;
  363.         }
  364.       } else { // work in <1.4 compatible mode
  365.         if (detail.permission) {
  366.           this.permissionType = detail.permission;
  367.           if ('video-capture' === detail.permission) {
  368.             this.isVideo = true;
  369.           }
  370.           if ('audio-capture' === detail.permission) {
  371.             this.isAudio = true;
  372.           }
  373.         }
  374.       }
  376.       // Set default permission
  377.       if (this.isVideo && this.isAudio) {
  378.         this.permissionType = 'media-capture';
  379.       } else {
  380.         if (detail.permission) {
  381.           this.permissionType = detail.permission;
  382.         } else if (detail.permissions) {
  383.           this.permissionType = Object.keys(detail.permissions)[0];
  384.         }
  385.       }
  386.       this.overlay.dataset.type = this.permissionType;
  388.       if (this.isAudio || this.isVideo) {
  389.         if (!detail.isApp) {
  390.           // Not show remember my choice option in website
  391.           this.rememberSection.style.display = 'none';
  392.         } else {
  393.           this.rememberSection.style.display = 'block';
  394.         }
  396.         // Set default options
  397.         this.currentPermissions = detail.permissions;
  398.         for (var permission2 in detail.permissions) {
  399.           if (detail.permissions.hasOwnProperty(permission2)) {
  400.             // gecko might not support audio/video option
  401.             if (detail.permissions[permission2].length > 0) {
  402.               this.currentChoices[permission2] =
  403.                 detail.permissions[permission2][0];
  404.             }
  405.           }
  406.         }
  407.       }
  409.       if ((this.isAudio || this.isVideo) && !detail.isApp &&
  410.         !this.isCamSelector) {
  411.         // gUM always not remember in web mode
  412.         this.remember.checked = false;
  413.       } else {
  414.         this.remember.checked = detail.remember ? true : false;
  415.       }
  417.       if (detail.isApp) { // App
  418.         var app = applications.getByManifestURL(detail.manifestURL);
  420.         if (this.isCamSelector) {
  421.           this.title.setAttribute('data-l10n-id', 'title-cam');
  422.         } else {
  423.           this.title.setAttribute('data-l10n-id', 'title-app');
  424.         }
  425.         navigator.mozL10n.setAttributes(
  426.           this.deviceSelector,
  427.           'perm-camera-selector-appRequest',
  428.           { 'app': new ManifestHelper(app.manifest).name }
  429.         );
  430.       } else { // Web content
  431.         this.title.setAttribute('data-l10n-id', 'title-web');
  432.         navigator.mozL10n.setAttributes(
  433.           this.deviceSelector,
  434.           'perm-camera-selector-webRequest',
  435.           { 'site': detail.origin }
  436.         );
  437.       }
  439.       var self = this;
  441.       this.showPermissionPrompt(
  442.         detail,
  443.         function pm_permYesCB() {
  444.           self.dispatchResponse(
  445.             detail.id,
  446.             'permission-allow',
  447.             self.remember.checked
  448.           );
  449.         },
  450.         function pm_permNoCB() {
  451.           self.dispatchResponse(
  452.             detail.id,
  453.             'permission-deny',
  454.             self.remember.checked
  455.           );
  456.         }
  457.       );
  458.     },
  459.     /**
  460.      * Send permission choice to gecko
  461.      * @memberof PermissionManager.prototype
  462.      */
  463.     dispatchResponse: function pm_dispatchResponse(id, type, remember) {
  464.       if (this.isCamSelector) {
  465.         remember = true;
  466.       }
  467.       this.responseStatus = type;
  469.       var response = {
  470.         id: id,
  471.         type: type,
  472.         remember: remember
  473.       };
  475.       if (this.isVideo || this.isAudio || this.isCamSelector) {
  476.         response.choices = this.currentChoices;
  477.       }
  478.       var event = document.createEvent('CustomEvent');
  479.       event.initCustomEvent('mozContentEvent', true, true, response);
  480.       window.dispatchEvent(event);
  481.     },
  483.     /**
  484.      * Hide prompt
  485.      * @memberof PermissionManager.prototype
  486.      */
  487.     hidePermissionPrompt: function pm_hidePermissionPrompt() {
  488.       this.overlay.classList.remove('visible');
  489.       this.devices.removeEventListener('click', this);
  490.       this.devices.classList.remove('visible');
  491.       this.currentRequestId = undefined;
  492.       // Cleanup the event handlers.
  493.       this.yes.removeEventListener('click', this.yesHandler);
  494.       this.yes.callback = null;
  495.       this.no.removeEventListener('click', this.noHandler);
  496.       this.no.callback = null;
  497.       this.moreInfo.classList.add('hidden');
  498.       this.moreInfoLink.removeEventListener('click',
  499.         this.moreInfoHandler);
  500.       this.hideInfoLink.removeEventListener('click',
  501.         this.hideInfoHandler);
  502.       if (!this.hideInfoLink.classList.contains('hidden')) {
  503.         this.toggleInfo();
  504.       }
  505.       // XXX: This is telling AppWindowManager to focus the active app.
  506.       // After we are moving into AppWindow, we need to remove that
  507.       // and call this.app.focus() instead.
  508.       this.publish('permissiondialoghide');
  509.     },
  511.     publish: function(eventName, detail) {
  512.       var event = document.createEvent('CustomEvent');
  513.       event.initCustomEvent(eventName, true, true, detail);
  514.       window.dispatchEvent(event);
  515.     },
  517.     /**
  518.      * Show the next request, if we have one.
  519.      * @memberof PermissionManager.prototype
  520.      */
  521.     showNextPendingRequest: function pm_showNextPendingRequest() {
  522.       if (this.pending.length === 0) {
  523.         return;
  524.       }
  526.       var request = this.pending.shift();
  528.       if ((this.currentOrigin === request.origin) &&
  529.         (this.permissionType === Object.keys(request.permissions)[0])) {
  530.         this.dispatchResponse(request.id, this.responseStatus,
  531.             this.remember.checked);
  532.         this.showNextPendingRequest();
  533.         return;
  534.       }
  536.       this.handlePermissionPrompt(request);
  537.     },
  539.     /**
  540.      * Event listener function for the yes/no buttons.
  541.      * @memberof PermissionManager.prototype
  542.      */
  543.     clickHandler: function pm_clickHandler(evt) {
  544.       var callback = null;
  545.       if (evt.target === this.yes && this.yes.callback) {
  546.         callback = this.yes.callback;
  547.         this.responseStatus = 'permission-allow';
  548.       } else if (evt.target === this.no && this.no.callback) {
  549.         callback = this.no.callback;
  550.         this.responseStatus = 'permission-deny';
  551.       } else if (evt.target === this.moreInfoLink ||
  552.                  evt.target === this.hideInfoLink) {
  553.         this.toggleInfo();
  554.         return;
  555.       }
  556.       this.hidePermissionPrompt();
  558.       // Call the appropriate callback, if it is defined.
  559.       if (callback) {
  560.         window.setTimeout(callback, 0);
  561.       }
  562.       this.showNextPendingRequest();
  563.     },
  565.     toggleInfo: function pm_toggleInfo() {
  566.       this.moreInfoLink.classList.toggle('hidden');
  567.       this.hideInfoLink.classList.toggle('hidden');
  568.       this.moreInfoBox.classList.toggle('hidden');
  569.     },
  571.     /**
  572.      * Form the media source selection list
  573.      * @memberof PermissionManager.prototype
  574.      */
  575.     listDeviceOptions: function pm_listDeviceOptions() {
  576.       var checked;
  578.       // show description
  579.       this.deviceSelector.classList.remove('hidden');
  580.       // build device list
  581.       this.currentPermissions['video-capture'].forEach(option => {
  582.         // Match currentChoices
  583.         checked = (this.currentChoices['video-capture'] === option) ?
  584.             'checked=true disabled=true' : '';
  585.         if (checked) {
  586.           this.currentChoices['video-capture'] = option;
  587.         }
  589.         var item_li = document.createElement('li');
  590.         item_li.className = 'device-cell';
  591.         item_li.innerHTML = this.deviceOptionView({
  592.                               id: option,
  593.                               checked: checked,
  594.                               label: 'device-' + option
  595.                             });
  596.         this.devices.appendChild(item_li);
  597.       });
  598.       this.devices.addEventListener('click',
  599.         this.optionClickhandler.bind(this));
  600.       this.devices.classList.add('visible');
  601.     },
  603.     /**
  604.      * Put the message in the dialog.
  605.      * @memberof PermissionManager.prototype
  606.      */
  607.     showPermissionPrompt:
  608.       function pm_showPermissionPrompt(detail, yescallback, nocallback) {
  609.       // Note plain text since this may include text from
  610.       // untrusted app manifests, for example.
  611.       var text = this.getStrings(detail);
  612.       if (typeof(text.message) === 'object') {
  613.         navigator.mozL10n.setAttributes(this.message,
  614.           text.message.id, text.message.args);
  615.       } else {
  616.         this.message.setAttribute('data-l10n-id', text.message);
  617.       }
  618.       if (text.moreInfoText) {
  619.         // Show the "More info… " link.
  620.         this.moreInfo.classList.remove('hidden');
  621.         this.moreInfoHandler = this.clickHandler.bind(this);
  622.         this.hideInfoHandler = this.clickHandler.bind(this);
  623.         this.moreInfoLink.addEventListener('click', this.moreInfoHandler);
  624.         this.hideInfoLink.addEventListener('click', this.hideInfoHandler);
  625.         this.moreInfoBox.setAttribute('data-l10n-id', text.moreInfoText);
  626.       }
  627.       this.currentRequestId = detail.id;
  629.       // Not show the list if there's only 1 option
  630.       if (this.isVideo && this.currentPermissions['video-capture'].length > 1) {
  631.         this.listDeviceOptions();
  632.       }
  634.       // Set event listeners for the yes and no buttons
  635.       var isSharedPermission = this.isVideo || this.isAudio ||
  636.            this.permissionType === 'geolocation';
  638.       this.yes.setAttribute('data-l10n-id',
  639.         isSharedPermission ? 'share-' + this.permissionType : 'allow');
  640.       this.yesHandler = this.clickHandler.bind(this);
  641.       this.yes.addEventListener('click', this.yesHandler);
  642.       this.yes.callback = yescallback;
  644.       this.no.setAttribute('data-l10n-id', isSharedPermission ?
  645.         'dontshare-' + this.permissionType : 'dontallow');
  646.       this.noHandler = this.clickHandler.bind(this);
  647.       this.no.addEventListener('click', this.noHandler);
  648.       this.no.callback = nocallback;
  650.       // customize camera selector dialog
  651.       if (this.isCamSelector) {
  652.         this.message.classList.add('hidden');
  653.         this.rememberSection.style.display = 'none';
  654.         this.buttons.dataset.items = 1;
  655.         this.no.style.display = 'none';
  656.         this.yes.setAttribute('data-l10n-id', 'ok');
  657.       }
  658.       // Make the screen visible
  659.       this.overlay.classList.add('visible');
  660.     },
  662.     /**
  663.      * Cancels a request with a specfied id. Request can either be
  664.      * currently showing, or pending. If there are further pending requests,
  665.      * the next is shown.
  666.      * @memberof PermissionManager.prototype
  667.      */
  668.     cancelRequest: function pm_cancelRequest(id) {
  669.       if (this.currentRequestId === id) {
  670.         // Request is currently being displayed. Hide the permission prompt,
  671.         // and show the next request, if we have any.
  672.         this.hidePermissionPrompt();
  673.         this.showNextPendingRequest();
  674.       } else {
  675.         // The request is currently not being displayed. Search through the
  676.         // list of pending requests, and remove it from the list if present.
  677.         for (var i = 0; i < this.pending.length; i++) {
  678.           if (this.pending[i].id === id) {
  679.             this.pending.splice(i, 1);
  680.             break;
  681.           }
  682.         }
  683.       }
  684.     },
  686.     /**
  687.      * Clean current request queue and
  688.      * send refuse permission request message to gecko
  689.      * @memberof PermissionManager.prototype
  690.      */
  691.     discardPermissionRequest: function pm_discardPermissionRequest() {
  692.       if (this.currentRequestId === undefined ||
  693.           this.currentRequestId === null) {
  694.         return;
  695.       }
  697.       if (this.currentRequestId == 'fullscreen') {
  698.         if (this.no.callback) {
  699.           this.no.callback();
  700.         }
  701.         this.isFullscreenRequest = false;
  702.       } else {
  703.         this.dispatchResponse(this.currentRequestId, 'permission-deny', false);
  704.       }
  706.       this.hidePermissionPrompt();
  707.       this.pending = [];
  708.     }
  709.   };
  711.   exports.PermissionManager = PermissionManager;
  713. })(window);