dom/permission/PermissionPromptHelper.jsm
author Dan Minor <dminor@mozilla.com>
Thu, 27 Mar 2014 10:16:14 -0400
changeset 194713 12fbb6719ce94fed90c0a3ffccc887f5818e8353
parent 187536 8f7defebd30a011617ee18277ee0daf7da968417
child 213514 465280604ea6edd9e64e4f05e88b7e81ac99dee6
permissions -rw-r--r--
Bug 988849 - Add mach target for jit tests; r=gps

/* 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/. */

/* PermissionPromptHelper checks the permissionDB for a given permission
 * name and performs prompting if needed.
 * Usage: send PermissionPromptHelper:AskPermission via the FrameMessageManager with:
 * |origin|, |appID|, |browserFlag| -> used for getting the principal and
 * |type| and |access| to call testExactPermissionFromPrincipal.
 * Note that |access| isn't currently used.
 * Other arugments are:
 * requestID: ID that gets returned with the result message.
 *
 * Once the permission is checked, it returns with the message
 * "PermissionPromptHelper:AskPermission:OK"
 * The result contains the |result| e.g.Ci.nsIPermissionManager.ALLOW_ACTION
 * and a requestID that
 */

"use strict";

let DEBUG = 0;
let debug;
if (DEBUG)
  debug = function (s) { dump("-*- Permission Prompt Helper component: " + s + "\n"); }
else
  debug = function (s) {}

const Cu = Components.utils;
const Cc = Components.classes;
const Ci = Components.interfaces;

this.EXPORTED_SYMBOLS = ["PermissionPromptHelper"];

Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");

XPCOMUtils.defineLazyServiceGetter(this, "ppmm",
                                   "@mozilla.org/parentprocessmessagemanager;1",
                                   "nsIMessageListenerManager");

XPCOMUtils.defineLazyServiceGetter(this, "permissionPromptService",
                                   "@mozilla.org/permission-prompt-service;1",
                                   "nsIPermissionPromptService");

let appsService = Cc["@mozilla.org/AppsService;1"].getService(Ci.nsIAppsService);

this.PermissionPromptHelper = {
  init: function init() {
    debug("Init");
    ppmm.addMessageListener("PermissionPromptHelper:AskPermission", this);
    Services.obs.addObserver(this, "profile-before-change", false);
  },

  askPermission: function askPermission(aMessage, aCallbacks) {
    let msg = aMessage.json;

    let access = msg.type;
    if (msg.access) {
      access = access + "-" + msg.access;
    }

    let uri = Services.io.newURI(msg.origin, null, null);
    let principal =
      Services.scriptSecurityManager.getAppCodebasePrincipal(uri, msg.appID, msg.browserFlag);

    let permValue =
      Services.perms.testExactPermissionFromPrincipal(principal, access);

    if (permValue == Ci.nsIPermissionManager.DENY_ACTION ||
        permValue == Ci.nsIPermissionManager.UNKNOWN_ACTION) {
      aCallbacks.cancel();
      return;
    }

    if (permValue == Ci.nsIPermissionManager.PROMPT_ACTION) {

      // create the options from permission request.
      let options = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
      if (msg.options) {
        for (let option of options) {
          options.appendElement(option);
        }
      }

      // create an array with a nsIContentPermissionType element
      let type = {
        type: msg.type,
        access: msg.access ? msg.access : "unused",
        options: options,
        QueryInterface: XPCOMUtils.generateQI([Ci.nsIContentPermissionType])
      };
      let typeArray = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
      typeArray.appendElement(type, false);

      // create a nsIContentPermissionRequest
      let request = {
        types: typeArray,
        principal: principal,
        QueryInterface: XPCOMUtils.generateQI([Ci.nsIContentPermissionRequest]),
        allow: aCallbacks.allow,
        cancel: aCallbacks.cancel,
        window: Services.wm.getOuterWindowWithId(msg.windowID)
      };

      permissionPromptService.getPermission(request);
      return;
    }

    if (permValue == Ci.nsIPermissionManager.ALLOW_ACTION) {
      aCallbacks.allow();
      return;
    }
  },

  observe: function observe(aSubject, aTopic, aData) {
    ppmm.removeMessageListener("PermissionPromptHelper:AskPermission", this);
    Services.obs.removeObserver(this, "profile-before-change");
    ppmm = null;
  },

  receiveMessage: function receiveMessage(aMessage) {
    debug("PermissionPromptHelper::receiveMessage " + aMessage.name);
    let mm = aMessage.target;
    let msg = aMessage.data;

    let result;
    if (aMessage.name == "PermissionPromptHelper:AskPermission") {
      this.askPermission(aMessage, {
        cancel: function() {
          mm.sendAsyncMessage("PermissionPromptHelper:AskPermission:OK",
                              { result: Ci.nsIPermissionManager.DENY_ACTION,
                                requestID: msg.requestID });
        },
        allow: function(aChoice) {
          mm.sendAsyncMessage("PermissionPromptHelper:AskPermission:OK",
                              { result: Ci.nsIPermissionManager.ALLOW_ACTION,
                                choice: aChoice,
                                requestID: msg.requestID });
        }
      });
    }
  }
}

PermissionPromptHelper.init();