forked from mirrors/gecko-dev
3d7ffd608a
Differential Revision: https://phabricator.services.mozilla.com/D58990 --HG-- extra : moz-landing-system : lando
2152 lines
64 KiB
JavaScript
2152 lines
64 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 { Services } = ChromeUtils.import(
|
|
"resource://gre/modules/Services.jsm"
|
|
);
|
|
const { AppConstants } = ChromeUtils.import(
|
|
"resource://gre/modules/AppConstants.jsm"
|
|
);
|
|
|
|
let LazyModules = {};
|
|
|
|
ChromeUtils.defineModuleGetter(
|
|
LazyModules,
|
|
"PermitUnloader",
|
|
"resource://gre/actors/BrowserElementParent.jsm"
|
|
);
|
|
|
|
ChromeUtils.defineModuleGetter(
|
|
LazyModules,
|
|
"E10SUtils",
|
|
"resource://gre/modules/E10SUtils.jsm"
|
|
);
|
|
|
|
ChromeUtils.defineModuleGetter(
|
|
LazyModules,
|
|
"RemoteWebNavigation",
|
|
"resource://gre/modules/RemoteWebNavigation.jsm"
|
|
);
|
|
|
|
const elementsToDestroyOnUnload = new Set();
|
|
|
|
window.addEventListener(
|
|
"unload",
|
|
() => {
|
|
for (let element of elementsToDestroyOnUnload.values()) {
|
|
element.destroy();
|
|
}
|
|
elementsToDestroyOnUnload.clear();
|
|
},
|
|
{ mozSystemGroup: true, once: true }
|
|
);
|
|
|
|
class MozBrowser extends MozElements.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.
|
|
//
|
|
// Only do this when the rebuild frameloaders pref is off. This update isn't
|
|
// required when we rebuild the frameloaders in the backend.
|
|
let rebuildFrameLoaders =
|
|
LazyModules.E10SUtils.rebuildFrameloadersOnRemotenessChange ||
|
|
this.ownerGlobal.docShell.nsILoadContext.useRemoteSubframes;
|
|
if (
|
|
!rebuildFrameLoaders &&
|
|
name === "remote" &&
|
|
oldValue != newValue &&
|
|
this.isConnectedAndReady
|
|
) {
|
|
this.destroy();
|
|
this.construct();
|
|
}
|
|
}
|
|
|
|
constructor() {
|
|
super();
|
|
|
|
this.onPageHide = this.onPageHide.bind(this);
|
|
|
|
this.isNavigating = false;
|
|
|
|
this._documentURI = null;
|
|
this._characterSet = null;
|
|
this._documentContentType = null;
|
|
|
|
/**
|
|
* These are managed by the tabbrowser:
|
|
*/
|
|
this.droppedLinkHandler = null;
|
|
this.mIconURL = null;
|
|
this.lastURI = null;
|
|
|
|
// Track progress listeners added to this <browser>. These need to persist
|
|
// between calls to destroy().
|
|
this.progressListeners = [];
|
|
|
|
this.addEventListener(
|
|
"keypress",
|
|
event => {
|
|
if (event.keyCode != KeyEvent.DOM_VK_F7) {
|
|
return;
|
|
}
|
|
|
|
// shift + F7 is the default DevTools shortcut for the Style Editor.
|
|
if (event.shiftKey) {
|
|
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._webBrowserFind = null;
|
|
|
|
this._finder = null;
|
|
|
|
this._remoteFinder = null;
|
|
|
|
this._fastFind = null;
|
|
|
|
this._outerWindowID = null;
|
|
|
|
this._innerWindowID = null;
|
|
|
|
this._lastSearchString = null;
|
|
|
|
this._controller = null;
|
|
|
|
this._remoteWebNavigation = null;
|
|
|
|
this._remoteWebProgress = null;
|
|
|
|
this._contentTitle = "";
|
|
|
|
this._characterSet = "";
|
|
|
|
this._mayEnableCharacterEncodingMenu = null;
|
|
|
|
this._charsetAutodetected = false;
|
|
|
|
this._contentPrincipal = null;
|
|
|
|
this._contentStoragePrincipal = null;
|
|
|
|
this._contentBlockingAllowListPrincipal = null;
|
|
|
|
this._csp = null;
|
|
|
|
this._referrerInfo = 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._autoScrollBrowsingContext = null;
|
|
|
|
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;
|
|
}
|
|
|
|
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 documentContentType(aContentType) {
|
|
if (aContentType != null) {
|
|
if (this.isRemoteBrowser) {
|
|
this._documentContentType = aContentType;
|
|
} else {
|
|
this.contentDocument.documentContentType = aContentType;
|
|
}
|
|
}
|
|
}
|
|
|
|
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"));
|
|
}
|
|
|
|
/**
|
|
* Provides a node to hang popups (such as the datetimepicker) from.
|
|
* If this <browser> isn't the descendant of a <stack>, null is returned
|
|
* instead and popup code must handle this case.
|
|
*/
|
|
get popupAnchor() {
|
|
let stack = this.closest("stack");
|
|
if (!stack) {
|
|
return null;
|
|
}
|
|
|
|
let popupAnchor = stack.querySelector(".popup-anchor");
|
|
if (popupAnchor) {
|
|
return popupAnchor;
|
|
}
|
|
|
|
// Create an anchor for the popup
|
|
popupAnchor = document.createElement("div");
|
|
popupAnchor.className = "popup-anchor";
|
|
popupAnchor.hidden = true;
|
|
stack.appendChild(popupAnchor);
|
|
return popupAnchor;
|
|
}
|
|
|
|
set docShellIsActive(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.remoteTab) {
|
|
frameLoader.remoteTab.docShellIsActive = val;
|
|
}
|
|
} else if (this.docShell) {
|
|
this.docShell.isActive = val;
|
|
}
|
|
}
|
|
|
|
get docShellIsActive() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.remoteTab) {
|
|
return frameLoader.remoteTab.docShellIsActive;
|
|
}
|
|
return false;
|
|
}
|
|
return this.docShell && this.docShell.isActive;
|
|
}
|
|
|
|
set renderLayers(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.remoteTab) {
|
|
frameLoader.remoteTab.renderLayers = val;
|
|
}
|
|
} else {
|
|
this.docShellIsActive = val;
|
|
}
|
|
}
|
|
|
|
get renderLayers() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.remoteTab) {
|
|
return frameLoader.remoteTab.renderLayers;
|
|
}
|
|
return false;
|
|
}
|
|
return this.docShellIsActive;
|
|
}
|
|
|
|
get hasLayers() {
|
|
if (this.isRemoteBrowser) {
|
|
let { frameLoader } = this;
|
|
if (frameLoader && frameLoader.remoteTab) {
|
|
return frameLoader.remoteTab.hasLayers;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return this.docShellIsActive;
|
|
}
|
|
|
|
get isRemoteBrowser() {
|
|
return this.getAttribute("remote") == "true";
|
|
}
|
|
|
|
get remoteType() {
|
|
if (!this.isRemoteBrowser || !this.messageManager) {
|
|
return null;
|
|
}
|
|
|
|
return this.messageManager.remoteType;
|
|
}
|
|
|
|
get isCrashed() {
|
|
if (!this.isRemoteBrowser || !this.frameLoader) {
|
|
return false;
|
|
}
|
|
|
|
return !this.frameLoader.remoteTab;
|
|
}
|
|
|
|
get messageManager() {
|
|
// Bug 1524084 - Trying to get at the message manager while in the crashed state will
|
|
// create a new message manager that won't shut down properly when the crashed browser
|
|
// is removed from the DOM. We work around that right now by returning null if we're
|
|
// in the crashed state.
|
|
if (this.frameLoader && !this.isCrashed) {
|
|
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) {
|
|
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.frameLoader) {
|
|
return this.frameLoader.browsingContext;
|
|
}
|
|
return null;
|
|
}
|
|
/**
|
|
* 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.sendMessageToActor(
|
|
"UpdateCharacterSet",
|
|
{ value: val },
|
|
"BrowserTab"
|
|
);
|
|
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;
|
|
}
|
|
|
|
set mayEnableCharacterEncodingMenu(aMayEnable) {
|
|
if (this.isRemoteBrowser) {
|
|
this._mayEnableCharacterEncodingMenu = aMayEnable;
|
|
}
|
|
}
|
|
|
|
get charsetAutodetected() {
|
|
return this.isRemoteBrowser
|
|
? this._charsetAutodetected
|
|
: this.docShell.charsetAutodetected;
|
|
}
|
|
|
|
set charsetAutodetected(aAutodetected) {
|
|
if (this.isRemoteBrowser) {
|
|
this._charsetAutodetected = aAutodetected;
|
|
}
|
|
}
|
|
|
|
get contentPrincipal() {
|
|
return this.isRemoteBrowser
|
|
? this._contentPrincipal
|
|
: this.contentDocument.nodePrincipal;
|
|
}
|
|
|
|
get contentStoragePrincipal() {
|
|
return this.isRemoteBrowser
|
|
? this._contentStoragePrincipal
|
|
: this.contentDocument.effectiveStoragePrincipal;
|
|
}
|
|
|
|
get contentBlockingAllowListPrincipal() {
|
|
return this.isRemoteBrowser
|
|
? this._contentBlockingAllowListPrincipal
|
|
: this.contentDocument.contentBlockingAllowListPrincipal;
|
|
}
|
|
|
|
get csp() {
|
|
return this.isRemoteBrowser ? this._csp : this.contentDocument.csp;
|
|
}
|
|
|
|
get contentRequestContextID() {
|
|
if (this.isRemoteBrowser) {
|
|
return this._contentRequestContextID;
|
|
}
|
|
try {
|
|
return this.contentDocument.documentLoadGroup.requestContextID;
|
|
} catch (e) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
set fullZoom(val) {
|
|
if (this.isRemoteBrowser) {
|
|
let changed = val.toFixed(2) != this._fullZoom.toFixed(2);
|
|
|
|
if (changed) {
|
|
this._fullZoom = val;
|
|
this.sendMessageToActor("FullZoom", { value: val }, "Zoom", "roots");
|
|
|
|
let event = new Event("FullZoomChange", { bubbles: true });
|
|
this.dispatchEvent(event);
|
|
}
|
|
} else {
|
|
this.markupDocumentViewer.fullZoom = val;
|
|
}
|
|
}
|
|
|
|
get referrerInfo() {
|
|
return this.isRemoteBrowser
|
|
? this._referrerInfo
|
|
: this.contentDocument.referrerInfo;
|
|
}
|
|
|
|
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;
|
|
this.sendMessageToActor("TextZoom", { value: val }, "Zoom", "roots");
|
|
|
|
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() {
|
|
return !!this.browsingContext.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.isNavigating = true;
|
|
try {
|
|
fn();
|
|
} finally {
|
|
this.isNavigating = 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 {
|
|
referrerInfo,
|
|
triggeringPrincipal,
|
|
postData,
|
|
headers,
|
|
csp,
|
|
} = aParams;
|
|
let loadFlags =
|
|
aParams.loadFlags ||
|
|
aParams.flags ||
|
|
Ci.nsIWebNavigation.LOAD_FLAGS_NONE;
|
|
let loadURIOptions = {
|
|
triggeringPrincipal,
|
|
csp,
|
|
referrerInfo,
|
|
loadFlags,
|
|
postData,
|
|
headers,
|
|
};
|
|
this._wrapURIChangeCall(() =>
|
|
this.webNavigation.loadURI(aURI, loadURIOptions)
|
|
);
|
|
}
|
|
|
|
gotoIndex(aIndex) {
|
|
this._wrapURIChangeCall(() => this.webNavigation.gotoIndex(aIndex));
|
|
}
|
|
|
|
preserveLayers(preserve) {
|
|
if (!this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
let { frameLoader } = this;
|
|
if (frameLoader.remoteTab) {
|
|
frameLoader.remoteTab.preserveLayers(preserve);
|
|
}
|
|
}
|
|
|
|
deprioritize() {
|
|
if (!this.isRemoteBrowser) {
|
|
return;
|
|
}
|
|
let { frameLoader } = this;
|
|
if (frameLoader.remoteTab) {
|
|
frameLoader.remoteTab.deprioritize();
|
|
}
|
|
}
|
|
|
|
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.progressListeners.push({
|
|
weakListener: Cu.getWeakReference(aListener),
|
|
mask: aNotifyMask,
|
|
});
|
|
|
|
this.webProgress.addProgressListener(aListener, aNotifyMask);
|
|
}
|
|
|
|
removeProgressListener(aListener) {
|
|
this.webProgress.removeProgressListener(aListener);
|
|
|
|
// Remove aListener from our progress listener list, and clear out dead
|
|
// weak references while we're at it.
|
|
this.progressListeners = this.progressListeners.filter(
|
|
({ weakListener }) =>
|
|
weakListener.get() && weakListener.get() !== aListener
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Move the previously-tracked web progress listeners to this <browser>'s
|
|
* current WebProgress.
|
|
*/
|
|
restoreProgressListeners() {
|
|
let listeners = this.progressListeners;
|
|
this.progressListeners = [];
|
|
|
|
for (let { weakListener, mask } of listeners) {
|
|
let listener = weakListener.get();
|
|
if (listener) {
|
|
this.addProgressListener(listener, mask);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* 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;
|
|
}
|
|
let context = this.frameLoader.browsingContext;
|
|
context.notifyMediaMutedChanged(true);
|
|
}
|
|
|
|
unmute() {
|
|
this._audioMuted = false;
|
|
let context = this.frameLoader.browsingContext;
|
|
context.notifyMediaMutedChanged(false);
|
|
}
|
|
|
|
pauseMedia(disposable) {
|
|
let suspendedReason;
|
|
if (disposable) {
|
|
suspendedReason = "mediaControlPaused";
|
|
} else {
|
|
suspendedReason = "lostAudioFocusTransiently";
|
|
}
|
|
|
|
this.sendMessageToActor(
|
|
"AudioPlayback",
|
|
{ type: suspendedReason },
|
|
"AudioPlayback",
|
|
"roots"
|
|
);
|
|
}
|
|
|
|
stopMedia() {
|
|
this.sendMessageToActor(
|
|
"AudioPlayback",
|
|
{ type: "mediaControlStopped" },
|
|
"AudioPlayback",
|
|
"roots"
|
|
);
|
|
}
|
|
|
|
resumeMedia() {
|
|
this.frameLoader.browsingContext.notifyStartDelayedAutoplayMedia();
|
|
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.isNavigating &&
|
|
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 = new LazyModules.RemoteWebNavigation(this);
|
|
|
|
// Initialize contentPrincipal to the about:blank principal for this loadcontext
|
|
let aboutBlank = Services.io.newURI("about:blank");
|
|
let ssm = Services.scriptSecurityManager;
|
|
this._contentPrincipal = ssm.getLoadContextContentPrincipal(
|
|
aboutBlank,
|
|
this.loadContext
|
|
);
|
|
// CSP for about:blank is null; if we ever change _contentPrincipal above,
|
|
// we should re-evaluate the CSP here.
|
|
this._csp = null;
|
|
|
|
this.messageManager.addMessageListener("Browser:Init", this);
|
|
this.messageManager.addMessageListener("DOMTitleChanged", this);
|
|
|
|
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;
|
|
|
|
if (!oldManager) {
|
|
// If we didn't have a manager, then we're transitioning from local to
|
|
// remote. Add all listeners from the previous <browser> to the new
|
|
// RemoteWebProgress.
|
|
this.restoreProgressListeners();
|
|
}
|
|
|
|
this.messageManager.loadFrameScript(
|
|
"chrome://global/content/browser-child.js",
|
|
true
|
|
);
|
|
|
|
if (!this.hasAttribute("disablehistory")) {
|
|
Services.obs.addObserver(
|
|
this.observer,
|
|
"browser:purge-session-history",
|
|
true
|
|
);
|
|
}
|
|
|
|
const { RemoteController } = ChromeUtils.import(
|
|
"resource://gre/modules/RemoteController.jsm"
|
|
);
|
|
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 no longer need
|
|
// our RemoteWebProgress or its associated manager, but we'll need to
|
|
// add the progress listeners to the new non-remote WebProgress.
|
|
this._remoteWebProgressManager = null;
|
|
this._remoteWebProgress = null;
|
|
this.restoreProgressListeners();
|
|
|
|
this.addEventListener("pagehide", this.onPageHide, true);
|
|
}
|
|
|
|
if (this.messageManager) {
|
|
this.messageManager.addMessageListener(
|
|
"PopupBlocking:UpdateBlockedPopups",
|
|
this
|
|
);
|
|
this.messageManager.addMessageListener(
|
|
"UnselectedTabHover:Toggle",
|
|
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.hasAttribute("selectmenulist")) {
|
|
let menulist = document.getElementById(
|
|
this.getAttribute("selectmenulist")
|
|
);
|
|
if (menulist && menulist.open) {
|
|
let resourcePath = "resource://gre/actors/SelectParent.jsm";
|
|
let { SelectParentHelper } = ChromeUtils.import(resourcePath);
|
|
SelectParentHelper.hide(menulist, this);
|
|
}
|
|
}
|
|
|
|
if (this._controller) {
|
|
try {
|
|
this.controllers.removeController(this._controller);
|
|
} catch (ex) {
|
|
Cu.reportError(ex);
|
|
}
|
|
}
|
|
|
|
this.resetFields();
|
|
|
|
if (!this.mInitialized) {
|
|
return;
|
|
}
|
|
|
|
this.mInitialized = false;
|
|
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 "UnselectedTabHover:Toggle":
|
|
this._shouldSendUnselectedTabHover = data.enable
|
|
? ++this._unselectedTabHoverMessageListenerCount > 0
|
|
: --this._unselectedTabHoverMessageListenerCount == 0;
|
|
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;
|
|
break;
|
|
case "DOMTitleChanged":
|
|
this._contentTitle = data.title;
|
|
break;
|
|
default:
|
|
return this._receiveMessage(aMessage);
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
enableDisableCommandsRemoteOnly(
|
|
aAction,
|
|
aEnabledCommands,
|
|
aDisabledCommands
|
|
) {
|
|
if (this._controller) {
|
|
this._controller.enableDisableCommands(
|
|
aAction,
|
|
aEnabledCommands,
|
|
aDisabledCommands
|
|
);
|
|
}
|
|
}
|
|
|
|
updateSecurityUIForSecurityChange(aSecurityInfo, aState, aIsSecureContext) {
|
|
if (this.isRemoteBrowser && this.messageManager) {
|
|
// Invoking this getter triggers the generation of the underlying object,
|
|
// which we need to access with ._securityUI, because .securityUI returns
|
|
// a wrapper that makes _update inaccessible.
|
|
void this.securityUI;
|
|
this._securityUI._update(aSecurityInfo, aState, aIsSecureContext);
|
|
}
|
|
}
|
|
|
|
get remoteWebProgressManager() {
|
|
return this._remoteWebProgressManager;
|
|
}
|
|
|
|
updateForStateChange(aCharset, aDocumentURI, aContentType) {
|
|
if (this.isRemoteBrowser && this.messageManager) {
|
|
if (aCharset != null) {
|
|
this._characterSet = aCharset;
|
|
}
|
|
|
|
if (aDocumentURI != null) {
|
|
this._documentURI = aDocumentURI;
|
|
}
|
|
|
|
if (aContentType != null) {
|
|
this._documentContentType = aContentType;
|
|
}
|
|
}
|
|
}
|
|
|
|
updateWebNavigationForLocationChange(aCanGoBack, aCanGoForward) {
|
|
if (this.isRemoteBrowser && this.messageManager) {
|
|
this._remoteWebNavigation.canGoBack = aCanGoBack;
|
|
this._remoteWebNavigation.canGoForward = aCanGoForward;
|
|
}
|
|
}
|
|
|
|
updateForLocationChange(
|
|
aLocation,
|
|
aCharset,
|
|
aMayEnableCharacterEncodingMenu,
|
|
aCharsetAutodetected,
|
|
aDocumentURI,
|
|
aTitle,
|
|
aContentPrincipal,
|
|
aContentStoragePrincipal,
|
|
aContentBlockingAllowListPrincipal,
|
|
aCSP,
|
|
aReferrerInfo,
|
|
aIsSynthetic,
|
|
aInnerWindowID,
|
|
aHaveRequestContextID,
|
|
aRequestContextID,
|
|
aContentType
|
|
) {
|
|
if (this.isRemoteBrowser && this.messageManager) {
|
|
if (aCharset != null) {
|
|
this._characterSet = aCharset;
|
|
this._mayEnableCharacterEncodingMenu = aMayEnableCharacterEncodingMenu;
|
|
this._charsetAutodetected = aCharsetAutodetected;
|
|
}
|
|
|
|
if (aContentType != null) {
|
|
this._documentContentType = aContentType;
|
|
}
|
|
|
|
this._remoteWebNavigation._currentURI = aLocation;
|
|
this._documentURI = aDocumentURI;
|
|
this._contentTitle = aTitle;
|
|
this._contentPrincipal = aContentPrincipal;
|
|
this._contentStoragePrincipal = aContentStoragePrincipal;
|
|
this._contentBlockingAllowListPrincipal = aContentBlockingAllowListPrincipal;
|
|
this._csp = aCSP;
|
|
this._referrerInfo = aReferrerInfo;
|
|
this._isSyntheticDocument = aIsSynthetic;
|
|
this._innerWindowID = aInnerWindowID;
|
|
this._contentRequestContextID = aHaveRequestContextID
|
|
? aRequestContextID
|
|
: null;
|
|
}
|
|
}
|
|
|
|
purgeSessionHistory() {
|
|
if (this.isRemoteBrowser) {
|
|
this._remoteWebNavigation.canGoBack = false;
|
|
this._remoteWebNavigation.canGoForward = false;
|
|
}
|
|
try {
|
|
this.sendMessageToActor(
|
|
"Browser:PurgeSessionHistory",
|
|
{},
|
|
"PurgeSessionHistory",
|
|
"roots"
|
|
);
|
|
} catch (ex) {
|
|
// This can throw if the browser has started to go away.
|
|
if (ex.result != Cr.NS_ERROR_NOT_INITIALIZED) {
|
|
throw ex;
|
|
}
|
|
}
|
|
}
|
|
|
|
createAboutBlankContentViewer(aPrincipal, aStoragePrincipal) {
|
|
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.remoteTab.transmitPermissionsForPrincipal(
|
|
permissionPrincipal
|
|
);
|
|
|
|
// This still uses the message manager, for the following reasons:
|
|
//
|
|
// 1. Due to bug 1523638, it's virtually certain that, if we've just created
|
|
// this <xul:browser>, that the WindowGlobalParent for the top-level frame
|
|
// of this browser doesn't exist yet, so it's not possible to get at a
|
|
// JS Window Actor for it.
|
|
//
|
|
// 2. JS Window Actors are tied to the principals for the frames they're running
|
|
// in - switching principals is therefore self-destructive and unexpected.
|
|
//
|
|
// So we'll continue to use the message manager until we come up with a better
|
|
// solution.
|
|
this.messageManager.sendAsyncMessage(
|
|
"BrowserElement:CreateAboutBlank",
|
|
{ principal: aPrincipal, storagePrincipal: aStoragePrincipal }
|
|
);
|
|
return;
|
|
}
|
|
let principal = BrowserUtils.principalWithMatchingOA(
|
|
aPrincipal,
|
|
this.contentPrincipal
|
|
);
|
|
let storagePrincipal = BrowserUtils.principalWithMatchingOA(
|
|
aStoragePrincipal,
|
|
this.contentStoragePrincipal
|
|
);
|
|
this.docShell.createAboutBlankContentViewer(principal, storagePrincipal);
|
|
}
|
|
|
|
stopScroll() {
|
|
if (this._autoScrollBrowsingContext) {
|
|
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);
|
|
|
|
let autoScrollWnd = this._autoScrollBrowsingContext.currentWindowGlobal;
|
|
if (autoScrollWnd) {
|
|
autoScrollWnd
|
|
.getActor("AutoScroll")
|
|
.sendAsyncMessage("Autoscroll:Stop", {});
|
|
}
|
|
this._autoScrollBrowsingContext = null;
|
|
|
|
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 { remoteTab } = this.frameLoader;
|
|
if (remoteTab) {
|
|
remoteTab.stopApzAutoscroll(
|
|
this._autoScrollScrollId,
|
|
this._autoScrollPresShellId
|
|
);
|
|
}
|
|
this._autoScrollScrollId = null;
|
|
this._autoScrollPresShellId = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
_createAutoScrollPopup() {
|
|
var popup = document.createXULElement("panel");
|
|
popup.className = "autoscroller";
|
|
popup.setAttribute("consumeoutsideclicks", "true");
|
|
popup.setAttribute("rolluponmousewheel", "true");
|
|
popup.setAttribute("hidden", "true");
|
|
return popup;
|
|
}
|
|
|
|
startScroll({
|
|
scrolldir,
|
|
screenX,
|
|
screenY,
|
|
scrollId,
|
|
presShellId,
|
|
browsingContext,
|
|
}) {
|
|
if (!this.autoscrollEnabled) {
|
|
return { autoscrollEnabled: false, usingApz: false };
|
|
}
|
|
|
|
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",
|
|
AppConstants.platform == "win" || AppConstants.platform == "macosx"
|
|
);
|
|
}
|
|
|
|
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._startX = screenX;
|
|
this._startY = screenY;
|
|
this._autoScrollBrowsingContext = browsingContext;
|
|
|
|
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);
|
|
|
|
let usingApz = false;
|
|
if (
|
|
this.isRemoteBrowser &&
|
|
scrollId != null &&
|
|
this.mPrefs.getBoolPref("apz.autoscroll.enabled", false)
|
|
) {
|
|
let { remoteTab } = this.frameLoader;
|
|
if (remoteTab) {
|
|
// 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.
|
|
Services.obs.addObserver(
|
|
this.observer,
|
|
"apz:cancel-autoscroll",
|
|
true
|
|
);
|
|
|
|
usingApz = remoteTab.startApzAutoscroll(
|
|
screenX,
|
|
screenY,
|
|
scrollId,
|
|
presShellId
|
|
);
|
|
}
|
|
// Save the IDs for later
|
|
this._autoScrollScrollId = scrollId;
|
|
this._autoScrollPresShellId = presShellId;
|
|
}
|
|
|
|
return { autoscrollEnabled: true, usingApz };
|
|
}
|
|
|
|
cancelScroll() {
|
|
this._autoScrollPopup.hidePopup();
|
|
}
|
|
|
|
handleEvent(aEvent) {
|
|
if (this._autoScrollBrowsingContext) {
|
|
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.
|
|
}
|
|
// fall through
|
|
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) {
|
|
// 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);
|
|
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",
|
|
"_remoteWebProgressManager",
|
|
"_remoteWebProgress",
|
|
"_remoteFinder",
|
|
"_securityUI",
|
|
"_documentURI",
|
|
"_documentContentType",
|
|
"_contentTitle",
|
|
"_characterSet",
|
|
"_mayEnableCharacterEncodingMenu",
|
|
"_charsetAutodetected",
|
|
"_contentPrincipal",
|
|
"_contentStoragePrincipal",
|
|
"_contentBlockingAllowListPrincipal",
|
|
"_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._remoteWebNavigation.swapBrowser(this);
|
|
aOtherBrowser._remoteWebNavigation.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 { remoteTab } = this.frameLoader;
|
|
if (!remoteTab) {
|
|
// If we're crashed, we're definitely not in this state anymore.
|
|
aCallback(false);
|
|
return;
|
|
}
|
|
aCallback(LazyModules.PermitUnloader.inPermitUnload(this.frameLoader));
|
|
return;
|
|
}
|
|
|
|
if (!this.docShell || !this.docShell.contentViewer) {
|
|
aCallback(false);
|
|
return;
|
|
}
|
|
aCallback(this.docShell.contentViewer.inPermitUnload);
|
|
}
|
|
|
|
permitUnload(aPermitUnloadFlags) {
|
|
if (this.isRemoteBrowser) {
|
|
if (!LazyModules.PermitUnloader.hasBeforeUnload(this.frameLoader)) {
|
|
return { permitUnload: true, timedOut: false };
|
|
}
|
|
|
|
return LazyModules.PermitUnloader.permitUnload(
|
|
this.frameLoader,
|
|
aPermitUnloadFlags
|
|
);
|
|
}
|
|
|
|
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
|
|
);
|
|
}
|
|
|
|
async drawSnapshot(x, y, w, h, scale, backgroundColor) {
|
|
let rect = new DOMRect(x, y, w, h);
|
|
try {
|
|
return this.browsingContext.currentWindowGlobal.drawSnapshot(
|
|
rect,
|
|
scale,
|
|
backgroundColor
|
|
);
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
dropLinks(aLinks, aTriggeringPrincipal) {
|
|
if (!this.droppedLinkHandler) {
|
|
return false;
|
|
}
|
|
let links = [];
|
|
for (let i = 0; i < aLinks.length; i += 3) {
|
|
links.push({
|
|
url: aLinks[i],
|
|
name: aLinks[i + 1],
|
|
type: aLinks[i + 2],
|
|
});
|
|
}
|
|
this.droppedLinkHandler(null, links, aTriggeringPrincipal);
|
|
return true;
|
|
}
|
|
|
|
getContentBlockingLog() {
|
|
let windowGlobal = this.browsingContext.currentWindowGlobal;
|
|
if (!windowGlobal) {
|
|
return null;
|
|
}
|
|
return windowGlobal.contentBlockingLog;
|
|
}
|
|
|
|
getContentBlockingEvents() {
|
|
let windowGlobal = this.browsingContext.currentWindowGlobal;
|
|
if (!windowGlobal) {
|
|
return 0;
|
|
}
|
|
return windowGlobal.contentBlockingEvents;
|
|
}
|
|
|
|
// Send an asynchronous message to the remote child via an actor.
|
|
// Note: use this only for messages through an actor. For old-style
|
|
// messages, use the message manager.
|
|
// The value of the scope argument determines which browsing contexts
|
|
// are sent to:
|
|
// 'all' - send to actors associated with all descendant child frames.
|
|
// 'roots' - send only to actors associated with process roots.
|
|
// undefined/'' - send only to the top-level actor and not any descendants.
|
|
sendMessageToActor(messageName, args, actorName, scope) {
|
|
if (!this.frameLoader) {
|
|
return;
|
|
}
|
|
|
|
function sendToChildren(browsingContext, childScope) {
|
|
let windowGlobal = browsingContext.currentWindowGlobal;
|
|
// If 'roots' is set, only send if windowGlobal.isProcessRoot is true.
|
|
if (
|
|
windowGlobal &&
|
|
(childScope != "roots" || windowGlobal.isProcessRoot)
|
|
) {
|
|
windowGlobal.getActor(actorName).sendAsyncMessage(messageName, args);
|
|
}
|
|
|
|
// Iterate as long as scope in assigned. Note that we use the original
|
|
// passed in scope, not childScope here.
|
|
if (scope) {
|
|
let contexts = browsingContext.getChildren();
|
|
for (let context of contexts) {
|
|
sendToChildren(context, scope);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Pass no second argument to always send to the top-level browsing context.
|
|
sendToChildren(this.browsingContext);
|
|
}
|
|
|
|
enterModalState() {
|
|
this.sendMessageToActor("EnterModalState", {}, "BrowserElement", "roots");
|
|
}
|
|
|
|
leaveModalState() {
|
|
this.sendMessageToActor("LeaveModalState", {}, "BrowserElement", "roots");
|
|
}
|
|
|
|
getDevicePermissionOrigins(key) {
|
|
if (typeof key !== "string" || key.length === 0) {
|
|
throw new Error("Key must be non empty string.");
|
|
}
|
|
if (!this._devicePermissionOrigins) {
|
|
this._devicePermissionOrigins = new Map();
|
|
}
|
|
let origins = this._devicePermissionOrigins.get(key);
|
|
if (!origins) {
|
|
origins = new Set();
|
|
this._devicePermissionOrigins.set(key, origins);
|
|
}
|
|
return origins;
|
|
}
|
|
}
|
|
|
|
MozXULElement.implementCustomInterface(MozBrowser, [Ci.nsIBrowser]);
|
|
customElements.define("browser", MozBrowser);
|
|
}
|