1328 lines
44 KiB
JavaScript
1328 lines
44 KiB
JavaScript
/* 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/. */
|
|
|
|
"use strict";
|
|
|
|
var Cu = Components.utils;
|
|
var Ci = Components.interfaces;
|
|
var Cc = Components.classes;
|
|
var Cr = Components.results;
|
|
|
|
/* BrowserElementParent injects script to listen for certain events in the
|
|
* child. We then listen to messages from the child script and take
|
|
* appropriate action here in the parent.
|
|
*/
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
Cu.import("resource://gre/modules/BrowserElementPromptService.jsm");
|
|
|
|
XPCOMUtils.defineLazyGetter(this, "DOMApplicationRegistry", function () {
|
|
Cu.import("resource://gre/modules/Webapps.jsm");
|
|
return DOMApplicationRegistry;
|
|
});
|
|
|
|
XPCOMUtils.defineLazyServiceGetter(this, "systemMessenger",
|
|
"@mozilla.org/system-message-internal;1",
|
|
"nsISystemMessagesInternal");
|
|
|
|
function debug(msg) {
|
|
//dump("BrowserElementParent - " + msg + "\n");
|
|
}
|
|
|
|
function getIntPref(prefName, def) {
|
|
try {
|
|
return Services.prefs.getIntPref(prefName);
|
|
}
|
|
catch(err) {
|
|
return def;
|
|
}
|
|
}
|
|
|
|
function handleWindowEvent(e) {
|
|
if (this._browserElementParents) {
|
|
let beps = ThreadSafeChromeUtils.nondeterministicGetWeakMapKeys(this._browserElementParents);
|
|
beps.forEach(bep => bep._handleOwnerEvent(e));
|
|
}
|
|
}
|
|
|
|
function defineNoReturnMethod(fn) {
|
|
return function method() {
|
|
if (!this._domRequestReady) {
|
|
// Remote browser haven't been created, we just queue the API call.
|
|
let args = Array.slice(arguments);
|
|
args.unshift(this);
|
|
this._pendingAPICalls.push(method.bind.apply(fn, args));
|
|
return;
|
|
}
|
|
if (this._isAlive()) {
|
|
fn.apply(this, arguments);
|
|
}
|
|
};
|
|
}
|
|
|
|
function defineDOMRequestMethod(msgName) {
|
|
return function() {
|
|
return this._sendDOMRequest(msgName);
|
|
};
|
|
}
|
|
|
|
function BrowserElementParentProxyCallHandler() {
|
|
}
|
|
|
|
BrowserElementParentProxyCallHandler.prototype = {
|
|
_frameElement: null,
|
|
_mm: null,
|
|
|
|
MOZBROWSER_EVENT_NAMES: Object.freeze([
|
|
"loadstart", "loadend", "close", "error", "firstpaint",
|
|
"documentfirstpaint", "audioplaybackchange",
|
|
"contextmenu", "securitychange", "locationchange",
|
|
"iconchange", "scrollareachanged", "titlechange",
|
|
"opensearch", "manifestchange", "metachange",
|
|
"resize", "selectionstatechanged", "scrollviewchange",
|
|
"caretstatechanged", "activitydone", "scroll", "opentab"]),
|
|
|
|
init: function(frameElement, mm) {
|
|
this._frameElement = frameElement;
|
|
this._mm = mm;
|
|
this.innerWindowIDSet = new Set();
|
|
|
|
mm.addMessageListener("browser-element-api:proxy-call", this);
|
|
},
|
|
|
|
// Message manager callback receives messages from BrowserElementProxy.js
|
|
receiveMessage: function(mmMsg) {
|
|
let data = mmMsg.json;
|
|
|
|
let mm;
|
|
try {
|
|
mm = mmMsg.target.QueryInterface(Ci.nsIFrameLoaderOwner)
|
|
.frameLoader.messageManager;
|
|
} catch(e) {
|
|
mm = mmMsg.target;
|
|
}
|
|
if (!mm.assertPermission("browser:embedded-system-app")) {
|
|
dump("BrowserElementParent.js: Method call " + data.methodName +
|
|
" from a content process with no 'browser:embedded-system-app'" +
|
|
" privileges.\n");
|
|
return;
|
|
}
|
|
|
|
switch (data.methodName) {
|
|
case '_proxyInstanceInit':
|
|
if (!this.innerWindowIDSet.size) {
|
|
this._attachEventListeners();
|
|
}
|
|
this.innerWindowIDSet.add(data.innerWindowID);
|
|
|
|
break;
|
|
|
|
case '_proxyInstanceUninit':
|
|
this.innerWindowIDSet.delete(data.innerWindowID);
|
|
if (!this.innerWindowIDSet.size) {
|
|
this._detachEventListeners();
|
|
}
|
|
|
|
break;
|
|
|
|
// void methods
|
|
case 'setVisible':
|
|
case 'setActive':
|
|
case 'sendMouseEvent':
|
|
case 'sendTouchEvent':
|
|
case 'goBack':
|
|
case 'goForward':
|
|
case 'reload':
|
|
case 'stop':
|
|
case 'zoom':
|
|
case 'setNFCFocus':
|
|
case 'findAll':
|
|
case 'findNext':
|
|
case 'clearMatch':
|
|
case 'mute':
|
|
case 'unmute':
|
|
case 'setVolume':
|
|
this._frameElement[data.methodName]
|
|
.apply(this._frameElement, data.args);
|
|
|
|
break;
|
|
|
|
// DOMRequest methods
|
|
case 'getVisible':
|
|
case 'download':
|
|
case 'purgeHistory':
|
|
case 'getCanGoBack':
|
|
case 'getCanGoForward':
|
|
case 'getContentDimensions':
|
|
case 'setInputMethodActive':
|
|
case 'executeScript':
|
|
case 'getMuted':
|
|
case 'getVolume':
|
|
let req = this._frameElement[data.methodName]
|
|
.apply(this._frameElement, data.args);
|
|
req.onsuccess = () => {
|
|
this._sendToProxy({
|
|
domRequestId: data.domRequestId,
|
|
innerWindowID: data.innerWindowID,
|
|
result: req.result
|
|
});
|
|
};
|
|
req.onerror = () => {
|
|
this._sendToProxy({
|
|
domRequestId: data.domRequestId,
|
|
innerWindowID: data.innerWindowID,
|
|
err: req.error
|
|
});
|
|
};
|
|
|
|
break;
|
|
|
|
// Not implemented
|
|
case 'getActive': // Sync ???
|
|
case 'addNextPaintListener': // Takes a callback
|
|
case 'removeNextPaintListener': // Takes a callback
|
|
case 'getScreenshot': // Need to pass a blob back
|
|
dump("BrowserElementParentProxyCallHandler Error:" +
|
|
"Attempt to call unimplemented method " + data.methodName + ".\n");
|
|
break;
|
|
|
|
default:
|
|
dump("BrowserElementParentProxyCallHandler Error:" +
|
|
"Attempt to call non-exist method " + data.methodName + ".\n");
|
|
break;
|
|
}
|
|
},
|
|
|
|
// Receving events from the frame element and forward it.
|
|
handleEvent: function(evt) {
|
|
// Ignore the events from nested mozbrowser iframes
|
|
if (evt.target !== this._frameElement) {
|
|
return;
|
|
}
|
|
|
|
let detailString;
|
|
try {
|
|
detailString = JSON.stringify(evt.detail);
|
|
} catch (e) {
|
|
dump("BrowserElementParentProxyCallHandler Error:" +
|
|
"Event detail of " + evt.type + " can't be stingified.\n");
|
|
return;
|
|
}
|
|
|
|
this.innerWindowIDSet.forEach((innerWindowID) => {
|
|
this._sendToProxy({
|
|
eventName: evt.type,
|
|
innerWindowID: innerWindowID,
|
|
eventDetailString: detailString
|
|
});
|
|
});
|
|
},
|
|
|
|
_sendToProxy: function(data) {
|
|
this._mm.sendAsyncMessage("browser-element-api:proxy", data);
|
|
},
|
|
|
|
_attachEventListeners: function() {
|
|
this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
|
|
this._frameElement.addEventListener(
|
|
"mozbrowser" + eventName, this, true);
|
|
}, this);
|
|
},
|
|
|
|
_detachEventListeners: function() {
|
|
this.MOZBROWSER_EVENT_NAMES.forEach(function(eventName) {
|
|
this._frameElement.removeEventListener(
|
|
"mozbrowser" + eventName, this, true);
|
|
}, this);
|
|
}
|
|
};
|
|
|
|
function BrowserElementParent() {
|
|
debug("Creating new BrowserElementParent object");
|
|
this._domRequestCounter = 0;
|
|
this._domRequestReady = false;
|
|
this._pendingAPICalls = [];
|
|
this._pendingDOMRequests = {};
|
|
this._pendingSetInputMethodActive = [];
|
|
this._nextPaintListeners = [];
|
|
this._pendingDOMFullscreen = false;
|
|
|
|
Services.obs.addObserver(this, 'oop-frameloader-crashed', /* ownsWeak = */ true);
|
|
Services.obs.addObserver(this, 'copypaste-docommand', /* ownsWeak = */ true);
|
|
Services.obs.addObserver(this, 'ask-children-to-execute-copypaste-command', /* ownsWeak = */ true);
|
|
Services.obs.addObserver(this, 'back-docommand', /* ownsWeak = */ true);
|
|
|
|
this.proxyCallHandler = new BrowserElementParentProxyCallHandler();
|
|
}
|
|
|
|
BrowserElementParent.prototype = {
|
|
|
|
classDescription: "BrowserElementAPI implementation",
|
|
classID: Components.ID("{9f171ac4-0939-4ef8-b360-3408aedc3060}"),
|
|
contractID: "@mozilla.org/dom/browser-element-api;1",
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIBrowserElementAPI,
|
|
Ci.nsIObserver,
|
|
Ci.nsISupportsWeakReference]),
|
|
|
|
setFrameLoader: function(frameLoader) {
|
|
this._frameLoader = frameLoader;
|
|
this._frameElement = frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerElement;
|
|
if (!this._frameElement) {
|
|
debug("No frame element?");
|
|
return;
|
|
}
|
|
// Listen to visibilitychange on the iframe's owner window, and forward
|
|
// changes down to the child. We want to do this while registering as few
|
|
// visibilitychange listeners on _window as possible, because such a listener
|
|
// may live longer than this BrowserElementParent object.
|
|
//
|
|
// To accomplish this, we register just one listener on the window, and have
|
|
// it reference a WeakMap whose keys are all the BrowserElementParent objects
|
|
// on the window. Then when the listener fires, we iterate over the
|
|
// WeakMap's keys (which we can do, because we're chrome) to notify the
|
|
// BrowserElementParents.
|
|
if (!this._window._browserElementParents) {
|
|
this._window._browserElementParents = new WeakMap();
|
|
let handler = handleWindowEvent.bind(this._window);
|
|
let windowEvents = ['visibilitychange', 'mozfullscreenchange'];
|
|
let els = Cc["@mozilla.org/eventlistenerservice;1"]
|
|
.getService(Ci.nsIEventListenerService);
|
|
for (let event of windowEvents) {
|
|
els.addSystemEventListener(this._window, event, handler,
|
|
/* useCapture = */ true);
|
|
}
|
|
}
|
|
|
|
this._window._browserElementParents.set(this, null);
|
|
|
|
// Insert ourself into the prompt service.
|
|
BrowserElementPromptService.mapFrameToBrowserElementParent(this._frameElement, this);
|
|
this._setupMessageListener();
|
|
this._registerAppManifest();
|
|
|
|
this.proxyCallHandler.init(
|
|
this._frameElement, this._frameLoader.messageManager);
|
|
},
|
|
|
|
_runPendingAPICall: function() {
|
|
if (!this._pendingAPICalls) {
|
|
return;
|
|
}
|
|
for (let i = 0; i < this._pendingAPICalls.length; i++) {
|
|
try {
|
|
this._pendingAPICalls[i]();
|
|
} catch (e) {
|
|
// throw the expections from pending functions.
|
|
debug('Exception when running pending API call: ' + e);
|
|
}
|
|
}
|
|
delete this._pendingAPICalls;
|
|
},
|
|
|
|
_registerAppManifest: function() {
|
|
// If this browser represents an app then let the Webapps module register for
|
|
// any messages that it needs.
|
|
let appManifestURL =
|
|
this._frameElement.QueryInterface(Ci.nsIMozBrowserFrame).appManifestURL;
|
|
if (appManifestURL) {
|
|
let inParent = Cc["@mozilla.org/xre/app-info;1"]
|
|
.getService(Ci.nsIXULRuntime)
|
|
.processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
|
|
if (inParent) {
|
|
DOMApplicationRegistry.registerBrowserElementParentForApp(
|
|
{ manifestURL: appManifestURL }, this._mm);
|
|
} else {
|
|
this._mm.sendAsyncMessage("Webapps:RegisterBEP",
|
|
{ manifestURL: appManifestURL });
|
|
}
|
|
}
|
|
},
|
|
|
|
_setupMessageListener: function() {
|
|
this._mm = this._frameLoader.messageManager;
|
|
this._isWidget = this._frameLoader
|
|
.QueryInterface(Ci.nsIFrameLoader)
|
|
.ownerIsWidget;
|
|
this._mm.addMessageListener('browser-element-api:call', this);
|
|
this._mm.loadFrameScript("chrome://global/content/extensions.js", true);
|
|
},
|
|
|
|
receiveMessage: function(aMsg) {
|
|
if (!this._isAlive()) {
|
|
return;
|
|
}
|
|
|
|
// Messages we receive are handed to functions which take a (data) argument,
|
|
// where |data| is the message manager's data object.
|
|
// We use a single message and dispatch to various function based
|
|
// on data.msg_name
|
|
let mmCalls = {
|
|
"hello": this._recvHello,
|
|
"loadstart": this._fireProfiledEventFromMsg,
|
|
"loadend": this._fireProfiledEventFromMsg,
|
|
"close": this._fireEventFromMsg,
|
|
"error": this._fireEventFromMsg,
|
|
"firstpaint": this._fireProfiledEventFromMsg,
|
|
"documentfirstpaint": this._fireProfiledEventFromMsg,
|
|
"nextpaint": this._recvNextPaint,
|
|
"got-purge-history": this._gotDOMRequestResult,
|
|
"got-screenshot": this._gotDOMRequestResult,
|
|
"got-contentdimensions": this._gotDOMRequestResult,
|
|
"got-can-go-back": this._gotDOMRequestResult,
|
|
"got-can-go-forward": this._gotDOMRequestResult,
|
|
"got-muted": this._gotDOMRequestResult,
|
|
"got-volume": this._gotDOMRequestResult,
|
|
"requested-dom-fullscreen": this._requestedDOMFullscreen,
|
|
"fullscreen-origin-change": this._fullscreenOriginChange,
|
|
"exit-dom-fullscreen": this._exitDomFullscreen,
|
|
"got-visible": this._gotDOMRequestResult,
|
|
"visibilitychange": this._childVisibilityChange,
|
|
"got-set-input-method-active": this._gotDOMRequestResult,
|
|
"selectionstatechanged": this._handleSelectionStateChanged,
|
|
"scrollviewchange": this._handleScrollViewChange,
|
|
"caretstatechanged": this._handleCaretStateChanged,
|
|
"findchange": this._handleFindChange,
|
|
"execute-script-done": this._gotDOMRequestResult,
|
|
"got-audio-channel-volume": this._gotDOMRequestResult,
|
|
"got-set-audio-channel-volume": this._gotDOMRequestResult,
|
|
"got-audio-channel-muted": this._gotDOMRequestResult,
|
|
"got-set-audio-channel-muted": this._gotDOMRequestResult,
|
|
"got-is-audio-channel-active": this._gotDOMRequestResult,
|
|
"got-structured-data": this._gotDOMRequestResult,
|
|
"got-web-manifest": this._gotDOMRequestResult,
|
|
};
|
|
|
|
let mmSecuritySensitiveCalls = {
|
|
"audioplaybackchange": this._fireEventFromMsg,
|
|
"showmodalprompt": this._handleShowModalPrompt,
|
|
"contextmenu": this._fireCtxMenuEvent,
|
|
"securitychange": this._fireEventFromMsg,
|
|
"locationchange": this._fireEventFromMsg,
|
|
"iconchange": this._fireEventFromMsg,
|
|
"scrollareachanged": this._fireEventFromMsg,
|
|
"titlechange": this._fireProfiledEventFromMsg,
|
|
"opensearch": this._fireEventFromMsg,
|
|
"manifestchange": this._fireEventFromMsg,
|
|
"metachange": this._fireEventFromMsg,
|
|
"resize": this._fireEventFromMsg,
|
|
"activitydone": this._fireEventFromMsg,
|
|
"scroll": this._fireEventFromMsg,
|
|
"opentab": this._fireEventFromMsg
|
|
};
|
|
|
|
if (aMsg.data.msg_name in mmCalls) {
|
|
return mmCalls[aMsg.data.msg_name].apply(this, arguments);
|
|
} else if (!this._isWidget && aMsg.data.msg_name in mmSecuritySensitiveCalls) {
|
|
return mmSecuritySensitiveCalls[aMsg.data.msg_name].apply(this, arguments);
|
|
}
|
|
},
|
|
|
|
_removeMessageListener: function() {
|
|
this._mm.removeMessageListener('browser-element-api:call', this);
|
|
},
|
|
|
|
/**
|
|
* You shouldn't touch this._frameElement or this._window if _isAlive is
|
|
* false. (You'll likely get an exception if you do.)
|
|
*/
|
|
_isAlive: function() {
|
|
return !Cu.isDeadWrapper(this._frameElement) &&
|
|
!Cu.isDeadWrapper(this._frameElement.ownerDocument) &&
|
|
!Cu.isDeadWrapper(this._frameElement.ownerDocument.defaultView);
|
|
},
|
|
|
|
get _window() {
|
|
return this._frameElement.ownerDocument.defaultView;
|
|
},
|
|
|
|
get _windowUtils() {
|
|
return this._window.QueryInterface(Ci.nsIInterfaceRequestor)
|
|
.getInterface(Ci.nsIDOMWindowUtils);
|
|
},
|
|
|
|
promptAuth: function(authDetail, callback) {
|
|
let evt;
|
|
let self = this;
|
|
let callbackCalled = false;
|
|
let cancelCallback = function() {
|
|
if (!callbackCalled) {
|
|
callbackCalled = true;
|
|
callback(false, null, null);
|
|
}
|
|
};
|
|
|
|
// 1. We don't handle password-only prompts.
|
|
// 2. We don't handle for widget case because of security concern.
|
|
if (authDetail.isOnlyPassword ||
|
|
this._frameLoader.QueryInterface(Ci.nsIFrameLoader).ownerIsWidget) {
|
|
cancelCallback();
|
|
return;
|
|
}
|
|
|
|
/* username and password */
|
|
let detail = {
|
|
host: authDetail.host,
|
|
realm: authDetail.realm,
|
|
isProxy: authDetail.isProxy
|
|
};
|
|
|
|
evt = this._createEvent('usernameandpasswordrequired', detail,
|
|
/* cancelable */ true);
|
|
Cu.exportFunction(function(username, password) {
|
|
if (callbackCalled)
|
|
return;
|
|
callbackCalled = true;
|
|
callback(true, username, password);
|
|
}, evt.detail, { defineAs: 'authenticate' });
|
|
|
|
Cu.exportFunction(cancelCallback, evt.detail, { defineAs: 'cancel' });
|
|
|
|
this._frameElement.dispatchEvent(evt);
|
|
|
|
if (!evt.defaultPrevented) {
|
|
cancelCallback();
|
|
}
|
|
},
|
|
|
|
_sendAsyncMsg: function(msg, data) {
|
|
try {
|
|
if (!data) {
|
|
data = { };
|
|
}
|
|
|
|
data.msg_name = msg;
|
|
this._mm.sendAsyncMessage('browser-element-api:call', data);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
return true;
|
|
},
|
|
|
|
_recvHello: function() {
|
|
debug("recvHello");
|
|
|
|
// Inform our child if our owner element's document is invisible. Note
|
|
// that we must do so here, rather than in the BrowserElementParent
|
|
// constructor, because the BrowserElementChild may not be initialized when
|
|
// we run our constructor.
|
|
if (this._window.document.hidden) {
|
|
this._ownerVisibilityChange();
|
|
}
|
|
|
|
if (!this._domRequestReady) {
|
|
// At least, one message listener such as for hello is registered.
|
|
// So we can use sendAsyncMessage now.
|
|
this._domRequestReady = true;
|
|
this._runPendingAPICall();
|
|
}
|
|
},
|
|
|
|
_fireCtxMenuEvent: function(data) {
|
|
let detail = data.json;
|
|
let evtName = detail.msg_name;
|
|
|
|
debug('fireCtxMenuEventFromMsg: ' + evtName + ' ' + detail);
|
|
let evt = this._createEvent(evtName, detail, /* cancellable */ true);
|
|
|
|
if (detail.contextmenu) {
|
|
var self = this;
|
|
Cu.exportFunction(function(id) {
|
|
self._sendAsyncMsg('fire-ctx-callback', {menuitem: id});
|
|
}, evt.detail, { defineAs: 'contextMenuItemSelected' });
|
|
}
|
|
|
|
// The embedder may have default actions on context menu events, so
|
|
// we fire a context menu event even if the child didn't define a
|
|
// custom context menu
|
|
return !this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
/**
|
|
* add profiler marker for each event fired.
|
|
*/
|
|
_fireProfiledEventFromMsg: function(data) {
|
|
if (Services.profiler !== undefined) {
|
|
Services.profiler.AddMarker(data.json.msg_name);
|
|
}
|
|
this._fireEventFromMsg(data);
|
|
},
|
|
|
|
/**
|
|
* Fire either a vanilla or a custom event, depending on the contents of
|
|
* |data|.
|
|
*/
|
|
_fireEventFromMsg: function(data) {
|
|
let detail = data.json;
|
|
let name = detail.msg_name;
|
|
|
|
// For events that send a "_payload_" property, we just want to transmit
|
|
// this in the event.
|
|
if ("_payload_" in detail) {
|
|
detail = detail._payload_;
|
|
}
|
|
|
|
debug('fireEventFromMsg: ' + name + ', ' + JSON.stringify(detail));
|
|
let evt = this._createEvent(name, detail,
|
|
/* cancelable = */ false);
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
_handleShowModalPrompt: function(data) {
|
|
// Fire a showmodalprmopt event on the iframe. When this method is called,
|
|
// the child is spinning in a nested event loop waiting for an
|
|
// unblock-modal-prompt message.
|
|
//
|
|
// If the embedder calls preventDefault() on the showmodalprompt event,
|
|
// we'll block the child until event.detail.unblock() is called.
|
|
//
|
|
// Otherwise, if preventDefault() is not called, we'll send the
|
|
// unblock-modal-prompt message to the child as soon as the event is done
|
|
// dispatching.
|
|
|
|
let detail = data.json;
|
|
debug('handleShowPrompt ' + JSON.stringify(detail));
|
|
|
|
// Strip off the windowID property from the object we send along in the
|
|
// event.
|
|
let windowID = detail.windowID;
|
|
delete detail.windowID;
|
|
debug("Event will have detail: " + JSON.stringify(detail));
|
|
let evt = this._createEvent('showmodalprompt', detail,
|
|
/* cancelable = */ true);
|
|
|
|
let self = this;
|
|
let unblockMsgSent = false;
|
|
function sendUnblockMsg() {
|
|
if (unblockMsgSent) {
|
|
return;
|
|
}
|
|
unblockMsgSent = true;
|
|
|
|
// We don't need to sanitize evt.detail.returnValue (e.g. converting the
|
|
// return value of confirm() to a boolean); Gecko does that for us.
|
|
|
|
let data = { windowID: windowID,
|
|
returnValue: evt.detail.returnValue };
|
|
self._sendAsyncMsg('unblock-modal-prompt', data);
|
|
}
|
|
|
|
Cu.exportFunction(sendUnblockMsg, evt.detail, { defineAs: 'unblock' });
|
|
|
|
this._frameElement.dispatchEvent(evt);
|
|
|
|
if (!evt.defaultPrevented) {
|
|
// Unblock the inner frame immediately. Otherwise we'll unblock upon
|
|
// evt.detail.unblock().
|
|
sendUnblockMsg();
|
|
}
|
|
},
|
|
|
|
_handleSelectionStateChanged: function(data) {
|
|
let evt = this._createEvent('selectionstatechanged', data.json,
|
|
/* cancelable = */ false);
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
// Called when state of accessible caret in child has changed.
|
|
// The fields of data is as following:
|
|
// - rect: Contains bounding rectangle of selection, Include width, height,
|
|
// top, bottom, left and right.
|
|
// - commands: Describe what commands can be executed in child. Include canSelectAll,
|
|
// canCut, canCopy and canPaste. For example: if we want to check if cut
|
|
// command is available, using following code, if (data.commands.canCut) {}.
|
|
// - zoomFactor: Current zoom factor in child frame.
|
|
// - reason: The reason causes the state changed. Include "visibilitychange",
|
|
// "updateposition", "longpressonemptycontent", "taponcaret", "presscaret",
|
|
// "releasecaret".
|
|
// - collapsed: Indicate current selection is collapsed or not.
|
|
// - caretVisible: Indicate the caret visiibility.
|
|
// - selectionVisible: Indicate current selection is visible or not.
|
|
// - selectionEditable: Indicate current selection is editable or not.
|
|
// - selectedTextContent: Contains current selected text content, which is
|
|
// equivalent to the string returned by Selection.toString().
|
|
_handleCaretStateChanged: function(data) {
|
|
let evt = this._createEvent('caretstatechanged', data.json,
|
|
/* cancelable = */ false);
|
|
|
|
let self = this;
|
|
function sendDoCommandMsg(cmd) {
|
|
let data = { command: cmd };
|
|
self._sendAsyncMsg('copypaste-do-command', data);
|
|
}
|
|
Cu.exportFunction(sendDoCommandMsg, evt.detail, { defineAs: 'sendDoCommandMsg' });
|
|
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
_handleScrollViewChange: function(data) {
|
|
let evt = this._createEvent("scrollviewchange", data.json,
|
|
/* cancelable = */ false);
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
_handleFindChange: function(data) {
|
|
let evt = this._createEvent("findchange", data.json,
|
|
/* cancelable = */ false);
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
_createEvent: function(evtName, detail, cancelable) {
|
|
// This will have to change if we ever want to send a CustomEvent with null
|
|
// detail. For now, it's OK.
|
|
if (detail !== undefined && detail !== null) {
|
|
detail = Cu.cloneInto(detail, this._window);
|
|
return new this._window.CustomEvent('mozbrowser' + evtName,
|
|
{ bubbles: true,
|
|
cancelable: cancelable,
|
|
detail: detail });
|
|
}
|
|
|
|
return new this._window.Event('mozbrowser' + evtName,
|
|
{ bubbles: true,
|
|
cancelable: cancelable });
|
|
},
|
|
|
|
/**
|
|
* Kick off a DOMRequest in the child process.
|
|
*
|
|
* We'll fire an event called |msgName| on the child process, passing along
|
|
* an object with two fields:
|
|
*
|
|
* - id: the ID of this request.
|
|
* - arg: arguments to pass to the child along with this request.
|
|
*
|
|
* We expect the child to pass the ID back to us upon completion of the
|
|
* request. See _gotDOMRequestResult.
|
|
*/
|
|
_sendDOMRequest: function(msgName, args) {
|
|
let id = 'req_' + this._domRequestCounter++;
|
|
let req = Services.DOMRequest.createRequest(this._window);
|
|
let self = this;
|
|
let send = function() {
|
|
if (!self._isAlive()) {
|
|
return;
|
|
}
|
|
if (self._sendAsyncMsg(msgName, {id: id, args: args})) {
|
|
self._pendingDOMRequests[id] = req;
|
|
} else {
|
|
Services.DOMRequest.fireErrorAsync(req, "fail");
|
|
}
|
|
};
|
|
if (this._domRequestReady) {
|
|
send();
|
|
} else {
|
|
// Child haven't been loaded.
|
|
this._pendingAPICalls.push(send);
|
|
}
|
|
return req;
|
|
},
|
|
|
|
/**
|
|
* Called when the child process finishes handling a DOMRequest. data.json
|
|
* must have the fields [id, successRv], if the DOMRequest was successful, or
|
|
* [id, errorMsg], if the request was not successful.
|
|
*
|
|
* The fields have the following meanings:
|
|
*
|
|
* - id: the ID of the DOM request (see _sendDOMRequest)
|
|
* - successRv: the request's return value, if the request succeeded
|
|
* - errorMsg: the message to pass to DOMRequest.fireError(), if the request
|
|
* failed.
|
|
*
|
|
*/
|
|
_gotDOMRequestResult: function(data) {
|
|
let req = this._pendingDOMRequests[data.json.id];
|
|
delete this._pendingDOMRequests[data.json.id];
|
|
|
|
if ('successRv' in data.json) {
|
|
debug("Successful gotDOMRequestResult.");
|
|
let clientObj = Cu.cloneInto(data.json.successRv, this._window);
|
|
Services.DOMRequest.fireSuccess(req, clientObj);
|
|
}
|
|
else {
|
|
debug("Got error in gotDOMRequestResult.");
|
|
Services.DOMRequest.fireErrorAsync(req,
|
|
Cu.cloneInto(data.json.errorMsg, this._window));
|
|
}
|
|
},
|
|
|
|
setVisible: defineNoReturnMethod(function(visible) {
|
|
this._sendAsyncMsg('set-visible', {visible: visible});
|
|
this._frameLoader.visible = visible;
|
|
}),
|
|
|
|
getVisible: defineDOMRequestMethod('get-visible'),
|
|
|
|
setActive: defineNoReturnMethod(function(active) {
|
|
this._frameLoader.visible = active;
|
|
}),
|
|
|
|
getActive: function() {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
return this._frameLoader.visible;
|
|
},
|
|
|
|
getChildProcessOffset: function() {
|
|
let offset = { x: 0, y: 0 };
|
|
let tabParent = this._frameLoader.tabParent;
|
|
if (tabParent) {
|
|
let offsetX = {};
|
|
let offsetY = {};
|
|
tabParent.getChildProcessOffset(offsetX, offsetY);
|
|
offset.x = offsetX.value;
|
|
offset.y = offsetY.value;
|
|
}
|
|
return offset;
|
|
},
|
|
|
|
sendMouseEvent: defineNoReturnMethod(function(type, x, y, button, clickCount, modifiers) {
|
|
let offset = this.getChildProcessOffset();
|
|
x += offset.x;
|
|
y += offset.y;
|
|
|
|
this._sendAsyncMsg("send-mouse-event", {
|
|
"type": type,
|
|
"x": x,
|
|
"y": y,
|
|
"button": button,
|
|
"clickCount": clickCount,
|
|
"modifiers": modifiers
|
|
});
|
|
}),
|
|
|
|
sendTouchEvent: defineNoReturnMethod(function(type, identifiers, touchesX, touchesY,
|
|
radiisX, radiisY, rotationAngles, forces,
|
|
count, modifiers) {
|
|
|
|
let tabParent = this._frameLoader.tabParent;
|
|
if (tabParent && tabParent.useAsyncPanZoom) {
|
|
tabParent.injectTouchEvent(type,
|
|
identifiers,
|
|
touchesX,
|
|
touchesY,
|
|
radiisX,
|
|
radiisY,
|
|
rotationAngles,
|
|
forces,
|
|
count,
|
|
modifiers);
|
|
} else {
|
|
let offset = this.getChildProcessOffset();
|
|
for (var i = 0; i < touchesX.length; i++) {
|
|
touchesX[i] += offset.x;
|
|
}
|
|
for (var i = 0; i < touchesY.length; i++) {
|
|
touchesY[i] += offset.y;
|
|
}
|
|
this._sendAsyncMsg("send-touch-event", {
|
|
"type": type,
|
|
"identifiers": identifiers,
|
|
"touchesX": touchesX,
|
|
"touchesY": touchesY,
|
|
"radiisX": radiisX,
|
|
"radiisY": radiisY,
|
|
"rotationAngles": rotationAngles,
|
|
"forces": forces,
|
|
"count": count,
|
|
"modifiers": modifiers
|
|
});
|
|
}
|
|
}),
|
|
|
|
getCanGoBack: defineDOMRequestMethod('get-can-go-back'),
|
|
getCanGoForward: defineDOMRequestMethod('get-can-go-forward'),
|
|
getContentDimensions: defineDOMRequestMethod('get-contentdimensions'),
|
|
|
|
findAll: defineNoReturnMethod(function(searchString, caseSensitivity) {
|
|
return this._sendAsyncMsg('find-all', {
|
|
searchString,
|
|
caseSensitive: caseSensitivity == Ci.nsIBrowserElementAPI.FIND_CASE_SENSITIVE
|
|
});
|
|
}),
|
|
|
|
findNext: defineNoReturnMethod(function(direction) {
|
|
return this._sendAsyncMsg('find-next', {
|
|
backward: direction == Ci.nsIBrowserElementAPI.FIND_BACKWARD
|
|
});
|
|
}),
|
|
|
|
clearMatch: defineNoReturnMethod(function() {
|
|
return this._sendAsyncMsg('clear-match');
|
|
}),
|
|
|
|
mute: defineNoReturnMethod(function() {
|
|
this._sendAsyncMsg('mute');
|
|
}),
|
|
|
|
unmute: defineNoReturnMethod(function() {
|
|
this._sendAsyncMsg('unmute');
|
|
}),
|
|
|
|
getMuted: defineDOMRequestMethod('get-muted'),
|
|
|
|
getVolume: defineDOMRequestMethod('get-volume'),
|
|
|
|
setVolume: defineNoReturnMethod(function(volume) {
|
|
this._sendAsyncMsg('set-volume', {volume});
|
|
}),
|
|
|
|
goBack: defineNoReturnMethod(function() {
|
|
this._sendAsyncMsg('go-back');
|
|
}),
|
|
|
|
goForward: defineNoReturnMethod(function() {
|
|
this._sendAsyncMsg('go-forward');
|
|
}),
|
|
|
|
reload: defineNoReturnMethod(function(hardReload) {
|
|
this._sendAsyncMsg('reload', {hardReload: hardReload});
|
|
}),
|
|
|
|
stop: defineNoReturnMethod(function() {
|
|
this._sendAsyncMsg('stop');
|
|
}),
|
|
|
|
executeScript: function(script, options) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
// Enforcing options.url or options.origin
|
|
if (!options.url && !options.origin) {
|
|
throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
|
|
}
|
|
return this._sendDOMRequest('execute-script', {script, options});
|
|
},
|
|
|
|
/*
|
|
* The valid range of zoom scale is defined in preference "zoom.maxPercent" and "zoom.minPercent".
|
|
*/
|
|
zoom: defineNoReturnMethod(function(zoom) {
|
|
zoom *= 100;
|
|
zoom = Math.min(getIntPref("zoom.maxPercent", 300), zoom);
|
|
zoom = Math.max(getIntPref("zoom.minPercent", 50), zoom);
|
|
this._sendAsyncMsg('zoom', {zoom: zoom / 100.0});
|
|
}),
|
|
|
|
purgeHistory: defineDOMRequestMethod('purge-history'),
|
|
|
|
|
|
download: function(_url, _options) {
|
|
if (!this._isAlive()) {
|
|
return null;
|
|
}
|
|
|
|
let uri = Services.io.newURI(_url, null, null);
|
|
let url = uri.QueryInterface(Ci.nsIURL);
|
|
|
|
debug('original _options = ' + uneval(_options));
|
|
|
|
// Ensure we have _options, we always use it to send the filename.
|
|
_options = _options || {};
|
|
if (!_options.filename) {
|
|
_options.filename = url.fileName;
|
|
}
|
|
|
|
debug('final _options = ' + uneval(_options));
|
|
|
|
// Ensure we have a filename.
|
|
if (!_options.filename) {
|
|
throw Components.Exception("Invalid argument", Cr.NS_ERROR_INVALID_ARG);
|
|
}
|
|
|
|
let interfaceRequestor =
|
|
this._frameLoader.loadContext.QueryInterface(Ci.nsIInterfaceRequestor);
|
|
let req = Services.DOMRequest.createRequest(this._window);
|
|
|
|
function DownloadListener() {
|
|
debug('DownloadListener Constructor');
|
|
}
|
|
DownloadListener.prototype = {
|
|
extListener: null,
|
|
onStartRequest: function(aRequest, aContext) {
|
|
debug('DownloadListener - onStartRequest');
|
|
let extHelperAppSvc =
|
|
Cc['@mozilla.org/uriloader/external-helper-app-service;1'].
|
|
getService(Ci.nsIExternalHelperAppService);
|
|
let channel = aRequest.QueryInterface(Ci.nsIChannel);
|
|
|
|
// First, we'll ensure the filename doesn't have any leading
|
|
// periods. We have to do it here to avoid ending up with a filename
|
|
// that's only an extension with no extension (e.g. Sending in
|
|
// '.jpeg' without stripping the '.' would result in a filename of
|
|
// 'jpeg' where we want 'jpeg.jpeg'.
|
|
_options.filename = _options.filename.replace(/^\.+/, "");
|
|
|
|
let ext = null;
|
|
let mimeSvc = extHelperAppSvc.QueryInterface(Ci.nsIMIMEService);
|
|
try {
|
|
ext = '.' + mimeSvc.getPrimaryExtension(channel.contentType, '');
|
|
} catch (e) { ext = null; }
|
|
|
|
// Check if we need to add an extension to the filename.
|
|
if (ext && !_options.filename.endsWith(ext)) {
|
|
_options.filename += ext;
|
|
}
|
|
// Set the filename to use when saving to disk.
|
|
channel.contentDispositionFilename = _options.filename;
|
|
|
|
this.extListener =
|
|
extHelperAppSvc.doContent(
|
|
channel.contentType,
|
|
aRequest,
|
|
interfaceRequestor,
|
|
true);
|
|
this.extListener.onStartRequest(aRequest, aContext);
|
|
},
|
|
onStopRequest: function(aRequest, aContext, aStatusCode) {
|
|
debug('DownloadListener - onStopRequest (aStatusCode = ' +
|
|
aStatusCode + ')');
|
|
if (aStatusCode == Cr.NS_OK) {
|
|
// Everything looks great.
|
|
debug('DownloadListener - Download Successful.');
|
|
Services.DOMRequest.fireSuccess(req, aStatusCode);
|
|
}
|
|
else {
|
|
// In case of failure, we'll simply return the failure status code.
|
|
debug('DownloadListener - Download Failed!');
|
|
Services.DOMRequest.fireError(req, aStatusCode);
|
|
}
|
|
|
|
if (this.extListener) {
|
|
this.extListener.onStopRequest(aRequest, aContext, aStatusCode);
|
|
}
|
|
},
|
|
onDataAvailable: function(aRequest, aContext, aInputStream,
|
|
aOffset, aCount) {
|
|
this.extListener.onDataAvailable(aRequest, aContext, aInputStream,
|
|
aOffset, aCount);
|
|
},
|
|
QueryInterface: XPCOMUtils.generateQI([Ci.nsIStreamListener,
|
|
Ci.nsIRequestObserver])
|
|
};
|
|
|
|
// If we have a URI we'll use it to get the triggering principal to use,
|
|
// if not available a null principal is acceptable.
|
|
let referrer = null;
|
|
let principal = null;
|
|
if (_options.referrer) {
|
|
// newURI can throw on malformed URIs.
|
|
try {
|
|
referrer = Services.io.newURI(_options.referrer, null, null);
|
|
}
|
|
catch(e) {
|
|
debug('Malformed referrer -- ' + e);
|
|
}
|
|
|
|
// This simply returns null if there is no principal available
|
|
// for the requested uri. This is an acceptable fallback when
|
|
// calling newChannelFromURI2.
|
|
principal =
|
|
Services.scriptSecurityManager.createCodebasePrincipal(
|
|
referrer, this._frameLoader.loadContext.originAttributes);
|
|
}
|
|
|
|
debug('Using principal? ' + !!principal);
|
|
|
|
let channel =
|
|
Services.io.newChannelFromURI2(url,
|
|
null, // No document.
|
|
principal, // Loading principal
|
|
principal, // Triggering principal
|
|
Ci.nsILoadInfo.SEC_NORMAL,
|
|
Ci.nsIContentPolicy.TYPE_OTHER);
|
|
|
|
// XXX We would set private browsing information prior to calling this.
|
|
channel.notificationCallbacks = interfaceRequestor;
|
|
|
|
// Since we're downloading our own local copy we'll want to bypass the
|
|
// cache and local cache if the channel let's us specify this.
|
|
let flags = Ci.nsIChannel.LOAD_CALL_CONTENT_SNIFFERS |
|
|
Ci.nsIChannel.LOAD_BYPASS_CACHE;
|
|
if (channel instanceof Ci.nsICachingChannel) {
|
|
debug('This is a caching channel. Forcing bypass.');
|
|
flags |= Ci.nsICachingChannel.LOAD_BYPASS_LOCAL_CACHE_IF_BUSY;
|
|
}
|
|
|
|
channel.loadFlags |= flags;
|
|
|
|
if (channel instanceof Ci.nsIHttpChannel) {
|
|
debug('Setting HTTP referrer = ' + (referrer && referrer.spec));
|
|
channel.referrer = referrer;
|
|
if (channel instanceof Ci.nsIHttpChannelInternal) {
|
|
channel.forceAllowThirdPartyCookie = true;
|
|
}
|
|
}
|
|
|
|
// Set-up complete, let's get things started.
|
|
channel.asyncOpen(new DownloadListener(), null);
|
|
|
|
return req;
|
|
},
|
|
|
|
getScreenshot: function(_width, _height, _mimeType) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
let width = parseInt(_width);
|
|
let height = parseInt(_height);
|
|
let mimeType = (typeof _mimeType === 'string') ?
|
|
_mimeType.trim().toLowerCase() : 'image/jpeg';
|
|
if (isNaN(width) || isNaN(height) || width < 0 || height < 0) {
|
|
throw Components.Exception("Invalid argument",
|
|
Cr.NS_ERROR_INVALID_ARG);
|
|
}
|
|
|
|
return this._sendDOMRequest('get-screenshot',
|
|
{width: width, height: height,
|
|
mimeType: mimeType});
|
|
},
|
|
|
|
_recvNextPaint: function(data) {
|
|
let listeners = this._nextPaintListeners;
|
|
this._nextPaintListeners = [];
|
|
for (let listener of listeners) {
|
|
try {
|
|
listener.recvNextPaint();
|
|
} catch (e) {
|
|
// If a listener throws we'll continue.
|
|
}
|
|
}
|
|
},
|
|
|
|
addNextPaintListener: function(listener) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
let self = this;
|
|
let run = function() {
|
|
if (self._nextPaintListeners.push(listener) == 1)
|
|
self._sendAsyncMsg('activate-next-paint-listener');
|
|
};
|
|
if (!this._domRequestReady) {
|
|
this._pendingAPICalls.push(run);
|
|
} else {
|
|
run();
|
|
}
|
|
},
|
|
|
|
removeNextPaintListener: function(listener) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
let self = this;
|
|
let run = function() {
|
|
for (let i = self._nextPaintListeners.length - 1; i >= 0; i--) {
|
|
if (self._nextPaintListeners[i] == listener) {
|
|
self._nextPaintListeners.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (self._nextPaintListeners.length == 0)
|
|
self._sendAsyncMsg('deactivate-next-paint-listener');
|
|
};
|
|
if (!this._domRequestReady) {
|
|
this._pendingAPICalls.push(run);
|
|
} else {
|
|
run();
|
|
}
|
|
},
|
|
|
|
setInputMethodActive: function(isActive) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
if (typeof isActive !== 'boolean') {
|
|
throw Components.Exception("Invalid argument",
|
|
Cr.NS_ERROR_INVALID_ARG);
|
|
}
|
|
|
|
return this._sendDOMRequest('set-input-method-active',
|
|
{isActive: isActive});
|
|
},
|
|
|
|
setNFCFocus: function(isFocus) {
|
|
if (!this._isAlive()) {
|
|
throw Components.Exception("Dead content process",
|
|
Cr.NS_ERROR_DOM_INVALID_STATE_ERR);
|
|
}
|
|
|
|
// For now, we use tab id as an identifier to let NFC module know
|
|
// which app is in foreground. But this approach will not work in
|
|
// in-process mode because tab id doesn't exist. Fix bug 1116449
|
|
// if we are going to support in-process mode.
|
|
try {
|
|
var tabId = this._frameLoader.QueryInterface(Ci.nsIFrameLoader)
|
|
.tabParent
|
|
.tabId;
|
|
} catch(e) {
|
|
debug("SetNFCFocus for in-process mode is not yet supported");
|
|
throw Components.Exception("SetNFCFocus for in-process mode is not yet supported",
|
|
Cr.NS_ERROR_NOT_IMPLEMENTED);
|
|
}
|
|
|
|
try {
|
|
let nfcContentHelper =
|
|
Cc["@mozilla.org/nfc/content-helper;1"].getService(Ci.nsINfcBrowserAPI);
|
|
nfcContentHelper.setFocusTab(tabId, isFocus);
|
|
} catch(e) {
|
|
// Not all platforms support NFC
|
|
}
|
|
},
|
|
|
|
getAudioChannelVolume: function(aAudioChannel) {
|
|
return this._sendDOMRequest('get-audio-channel-volume',
|
|
{audioChannel: aAudioChannel});
|
|
},
|
|
|
|
setAudioChannelVolume: function(aAudioChannel, aVolume) {
|
|
return this._sendDOMRequest('set-audio-channel-volume',
|
|
{audioChannel: aAudioChannel,
|
|
volume: aVolume});
|
|
},
|
|
|
|
getAudioChannelMuted: function(aAudioChannel) {
|
|
return this._sendDOMRequest('get-audio-channel-muted',
|
|
{audioChannel: aAudioChannel});
|
|
},
|
|
|
|
setAudioChannelMuted: function(aAudioChannel, aMuted) {
|
|
return this._sendDOMRequest('set-audio-channel-muted',
|
|
{audioChannel: aAudioChannel,
|
|
muted: aMuted});
|
|
},
|
|
|
|
isAudioChannelActive: function(aAudioChannel) {
|
|
return this._sendDOMRequest('get-is-audio-channel-active',
|
|
{audioChannel: aAudioChannel});
|
|
},
|
|
|
|
notifyChannel: function(aEvent, aManifest, aAudioChannel) {
|
|
var self = this;
|
|
var req = Services.DOMRequest.createRequest(self._window);
|
|
|
|
// Since the pageURI of the app has been registered to the system messager,
|
|
// when the app was installed. The system messager can only use the manifest
|
|
// to send the message to correct page.
|
|
let manifestURL = Services.io.newURI(aManifest, null, null);
|
|
systemMessenger.sendMessage(aEvent, aAudioChannel, null, manifestURL)
|
|
.then(function() {
|
|
Services.DOMRequest.fireSuccess(req,
|
|
Cu.cloneInto(true, self._window));
|
|
}, function() {
|
|
debug("Error : NotifyChannel fail.");
|
|
Services.DOMRequest.fireErrorAsync(req,
|
|
Cu.cloneInto("NotifyChannel fail.", self._window));
|
|
});
|
|
return req;
|
|
},
|
|
|
|
getStructuredData: defineDOMRequestMethod('get-structured-data'),
|
|
|
|
getWebManifest: defineDOMRequestMethod('get-web-manifest'),
|
|
/**
|
|
* Called when the visibility of the window which owns this iframe changes.
|
|
*/
|
|
_ownerVisibilityChange: function() {
|
|
this._sendAsyncMsg('owner-visibility-change',
|
|
{visible: !this._window.document.hidden});
|
|
},
|
|
|
|
/*
|
|
* Called when the child notices that its visibility has changed.
|
|
*
|
|
* This is sometimes redundant; for example, the child's visibility may
|
|
* change in response to a setVisible request that we made here! But it's
|
|
* not always redundant; for example, the child's visibility may change in
|
|
* response to its parent docshell being hidden.
|
|
*/
|
|
_childVisibilityChange: function(data) {
|
|
debug("_childVisibilityChange(" + data.json.visible + ")");
|
|
this._frameLoader.visible = data.json.visible;
|
|
|
|
this._fireEventFromMsg(data);
|
|
},
|
|
|
|
_requestedDOMFullscreen: function() {
|
|
this._pendingDOMFullscreen = true;
|
|
this._windowUtils.remoteFrameFullscreenChanged(this._frameElement);
|
|
},
|
|
|
|
_fullscreenOriginChange: function(data) {
|
|
Services.obs.notifyObservers(
|
|
this._frameElement, "fullscreen-origin-change", data.json.originNoSuffix);
|
|
},
|
|
|
|
_exitDomFullscreen: function(data) {
|
|
this._windowUtils.remoteFrameFullscreenReverted();
|
|
},
|
|
|
|
_handleOwnerEvent: function(evt) {
|
|
switch (evt.type) {
|
|
case 'visibilitychange':
|
|
this._ownerVisibilityChange();
|
|
break;
|
|
case 'mozfullscreenchange':
|
|
if (!this._window.document.mozFullScreen) {
|
|
this._sendAsyncMsg('exit-fullscreen');
|
|
} else if (this._pendingDOMFullscreen) {
|
|
this._pendingDOMFullscreen = false;
|
|
this._sendAsyncMsg('entered-fullscreen');
|
|
}
|
|
break;
|
|
}
|
|
},
|
|
|
|
_fireFatalError: function() {
|
|
let evt = this._createEvent('error', {type: 'fatal'},
|
|
/* cancelable = */ false);
|
|
this._frameElement.dispatchEvent(evt);
|
|
},
|
|
|
|
observe: function(subject, topic, data) {
|
|
switch(topic) {
|
|
case 'oop-frameloader-crashed':
|
|
if (this._isAlive() && subject == this._frameLoader) {
|
|
this._fireFatalError();
|
|
}
|
|
break;
|
|
case 'copypaste-docommand':
|
|
if (this._isAlive() && this._frameElement.isEqualNode(subject.wrappedJSObject)) {
|
|
this._sendAsyncMsg('do-command', { command: data });
|
|
}
|
|
break;
|
|
case 'ask-children-to-execute-copypaste-command':
|
|
if (this._isAlive() && this._frameElement == subject.wrappedJSObject) {
|
|
this._sendAsyncMsg('copypaste-do-command', { command: data });
|
|
}
|
|
break;
|
|
case 'back-docommand':
|
|
if (this._isAlive() && this._frameLoader.visible) {
|
|
this.goBack();
|
|
}
|
|
break;
|
|
default:
|
|
debug('Unknown topic: ' + topic);
|
|
break;
|
|
};
|
|
},
|
|
};
|
|
|
|
this.NSGetFactory = XPCOMUtils.generateNSGetFactory([BrowserElementParent]);
|