forked from mirrors/gecko-dev
cdd4391679
This is more consistent with other setters, and lets us handle the null frameLoader case a bit more simply. Differential Revision: https://phabricator.services.mozilla.com/D16370 --HG-- extra : moz-landing-system : lando
1852 lines
57 KiB
JavaScript
1852 lines
57 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";
|
|
|
|
// This is loaded into all XUL windows. Wrap in a block to prevent
|
|
// leaking to window scope.
|
|
{
|
|
|
|
const elementsToDestroyOnUnload = new Set();
|
|
|
|
window.addEventListener("unload", () => {
|
|
for (let element of elementsToDestroyOnUnload.values()) {
|
|
element.destroy();
|
|
}
|
|
elementsToDestroyOnUnload.clear();
|
|
}, { mozSystemGroup: true, once: true });
|
|
|
|
class MozBrowser extends MozElementMixin(XULFrameElement) {
|
|
static get observedAttributes() {
|
|
return ["remote"];
|
|
}
|
|
|
|
attributeChangedCallback(name, oldValue, newValue) {
|
|
// When we have already been set up via connectedCallback and the
|
|
// and the [remote] value changes, we need to start over. This used
|
|
// to happen due to a XBL binding change.
|
|
if (name === "remote" && oldValue != newValue && this.isConnectedAndReady) {
|
|
this.destroy();
|
|
this.construct();
|
|
}
|
|
}
|
|
|
|
constructor() {
|
|
super();
|
|
|
|
this.onPageHide = this.onPageHide.bind(this);
|
|
|
|
/**
|
|
* These are managed by the tabbrowser:
|
|
*/
|
|
this.droppedLinkHandler = null;
|
|
this.mIconURL = null;
|
|
this.lastURI = null;
|
|
|
|
this.addEventListener("keypress", (event) => {
|
|
if (event.keyCode != KeyEvent.DOM_VK_F7) {
|
|
return;
|
|
}
|
|
|
|
if (event.defaultPrevented || !event.isTrusted) {
|
|
return;
|
|
}
|
|
|
|
const kPrefShortcutEnabled = "accessibility.browsewithcaret_shortcut.enabled";
|
|
const kPrefWarnOnEnable = "accessibility.warn_on_browsewithcaret";
|
|
const kPrefCaretBrowsingOn = "accessibility.browsewithcaret";
|
|
|
|
var isEnabled = this.mPrefs.getBoolPref(kPrefShortcutEnabled);
|
|
if (!isEnabled)
|
|
return;
|
|
|
|
// Toggle browse with caret mode
|
|
var browseWithCaretOn = this.mPrefs.getBoolPref(kPrefCaretBrowsingOn, false);
|
|
var warn = this.mPrefs.getBoolPref(kPrefWarnOnEnable, true);
|
|
if (warn && !browseWithCaretOn) {
|
|
var checkValue = { value: false };
|
|
var promptService = Services.prompt;
|
|
|
|
var buttonPressed = promptService.confirmEx(window,
|
|
this.mStrBundle.GetStringFromName("browsewithcaret.checkWindowTitle"),
|
|
this.mStrBundle.GetStringFromName("browsewithcaret.checkLabel"),
|
|
// Make "No" the default:
|
|
promptService.STD_YES_NO_BUTTONS | promptService.BUTTON_POS_1_DEFAULT,
|
|
null, null, null, this.mStrBundle.GetStringFromName("browsewithcaret.checkMsg"),
|
|
checkValue);
|
|
if (buttonPressed != 0) {
|
|
if (checkValue.value) {
|
|
try {
|
|
this.mPrefs.setBoolPref(kPrefShortcutEnabled, false);
|
|
} catch (ex) {}
|
|
}
|
|
return;
|
|
}
|
|
if (checkValue.value) {
|
|
try {
|
|
this.mPrefs.setBoolPref(kPrefWarnOnEnable, false);
|
|
} catch (ex) {}
|
|
}
|
|
}
|
|
|
|
// Toggle the pref
|
|
try {
|
|
this.mPrefs.setBoolPref(kPrefCaretBrowsingOn, !browseWithCaretOn);
|
|
} catch (ex) {}
|
|
}, { mozSystemGroup: true });
|
|
|
|
this.addEventListener("dragover", (event) => {
|
|
if (!this.droppedLinkHandler || event.defaultPrevented) {
|
|
return;
|
|
}
|
|
|
|
// For drags that appear to be internal text (for example, tab drags),
|
|
// set the dropEffect to 'none'. This prevents the drop even if some
|
|
// other listener cancelled the event.
|
|
var types = event.dataTransfer.types;
|
|
if (types.includes("text/x-moz-text-internal") && !types.includes("text/plain")) {
|
|
event.dataTransfer.dropEffect = "none";
|
|
event.stopPropagation();
|
|
event.preventDefault();
|
|
}
|
|
|
|
// No need to handle "dragover" in e10s, since nsDocShellTreeOwner.cpp in the child process
|
|
// handles that case using "@mozilla.org/content/dropped-link-handler;1" service.
|
|
if (this.isRemoteBrowser)
|
|
return;
|
|
|
|
let linkHandler = Services.droppedLinkHandler;
|
|
if (linkHandler.canDropLink(event, false))
|
|
event.preventDefault();
|
|
}, { mozSystemGroup: true });
|
|
|
|
this.addEventListener("drop", (event) => {
|
|
// No need to handle "drop" in e10s, since nsDocShellTreeOwner.cpp in the child process
|
|
// handles that case using "@mozilla.org/content/dropped-link-handler;1" service.
|
|
if (!this.droppedLinkHandler || event.defaultPrevented || this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
|
|
let linkHandler = Services.droppedLinkHandler;
|
|
try {
|
|
// Pass true to prevent the dropping of javascript:/data: URIs
|
|
var links = linkHandler.dropLinks(event, true);
|
|
} catch (ex) {
|
|
return;
|
|
}
|
|
|
|
if (links.length) {
|
|
let triggeringPrincipal = linkHandler.getTriggeringPrincipal(event);
|
|
this.droppedLinkHandler(event, links, triggeringPrincipal);
|
|
}
|
|
}, { mozSystemGroup: true });
|
|
|
|
this.addEventListener("dragstart", (event) => {
|
|
// If we're a remote browser dealing with a dragstart, stop it
|
|
// from propagating up, since our content process should be dealing
|
|
// with the mouse movement.
|
|
if (this.isRemoteBrowser) {
|
|
event.stopPropagation();
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
resetFields() {
|
|
if (this.observer) {
|
|
try {
|
|
Services.obs.removeObserver(this.observer, "browser:purge-session-history");
|
|
} catch (ex) {
|
|
// It's not clear why this sometimes throws an exception.
|
|
}
|
|
this.observer = null;
|
|
}
|
|
|
|
let browser = this;
|
|
this.observer = {
|
|
observe(aSubject, aTopic, aState) {
|
|
if (aTopic == "browser:purge-session-history") {
|
|
browser.purgeSessionHistory();
|
|
} else if (aTopic == "apz:cancel-autoscroll") {
|
|
if (aState == browser._autoScrollScrollId) {
|
|
// Set this._autoScrollScrollId to null, so in stopScroll() we
|
|
// don't call stopApzAutoscroll() (since it's APZ that
|
|
// initiated the stopping).
|
|
browser._autoScrollScrollId = null;
|
|
browser._autoScrollPresShellId = null;
|
|
|
|
browser._autoScrollPopup.hidePopup();
|
|
}
|
|
}
|
|
},
|
|
QueryInterface: ChromeUtils.generateQI([
|
|
Ci.nsIObserver,
|
|
Ci.nsISupportsWeakReference,
|
|
]),
|
|
};
|
|
|
|
|
|
this._documentURI = null;
|
|
|
|
this._documentContentType = null;
|
|
|
|
/**
|
|
* Weak reference to an optional frame loader that can be used to influence
|
|
* process selection for this browser.
|
|
* See nsIBrowser.sameProcessAsFrameLoader.
|
|
*/
|
|
this._sameProcessAsFrameLoader = null;
|
|
|
|
this._loadContext = null;
|
|
|
|
this._imageDocument = null;
|
|
|
|
this._webBrowserFind = null;
|
|
|
|
this._finder = null;
|
|
|
|
this._remoteFinder = null;
|
|
|
|
this._fastFind = null;
|
|
|
|
this._outerWindowID = null;
|
|
|
|
this._innerWindowID = null;
|
|
|
|
this._browsingContextId = null;
|
|
|
|
this._lastSearchString = null;
|
|
|
|
this._controller = null;
|
|
|
|
this._selectParentHelper = null;
|
|
|
|
this._remoteWebNavigation = null;
|
|
|
|
this._remoteWebProgress = null;
|
|
|
|
this._contentTitle = "";
|
|
|
|
this._characterSet = "";
|
|
|
|
this._mayEnableCharacterEncodingMenu = null;
|
|
|
|
this._contentPrincipal = null;
|
|
|
|
this._contentRequestContextID = null;
|
|
|
|
this._fullZoom = 1;
|
|
|
|
this._textZoom = 1;
|
|
|
|
this._isSyntheticDocument = false;
|
|
|
|
this.mPrefs = Services.prefs;
|
|
|
|
this._mStrBundle = null;
|
|
|
|
this.blockedPopups = null;
|
|
|
|
this._audioMuted = false;
|
|
|
|
this._hasAnyPlayingMediaBeenBlocked = false;
|
|
|
|
/**
|
|
* Only send the message "Browser:UnselectedTabHover" when someone requests
|
|
* for the message, which can reduce non-necessary communication.
|
|
*/
|
|
this._shouldSendUnselectedTabHover = false;
|
|
|
|
this._unselectedTabHoverMessageListenerCount = 0;
|
|
|
|
this._securityUI = null;
|
|
|
|
this.urlbarChangeTracker = {
|
|
_startedLoadSinceLastUserTyping: false,
|
|
|
|
startedLoad() {
|
|
this._startedLoadSinceLastUserTyping = true;
|
|
},
|
|
finishedLoad() {
|
|
this._startedLoadSinceLastUserTyping = false;
|
|
},
|
|
userTyped() {
|
|
this._startedLoadSinceLastUserTyping = false;
|
|
},
|
|
};
|
|
|
|
this._userTypedValue = null;
|
|
|
|
this._AUTOSCROLL_SNAP = 10;
|
|
|
|
this._scrolling = false;
|
|
|
|
this._startX = null;
|
|
|
|
this._startY = null;
|
|
|
|
this._autoScrollPopup = null;
|
|
|
|
this._autoScrollNeedsCleanup = false;
|
|
|
|
/**
|
|
* These IDs identify the scroll frame being autoscrolled.
|
|
*/
|
|
this._autoScrollScrollId = null;
|
|
|
|
this._autoScrollPresShellId = null;
|
|
|
|
this._permitUnloadId = 0;
|
|
}
|
|
|
|
connectedCallback() {
|
|
// We typically use this to avoid running JS that triggers a layout during parse
|
|
// (see comment on the delayConnectedCallback implementation). In this case, we
|
|
// are using it to avoid a leak - see https://bugzilla.mozilla.org/show_bug.cgi?id=1441935#c20.
|
|
if (this.delayConnectedCallback()) {
|
|
return;
|
|
}
|
|
|
|
this.construct();
|
|
}
|
|
|
|
disconnectedCallback() {
|
|
this.destroy();
|
|
}
|
|
|
|
get autoscrollEnabled() {
|
|
if (this.getAttribute("autoscroll") == "false")
|
|
return false;
|
|
|
|
return this.mPrefs.getBoolPref("general.autoScroll", true);
|
|
}
|
|
|
|
get canGoBack() {
|
|
return this.webNavigation.canGoBack;
|
|
}
|
|
|
|
get canGoForward() {
|
|
return this.webNavigation.canGoForward;
|
|
}
|
|
|
|
get currentURI() {
|
|
if (this.webNavigation) {
|
|
return this.webNavigation.currentURI;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
get documentURI() {
|
|
return this.isRemoteBrowser ? this._documentURI : this.contentDocument.documentURIObject;
|
|
}
|
|
|
|
get documentContentType() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._documentContentType;
|
|
}
|
|
return this.contentDocument ? this.contentDocument.contentType : null;
|
|
}
|
|
|
|
set sameProcessAsFrameLoader(val) {
|
|
this._sameProcessAsFrameLoader = Cu.getWeakReference(val);
|
|
}
|
|
|
|
get sameProcessAsFrameLoader() {
|
|
return this._sameProcessAsFrameLoader && this._sameProcessAsFrameLoader.get();
|
|
}
|
|
|
|
get loadContext() {
|
|
if (this._loadContext)
|
|
return this._loadContext;
|
|
|
|
let { frameLoader } = this;
|
|
if (!frameLoader)
|
|
return null;
|
|
this._loadContext = frameLoader.loadContext;
|
|
return this._loadContext;
|
|
}
|
|
|
|
get autoCompletePopup() {
|
|
return document.getElementById(this.getAttribute("autocompletepopup"));
|
|
}
|
|
|
|
get dateTimePicker() {
|
|
return document.getElementById(this.getAttribute("datetimepicker"));
|
|
}
|
|
|
|
set docShellIsActive(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
frameLoader.tabParent.docShellIsActive = val;
|
|
}
|
|
} else if (this.docShell) {
|
|
this.docShell.isActive = val;
|
|
}
|
|
}
|
|
|
|
get docShellIsActive() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
return frameLoader.tabParent.docShellIsActive;
|
|
}
|
|
return false;
|
|
}
|
|
return this.docShell && this.docShell.isActive;
|
|
}
|
|
|
|
set renderLayers(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
frameLoader.tabParent.renderLayers = val;
|
|
}
|
|
} else {
|
|
this.docShellIsActive = val;
|
|
}
|
|
}
|
|
|
|
get renderLayers() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
return frameLoader.tabParent.renderLayers;
|
|
}
|
|
return false;
|
|
}
|
|
return this.docShellIsActive;
|
|
}
|
|
|
|
get hasLayers() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
return frameLoader.tabParent.hasLayers;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return this.docShellIsActive;
|
|
}
|
|
|
|
get imageDocument() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._imageDocument;
|
|
}
|
|
var document = this.contentDocument;
|
|
if (!document || !(document instanceof Ci.nsIImageDocument))
|
|
return null;
|
|
|
|
try {
|
|
return { width: document.imageRequest.image.width, height: document.imageRequest.image.height };
|
|
} catch (e) {}
|
|
return null;
|
|
}
|
|
|
|
get isRemoteBrowser() {
|
|
return (this.getAttribute("remote") == "true");
|
|
}
|
|
|
|
get remoteType() {
|
|
if (!this.isRemoteBrowser) {
|
|
return null;
|
|
}
|
|
|
|
let remoteType = this.getAttribute("remoteType");
|
|
if (remoteType) {
|
|
return remoteType;
|
|
}
|
|
|
|
let E10SUtils = ChromeUtils.import("resource://gre/modules/E10SUtils.jsm", {}).E10SUtils;
|
|
return E10SUtils.DEFAULT_REMOTE_TYPE;
|
|
}
|
|
|
|
get messageManager() {
|
|
if (this.frameLoader) {
|
|
return this.frameLoader.messageManager;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
get webBrowserFind() {
|
|
if (!this._webBrowserFind)
|
|
this._webBrowserFind = this.docShell.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIWebBrowserFind);
|
|
return this._webBrowserFind;
|
|
}
|
|
|
|
get finder() {
|
|
if (this.isRemoteBrowser) {
|
|
if (!this._remoteFinder) {
|
|
// Don't attempt to create the remote finder if the
|
|
// messageManager has already gone away
|
|
if (!this.messageManager)
|
|
return null;
|
|
|
|
let jsm = "resource://gre/modules/FinderParent.jsm";
|
|
let { FinderParent } = ChromeUtils.import(jsm, {});
|
|
this._remoteFinder = new FinderParent(this);
|
|
}
|
|
return this._remoteFinder;
|
|
}
|
|
if (!this._finder) {
|
|
if (!this.docShell)
|
|
return null;
|
|
|
|
let Finder = ChromeUtils.import("resource://gre/modules/Finder.jsm", {}).Finder;
|
|
this._finder = new Finder(this.docShell);
|
|
}
|
|
return this._finder;
|
|
}
|
|
|
|
get fastFind() {
|
|
if (!this._fastFind) {
|
|
if (!("@mozilla.org/typeaheadfind;1" in Cc))
|
|
return null;
|
|
|
|
var tabBrowser = this.getTabBrowser();
|
|
if (tabBrowser && "fastFind" in tabBrowser)
|
|
return this._fastFind = tabBrowser.fastFind;
|
|
|
|
if (!this.docShell)
|
|
return null;
|
|
|
|
this._fastFind = Cc["@mozilla.org/typeaheadfind;1"]
|
|
.createInstance(Ci.nsITypeAheadFind);
|
|
this._fastFind.init(this.docShell);
|
|
}
|
|
return this._fastFind;
|
|
}
|
|
|
|
get outerWindowID() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._outerWindowID;
|
|
}
|
|
return this.docShell.outerWindowID;
|
|
}
|
|
|
|
get innerWindowID() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._innerWindowID;
|
|
}
|
|
try {
|
|
return this.contentWindow.windowUtils.currentInnerWindowID;
|
|
} catch (e) {
|
|
if (e.result != Cr.NS_ERROR_NOT_AVAILABLE) {
|
|
throw e;
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
|
|
get browsingContext() {
|
|
if (!this.isRemoteBrowser) {
|
|
return this.docShell.browsingContext;
|
|
}
|
|
|
|
return ChromeUtils.getBrowsingContext(this._browsingContextId);
|
|
}
|
|
/**
|
|
* Note that this overrides webNavigation on XULFrameElement, and duplicates the return value for the non-remote case
|
|
*/
|
|
get webNavigation() {
|
|
return this.isRemoteBrowser ? this._remoteWebNavigation : this.docShell && this.docShell.QueryInterface(Ci.nsIWebNavigation);
|
|
}
|
|
|
|
get webProgress() {
|
|
return this.isRemoteBrowser ? this._remoteWebProgress : this.docShell && this.docShell.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIWebProgress);
|
|
}
|
|
|
|
get sessionHistory() {
|
|
return this.webNavigation.sessionHistory;
|
|
}
|
|
|
|
get markupDocumentViewer() {
|
|
return this.docShell.contentViewer;
|
|
}
|
|
|
|
get contentTitle() {
|
|
return this.isRemoteBrowser ? this._contentTitle : this.contentDocument.title;
|
|
}
|
|
|
|
set characterSet(val) {
|
|
if (this.isRemoteBrowser) {
|
|
this.messageManager.sendAsyncMessage("UpdateCharacterSet", { value: val });
|
|
this._characterSet = val;
|
|
} else {
|
|
this.docShell.charset = val;
|
|
this.docShell.gatherCharsetMenuTelemetry();
|
|
}
|
|
}
|
|
|
|
get characterSet() {
|
|
return this.isRemoteBrowser ? this._characterSet : this.docShell.charset;
|
|
}
|
|
|
|
get mayEnableCharacterEncodingMenu() {
|
|
return this.isRemoteBrowser ? this._mayEnableCharacterEncodingMenu : this.docShell.mayEnableCharacterEncodingMenu;
|
|
}
|
|
|
|
get contentPrincipal() {
|
|
return this.isRemoteBrowser ? this._contentPrincipal : this.contentDocument.nodePrincipal;
|
|
}
|
|
|
|
get contentRequestContextID() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._contentRequestContextID;
|
|
}
|
|
try {
|
|
return this.contentDocument.documentLoadGroup
|
|
.requestContextID;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
set showWindowResizer(val) {
|
|
if (val) {
|
|
this.setAttribute("showresizer", "true");
|
|
} else {
|
|
this.removeAttribute("showresizer");
|
|
}
|
|
}
|
|
|
|
get showWindowResizer() {
|
|
return this.getAttribute("showresizer") == "true";
|
|
}
|
|
|
|
set fullZoom(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let changed = val.toFixed(2) != this._fullZoom.toFixed(2);
|
|
|
|
if (changed) {
|
|
this._fullZoom = val;
|
|
try {
|
|
this.messageManager.sendAsyncMessage("FullZoom", { value: val });
|
|
} catch (ex) {}
|
|
|
|
let event = new Event("FullZoomChange", { bubbles: true });
|
|
this.dispatchEvent(event);
|
|
}
|
|
} else {
|
|
this.markupDocumentViewer.fullZoom = val;
|
|
}
|
|
}
|
|
|
|
get fullZoom() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._fullZoom;
|
|
}
|
|
return this.markupDocumentViewer.fullZoom;
|
|
}
|
|
|
|
set textZoom(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let changed = val.toFixed(2) != this._textZoom.toFixed(2);
|
|
|
|
if (changed) {
|
|
this._textZoom = val;
|
|
try {
|
|
this.messageManager.sendAsyncMessage("TextZoom", { value: val });
|
|
} catch (ex) {}
|
|
|
|
let event = new Event("TextZoomChange", { bubbles: true });
|
|
this.dispatchEvent(event);
|
|
}
|
|
} else {
|
|
this.markupDocumentViewer.textZoom = val;
|
|
}
|
|
|
|
}
|
|
|
|
get textZoom() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._textZoom;
|
|
}
|
|
return this.markupDocumentViewer.textZoom;
|
|
}
|
|
|
|
get isSyntheticDocument() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._isSyntheticDocument;
|
|
}
|
|
return this.contentDocument.mozSyntheticDocument;
|
|
}
|
|
|
|
get hasContentOpener() {
|
|
if (this.isRemoteBrowser) {
|
|
return this.frameLoader.tabParent.hasContentOpener;
|
|
}
|
|
return !!this.contentWindow.opener;
|
|
}
|
|
|
|
get mStrBundle() {
|
|
if (!this._mStrBundle) {
|
|
// need to create string bundle manually instead of using <xul:stringbundle/>
|
|
// see bug 63370 for details
|
|
this._mStrBundle = Services.strings
|
|
.createBundle("chrome://global/locale/browser.properties");
|
|
}
|
|
return this._mStrBundle;
|
|
}
|
|
|
|
get audioMuted() {
|
|
return this._audioMuted;
|
|
}
|
|
|
|
get shouldHandleUnselectedTabHover() {
|
|
return this._shouldSendUnselectedTabHover;
|
|
}
|
|
|
|
get securityUI() {
|
|
if (this.isRemoteBrowser) {
|
|
if (!this._securityUI) {
|
|
// Don't attempt to create the remote web progress if the
|
|
// messageManager has already gone away
|
|
if (!this.messageManager)
|
|
return null;
|
|
|
|
let jsm = "resource://gre/modules/RemoteSecurityUI.jsm";
|
|
let RemoteSecurityUI = ChromeUtils.import(jsm, {}).RemoteSecurityUI;
|
|
this._securityUI = new RemoteSecurityUI();
|
|
}
|
|
|
|
// We want to double-wrap the JS implemented interface, so that QI and instanceof works.
|
|
var ptr = Cc["@mozilla.org/supports-interface-pointer;1"]
|
|
.createInstance(Ci.nsISupportsInterfacePointer);
|
|
ptr.data = this._securityUI;
|
|
return ptr.data.QueryInterface(Ci.nsISecureBrowserUI);
|
|
}
|
|
|
|
if (!this.docShell.securityUI) {
|
|
const SECUREBROWSERUI_CONTRACTID = "@mozilla.org/secure_browser_ui;1";
|
|
var securityUI = Cc[SECUREBROWSERUI_CONTRACTID]
|
|
.createInstance(Ci.nsISecureBrowserUI);
|
|
securityUI.init(this.docShell);
|
|
}
|
|
|
|
return this.docShell.securityUI;
|
|
}
|
|
|
|
set userTypedValue(val) {
|
|
this.urlbarChangeTracker.userTyped();
|
|
this._userTypedValue = val;
|
|
}
|
|
|
|
get userTypedValue() {
|
|
return this._userTypedValue;
|
|
}
|
|
|
|
get dontPromptAndDontUnload() {
|
|
return 1;
|
|
}
|
|
|
|
get dontPromptAndUnload() {
|
|
return 2;
|
|
}
|
|
|
|
_wrapURIChangeCall(fn) {
|
|
if (!this.isRemoteBrowser) {
|
|
this.inLoadURI = true;
|
|
try {
|
|
fn();
|
|
} finally {
|
|
this.inLoadURI = false;
|
|
}
|
|
} else {
|
|
fn();
|
|
}
|
|
}
|
|
|
|
goBack() {
|
|
var webNavigation = this.webNavigation;
|
|
if (webNavigation.canGoBack)
|
|
this._wrapURIChangeCall(() => webNavigation.goBack());
|
|
}
|
|
|
|
goForward() {
|
|
var webNavigation = this.webNavigation;
|
|
if (webNavigation.canGoForward)
|
|
this._wrapURIChangeCall(() => webNavigation.goForward());
|
|
}
|
|
|
|
reload() {
|
|
const nsIWebNavigation = Ci.nsIWebNavigation;
|
|
const flags = nsIWebNavigation.LOAD_FLAGS_NONE;
|
|
this.reloadWithFlags(flags);
|
|
}
|
|
|
|
reloadWithFlags(aFlags) {
|
|
this.webNavigation.reload(aFlags);
|
|
}
|
|
|
|
stop() {
|
|
const nsIWebNavigation = Ci.nsIWebNavigation;
|
|
const flags = nsIWebNavigation.STOP_ALL;
|
|
this.webNavigation.stop(flags);
|
|
}
|
|
|
|
/**
|
|
* throws exception for unknown schemes
|
|
*/
|
|
loadURI(aURI, aParams) {
|
|
if (!aURI) {
|
|
aURI = "about:blank";
|
|
}
|
|
|
|
let {
|
|
flags = Ci.nsIWebNavigation.LOAD_FLAGS_NONE,
|
|
referrerURI,
|
|
referrerPolicy = Ci.nsIHttpChannel.REFERRER_POLICY_UNSET,
|
|
triggeringPrincipal,
|
|
postData,
|
|
} = aParams || {};
|
|
let loadURIOptions = {
|
|
triggeringPrincipal,
|
|
referrerURI,
|
|
loadFlags: flags,
|
|
referrerPolicy,
|
|
postData,
|
|
};
|
|
this._wrapURIChangeCall(() =>
|
|
this.webNavigation.loadURI(aURI, loadURIOptions));
|
|
}
|
|
|
|
gotoIndex(aIndex) {
|
|
this._wrapURIChangeCall(() => this.webNavigation.gotoIndex(aIndex));
|
|
}
|
|
|
|
/**
|
|
* Used by session restore to ensure that currentURI is set so
|
|
* that switch-to-tab works before the tab is fully
|
|
* restored. This function also invokes onLocationChanged
|
|
* listeners in tabbrowser.xml.
|
|
*/
|
|
_setCurrentURI(aURI) {
|
|
if (this.isRemoteBrowser) {
|
|
this._remoteWebProgressManager.setCurrentURI(aURI);
|
|
} else {
|
|
this.docShell.setCurrentURI(aURI);
|
|
}
|
|
}
|
|
|
|
preserveLayers(preserve) {
|
|
if (!this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
let { frameLoader } = this;
|
|
if (frameLoader.tabParent) {
|
|
frameLoader.tabParent.preserveLayers(preserve);
|
|
}
|
|
}
|
|
|
|
deprioritize() {
|
|
if (!this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
let { frameLoader } = this;
|
|
if (frameLoader.tabParent) {
|
|
frameLoader.tabParent.deprioritize();
|
|
}
|
|
}
|
|
|
|
forceRepaint() {
|
|
if (!this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.tabParent) {
|
|
frameLoader.tabParent.forceRepaint();
|
|
}
|
|
}
|
|
|
|
getTabBrowser() {
|
|
if (this.ownerGlobal.gBrowser &&
|
|
this.ownerGlobal.gBrowser.getTabForBrowser &&
|
|
this.ownerGlobal.gBrowser.getTabForBrowser(this)) {
|
|
return this.ownerGlobal.gBrowser;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
addProgressListener(aListener, aNotifyMask) {
|
|
if (!aNotifyMask) {
|
|
aNotifyMask = Ci.nsIWebProgress.NOTIFY_ALL;
|
|
}
|
|
this.webProgress.addProgressListener(aListener, aNotifyMask);
|
|
}
|
|
|
|
removeProgressListener(aListener) {
|
|
this.webProgress.removeProgressListener(aListener);
|
|
}
|
|
|
|
onPageHide(aEvent) {
|
|
if (!this.docShell || !this.fastFind)
|
|
return;
|
|
var tabBrowser = this.getTabBrowser();
|
|
if (!tabBrowser || !("fastFind" in tabBrowser) ||
|
|
tabBrowser.selectedBrowser == this)
|
|
this.fastFind.setDocShell(this.docShell);
|
|
}
|
|
|
|
updateBlockedPopups() {
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMUpdateBlockedPopups", true, true);
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
retrieveListOfBlockedPopups() {
|
|
this.messageManager.sendAsyncMessage("PopupBlocking:GetBlockedPopupList", null);
|
|
return new Promise(resolve => {
|
|
let self = this;
|
|
this.messageManager.addMessageListener("PopupBlocking:ReplyGetBlockedPopupList",
|
|
function replyReceived(msg) {
|
|
self.messageManager.removeMessageListener("PopupBlocking:ReplyGetBlockedPopupList",
|
|
replyReceived);
|
|
resolve(msg.data.popupData);
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
unblockPopup(aPopupIndex) {
|
|
this.messageManager.sendAsyncMessage("PopupBlocking:UnblockPopup", { index: aPopupIndex });
|
|
}
|
|
|
|
audioPlaybackStarted() {
|
|
if (this._audioMuted) {
|
|
return;
|
|
}
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMAudioPlaybackStarted", true, false);
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
audioPlaybackStopped() {
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMAudioPlaybackStopped", true, false);
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
notifyGloballyAutoplayBlocked() {
|
|
let event = document.createEvent("CustomEvent");
|
|
event.initCustomEvent("GloballyAutoplayBlocked", true, false, {
|
|
url: this.documentURI,
|
|
});
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
/**
|
|
* When the pref "media.block-autoplay-until-in-foreground" is on,
|
|
* Gecko delays starting playback of media resources in tabs until the
|
|
* tab has been in the foreground or resumed by tab's play tab icon.
|
|
* - When Gecko delays starting playback of a media resource in a window,
|
|
* it sends a message to call activeMediaBlockStarted(). This causes the
|
|
* tab audio indicator to show.
|
|
* - When a tab is foregrounded, Gecko starts playing all delayed media
|
|
* resources in that tab, and sends a message to call
|
|
* activeMediaBlockStopped(). This causes the tab audio indicator to hide.
|
|
*/
|
|
activeMediaBlockStarted() {
|
|
this._hasAnyPlayingMediaBeenBlocked = true;
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMAudioPlaybackBlockStarted", true, false);
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
activeMediaBlockStopped() {
|
|
if (!this._hasAnyPlayingMediaBeenBlocked) {
|
|
return;
|
|
}
|
|
this._hasAnyPlayingMediaBeenBlocked = false;
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMAudioPlaybackBlockStopped", true, false);
|
|
this.dispatchEvent(event);
|
|
}
|
|
|
|
mute(transientState) {
|
|
if (!transientState) {
|
|
this._audioMuted = true;
|
|
}
|
|
this.messageManager.sendAsyncMessage("AudioPlayback", { type: "mute" });
|
|
}
|
|
|
|
unmute() {
|
|
this._audioMuted = false;
|
|
this.messageManager.sendAsyncMessage("AudioPlayback", { type: "unmute" });
|
|
}
|
|
|
|
pauseMedia(disposable) {
|
|
let suspendedReason;
|
|
if (disposable) {
|
|
suspendedReason = "mediaControlPaused";
|
|
} else {
|
|
suspendedReason = "lostAudioFocusTransiently";
|
|
}
|
|
|
|
this.messageManager.sendAsyncMessage("AudioPlayback", { type: suspendedReason });
|
|
}
|
|
|
|
stopMedia() {
|
|
this.messageManager.sendAsyncMessage("AudioPlayback", { type: "mediaControlStopped" });
|
|
}
|
|
|
|
resumeMedia() {
|
|
this.messageManager.sendAsyncMessage("AudioPlayback", { type: "resumeMedia" });
|
|
if (this._hasAnyPlayingMediaBeenBlocked) {
|
|
this._hasAnyPlayingMediaBeenBlocked = false;
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("DOMAudioPlaybackBlockStopped", true, false);
|
|
this.dispatchEvent(event);
|
|
}
|
|
}
|
|
|
|
unselectedTabHover(hovered) {
|
|
if (!this._shouldSendUnselectedTabHover) {
|
|
return;
|
|
}
|
|
this.messageManager.sendAsyncMessage("Browser:UnselectedTabHover", { hovered });
|
|
}
|
|
|
|
didStartLoadSinceLastUserTyping() {
|
|
return !this.inLoadURI &&
|
|
this.urlbarChangeTracker._startedLoadSinceLastUserTyping;
|
|
}
|
|
|
|
construct() {
|
|
elementsToDestroyOnUnload.add(this);
|
|
this.resetFields();
|
|
this.mInitialized = true;
|
|
if (this.isRemoteBrowser) {
|
|
/*
|
|
* Don't try to send messages from this function. The message manager for
|
|
* the <browser> element may not be initialized yet.
|
|
*/
|
|
|
|
this._remoteWebNavigation = Cc["@mozilla.org/remote-web-navigation;1"]
|
|
.createInstance(Ci.nsIWebNavigation);
|
|
this._remoteWebNavigationImpl = this._remoteWebNavigation.wrappedJSObject;
|
|
this._remoteWebNavigationImpl.swapBrowser(this);
|
|
|
|
// Initialize contentPrincipal to the about:blank principal for this loadcontext
|
|
let { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm", {});
|
|
let aboutBlank = Services.io.newURI("about:blank");
|
|
let ssm = Services.scriptSecurityManager;
|
|
this._contentPrincipal = ssm.getLoadContextCodebasePrincipal(aboutBlank, this.loadContext);
|
|
|
|
this.messageManager.addMessageListener("Browser:Init", this);
|
|
this.messageManager.addMessageListener("DOMTitleChanged", this);
|
|
this.messageManager.addMessageListener("ImageDocumentLoaded", this);
|
|
this.messageManager.addMessageListener("FullZoomChange", this);
|
|
this.messageManager.addMessageListener("TextZoomChange", this);
|
|
this.messageManager.addMessageListener("ZoomChangeUsingMouseWheel", this);
|
|
|
|
// browser-child messages, such as Content:LocationChange, are handled in
|
|
// RemoteWebProgress, ensure it is loaded and ready.
|
|
let jsm = "resource://gre/modules/RemoteWebProgress.jsm";
|
|
let { RemoteWebProgressManager } = ChromeUtils.import(jsm, {});
|
|
|
|
let oldManager = this._remoteWebProgressManager;
|
|
this._remoteWebProgressManager = new RemoteWebProgressManager(this);
|
|
if (oldManager) {
|
|
// We're transitioning from one remote type to another. This means that
|
|
// the RemoteWebProgress listener is listening to the old message manager,
|
|
// and needs to be pointed at the new one.
|
|
this._remoteWebProgressManager.swapListeners(oldManager);
|
|
}
|
|
|
|
this._remoteWebProgress = this._remoteWebProgressManager.topLevelWebProgress;
|
|
|
|
this.messageManager.loadFrameScript("chrome://global/content/browser-child.js", true);
|
|
|
|
if (this.hasAttribute("selectmenulist")) {
|
|
this.messageManager.addMessageListener("Forms:ShowDropDown", this);
|
|
this.messageManager.addMessageListener("Forms:HideDropDown", this);
|
|
}
|
|
|
|
if (!this.hasAttribute("disablehistory")) {
|
|
Services.obs.addObserver(this.observer, "browser:purge-session-history", true);
|
|
}
|
|
|
|
let rc_js = "resource://gre/modules/RemoteController.js";
|
|
let scope = {};
|
|
Services.scriptloader.loadSubScript(rc_js, scope);
|
|
let RemoteController = scope.RemoteController;
|
|
this._controller = new RemoteController(this);
|
|
this.controllers.appendController(this._controller);
|
|
}
|
|
|
|
try {
|
|
// |webNavigation.sessionHistory| will have been set by the frame
|
|
// loader when creating the docShell as long as this xul:browser
|
|
// doesn't have the 'disablehistory' attribute set.
|
|
if (this.docShell && this.webNavigation.sessionHistory) {
|
|
Services.obs.addObserver(this.observer, "browser:purge-session-history", true);
|
|
|
|
// enable global history if we weren't told otherwise
|
|
if (!this.hasAttribute("disableglobalhistory") && !this.isRemoteBrowser) {
|
|
try {
|
|
this.docShell.useGlobalHistory = true;
|
|
} catch (ex) {
|
|
// This can occur if the Places database is locked
|
|
Cu.reportError("Error enabling browser global history: " + ex);
|
|
}
|
|
}
|
|
}
|
|
} catch (e) {
|
|
Cu.reportError(e);
|
|
}
|
|
try {
|
|
// Ensures the securityUI is initialized.
|
|
var securityUI = this.securityUI; // eslint-disable-line no-unused-vars
|
|
} catch (e) {}
|
|
|
|
// tabbrowser.xml sets "sameProcessAsFrameLoader" as a direct property
|
|
// on some browsers before they are put into a DOM (and get a
|
|
// binding). This hack makes sure that we hold a weak reference to
|
|
// the other browser (and go through the proper getter and setter).
|
|
if (this.hasOwnProperty("sameProcessAsFrameLoader")) {
|
|
var sameProcessAsFrameLoader = this.sameProcessAsFrameLoader;
|
|
delete this.sameProcessAsFrameLoader;
|
|
this.sameProcessAsFrameLoader = sameProcessAsFrameLoader;
|
|
}
|
|
|
|
if (!this.isRemoteBrowser) {
|
|
// If we've transitioned from remote to non-remote, we'll give up trying to
|
|
// keep the web progress listeners persisted during the transition.
|
|
delete this._remoteWebProgressManager;
|
|
delete this._remoteWebProgress;
|
|
|
|
this.addEventListener("pagehide", this.onPageHide, true);
|
|
}
|
|
|
|
if (this.messageManager) {
|
|
this.messageManager.addMessageListener("PopupBlocking:UpdateBlockedPopups", this);
|
|
this.messageManager.addMessageListener("Autoscroll:Start", this);
|
|
this.messageManager.addMessageListener("Autoscroll:Cancel", this);
|
|
this.messageManager.addMessageListener("AudioPlayback:Start", this);
|
|
this.messageManager.addMessageListener("AudioPlayback:Stop", this);
|
|
this.messageManager.addMessageListener("AudioPlayback:ActiveMediaBlockStart", this);
|
|
this.messageManager.addMessageListener("AudioPlayback:ActiveMediaBlockStop", this);
|
|
this.messageManager.addMessageListener("UnselectedTabHover:Toggle", this);
|
|
this.messageManager.addMessageListener("GloballyAutoplayBlocked", this);
|
|
|
|
if (this.hasAttribute("selectmenulist")) {
|
|
this.messageManager.addMessageListener("Forms:ShowDropDown", this);
|
|
this.messageManager.addMessageListener("Forms:HideDropDown", this);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This is necessary because the destructor doesn't always get called when
|
|
* we are removed from a tabbrowser. This will be explicitly called by tabbrowser.
|
|
*/
|
|
destroy() {
|
|
elementsToDestroyOnUnload.delete(this);
|
|
|
|
// Make sure that any open select is closed.
|
|
if (this._selectParentHelper) {
|
|
let menulist = document.getElementById(this.getAttribute("selectmenulist"));
|
|
this._selectParentHelper.hide(menulist, this);
|
|
}
|
|
|
|
this.resetFields();
|
|
|
|
if (!this.mInitialized)
|
|
return;
|
|
|
|
this.mInitialized = false;
|
|
|
|
if (this.isRemoteBrowser) {
|
|
try {
|
|
this.controllers.removeController(this._controller);
|
|
} catch (ex) {
|
|
// This can fail when this browser element is not attached to a
|
|
// BrowserDOMWindow.
|
|
}
|
|
return;
|
|
}
|
|
|
|
this.lastURI = null;
|
|
|
|
if (!this.isRemoteBrowser) {
|
|
this.removeEventListener("pagehide", this.onPageHide, true);
|
|
}
|
|
|
|
if (this._autoScrollNeedsCleanup) {
|
|
// we polluted the global scope, so clean it up
|
|
this._autoScrollPopup.remove();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* We call this _receiveMessage (and alias receiveMessage to it) so that
|
|
* bindings that inherit from this one can delegate to it.
|
|
*/
|
|
_receiveMessage(aMessage) {
|
|
let data = aMessage.data;
|
|
switch (aMessage.name) {
|
|
case "PopupBlocking:UpdateBlockedPopups":
|
|
{
|
|
this.blockedPopups = {
|
|
length: data.count,
|
|
reported: !data.freshPopup,
|
|
};
|
|
|
|
this.updateBlockedPopups();
|
|
break;
|
|
}
|
|
case "Autoscroll:Start":
|
|
{
|
|
if (!this.autoscrollEnabled) {
|
|
return { autoscrollEnabled: false, usingApz: false };
|
|
}
|
|
this.startScroll(data.scrolldir, data.screenX, data.screenY);
|
|
let usingApz = false;
|
|
if (this.isRemoteBrowser && data.scrollId != null &&
|
|
this.mPrefs.getBoolPref("apz.autoscroll.enabled", false)) {
|
|
let { tabParent } = this.frameLoader;
|
|
if (tabParent) {
|
|
// If APZ is handling the autoscroll, it may decide to cancel
|
|
// it of its own accord, so register an observer to allow it
|
|
// to notify us of that.
|
|
var os = Services.obs;
|
|
os.addObserver(this.observer, "apz:cancel-autoscroll", true);
|
|
|
|
usingApz = tabParent.startApzAutoscroll(
|
|
data.screenX, data.screenY,
|
|
data.scrollId, data.presShellId);
|
|
}
|
|
// Save the IDs for later
|
|
this._autoScrollScrollId = data.scrollId;
|
|
this._autoScrollPresShellId = data.presShellId;
|
|
}
|
|
return { autoscrollEnabled: true, usingApz };
|
|
}
|
|
case "Autoscroll:Cancel":
|
|
this._autoScrollPopup.hidePopup();
|
|
break;
|
|
case "AudioPlayback:Start":
|
|
this.audioPlaybackStarted();
|
|
break;
|
|
case "AudioPlayback:Stop":
|
|
this.audioPlaybackStopped();
|
|
break;
|
|
case "AudioPlayback:ActiveMediaBlockStart":
|
|
this.activeMediaBlockStarted();
|
|
break;
|
|
case "AudioPlayback:ActiveMediaBlockStop":
|
|
this.activeMediaBlockStopped();
|
|
break;
|
|
case "UnselectedTabHover:Toggle":
|
|
this._shouldSendUnselectedTabHover = data.enable ?
|
|
++this._unselectedTabHoverMessageListenerCount > 0 :
|
|
--this._unselectedTabHoverMessageListenerCount == 0;
|
|
break;
|
|
case "GloballyAutoplayBlocked":
|
|
this.notifyGloballyAutoplayBlocked();
|
|
break;
|
|
case "Forms:ShowDropDown":
|
|
{
|
|
if (!this._selectParentHelper) {
|
|
this._selectParentHelper =
|
|
ChromeUtils.import("resource://gre/modules/SelectParentHelper.jsm", {}).SelectParentHelper;
|
|
}
|
|
|
|
let menulist = document.getElementById(this.getAttribute("selectmenulist"));
|
|
menulist.menupopup.style.direction = data.direction;
|
|
this._selectParentHelper.populate(menulist, data.options, data.selectedIndex, this._fullZoom,
|
|
data.uaSelectBackgroundColor, data.uaSelectColor,
|
|
data.selectBackgroundColor, data.selectColor, data.selectTextShadow);
|
|
this._selectParentHelper.open(this, menulist, data.rect, data.isOpenedViaTouch);
|
|
break;
|
|
}
|
|
|
|
case "Forms:HideDropDown":
|
|
{
|
|
if (this._selectParentHelper) {
|
|
let menulist = document.getElementById(this.getAttribute("selectmenulist"));
|
|
this._selectParentHelper.hide(menulist, this);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
receiveMessage(aMessage) {
|
|
if (!this.isRemoteBrowser) {
|
|
return this._receiveMessage(aMessage);
|
|
}
|
|
|
|
let data = aMessage.data;
|
|
switch (aMessage.name) {
|
|
case "Browser:Init":
|
|
this._outerWindowID = data.outerWindowID;
|
|
this._browsingContextId = data.browsingContextId;
|
|
break;
|
|
case "DOMTitleChanged":
|
|
this._contentTitle = data.title;
|
|
break;
|
|
case "ImageDocumentLoaded":
|
|
this._imageDocument = {
|
|
width: data.width,
|
|
height: data.height,
|
|
};
|
|
break;
|
|
|
|
case "Forms:ShowDropDown":
|
|
{
|
|
if (!this._selectParentHelper) {
|
|
this._selectParentHelper =
|
|
ChromeUtils.import("resource://gre/modules/SelectParentHelper.jsm", {}).SelectParentHelper;
|
|
}
|
|
|
|
let menulist = document.getElementById(this.getAttribute("selectmenulist"));
|
|
menulist.menupopup.style.direction = data.direction;
|
|
|
|
let zoom = Services.prefs.getBoolPref("browser.zoom.full") ||
|
|
this.isSyntheticDocument ? this._fullZoom : this._textZoom;
|
|
this._selectParentHelper.populate(menulist, data.options, data.selectedIndex,
|
|
zoom,
|
|
data.uaSelectBackgroundColor, data.uaSelectColor,
|
|
data.selectBackgroundColor, data.selectColor, data.selectTextShadow);
|
|
this._selectParentHelper.open(this, menulist, data.rect, data.isOpenedViaTouch);
|
|
break;
|
|
}
|
|
|
|
case "FullZoomChange":
|
|
{
|
|
this._fullZoom = data.value;
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("FullZoomChange", true, false);
|
|
this.dispatchEvent(event);
|
|
break;
|
|
}
|
|
|
|
case "TextZoomChange":
|
|
{
|
|
this._textZoom = data.value;
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("TextZoomChange", true, false);
|
|
this.dispatchEvent(event);
|
|
break;
|
|
}
|
|
|
|
case "ZoomChangeUsingMouseWheel":
|
|
{
|
|
let event = document.createEvent("Events");
|
|
event.initEvent("ZoomChangeUsingMouseWheel", true, false);
|
|
this.dispatchEvent(event);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return this._receiveMessage(aMessage);
|
|
}
|
|
return undefined;
|
|
|
|
}
|
|
|
|
enableDisableCommandsRemoteOnly(aAction, aEnabledLength, aEnabledCommands, aDisabledLength, aDisabledCommands) {
|
|
if (this._controller) {
|
|
this._controller.enableDisableCommands(aAction,
|
|
aEnabledLength, aEnabledCommands,
|
|
aDisabledLength, aDisabledCommands);
|
|
}
|
|
}
|
|
|
|
purgeSessionHistory() {
|
|
if (this.isRemoteBrowser) {
|
|
try {
|
|
this.messageManager.sendAsyncMessage("Browser:PurgeSessionHistory");
|
|
} catch (ex) {
|
|
// This can throw if the browser has started to go away.
|
|
if (ex.result != Cr.NS_ERROR_NOT_INITIALIZED) {
|
|
throw ex;
|
|
}
|
|
}
|
|
this._remoteWebNavigationImpl.canGoBack = false;
|
|
this._remoteWebNavigationImpl.canGoForward = false;
|
|
return;
|
|
}
|
|
this.messageManager.sendAsyncMessage("Browser:PurgeSessionHistory");
|
|
}
|
|
|
|
createAboutBlankContentViewer(aPrincipal) {
|
|
if (this.isRemoteBrowser) {
|
|
// Ensure that the content process has the permissions which are
|
|
// needed to create a document with the given principal.
|
|
let permissionPrincipal =
|
|
BrowserUtils.principalWithMatchingOA(aPrincipal, this.contentPrincipal);
|
|
this.frameLoader.tabParent.transmitPermissionsForPrincipal(permissionPrincipal);
|
|
|
|
// Create the about blank content viewer in the content process
|
|
this.messageManager.sendAsyncMessage("Browser:CreateAboutBlank", aPrincipal);
|
|
return;
|
|
}
|
|
let principal = BrowserUtils.principalWithMatchingOA(aPrincipal, this.contentPrincipal);
|
|
this.docShell.createAboutBlankContentViewer(principal);
|
|
}
|
|
|
|
stopScroll() {
|
|
if (this._scrolling) {
|
|
this._scrolling = false;
|
|
window.removeEventListener("mousemove", this, true);
|
|
window.removeEventListener("mousedown", this, true);
|
|
window.removeEventListener("mouseup", this, true);
|
|
window.removeEventListener("DOMMouseScroll", this, true);
|
|
window.removeEventListener("contextmenu", this, true);
|
|
window.removeEventListener("keydown", this, true);
|
|
window.removeEventListener("keypress", this, true);
|
|
window.removeEventListener("keyup", this, true);
|
|
this.messageManager.sendAsyncMessage("Autoscroll:Stop");
|
|
|
|
try {
|
|
Services.obs.removeObserver(this.observer, "apz:cancel-autoscroll");
|
|
} catch (ex) {
|
|
// It's not clear why this sometimes throws an exception
|
|
}
|
|
|
|
if (this.isRemoteBrowser && this._autoScrollScrollId != null) {
|
|
let { tabParent } = this.frameLoader;
|
|
if (tabParent) {
|
|
tabParent.stopApzAutoscroll(this._autoScrollScrollId,
|
|
this._autoScrollPresShellId);
|
|
}
|
|
this._autoScrollScrollId = null;
|
|
this._autoScrollPresShellId = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
_createAutoScrollPopup() {
|
|
var popup = document.createXULElement("panel");
|
|
popup.className = "autoscroller";
|
|
// We set this attribute on the element so that mousemove
|
|
// events can be handled by browser-content.js.
|
|
popup.setAttribute("mousethrough", "always");
|
|
popup.setAttribute("consumeoutsideclicks", "true");
|
|
popup.setAttribute("rolluponmousewheel", "true");
|
|
popup.setAttribute("hidden", "true");
|
|
return popup;
|
|
}
|
|
|
|
startScroll(scrolldir, screenX, screenY) {
|
|
const POPUP_SIZE = 32;
|
|
if (!this._autoScrollPopup) {
|
|
if (this.hasAttribute("autoscrollpopup")) {
|
|
// our creator provided a popup to share
|
|
this._autoScrollPopup = document.getElementById(this.getAttribute("autoscrollpopup"));
|
|
} else {
|
|
// we weren't provided a popup; we have to use the global scope
|
|
this._autoScrollPopup = this._createAutoScrollPopup();
|
|
document.documentElement.appendChild(this._autoScrollPopup);
|
|
this._autoScrollNeedsCleanup = true;
|
|
}
|
|
this._autoScrollPopup.removeAttribute("hidden");
|
|
this._autoScrollPopup.setAttribute("noautofocus", "true");
|
|
this._autoScrollPopup.style.height = POPUP_SIZE + "px";
|
|
this._autoScrollPopup.style.width = POPUP_SIZE + "px";
|
|
this._autoScrollPopup.style.margin = -POPUP_SIZE / 2 + "px";
|
|
}
|
|
|
|
let screenManager = Cc["@mozilla.org/gfx/screenmanager;1"]
|
|
.getService(Ci.nsIScreenManager);
|
|
let screen = screenManager.screenForRect(screenX, screenY, 1, 1);
|
|
|
|
// we need these attributes so themers don't need to create per-platform packages
|
|
if (screen.colorDepth > 8) { // need high color for transparency
|
|
// Exclude second-rate platforms
|
|
this._autoScrollPopup.setAttribute("transparent", !/BeOS|OS\/2/.test(navigator.appVersion));
|
|
// Enable translucency on Windows and Mac
|
|
this._autoScrollPopup.setAttribute("translucent", /Win|Mac/.test(navigator.platform));
|
|
}
|
|
|
|
this._autoScrollPopup.setAttribute("scrolldir", scrolldir);
|
|
this._autoScrollPopup.addEventListener("popuphidden", this, true);
|
|
|
|
// Sanitize screenX/screenY for available screen size with half the size
|
|
// of the popup removed. The popup uses negative margins to center on the
|
|
// coordinates we pass. Unfortunately `window.screen.availLeft` can be negative
|
|
// on Windows in multi-monitor setups, so we use nsIScreenManager instead:
|
|
let left = {},
|
|
top = {},
|
|
width = {},
|
|
height = {};
|
|
screen.GetAvailRect(left, top, width, height);
|
|
|
|
// We need to get screen CSS-pixel (rather than display-pixel) coordinates.
|
|
// With 175% DPI, the actual ratio of display pixels to CSS pixels is
|
|
// 1.7647 because of rounding inside gecko. Unfortunately defaultCSSScaleFactor
|
|
// returns the original 1.75 dpi factor. While window.devicePixelRatio would
|
|
// get us the correct ratio, if the window is split between 2 screens,
|
|
// window.devicePixelRatio isn't guaranteed to match the screen we're
|
|
// autoscrolling on. So instead we do the same math as Gecko.
|
|
const scaleFactor = 60 / Math.round(60 / screen.defaultCSSScaleFactor);
|
|
let minX = left.value / scaleFactor + 0.5 * POPUP_SIZE;
|
|
let maxX = (left.value + width.value) / scaleFactor - 0.5 * POPUP_SIZE;
|
|
let minY = top.value / scaleFactor + 0.5 * POPUP_SIZE;
|
|
let maxY = (top.value + height.value) / scaleFactor - 0.5 * POPUP_SIZE;
|
|
let popupX = Math.max(minX, Math.min(maxX, screenX));
|
|
let popupY = Math.max(minY, Math.min(maxY, screenY));
|
|
this._autoScrollPopup.openPopupAtScreen(popupX, popupY);
|
|
this._ignoreMouseEvents = true;
|
|
this._scrolling = true;
|
|
this._startX = screenX;
|
|
this._startY = screenY;
|
|
|
|
window.addEventListener("mousemove", this, true);
|
|
window.addEventListener("mousedown", this, true);
|
|
window.addEventListener("mouseup", this, true);
|
|
window.addEventListener("DOMMouseScroll", this, true);
|
|
window.addEventListener("contextmenu", this, true);
|
|
window.addEventListener("keydown", this, true);
|
|
window.addEventListener("keypress", this, true);
|
|
window.addEventListener("keyup", this, true);
|
|
}
|
|
|
|
handleEvent(aEvent) {
|
|
if (this._scrolling) {
|
|
switch (aEvent.type) {
|
|
case "mousemove":
|
|
{
|
|
var x = aEvent.screenX - this._startX;
|
|
var y = aEvent.screenY - this._startY;
|
|
|
|
if ((x > this._AUTOSCROLL_SNAP || x < -this._AUTOSCROLL_SNAP) ||
|
|
(y > this._AUTOSCROLL_SNAP || y < -this._AUTOSCROLL_SNAP))
|
|
this._ignoreMouseEvents = false;
|
|
break;
|
|
}
|
|
case "mouseup":
|
|
case "mousedown":
|
|
case "contextmenu":
|
|
{
|
|
if (!this._ignoreMouseEvents) {
|
|
// Use a timeout to prevent the mousedown from opening the popup again.
|
|
// Ideally, we could use preventDefault here, but contenteditable
|
|
// and middlemouse paste don't interact well. See bug 1188536.
|
|
setTimeout(() => this._autoScrollPopup.hidePopup(), 0);
|
|
}
|
|
this._ignoreMouseEvents = false;
|
|
break;
|
|
}
|
|
case "DOMMouseScroll":
|
|
{
|
|
this._autoScrollPopup.hidePopup();
|
|
aEvent.preventDefault();
|
|
break;
|
|
}
|
|
case "popuphidden":
|
|
{
|
|
this._autoScrollPopup.removeEventListener("popuphidden", this, true);
|
|
this.stopScroll();
|
|
break;
|
|
}
|
|
case "keydown":
|
|
{
|
|
if (aEvent.keyCode == aEvent.DOM_VK_ESCAPE) {
|
|
// the escape key will be processed by
|
|
// nsXULPopupManager::KeyDown and the panel will be closed.
|
|
// So, don't consume the key event here.
|
|
break;
|
|
}
|
|
// don't break here. we need to eat keydown events.
|
|
}
|
|
case "keypress":
|
|
case "keyup":
|
|
{
|
|
// All keyevents should be eaten here during autoscrolling.
|
|
aEvent.stopPropagation();
|
|
aEvent.preventDefault();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
closeBrowser() {
|
|
// The request comes from a XPCOM component, we'd want to redirect
|
|
// the request to tabbrowser.
|
|
let tabbrowser = this.getTabBrowser();
|
|
if (tabbrowser) {
|
|
let tab = tabbrowser.getTabForBrowser(this);
|
|
if (tab) {
|
|
tabbrowser.removeTab(tab);
|
|
return;
|
|
}
|
|
}
|
|
|
|
throw new Error("Closing a browser which was not attached to a tabbrowser is unsupported.");
|
|
}
|
|
|
|
swapBrowsers(aOtherBrowser, aFlags) {
|
|
// The request comes from a XPCOM component, we'd want to redirect
|
|
// the request to tabbrowser so tabbrowser will be setup correctly,
|
|
// and it will eventually call swapDocShells.
|
|
let ourTabBrowser = this.getTabBrowser();
|
|
let otherTabBrowser = aOtherBrowser.getTabBrowser();
|
|
if (ourTabBrowser && otherTabBrowser) {
|
|
let ourTab = ourTabBrowser.getTabForBrowser(this);
|
|
let otherTab = otherTabBrowser.getTabForBrowser(aOtherBrowser);
|
|
ourTabBrowser.swapBrowsers(ourTab, otherTab, aFlags);
|
|
return;
|
|
}
|
|
|
|
// One of us is not connected to a tabbrowser, so just swap.
|
|
this.swapDocShells(aOtherBrowser);
|
|
}
|
|
|
|
swapDocShells(aOtherBrowser) {
|
|
if (this.isRemoteBrowser != aOtherBrowser.isRemoteBrowser)
|
|
throw new Error("Can only swap docshells between browsers in the same process.");
|
|
|
|
// Give others a chance to swap state.
|
|
// IMPORTANT: Since a swapDocShells call does not swap the messageManager
|
|
// instances attached to a browser to aOtherBrowser, others
|
|
// will need to add the message listeners to the new
|
|
// messageManager.
|
|
// This is not a bug in swapDocShells or the FrameLoader,
|
|
// merely a design decision: If message managers were swapped,
|
|
// so that no new listeners were needed, the new
|
|
// aOtherBrowser.messageManager would have listeners pointing
|
|
// to the JS global of the current browser, which would rather
|
|
// easily create leaks while swapping.
|
|
// IMPORTANT2: When the current browser element is removed from DOM,
|
|
// which is quite common after a swpDocShells call, its
|
|
// frame loader is destroyed, and that destroys the relevant
|
|
// message manager, which will remove the listeners.
|
|
let event = new CustomEvent("SwapDocShells", { "detail": aOtherBrowser });
|
|
this.dispatchEvent(event);
|
|
event = new CustomEvent("SwapDocShells", { "detail": this });
|
|
aOtherBrowser.dispatchEvent(event);
|
|
|
|
// We need to swap fields that are tied to our docshell or related to
|
|
// the loaded page
|
|
// Fields which are built as a result of notifactions (pageshow/hide,
|
|
// DOMLinkAdded/Removed, onStateChange) should not be swapped here,
|
|
// because these notifications are dispatched again once the docshells
|
|
// are swapped.
|
|
var fieldsToSwap = [
|
|
"_webBrowserFind",
|
|
];
|
|
|
|
if (this.isRemoteBrowser) {
|
|
fieldsToSwap.push(...[
|
|
"_remoteWebNavigation",
|
|
"_remoteWebNavigationImpl",
|
|
"_remoteWebProgressManager",
|
|
"_remoteWebProgress",
|
|
"_remoteFinder",
|
|
"_securityUI",
|
|
"_documentURI",
|
|
"_documentContentType",
|
|
"_contentTitle",
|
|
"_characterSet",
|
|
"_mayEnableCharacterEncodingMenu",
|
|
"_contentPrincipal",
|
|
"_imageDocument",
|
|
"_fullZoom",
|
|
"_textZoom",
|
|
"_isSyntheticDocument",
|
|
"_innerWindowID",
|
|
]);
|
|
}
|
|
|
|
var ourFieldValues = {};
|
|
var otherFieldValues = {};
|
|
for (let field of fieldsToSwap) {
|
|
ourFieldValues[field] = this[field];
|
|
otherFieldValues[field] = aOtherBrowser[field];
|
|
}
|
|
|
|
if (window.PopupNotifications)
|
|
PopupNotifications._swapBrowserNotifications(aOtherBrowser, this);
|
|
|
|
try {
|
|
this.swapFrameLoaders(aOtherBrowser);
|
|
} catch (ex) {
|
|
// This may not be implemented for browser elements that are not
|
|
// attached to a BrowserDOMWindow.
|
|
}
|
|
|
|
for (let field of fieldsToSwap) {
|
|
this[field] = otherFieldValues[field];
|
|
aOtherBrowser[field] = ourFieldValues[field];
|
|
}
|
|
|
|
if (!this.isRemoteBrowser) {
|
|
// Null the current nsITypeAheadFind instances so that they're
|
|
// lazily re-created on access. We need to do this because they
|
|
// might have attached the wrong docShell.
|
|
this._fastFind = aOtherBrowser._fastFind = null;
|
|
} else {
|
|
// Rewire the remote listeners
|
|
this._remoteWebNavigationImpl.swapBrowser(this);
|
|
aOtherBrowser._remoteWebNavigationImpl.swapBrowser(aOtherBrowser);
|
|
|
|
if (this._remoteWebProgressManager && aOtherBrowser._remoteWebProgressManager) {
|
|
this._remoteWebProgressManager.swapBrowser(this);
|
|
aOtherBrowser._remoteWebProgressManager.swapBrowser(aOtherBrowser);
|
|
}
|
|
|
|
if (this._remoteFinder)
|
|
this._remoteFinder.swapBrowser(this);
|
|
if (aOtherBrowser._remoteFinder)
|
|
aOtherBrowser._remoteFinder.swapBrowser(aOtherBrowser);
|
|
}
|
|
|
|
event = new CustomEvent("EndSwapDocShells", { "detail": aOtherBrowser });
|
|
this.dispatchEvent(event);
|
|
event = new CustomEvent("EndSwapDocShells", { "detail": this });
|
|
aOtherBrowser.dispatchEvent(event);
|
|
}
|
|
|
|
getInPermitUnload(aCallback) {
|
|
if (this.isRemoteBrowser) {
|
|
let id = this._permitUnloadId++;
|
|
let mm = this.messageManager;
|
|
mm.sendAsyncMessage("InPermitUnload", { id });
|
|
mm.addMessageListener("InPermitUnload", function listener(msg) {
|
|
if (msg.data.id != id) {
|
|
return;
|
|
}
|
|
aCallback(msg.data.inPermitUnload);
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (!this.docShell || !this.docShell.contentViewer) {
|
|
aCallback(false);
|
|
return;
|
|
}
|
|
aCallback(this.docShell.contentViewer.inPermitUnload);
|
|
}
|
|
|
|
permitUnload(aPermitUnloadFlags) {
|
|
if (this.isRemoteBrowser) {
|
|
let { tabParent } = this.frameLoader;
|
|
|
|
if (!tabParent.hasBeforeUnload) {
|
|
return { permitUnload: true, timedOut: false };
|
|
}
|
|
|
|
const kTimeout = 1000;
|
|
|
|
let finished = false;
|
|
let responded = false;
|
|
let permitUnload;
|
|
let id = this._permitUnloadId++;
|
|
let mm = this.messageManager;
|
|
let Services = ChromeUtils.import("resource://gre/modules/Services.jsm", {}).Services;
|
|
|
|
let msgListener = msg => {
|
|
if (msg.data.id != id) {
|
|
return;
|
|
}
|
|
if (msg.data.kind == "start") {
|
|
responded = true;
|
|
return;
|
|
}
|
|
done(msg.data.permitUnload);
|
|
};
|
|
|
|
let observer = subject => {
|
|
if (subject == mm) {
|
|
done(true);
|
|
}
|
|
};
|
|
|
|
function done(result) {
|
|
finished = true;
|
|
permitUnload = result;
|
|
mm.removeMessageListener("PermitUnload", msgListener);
|
|
Services.obs.removeObserver(observer, "message-manager-close");
|
|
}
|
|
|
|
mm.sendAsyncMessage("PermitUnload", { id, aPermitUnloadFlags });
|
|
mm.addMessageListener("PermitUnload", msgListener);
|
|
Services.obs.addObserver(observer, "message-manager-close");
|
|
|
|
let timedOut = false;
|
|
|
|
function timeout() {
|
|
if (!responded) {
|
|
timedOut = true;
|
|
}
|
|
|
|
// Dispatch something to ensure that the main thread wakes up.
|
|
Services.tm.dispatchToMainThread(function() {});
|
|
}
|
|
|
|
let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
|
|
timer.initWithCallback(timeout, kTimeout, timer.TYPE_ONE_SHOT);
|
|
|
|
while (!finished && !timedOut) {
|
|
Services.tm.currentThread.processNextEvent(true);
|
|
}
|
|
|
|
return { permitUnload, timedOut };
|
|
}
|
|
|
|
if (!this.docShell || !this.docShell.contentViewer) {
|
|
return { permitUnload: true, timedOut: false };
|
|
}
|
|
return {
|
|
permitUnload: this.docShell.contentViewer.permitUnload(aPermitUnloadFlags),
|
|
timedOut: false,
|
|
};
|
|
}
|
|
|
|
print(aOuterWindowID, aPrintSettings, aPrintProgressListener) {
|
|
if (!this.frameLoader) {
|
|
throw Components.Exception("No frame loader.",
|
|
Cr.NS_ERROR_FAILURE);
|
|
}
|
|
|
|
this.frameLoader.print(aOuterWindowID, aPrintSettings,
|
|
aPrintProgressListener);
|
|
}
|
|
|
|
drawSnapshot(x, y, w, h, scale, backgroundColor) {
|
|
if (!this.frameLoader) {
|
|
throw Components.Exception("No frame loader.",
|
|
Cr.NS_ERROR_FAILURE);
|
|
}
|
|
return this.frameLoader.drawSnapshot(x, y, w, h, scale, backgroundColor);
|
|
}
|
|
|
|
dropLinks(aLinksCount, aLinks, aTriggeringPrincipal) {
|
|
if (!this.droppedLinkHandler) {
|
|
return false;
|
|
}
|
|
let links = [];
|
|
for (let i = 0; i < aLinksCount; i += 3) {
|
|
links.push({
|
|
url: aLinks[i],
|
|
name: aLinks[i + 1],
|
|
type: aLinks[i + 2],
|
|
});
|
|
}
|
|
this.droppedLinkHandler(null, links, aTriggeringPrincipal);
|
|
return true;
|
|
}
|
|
|
|
getContentBlockingLog() {
|
|
if (this.isRemoteBrowser) {
|
|
return this.frameLoader.tabParent.getContentBlockingLog();
|
|
}
|
|
return this.docShell ?
|
|
this.docShell.getContentBlockingLog() :
|
|
Promise.reject("docshell isn't available");
|
|
}
|
|
}
|
|
|
|
MozXULElement.implementCustomInterface(MozBrowser, [Ci.nsIBrowser, Ci.nsIFrameLoaderOwner]);
|
|
customElements.define("browser", MozBrowser);
|
|
|
|
}
|