summaryrefslogtreecommitdiffstats
path: root/mobile/android/chrome
diff options
context:
space:
mode:
Diffstat (limited to 'mobile/android/chrome')
-rw-r--r--mobile/android/chrome/geckoview/SessionStateAggregator.js677
-rw-r--r--mobile/android/chrome/geckoview/config.js719
-rw-r--r--mobile/android/chrome/geckoview/config.xhtml148
-rw-r--r--mobile/android/chrome/geckoview/geckoview.js945
-rw-r--r--mobile/android/chrome/geckoview/geckoview.xhtml19
-rw-r--r--mobile/android/chrome/geckoview/jar.mn14
-rw-r--r--mobile/android/chrome/geckoview/moz.build7
-rw-r--r--mobile/android/chrome/moz.build17
8 files changed, 2546 insertions, 0 deletions
diff --git a/mobile/android/chrome/geckoview/SessionStateAggregator.js b/mobile/android/chrome/geckoview/SessionStateAggregator.js
new file mode 100644
index 0000000000..ede17328ac
--- /dev/null
+++ b/mobile/android/chrome/geckoview/SessionStateAggregator.js
@@ -0,0 +1,677 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* 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/. */
+
+/* eslint-env mozilla/frame-script */
+
+"use strict";
+
+const { GeckoViewChildModule } = ChromeUtils.importESModule(
+ "resource://gre/modules/GeckoViewChildModule.sys.mjs"
+);
+const { XPCOMUtils } = ChromeUtils.importESModule(
+ "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+ SessionHistory: "resource://gre/modules/sessionstore/SessionHistory.sys.mjs",
+ clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+ setTimeoutWithTarget: "resource://gre/modules/Timer.sys.mjs",
+});
+
+const NO_INDEX = Number.MAX_SAFE_INTEGER;
+const LAST_INDEX = Number.MAX_SAFE_INTEGER - 1;
+const DEFAULT_INTERVAL_MS = 1500;
+
+// This pref controls whether or not we send updates to the parent on a timeout
+// or not, and should only be used for tests or debugging.
+const TIMEOUT_DISABLED_PREF = "browser.sessionstore.debug.no_auto_updates";
+
+const PREF_INTERVAL = "browser.sessionstore.interval";
+const PREF_SESSION_COLLECTION = "browser.sessionstore.platform_collection";
+
+class Handler {
+ constructor(store) {
+ this.store = store;
+ }
+
+ get mm() {
+ return this.store.mm;
+ }
+
+ get eventDispatcher() {
+ return this.store.eventDispatcher;
+ }
+
+ get messageQueue() {
+ return this.store.messageQueue;
+ }
+
+ get stateChangeNotifier() {
+ return this.store.stateChangeNotifier;
+ }
+}
+
+/**
+ * Listens for state change notifcations from webProgress and notifies each
+ * registered observer for either the start of a page load, or its completion.
+ */
+class StateChangeNotifier extends Handler {
+ constructor(store) {
+ super(store);
+
+ this._observers = new Set();
+ const ifreq = this.mm.docShell.QueryInterface(Ci.nsIInterfaceRequestor);
+ const webProgress = ifreq.getInterface(Ci.nsIWebProgress);
+ webProgress.addProgressListener(
+ this,
+ Ci.nsIWebProgress.NOTIFY_STATE_DOCUMENT
+ );
+ }
+
+ /**
+ * Adds a given observer |obs| to the set of observers that will be notified
+ * when when a new document starts or finishes loading.
+ *
+ * @param obs (object)
+ */
+ addObserver(obs) {
+ this._observers.add(obs);
+ }
+
+ /**
+ * Notifies all observers that implement the given |method|.
+ *
+ * @param method (string)
+ */
+ notifyObservers(method) {
+ for (const obs of this._observers) {
+ if (typeof obs[method] == "function") {
+ obs[method]();
+ }
+ }
+ }
+
+ /**
+ * @see nsIWebProgressListener.onStateChange
+ */
+ onStateChange(webProgress, request, stateFlags, status) {
+ // Ignore state changes for subframes because we're only interested in the
+ // top-document starting or stopping its load.
+ if (!webProgress.isTopLevel || webProgress.DOMWindow != this.mm.content) {
+ return;
+ }
+
+ // onStateChange will be fired when loading the initial about:blank URI for
+ // a browser, which we don't actually care about. This is particularly for
+ // the case of unrestored background tabs, where the content has not yet
+ // been restored: we don't want to accidentally send any updates to the
+ // parent when the about:blank placeholder page has loaded.
+ if (!this.mm.docShell.hasLoadedNonBlankURI) {
+ return;
+ }
+
+ if (stateFlags & Ci.nsIWebProgressListener.STATE_START) {
+ this.notifyObservers("onPageLoadStarted");
+ } else if (stateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+ this.notifyObservers("onPageLoadCompleted");
+ }
+ }
+}
+StateChangeNotifier.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsIWebProgressListener",
+ "nsISupportsWeakReference",
+]);
+
+/**
+ * Listens for changes to the session history. Whenever the user navigates
+ * we will collect URLs and everything belonging to session history.
+ *
+ * Causes a SessionStore:update message to be sent that contains the current
+ * session history.
+ *
+ * Example:
+ * {entries: [{url: "about:mozilla", ...}, ...], index: 1}
+ */
+class SessionHistoryListener extends Handler {
+ constructor(store) {
+ super(store);
+
+ this._fromIdx = NO_INDEX;
+
+ // The state change observer is needed to handle initial subframe loads.
+ // It will redundantly invalidate with the SHistoryListener in some cases
+ // but these invalidations are very cheap.
+ this.stateChangeNotifier.addObserver(this);
+
+ // By adding the SHistoryListener immediately, we will unfortunately be
+ // notified of every history entry as the tab is restored. We don't bother
+ // waiting to add the listener later because these notifications are cheap.
+ // We will likely only collect once since we are batching collection on
+ // a delay.
+ this.mm.docShell
+ .QueryInterface(Ci.nsIWebNavigation)
+ .sessionHistory.legacySHistory.addSHistoryListener(this);
+
+ // Listen for page title changes.
+ this.mm.addEventListener("DOMTitleChanged", this);
+ }
+
+ uninit() {
+ const sessionHistory = this.mm.docShell.QueryInterface(
+ Ci.nsIWebNavigation
+ ).sessionHistory;
+ if (sessionHistory) {
+ sessionHistory.legacySHistory.removeSHistoryListener(this);
+ }
+ }
+
+ collect() {
+ // We want to send down a historychange even for full collects in case our
+ // session history is a partial session history, in which case we don't have
+ // enough information for a full update. collectFrom(-1) tells the collect
+ // function to collect all data avaliable in this process.
+ if (this.mm.docShell) {
+ this.collectFrom(-1);
+ }
+ }
+
+ // History can grow relatively big with the nested elements, so if we don't have to, we
+ // don't want to send the entire history all the time. For a simple optimization
+ // we keep track of the smallest index from after any change has occured and we just send
+ // the elements from that index. If something more complicated happens we just clear it
+ // and send the entire history. We always send the additional info like the current selected
+ // index (so for going back and forth between history entries we set the index to LAST_INDEX
+ // if nothing else changed send an empty array and the additonal info like the selected index)
+ collectFrom(idx) {
+ if (this._fromIdx <= idx) {
+ // If we already know that we need to update history fromn index N we can ignore any changes
+ // tha happened with an element with index larger than N.
+ // Note: initially we use NO_INDEX which is MAX_SAFE_INTEGER which means we don't ignore anything
+ // here, and in case of navigation in the history back and forth we use LAST_INDEX which ignores
+ // only the subsequent navigations, but not any new elements added.
+ return;
+ }
+
+ this._fromIdx = idx;
+ this.messageQueue.push("historychange", () => {
+ if (this._fromIdx === NO_INDEX) {
+ return null;
+ }
+
+ const history = SessionHistory.collect(this.mm.docShell, this._fromIdx);
+ this._fromIdx = NO_INDEX;
+ return history;
+ });
+ }
+
+ handleEvent(event) {
+ this.collect();
+ }
+
+ onPageLoadCompleted() {
+ this.collect();
+ }
+
+ onPageLoadStarted() {
+ this.collect();
+ }
+
+ OnHistoryNewEntry(newURI, oldIndex) {
+ // We ought to collect the previously current entry as well, see bug 1350567.
+ // TODO: Reenable partial history collection for performance
+ // this.collectFrom(oldIndex);
+ this.collect();
+ }
+
+ OnHistoryGotoIndex(index, gotoURI) {
+ // We ought to collect the previously current entry as well, see bug 1350567.
+ // TODO: Reenable partial history collection for performance
+ // this.collectFrom(LAST_INDEX);
+ this.collect();
+ }
+
+ OnHistoryPurge(numEntries) {
+ this.collect();
+ }
+
+ OnHistoryReload(reloadURI, reloadFlags) {
+ this.collect();
+ return true;
+ }
+
+ OnHistoryReplaceEntry(index) {
+ this.collect();
+ }
+}
+SessionHistoryListener.prototype.QueryInterface = ChromeUtils.generateQI([
+ "nsISHistoryListener",
+ "nsISupportsWeakReference",
+]);
+
+/**
+ * Listens for scroll position changes. Whenever the user scrolls the top-most
+ * frame we update the scroll position and will restore it when requested.
+ *
+ * Causes a SessionStore:update message to be sent that contains the current
+ * scroll positions as a tree of strings. If no frame of the whole frame tree
+ * is scrolled this will return null so that we don't tack a property onto
+ * the tabData object in the parent process.
+ *
+ * Example:
+ * {scroll: "100,100", zoom: {resolution: "1.5", displaySize:
+ * {height: "1600", width: "1000"}}, children:
+ * [null, null, {scroll: "200,200"}]}
+ */
+class ScrollPositionListener extends Handler {
+ constructor(store) {
+ super(store);
+
+ SessionStoreUtils.addDynamicFrameFilteredListener(
+ this.mm,
+ "mozvisualscroll",
+ this,
+ /* capture */ false,
+ /* system group */ true
+ );
+
+ SessionStoreUtils.addDynamicFrameFilteredListener(
+ this.mm,
+ "mozvisualresize",
+ this,
+ /* capture */ false,
+ /* system group */ true
+ );
+
+ this.stateChangeNotifier.addObserver(this);
+ }
+
+ handleEvent() {
+ this.messageQueue.push("scroll", () => this.collect());
+ }
+
+ onPageLoadCompleted() {
+ this.messageQueue.push("scroll", () => this.collect());
+ }
+
+ onPageLoadStarted() {
+ this.messageQueue.push("scroll", () => null);
+ }
+
+ collect() {
+ // TODO: Keep an eye on bug 1525259; we may not have to manually store zoom
+ // Save the current document resolution.
+ let zoom = 1;
+ const scrolldata =
+ SessionStoreUtils.collectScrollPosition(this.mm.content) || {};
+ const domWindowUtils = this.mm.content.windowUtils;
+ zoom = domWindowUtils.getResolution();
+ scrolldata.zoom = {};
+ scrolldata.zoom.resolution = zoom;
+
+ // Save some data that'll help in adjusting the zoom level
+ // when restoring in a different screen orientation.
+ const displaySize = {};
+ const width = {},
+ height = {};
+ domWindowUtils.getDocumentViewerSize(width, height);
+
+ displaySize.width = width.value;
+ displaySize.height = height.value;
+
+ scrolldata.zoom.displaySize = displaySize;
+
+ return scrolldata;
+ }
+}
+
+/**
+ * Listens for changes to input elements. Whenever the value of an input
+ * element changes we will re-collect data for the current frame tree and send
+ * a message to the parent process.
+ *
+ * Causes a SessionStore:update message to be sent that contains the form data
+ * for all reachable frames.
+ *
+ * Example:
+ * {
+ * formdata: {url: "http://mozilla.org/", id: {input_id: "input value"}},
+ * children: [
+ * null,
+ * {url: "http://sub.mozilla.org/", id: {input_id: "input value 2"}}
+ * ]
+ * }
+ */
+class FormDataListener extends Handler {
+ constructor(store) {
+ super(store);
+
+ SessionStoreUtils.addDynamicFrameFilteredListener(
+ this.mm,
+ "input",
+ this,
+ true
+ );
+ this.stateChangeNotifier.addObserver(this);
+ }
+
+ handleEvent() {
+ this.messageQueue.push("formdata", () => this.collect());
+ }
+
+ onPageLoadStarted() {
+ this.messageQueue.push("formdata", () => null);
+ }
+
+ collect() {
+ return SessionStoreUtils.collectFormData(this.mm.content);
+ }
+}
+
+/**
+ * A message queue that takes collected data and will take care of sending it
+ * to the chrome process. It allows flushing using synchronous messages and
+ * takes care of any race conditions that might occur because of that. Changes
+ * will be batched if they're pushed in quick succession to avoid a message
+ * flood.
+ */
+class MessageQueue extends Handler {
+ constructor(store) {
+ super(store);
+
+ /**
+ * A map (string -> lazy fn) holding lazy closures of all queued data
+ * collection routines. These functions will return data collected from the
+ * docShell.
+ */
+ this._data = new Map();
+
+ /**
+ * The delay (in ms) used to delay sending changes after data has been
+ * invalidated.
+ */
+ this.BATCH_DELAY_MS = 1000;
+
+ /**
+ * The minimum idle period (in ms) we need for sending data to chrome process.
+ */
+ this.NEEDED_IDLE_PERIOD_MS = 5;
+
+ /**
+ * Timeout for waiting an idle period to send data. We will set this from
+ * the pref "browser.sessionstore.interval".
+ */
+ this._timeoutWaitIdlePeriodMs = null;
+
+ /**
+ * The current timeout ID, null if there is no queue data. We use timeouts
+ * to damp a flood of data changes and send lots of changes as one batch.
+ */
+ this._timeout = null;
+
+ /**
+ * Whether or not sending batched messages on a timer is disabled. This should
+ * only be used for debugging or testing. If you need to access this value,
+ * you should probably use the timeoutDisabled getter.
+ */
+ this._timeoutDisabled = false;
+
+ /**
+ * True if there is already a send pending idle dispatch, set to prevent
+ * scheduling more than one. If false there may or may not be one scheduled.
+ */
+ this._idleScheduled = false;
+
+ this.timeoutDisabled = Services.prefs.getBoolPref(
+ TIMEOUT_DISABLED_PREF,
+ false
+ );
+ this._timeoutWaitIdlePeriodMs = Services.prefs.getIntPref(
+ PREF_INTERVAL,
+ DEFAULT_INTERVAL_MS
+ );
+
+ Services.prefs.addObserver(TIMEOUT_DISABLED_PREF, this);
+ Services.prefs.addObserver(PREF_INTERVAL, this);
+ }
+
+ /**
+ * True if batched messages are not being fired on a timer. This should only
+ * ever be true when debugging or during tests.
+ */
+ get timeoutDisabled() {
+ return this._timeoutDisabled;
+ }
+
+ /**
+ * Disables sending batched messages on a timer. Also cancels any pending
+ * timers.
+ */
+ set timeoutDisabled(val) {
+ this._timeoutDisabled = val;
+
+ if (val && this._timeout) {
+ clearTimeout(this._timeout);
+ this._timeout = null;
+ }
+ }
+
+ uninit() {
+ this.cleanupTimers();
+ }
+
+ /**
+ * Cleanup pending idle callback and timer.
+ */
+ cleanupTimers() {
+ this._idleScheduled = false;
+ if (this._timeout) {
+ clearTimeout(this._timeout);
+ this._timeout = null;
+ }
+ }
+
+ observe(subject, topic, data) {
+ if (topic == "nsPref:changed") {
+ switch (data) {
+ case TIMEOUT_DISABLED_PREF:
+ this.timeoutDisabled = Services.prefs.getBoolPref(
+ TIMEOUT_DISABLED_PREF,
+ false
+ );
+ break;
+ case PREF_INTERVAL:
+ this._timeoutWaitIdlePeriodMs = Services.prefs.getIntPref(
+ PREF_INTERVAL,
+ DEFAULT_INTERVAL_MS
+ );
+ break;
+ default:
+ debug`Received unknown message: ${data}`;
+ break;
+ }
+ }
+ }
+
+ /**
+ * Pushes a given |value| onto the queue. The given |key| represents the type
+ * of data that is stored and can override data that has been queued before
+ * but has not been sent to the parent process, yet.
+ *
+ * @param key (string)
+ * A unique identifier specific to the type of data this is passed.
+ * @param fn (function)
+ * A function that returns the value that will be sent to the parent
+ * process.
+ */
+ push(key, fn) {
+ this._data.set(key, fn);
+
+ if (!this._timeout && !this._timeoutDisabled) {
+ // Wait a little before sending the message to batch multiple changes.
+ this._timeout = setTimeoutWithTarget(
+ () => this.sendWhenIdle(),
+ this.BATCH_DELAY_MS,
+ this.mm.tabEventTarget
+ );
+ }
+ }
+
+ /**
+ * Sends queued data when the remaining idle time is enough or waiting too
+ * long; otherwise, request an idle time again. If the |deadline| is not
+ * given, this function is going to schedule the first request.
+ *
+ * @param deadline (object)
+ * An IdleDeadline object passed by idleDispatch().
+ */
+ sendWhenIdle(deadline) {
+ if (!this.mm.content) {
+ // The frameloader is being torn down. Nothing more to do.
+ return;
+ }
+
+ if (deadline) {
+ if (
+ deadline.didTimeout ||
+ deadline.timeRemaining() > this.NEEDED_IDLE_PERIOD_MS
+ ) {
+ this.send();
+ return;
+ }
+ } else if (this._idleScheduled) {
+ // Bail out if there's a pending run.
+ return;
+ }
+ ChromeUtils.idleDispatch(deadline_ => this.sendWhenIdle(deadline_), {
+ timeout: this._timeoutWaitIdlePeriodMs,
+ });
+ this._idleScheduled = true;
+ }
+
+ /**
+ * Sends queued data to the chrome process.
+ *
+ * @param options (object)
+ * {isFinal: true} to signal this is the final message sent on unload
+ */
+ send(options = {}) {
+ // Looks like we have been called off a timeout after the tab has been
+ // closed. The docShell is gone now and we can just return here as there
+ // is nothing to do.
+ if (!this.mm.docShell) {
+ return;
+ }
+
+ this.cleanupTimers();
+
+ const data = {};
+ for (const [key, func] of this._data) {
+ const value = func();
+
+ if (value || (key != "storagechange" && key != "historychange")) {
+ data[key] = value;
+ }
+ }
+
+ this._data.clear();
+
+ try {
+ // Send all data to the parent process.
+ this.eventDispatcher.sendRequest({
+ type: "GeckoView:StateUpdated",
+ data,
+ isFinal: options.isFinal || false,
+ epoch: this.store.epoch,
+ });
+ } catch (ex) {
+ if (ex && ex.result == Cr.NS_ERROR_OUT_OF_MEMORY) {
+ warn`Failed to save session state`;
+ }
+ }
+ }
+}
+
+class SessionStateAggregator extends GeckoViewChildModule {
+ constructor(aModuleName, aMessageManager) {
+ super(aModuleName, aMessageManager);
+
+ this.mm = aMessageManager;
+ this.messageQueue = new MessageQueue(this);
+ this.stateChangeNotifier = new StateChangeNotifier(this);
+
+ this.handlers = [
+ new SessionHistoryListener(this),
+ this.stateChangeNotifier,
+ this.messageQueue,
+ ];
+
+ if (!Services.prefs.getBoolPref(PREF_SESSION_COLLECTION, false)) {
+ this.handlers.push(
+ new FormDataListener(this),
+ new ScrollPositionListener(this)
+ );
+ }
+
+ this.messageManager.addMessageListener("GeckoView:FlushSessionState", this);
+ }
+
+ receiveMessage(aMsg) {
+ debug`receiveMessage: ${aMsg.name}`;
+
+ switch (aMsg.name) {
+ case "GeckoView:FlushSessionState":
+ this.flush();
+ break;
+ }
+ }
+
+ flush() {
+ // Flush the message queue, send the latest updates.
+ this.messageQueue.send();
+ }
+
+ onUnload() {
+ // Upon frameLoader destruction, send a final update message to
+ // the parent and flush all data currently held in the child.
+ this.messageQueue.send({ isFinal: true });
+
+ for (const handler of this.handlers) {
+ if (handler.uninit) {
+ handler.uninit();
+ }
+ }
+
+ // We don't need to take care of any StateChangeNotifier observers as they
+ // will die with the content script.
+ }
+}
+
+// TODO: Bug 1648158 Move SessionAggregator to the parent process
+class DummySessionStateAggregator extends GeckoViewChildModule {
+ constructor(aModuleName, aMessageManager) {
+ super(aModuleName, aMessageManager);
+ this.messageManager.addMessageListener("GeckoView:FlushSessionState", this);
+ }
+
+ receiveMessage(aMsg) {
+ debug`receiveMessage: ${aMsg.name}`;
+
+ switch (aMsg.name) {
+ case "GeckoView:FlushSessionState":
+ // Do nothing
+ break;
+ }
+ }
+}
+
+const { debug, warn } = SessionStateAggregator.initLogging(
+ "SessionStateAggregator"
+);
+
+const module = Services.appinfo.sessionHistoryInParent
+ ? // If history is handled in the parent we don't need a session aggregator
+ // TODO: Bug 1648158 remove this and do everything in the parent
+ DummySessionStateAggregator.create(this)
+ : SessionStateAggregator.create(this);
diff --git a/mobile/android/chrome/geckoview/config.js b/mobile/android/chrome/geckoview/config.js
new file mode 100644
index 0000000000..1cf92416ac
--- /dev/null
+++ b/mobile/android/chrome/geckoview/config.js
@@ -0,0 +1,719 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+
+var Cm = Components.manager;
+
+const VKB_ENTER_KEY = 13; // User press of VKB enter key
+const INITIAL_PAGE_DELAY = 500; // Initial pause on program start for scroll alignment
+const PREFS_BUFFER_MAX = 30; // Max prefs buffer size for getPrefsBuffer()
+const PAGE_SCROLL_TRIGGER = 200; // Triggers additional getPrefsBuffer() on user scroll-to-bottom
+const FILTER_CHANGE_TRIGGER = 200; // Delay between responses to filterInput changes
+const INNERHTML_VALUE_DELAY = 100; // Delay before providing prefs innerHTML value
+
+var gClipboardHelper = Cc["@mozilla.org/widget/clipboardhelper;1"].getService(
+ Ci.nsIClipboardHelper
+);
+
+/* ============================== NewPrefDialog ==============================
+ *
+ * New Preference Dialog Object and methods
+ *
+ * Implements User Interfaces for creation of a single(new) Preference setting
+ *
+ */
+var NewPrefDialog = {
+ _prefsShield: null,
+
+ _newPrefsDialog: null,
+ _newPrefItem: null,
+ _prefNameInputElt: null,
+ _prefTypeSelectElt: null,
+
+ _booleanValue: null,
+ _booleanToggle: null,
+ _stringValue: null,
+ _intValue: null,
+
+ _positiveButton: null,
+
+ get type() {
+ return this._prefTypeSelectElt.value;
+ },
+
+ set type(aType) {
+ this._prefTypeSelectElt.value = aType;
+ switch (this._prefTypeSelectElt.value) {
+ case "boolean":
+ this._prefTypeSelectElt.selectedIndex = 0;
+ break;
+ case "string":
+ this._prefTypeSelectElt.selectedIndex = 1;
+ break;
+ case "int":
+ this._prefTypeSelectElt.selectedIndex = 2;
+ break;
+ }
+
+ this._newPrefItem.setAttribute("typestyle", aType);
+ },
+
+ // Init the NewPrefDialog
+ init: function AC_init() {
+ this._prefsShield = document.getElementById("prefs-shield");
+
+ this._newPrefsDialog = document.getElementById("new-pref-container");
+ this._newPrefItem = document.getElementById("new-pref-item");
+ this._prefNameInputElt = document.getElementById("new-pref-name");
+ this._prefTypeSelectElt = document.getElementById("new-pref-type");
+
+ this._booleanValue = document.getElementById("new-pref-value-boolean");
+ this._stringValue = document.getElementById("new-pref-value-string");
+ this._intValue = document.getElementById("new-pref-value-int");
+
+ this._positiveButton = document.getElementById("positive-button");
+ },
+
+ // Called to update positive button to display text ("Create"/"Change), and enabled/disabled status
+ // As new pref name is initially displayed, re-focused, or modifed during user input
+ _updatePositiveButton: function AC_updatePositiveButton(aPrefName) {
+ document.l10n.setAttributes(
+ this._positiveButton,
+ "config-new-pref-create-button"
+ );
+ this._positiveButton.setAttribute("disabled", true);
+ if (aPrefName == "") {
+ return;
+ }
+
+ // If item already in list, it's being changed, else added
+ const item = AboutConfig._list.filter(i => {
+ return i.name == aPrefName;
+ });
+ if (item.length) {
+ document.l10n.setAttributes(
+ this._positiveButton,
+ "config-new-pref-change-button"
+ );
+ } else {
+ this._positiveButton.removeAttribute("disabled");
+ }
+ },
+
+ // When we want to cancel/hide an existing, or show a new pref dialog
+ toggleShowHide: function AC_toggleShowHide() {
+ if (this._newPrefsDialog.classList.contains("show")) {
+ this.hide();
+ } else {
+ this._show();
+ }
+ },
+
+ // When we want to show the new pref dialog / shield the prefs list
+ _show: function AC_show() {
+ this._newPrefsDialog.classList.add("show");
+ this._prefsShield.setAttribute("shown", true);
+
+ // Initial default field values
+ this._prefNameInputElt.value = "";
+ this._updatePositiveButton(this._prefNameInputElt.value);
+
+ this.type = "boolean";
+ this._booleanValue.value = "false";
+ this._stringValue.value = "";
+ this._intValue.value = "";
+
+ this._prefNameInputElt.focus();
+
+ window.addEventListener("keypress", this.handleKeypress);
+ },
+
+ // When we want to cancel/hide the new pref dialog / un-shield the prefs list
+ hide: function AC_hide() {
+ this._newPrefsDialog.classList.remove("show");
+ this._prefsShield.removeAttribute("shown");
+
+ window.removeEventListener("keypress", this.handleKeypress);
+ },
+
+ // Watch user key input so we can provide Enter key action, commit input values
+ handleKeypress: function AC_handleKeypress(aEvent) {
+ // Close our VKB on new pref enter key press
+ if (aEvent.keyCode == VKB_ENTER_KEY) {
+ aEvent.target.blur();
+ }
+ },
+
+ // New prefs create dialog only allows creating a non-existing preference, doesn't allow for
+ // Changing an existing one on-the-fly, tap existing/displayed line item pref for that
+ create: function AC_create(aEvent) {
+ if (this._positiveButton.getAttribute("disabled") == "true") {
+ return;
+ }
+
+ switch (this.type) {
+ case "boolean":
+ Services.prefs.setBoolPref(
+ this._prefNameInputElt.value,
+ !!(this._booleanValue.value == "true")
+ );
+ break;
+ case "string":
+ Services.prefs.setCharPref(
+ this._prefNameInputElt.value,
+ this._stringValue.value
+ );
+ break;
+ case "int":
+ Services.prefs.setIntPref(
+ this._prefNameInputElt.value,
+ this._intValue.value
+ );
+ break;
+ }
+
+ // Ensure pref adds flushed to disk immediately
+ Services.prefs.savePrefFile(null);
+
+ this.hide();
+ },
+
+ // Display proper positive button text/state on new prefs name input focus
+ focusName: function AC_focusName(aEvent) {
+ this._updatePositiveButton(aEvent.target.value);
+ },
+
+ // Display proper positive button text/state as user changes new prefs name
+ updateName: function AC_updateName(aEvent) {
+ this._updatePositiveButton(aEvent.target.value);
+ },
+
+ // In new prefs dialog, bool prefs are <input type="text">, as they aren't yet tied to an
+ // Actual Services.prefs.*etBoolPref()
+ toggleBoolValue: function AC_toggleBoolValue() {
+ this._booleanValue.value =
+ this._booleanValue.value == "true" ? "false" : "true";
+ },
+};
+
+/* ============================== AboutConfig ==============================
+ *
+ * Main AboutConfig object and methods
+ *
+ * Implements User Interfaces for maintenance of a list of Preference settings
+ *
+ */
+var AboutConfig = {
+ contextMenuLINode: null,
+ filterInput: null,
+ _filterPrevInput: null,
+ _filterChangeTimer: null,
+ _prefsContainer: null,
+ _loadingContainer: null,
+ _list: null,
+
+ // Init the main AboutConfig dialog
+ init: function AC_init() {
+ this.filterInput = document.getElementById("filter-input");
+ this._prefsContainer = document.getElementById("prefs-container");
+ this._loadingContainer = document.getElementById("loading-container");
+
+ const list = Services.prefs.getChildList("");
+ this._list = list.sort().map(function AC_getMapPref(aPref) {
+ return new Pref(aPref);
+ }, this);
+
+ // Support filtering about:config via a ?filter=<string> param
+ const match = /[?&]filter=([^&]+)/i.exec(window.location.href);
+ if (match) {
+ this.filterInput.value = decodeURIComponent(match[1]);
+ }
+
+ // Display the current prefs list (retains searchFilter value)
+ this.bufferFilterInput();
+
+ // Setup the prefs observers
+ Services.prefs.addObserver("", this);
+ },
+
+ // Uninit the main AboutConfig dialog
+ uninit: function AC_uninit() {
+ // Remove the prefs observer
+ Services.prefs.removeObserver("", this);
+ },
+
+ // Clear the filterInput value, to display the entire list
+ clearFilterInput: function AC_clearFilterInput() {
+ this.filterInput.value = "";
+ this.bufferFilterInput();
+ },
+
+ // Buffer down rapid changes in filterInput value from keyboard
+ bufferFilterInput: function AC_bufferFilterInput() {
+ if (this._filterChangeTimer) {
+ clearTimeout(this._filterChangeTimer);
+ }
+
+ this._filterChangeTimer = setTimeout(() => {
+ this._filterChangeTimer = null;
+ // Display updated prefs list when filterInput value settles
+ this._displayNewList();
+ }, FILTER_CHANGE_TRIGGER);
+ },
+
+ // Update displayed list when filterInput value changes
+ _displayNewList: function AC_displayNewList() {
+ // This survives the search filter value past a page refresh
+ this.filterInput.setAttribute("value", this.filterInput.value);
+
+ // Don't start new filter search if same as last
+ if (this.filterInput.value == this._filterPrevInput) {
+ return;
+ }
+ this._filterPrevInput = this.filterInput.value;
+
+ // Clear list item selection / context menu, prefs list, get first buffer, set scrolling on
+ this.selected = "";
+ this._clearPrefsContainer();
+ this._addMorePrefsToContainer();
+ window.onscroll = this.onScroll.bind(this);
+
+ // Pause for screen to settle, then ensure at top
+ setTimeout(() => {
+ window.scrollTo(0, 0);
+ }, INITIAL_PAGE_DELAY);
+ },
+
+ // Clear the displayed preferences list
+ _clearPrefsContainer: function AC_clearPrefsContainer() {
+ // Quick clear the prefsContainer list
+ const empty = this._prefsContainer.cloneNode(false);
+ this._prefsContainer.parentNode.replaceChild(empty, this._prefsContainer);
+ this._prefsContainer = empty;
+
+ // Quick clear the prefs li.HTML list
+ this._list.forEach(function (item) {
+ delete item.li;
+ });
+ },
+
+ // Get a small manageable block of prefs items, and add them to the displayed list
+ _addMorePrefsToContainer: function AC_addMorePrefsToContainer() {
+ // Create filter regex
+ const filterExp = this.filterInput.value
+ ? new RegExp(this.filterInput.value, "i")
+ : null;
+
+ // Get a new block for the display list
+ const prefsBuffer = [];
+ for (
+ let i = 0;
+ i < this._list.length && prefsBuffer.length < PREFS_BUFFER_MAX;
+ i++
+ ) {
+ if (!this._list[i].li && this._list[i].test(filterExp)) {
+ prefsBuffer.push(this._list[i]);
+ }
+ }
+
+ // Add the new block to the displayed list
+ for (let i = 0; i < prefsBuffer.length; i++) {
+ this._prefsContainer.appendChild(prefsBuffer[i].getOrCreateNewLINode());
+ }
+
+ // Determine if anything left to add later by scrolling
+ let anotherPrefsBufferRemains = false;
+ for (let i = 0; i < this._list.length; i++) {
+ if (!this._list[i].li && this._list[i].test(filterExp)) {
+ anotherPrefsBufferRemains = true;
+ break;
+ }
+ }
+
+ if (anotherPrefsBufferRemains) {
+ // If still more could be displayed, show the throbber
+ this._loadingContainer.style.display = "block";
+ } else {
+ // If no more could be displayed, hide the throbber, and stop noticing scroll events
+ this._loadingContainer.style.display = "none";
+ window.onscroll = null;
+ }
+ },
+
+ // If scrolling at the bottom, maybe add some more entries
+ onScroll: function AC_onScroll(aEvent) {
+ if (
+ this._prefsContainer.scrollHeight -
+ (window.pageYOffset + window.innerHeight) <
+ PAGE_SCROLL_TRIGGER
+ ) {
+ if (!this._filterChangeTimer) {
+ this._addMorePrefsToContainer();
+ }
+ }
+ },
+
+ // Return currently selected list item node
+ get selected() {
+ return document.querySelector(".pref-item.selected");
+ },
+
+ // Set list item node as selected
+ set selected(aSelection) {
+ const currentSelection = this.selected;
+ if (aSelection == currentSelection) {
+ return;
+ }
+
+ // Clear any previous selection
+ if (currentSelection) {
+ currentSelection.classList.remove("selected");
+ currentSelection.removeEventListener("keypress", this.handleKeypress);
+ }
+
+ // Set any current selection
+ if (aSelection) {
+ aSelection.classList.add("selected");
+ aSelection.addEventListener("keypress", this.handleKeypress);
+ }
+ },
+
+ // Watch user key input so we can provide Enter key action, commit input values
+ handleKeypress: function AC_handleKeypress(aEvent) {
+ if (aEvent.keyCode == VKB_ENTER_KEY) {
+ aEvent.target.blur();
+ }
+ },
+
+ // Return the target list item node of an action event
+ getLINodeForEvent: function AC_getLINodeForEvent(aEvent) {
+ let node = aEvent.target;
+ while (node && node.nodeName != "li") {
+ node = node.parentNode;
+ }
+
+ return node;
+ },
+
+ // Return a pref of a list item node
+ _getPrefForNode: function AC_getPrefForNode(aNode) {
+ const pref = aNode.getAttribute("name");
+
+ return new Pref(pref);
+ },
+
+ // When list item name or value are tapped
+ selectOrToggleBoolPref: function AC_selectOrToggleBoolPref(aEvent) {
+ const node = this.getLINodeForEvent(aEvent);
+
+ // If not already selected, just do so
+ if (this.selected != node) {
+ this.selected = node;
+ return;
+ }
+
+ // If already selected, and value is boolean, toggle it
+ const pref = this._getPrefForNode(node);
+ if (pref.type != Services.prefs.PREF_BOOL) {
+ return;
+ }
+
+ this.toggleBoolPref(aEvent);
+ },
+
+ // When finalizing list input values due to blur
+ setIntOrStringPref: function AC_setIntOrStringPref(aEvent) {
+ const node = this.getLINodeForEvent(aEvent);
+
+ // Skip if locked
+ const pref = this._getPrefForNode(node);
+ if (pref.locked) {
+ return;
+ }
+
+ // Boolean inputs blur to remove focus from "button"
+ if (pref.type == Services.prefs.PREF_BOOL) {
+ return;
+ }
+
+ // String and Int inputs change / commit on blur
+ pref.value = aEvent.target.value;
+ },
+
+ // When we reset a pref to it's default value (note resetting a user created pref will delete it)
+ resetDefaultPref: function AC_resetDefaultPref(aEvent) {
+ const node = this.getLINodeForEvent(aEvent);
+
+ // If not already selected, do so
+ if (this.selected != node) {
+ this.selected = node;
+ }
+
+ // Reset will handle any locked condition
+ const pref = this._getPrefForNode(node);
+ pref.reset();
+
+ // Ensure pref reset flushed to disk immediately
+ Services.prefs.savePrefFile(null);
+ },
+
+ // When we want to toggle a bool pref
+ toggleBoolPref: function AC_toggleBoolPref(aEvent) {
+ const node = this.getLINodeForEvent(aEvent);
+
+ // Skip if locked, or not boolean
+ const pref = this._getPrefForNode(node);
+ if (pref.locked) {
+ return;
+ }
+
+ // Toggle, and blur to remove field focus
+ pref.value = !pref.value;
+ aEvent.target.blur();
+ },
+
+ // When Int inputs have their Up or Down arrows toggled
+ incrOrDecrIntPref: function AC_incrOrDecrIntPref(aEvent, aInt) {
+ const node = this.getLINodeForEvent(aEvent);
+
+ // Skip if locked
+ const pref = this._getPrefForNode(node);
+ if (pref.locked) {
+ return;
+ }
+
+ pref.value += aInt;
+ },
+
+ // Observe preference changes
+ observe: function AC_observe(aSubject, aTopic, aPrefName) {
+ const pref = new Pref(aPrefName);
+
+ // Ignore uninteresting changes, and avoid "private" preferences
+ if (aTopic != "nsPref:changed") {
+ return;
+ }
+
+ // If pref type invalid, refresh display as user reset/removed an item from the list
+ if (pref.type == Services.prefs.PREF_INVALID) {
+ document.location.reload();
+ return;
+ }
+
+ // If pref onscreen, update in place.
+ const item = document.querySelector(
+ '.pref-item[name="' + CSS.escape(pref.name) + '"]'
+ );
+ if (item) {
+ item.setAttribute("value", pref.value);
+ const input = item.querySelector("input");
+ input.setAttribute("value", pref.value);
+ input.value = pref.value;
+
+ pref.default
+ ? item.querySelector(".reset").setAttribute("disabled", "true")
+ : item.querySelector(".reset").removeAttribute("disabled");
+ return;
+ }
+
+ // If pref not already in list, refresh display as it's being added
+ const anyWhere = this._list.filter(i => {
+ return i.name == pref.name;
+ });
+ if (!anyWhere.length) {
+ document.location.reload();
+ }
+ },
+
+ // Quick context menu helpers for about:config
+ clipboardCopy: function AC_clipboardCopy(aField) {
+ const pref = this._getPrefForNode(this.contextMenuLINode);
+ if (aField == "name") {
+ gClipboardHelper.copyString(pref.name);
+ } else {
+ gClipboardHelper.copyString(pref.value);
+ }
+ },
+};
+
+/* ============================== Pref ==============================
+ *
+ * Individual Preference object / methods
+ *
+ * Defines a Pref object, a document list item tied to Preferences Services
+ * And the methods by which they interact.
+ *
+ */
+function Pref(aName) {
+ this.name = aName;
+}
+
+Pref.prototype = {
+ get type() {
+ return Services.prefs.getPrefType(this.name);
+ },
+
+ get value() {
+ switch (this.type) {
+ case Services.prefs.PREF_BOOL:
+ return Services.prefs.getBoolPref(this.name);
+ case Services.prefs.PREF_INT:
+ return Services.prefs.getIntPref(this.name);
+ case Services.prefs.PREF_STRING:
+ default:
+ return Services.prefs.getCharPref(this.name);
+ }
+ },
+ set value(aPrefValue) {
+ switch (this.type) {
+ case Services.prefs.PREF_BOOL:
+ Services.prefs.setBoolPref(this.name, aPrefValue);
+ break;
+ case Services.prefs.PREF_INT:
+ Services.prefs.setIntPref(this.name, aPrefValue);
+ break;
+ case Services.prefs.PREF_STRING:
+ default:
+ Services.prefs.setCharPref(this.name, aPrefValue);
+ }
+
+ // Ensure pref change flushed to disk immediately
+ Services.prefs.savePrefFile(null);
+ },
+
+ get default() {
+ return !Services.prefs.prefHasUserValue(this.name);
+ },
+
+ get locked() {
+ return Services.prefs.prefIsLocked(this.name);
+ },
+
+ reset: function AC_reset() {
+ Services.prefs.clearUserPref(this.name);
+ },
+
+ test: function AC_test(aValue) {
+ return aValue ? aValue.test(this.name) : true;
+ },
+
+ // Get existing or create new LI node for the pref
+ getOrCreateNewLINode: function AC_getOrCreateNewLINode() {
+ if (!this.li) {
+ this.li = document.createElement("li");
+
+ this.li.className = "pref-item";
+ this.li.setAttribute("name", this.name);
+
+ // Click callback to ensure list item selected even on no-action tap events
+ this.li.addEventListener("click", function (aEvent) {
+ AboutConfig.selected = AboutConfig.getLINodeForEvent(aEvent);
+ });
+
+ // Contextmenu callback to identify selected list item
+ this.li.addEventListener("contextmenu", function (aEvent) {
+ AboutConfig.contextMenuLINode = AboutConfig.getLINodeForEvent(aEvent);
+ });
+
+ this.li.setAttribute("contextmenu", "prefs-context-menu");
+
+ const prefName = document.createElement("div");
+ prefName.className = "pref-name";
+ prefName.addEventListener("click", function (event) {
+ AboutConfig.selectOrToggleBoolPref(event);
+ });
+ prefName.textContent = this.name;
+
+ this.li.appendChild(prefName);
+
+ const prefItemLine = document.createElement("div");
+ prefItemLine.className = "pref-item-line";
+
+ const prefValue = document.createElement("input");
+ prefValue.className = "pref-value";
+ prefValue.addEventListener("blur", function (event) {
+ AboutConfig.setIntOrStringPref(event);
+ });
+ prefValue.addEventListener("click", function (event) {
+ AboutConfig.selectOrToggleBoolPref(event);
+ });
+ prefValue.value = "";
+ prefItemLine.appendChild(prefValue);
+
+ const resetButton = document.createElement("div");
+ resetButton.className = "pref-button reset";
+ resetButton.addEventListener("click", function (event) {
+ AboutConfig.resetDefaultPref(event);
+ });
+ resetButton.setAttribute("data-l10n-id", "config-pref-reset-button");
+ prefItemLine.appendChild(resetButton);
+
+ const toggleButton = document.createElement("div");
+ toggleButton.className = "pref-button toggle";
+ toggleButton.addEventListener("click", function (event) {
+ AboutConfig.toggleBoolPref(event);
+ });
+ toggleButton.setAttribute("data-l10n-id", "config-pref-toggle-button");
+ prefItemLine.appendChild(toggleButton);
+
+ const upButton = document.createElement("div");
+ upButton.className = "pref-button up";
+ upButton.addEventListener("click", function (event) {
+ AboutConfig.incrOrDecrIntPref(event, 1);
+ });
+ prefItemLine.appendChild(upButton);
+
+ const downButton = document.createElement("div");
+ downButton.className = "pref-button down";
+ downButton.addEventListener("click", function (event) {
+ AboutConfig.incrOrDecrIntPref(event, -1);
+ });
+ prefItemLine.appendChild(downButton);
+
+ this.li.appendChild(prefItemLine);
+
+ // Delay providing the list item values, until the LI is returned and added to the document
+ setTimeout(this._valueSetup.bind(this), INNERHTML_VALUE_DELAY);
+ }
+
+ return this.li;
+ },
+
+ // Initialize list item object values
+ _valueSetup: function AC_valueSetup() {
+ this.li.setAttribute("type", this.type);
+ this.li.setAttribute("value", this.value);
+
+ const valDiv = this.li.querySelector(".pref-value");
+ valDiv.value = this.value;
+
+ switch (this.type) {
+ case Services.prefs.PREF_BOOL:
+ valDiv.setAttribute("type", "button");
+ this.li.querySelector(".up").setAttribute("disabled", true);
+ this.li.querySelector(".down").setAttribute("disabled", true);
+ break;
+ case Services.prefs.PREF_STRING:
+ valDiv.setAttribute("type", "text");
+ this.li.querySelector(".up").setAttribute("disabled", true);
+ this.li.querySelector(".down").setAttribute("disabled", true);
+ this.li.querySelector(".toggle").setAttribute("disabled", true);
+ break;
+ case Services.prefs.PREF_INT:
+ valDiv.setAttribute("type", "number");
+ this.li.querySelector(".toggle").setAttribute("disabled", true);
+ break;
+ }
+
+ this.li.setAttribute("default", this.default);
+ if (this.default) {
+ this.li.querySelector(".reset").setAttribute("disabled", true);
+ }
+
+ if (this.locked) {
+ valDiv.setAttribute("disabled", this.locked);
+ this.li.querySelector(".pref-name").setAttribute("locked", true);
+ }
+ },
+};
diff --git a/mobile/android/chrome/geckoview/config.xhtml b/mobile/android/chrome/geckoview/config.xhtml
new file mode 100644
index 0000000000..ab760beea4
--- /dev/null
+++ b/mobile/android/chrome/geckoview/config.xhtml
@@ -0,0 +1,148 @@
+<?xml version="1.0"?>
+
+<!-- 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/. -->
+
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+
+<html xmlns="http://www.w3.org/1999/xhtml">
+ <head>
+ <meta name="viewport" content="width=device-width; user-scalable=0" />
+ <title>about:config</title>
+ <meta charset="UTF-8" />
+
+ <link rel="localization" href="mobile/android/aboutConfig.ftl" />
+ <link
+ rel="stylesheet"
+ href="chrome://geckoview/skin/config.css"
+ type="text/css"
+ />
+ <script
+ type="text/javascript"
+ src="chrome://geckoview/content/config.js"
+ ></script>
+ </head>
+
+ <body
+ onload="NewPrefDialog.init(); AboutConfig.init();"
+ onunload="AboutConfig.uninit();"
+ >
+ <div class="toolbar">
+ <div class="toolbar-container">
+ <div
+ id="new-pref-toggle-button"
+ onclick="NewPrefDialog.toggleShowHide();"
+ />
+
+ <div class="toolbar-item" id="filter-container">
+ <div id="filter-search-button" />
+ <input
+ id="filter-input"
+ type="search"
+ data-l10n-id="config-toolbar-search"
+ value=""
+ oninput="AboutConfig.bufferFilterInput();"
+ />
+ <div
+ id="filter-input-clear-button"
+ onclick="AboutConfig.clearFilterInput();"
+ />
+ </div>
+ </div>
+ </div>
+
+ <div id="content" ontouchstart="AboutConfig.filterInput.blur();">
+ <div id="new-pref-container">
+ <li class="pref-item" id="new-pref-item">
+ <div class="pref-item-line">
+ <input
+ class="pref-name"
+ id="new-pref-name"
+ type="text"
+ data-l10n-id="config-new-pref-name"
+ onfocus="NewPrefDialog.focusName(event);"
+ oninput="NewPrefDialog.updateName(event);"
+ />
+ <select
+ id="new-pref-type"
+ onchange="NewPrefDialog.type = event.target.value;"
+ >
+ <option
+ value="boolean"
+ data-l10n-id="config-new-pref-value-boolean"
+ ></option>
+ <option
+ value="string"
+ data-l10n-id="config-new-pref-value-string"
+ ></option>
+ <option
+ value="int"
+ data-l10n-id="config-new-pref-value-integer"
+ ></option>
+ </select>
+ </div>
+
+ <div class="pref-item-line" id="new-pref-line-boolean">
+ <input
+ class="pref-value"
+ id="new-pref-value-boolean"
+ disabled="disabled"
+ />
+ <div
+ class="pref-button toggle"
+ onclick="NewPrefDialog.toggleBoolValue();"
+ data-l10n-id="config-pref-toggle-button"
+ ></div>
+ </div>
+
+ <div class="pref-item-line" id="new-pref-line-input">
+ <input
+ class="pref-value"
+ id="new-pref-value-string"
+ data-l10n-id="config-new-pref-string"
+ />
+ <input
+ class="pref-value"
+ id="new-pref-value-int"
+ data-l10n-id="config-new-pref-number"
+ type="number"
+ />
+ </div>
+
+ <div class="pref-item-line">
+ <div
+ class="pref-button cancel"
+ id="negative-button"
+ onclick="NewPrefDialog.hide();"
+ data-l10n-id="config-new-pref-cancel-button"
+ ></div>
+ <div
+ class="pref-button create"
+ id="positive-button"
+ onclick="NewPrefDialog.create(event);"
+ data-l10n-id="config-new-pref-create-button"
+ ></div>
+ </div>
+ </li>
+ </div>
+
+ <div id="prefs-shield"></div>
+
+ <ul id="prefs-container" />
+
+ <div id="loading-container"></div>
+ </div>
+
+ <menu type="context" id="prefs-context-menu">
+ <menuitem
+ data-l10n-id="config-context-menu-copy-pref-name"
+ onclick="AboutConfig.clipboardCopy('name');"
+ ></menuitem>
+ <menuitem
+ data-l10n-id="config-context-menu-copy-pref-value"
+ onclick="AboutConfig.clipboardCopy('value');"
+ ></menuitem>
+ </menu>
+ </body>
+</html>
diff --git a/mobile/android/chrome/geckoview/geckoview.js b/mobile/android/chrome/geckoview/geckoview.js
new file mode 100644
index 0000000000..6dc5ed4610
--- /dev/null
+++ b/mobile/android/chrome/geckoview/geckoview.js
@@ -0,0 +1,945 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+var { DelayedInit } = ChromeUtils.importESModule(
+ "resource://gre/modules/DelayedInit.sys.mjs"
+);
+var { XPCOMUtils } = ChromeUtils.importESModule(
+ "resource://gre/modules/XPCOMUtils.sys.mjs"
+);
+
+ChromeUtils.defineESModuleGetters(this, {
+ Blocklist: "resource://gre/modules/Blocklist.sys.mjs",
+ E10SUtils: "resource://gre/modules/E10SUtils.sys.mjs",
+ EventDispatcher: "resource://gre/modules/Messaging.sys.mjs",
+ GeckoViewActorManager: "resource://gre/modules/GeckoViewActorManager.sys.mjs",
+ GeckoViewSettings: "resource://gre/modules/GeckoViewSettings.sys.mjs",
+ GeckoViewUtils: "resource://gre/modules/GeckoViewUtils.sys.mjs",
+ InitializationTracker: "resource://gre/modules/GeckoViewTelemetry.sys.mjs",
+ RemoteSecuritySettings:
+ "resource://gre/modules/psm/RemoteSecuritySettings.sys.mjs",
+ SafeBrowsing: "resource://gre/modules/SafeBrowsing.sys.mjs",
+});
+
+ChromeUtils.defineLazyGetter(this, "WindowEventDispatcher", () =>
+ EventDispatcher.for(window)
+);
+
+XPCOMUtils.defineLazyScriptGetter(
+ this,
+ "PrintUtils",
+ "chrome://global/content/printUtils.js"
+);
+
+// This file assumes `warn` and `debug` are imported into scope
+// by the child scripts.
+/* global debug, warn */
+
+/**
+ * ModuleManager creates and manages GeckoView modules. Each GeckoView module
+ * normally consists of a JSM module file with an optional content module file.
+ * The module file contains a class that extends GeckoViewModule, and the
+ * content module file contains a class that extends GeckoViewChildModule. A
+ * module usually pairs with a particular GeckoSessionHandler or delegate on the
+ * Java side, and automatically receives module lifetime events such as
+ * initialization, change in enabled state, and change in settings.
+ */
+var ModuleManager = {
+ get _initData() {
+ return window.arguments[0].QueryInterface(Ci.nsIAndroidView).initData;
+ },
+
+ init(aBrowser, aModules) {
+ const initData = this._initData;
+ this._browser = aBrowser;
+ this._settings = initData.settings;
+ this._frozenSettings = Object.freeze(Object.assign({}, this._settings));
+
+ const self = this;
+ this._modules = new Map(
+ (function* () {
+ for (const module of aModules) {
+ yield [
+ module.name,
+ new ModuleInfo({
+ enabled: !!initData.modules[module.name],
+ manager: self,
+ ...module,
+ }),
+ ];
+ }
+ })()
+ );
+
+ window.document.documentElement.appendChild(aBrowser);
+
+ // By default all layers are discarded when a browser is set to inactive.
+ // GeckoView by default sets browsers to inactive every time they're not
+ // visible. To avoid flickering when changing tabs, we preserve layers for
+ // all loaded tabs.
+ aBrowser.preserveLayers(true);
+ // GeckoView browsers start off as active (for now at least).
+ // See bug 1815015 for an attempt at making them start off inactive.
+ aBrowser.docShellIsActive = true;
+
+ WindowEventDispatcher.registerListener(this, [
+ "GeckoView:UpdateModuleState",
+ "GeckoView:UpdateInitData",
+ "GeckoView:UpdateSettings",
+ ]);
+
+ this.messageManager.addMessageListener(
+ "GeckoView:ContentModuleLoaded",
+ this
+ );
+
+ this._moduleByActorName = new Map();
+ this.forEach(module => {
+ module.onInit();
+ module.loadInitFrameScript();
+ for (const actorName of module.actorNames) {
+ this._moduleByActorName[actorName] = module;
+ }
+ });
+
+ window.addEventListener("unload", () => {
+ this.forEach(module => {
+ module.enabled = false;
+ module.onDestroy();
+ });
+
+ this._modules.clear();
+ });
+ },
+
+ onPrintWindow(aParams) {
+ if (!aParams.openWindowInfo.isForWindowDotPrint) {
+ return PrintUtils.handleStaticCloneCreatedForPrint(
+ aParams.openWindowInfo
+ );
+ }
+ const printActor = this.window.moduleManager.getActor(
+ "GeckoViewPrintDelegate"
+ );
+ // Prevents continually making new static browsers
+ if (printActor.browserStaticClone != null) {
+ throw new Error("A prior window.print is still in progress.");
+ }
+ const staticBrowser = PrintUtils.createParentBrowserForStaticClone(
+ aParams.openWindowInfo.parent,
+ aParams.openWindowInfo
+ );
+ printActor.browserStaticClone = staticBrowser;
+ printActor.printRequest();
+ return staticBrowser;
+ },
+
+ get window() {
+ return window;
+ },
+
+ get browser() {
+ return this._browser;
+ },
+
+ get messageManager() {
+ return this._browser.messageManager;
+ },
+
+ get eventDispatcher() {
+ return WindowEventDispatcher;
+ },
+
+ get settings() {
+ return this._frozenSettings;
+ },
+
+ forEach(aCallback) {
+ this._modules.forEach(aCallback, this);
+ },
+
+ getActor(aActorName) {
+ return this.browser.browsingContext.currentWindowGlobal?.getActor(
+ aActorName
+ );
+ },
+
+ // Ensures that session history has been flushed before changing remoteness
+ async prepareToChangeRemoteness() {
+ // Session state like history is maintained at the process level so we need
+ // to collect it and restore it in the other process when switching.
+ // TODO: This should go away when we migrate the history to the main
+ // process Bug 1507287.
+ const { history } = await this.getActor("GeckoViewContent").collectState();
+
+ // Ignore scroll and form data since we're navigating away from this page
+ // anyway
+ this.sessionState = { history };
+ },
+
+ willChangeBrowserRemoteness() {
+ debug`WillChangeBrowserRemoteness`;
+
+ // Now we're switching the remoteness.
+ this.disabledModules = [];
+ this.forEach(module => {
+ if (module.enabled && module.disableOnProcessSwitch) {
+ module.enabled = false;
+ this.disabledModules.push(module);
+ }
+ });
+
+ this.forEach(module => {
+ module.onDestroyBrowser();
+ });
+ },
+
+ didChangeBrowserRemoteness() {
+ debug`DidChangeBrowserRemoteness`;
+
+ this.forEach(module => {
+ if (module.impl) {
+ module.impl.onInitBrowser();
+ }
+ });
+
+ this.messageManager.addMessageListener(
+ "GeckoView:ContentModuleLoaded",
+ this
+ );
+
+ this.forEach(module => {
+ // We're attaching a new browser so we have to reload the frame scripts
+ module.loadInitFrameScript();
+ });
+
+ this.disabledModules.forEach(module => {
+ module.enabled = true;
+ });
+ this.disabledModules = null;
+ },
+
+ afterBrowserRemotenessChange(aSwitchId) {
+ const { sessionState } = this;
+ this.sessionState = null;
+
+ sessionState.switchId = aSwitchId;
+
+ this.getActor("GeckoViewContent").restoreState(sessionState);
+ this.browser.focus();
+
+ // Load was handled
+ return true;
+ },
+
+ _updateSettings(aSettings) {
+ Object.assign(this._settings, aSettings);
+ this._frozenSettings = Object.freeze(Object.assign({}, this._settings));
+
+ const windowType = aSettings.isPopup
+ ? "navigator:popup"
+ : "navigator:geckoview";
+ window.document.documentElement.setAttribute("windowtype", windowType);
+
+ this.forEach(module => {
+ if (module.impl) {
+ module.impl.onSettingsUpdate();
+ }
+ });
+ },
+
+ onMessageFromActor(aActorName, aMessage) {
+ this._moduleByActorName[aActorName].receiveMessage(aMessage);
+ },
+
+ onEvent(aEvent, aData, aCallback) {
+ debug`onEvent ${aEvent} ${aData}`;
+ switch (aEvent) {
+ case "GeckoView:UpdateModuleState": {
+ const module = this._modules.get(aData.module);
+ if (module) {
+ module.enabled = aData.enabled;
+ }
+ break;
+ }
+
+ case "GeckoView:UpdateInitData": {
+ // Replace all settings during a transfer.
+ const initData = this._initData;
+ this._updateSettings(initData.settings);
+
+ // Update module enabled states.
+ for (const name in initData.modules) {
+ const module = this._modules.get(name);
+ if (module) {
+ module.enabled = initData.modules[name];
+ }
+ }
+
+ // Notify child of the transfer.
+ this._browser.messageManager.sendAsyncMessage(aEvent);
+ break;
+ }
+
+ case "GeckoView:UpdateSettings": {
+ this._updateSettings(aData);
+ break;
+ }
+ }
+ },
+
+ receiveMessage(aMsg) {
+ debug`receiveMessage ${aMsg.name} ${aMsg.data}`;
+ switch (aMsg.name) {
+ case "GeckoView:ContentModuleLoaded": {
+ const module = this._modules.get(aMsg.data.module);
+ if (module) {
+ module.onContentModuleLoaded();
+ }
+ break;
+ }
+ }
+ },
+};
+
+/**
+ * ModuleInfo is the structure used by ModuleManager to represent individual
+ * modules. It is responsible for loading the module JSM file if necessary,
+ * and it acts as the intermediary between ModuleManager and the module
+ * object that extends GeckoViewModule.
+ */
+class ModuleInfo {
+ /**
+ * Create a ModuleInfo instance. See _loadPhase for phase object description.
+ *
+ * @param manager the ModuleManager instance.
+ * @param name Name of the module.
+ * @param enabled Enabled state of the module at startup.
+ * @param onInit Phase object for the init phase, when the window is created.
+ * @param onEnable Phase object for the enable phase, when the module is first
+ * enabled by setting a delegate in Java.
+ */
+ constructor({ manager, name, enabled, onInit, onEnable }) {
+ this._manager = manager;
+ this._name = name;
+
+ // We don't support having more than one main process script, so let's
+ // check that we're not accidentally defining two. We could support this if
+ // needed by making _impl an array for each phase impl.
+ if (onInit?.resource !== undefined && onEnable?.resource !== undefined) {
+ throw new Error(
+ "Only one main process script is allowed for each module."
+ );
+ }
+
+ this._impl = null;
+ this._contentModuleLoaded = false;
+ this._enabled = false;
+ // Only enable once we performed initialization.
+ this._enabledOnInit = enabled;
+
+ // For init, load resource _before_ initializing browser to support the
+ // onInitBrowser() override. However, load content module after initializing
+ // browser, because we don't have a message manager before then.
+ this._loadResource(onInit);
+ this._loadActors(onInit);
+ if (this._enabledOnInit) {
+ this._loadActors(onEnable);
+ }
+
+ this._onInitPhase = onInit;
+ this._onEnablePhase = onEnable;
+
+ const actorNames = [];
+ if (this._onInitPhase?.actors) {
+ actorNames.push(Object.keys(this._onInitPhase.actors));
+ }
+ if (this._onEnablePhase?.actors) {
+ actorNames.push(Object.keys(this._onEnablePhase.actors));
+ }
+ this._actorNames = Object.freeze(actorNames);
+ }
+
+ get actorNames() {
+ return this._actorNames;
+ }
+
+ onInit() {
+ if (this._impl) {
+ this._impl.onInit();
+ this._impl.onSettingsUpdate();
+ }
+
+ this.enabled = this._enabledOnInit;
+ }
+
+ /**
+ * Loads the onInit frame script
+ */
+ loadInitFrameScript() {
+ this._loadFrameScript(this._onInitPhase);
+ }
+
+ onDestroy() {
+ if (this._impl) {
+ this._impl.onDestroy();
+ }
+ }
+
+ /**
+ * Called before the browser is removed
+ */
+ onDestroyBrowser() {
+ if (this._impl) {
+ this._impl.onDestroyBrowser();
+ }
+ this._contentModuleLoaded = false;
+ }
+
+ _loadActors(aPhase) {
+ if (!aPhase || !aPhase.actors) {
+ return;
+ }
+
+ GeckoViewActorManager.addJSWindowActors(aPhase.actors);
+ }
+
+ /**
+ * Load resource according to a phase object that contains possible keys,
+ *
+ * "resource": specify the JSM resource to load for this module.
+ * "frameScript": specify a content JS frame script to load for this module.
+ */
+ _loadResource(aPhase) {
+ if (!aPhase || !aPhase.resource || this._impl) {
+ return;
+ }
+
+ const exports = ChromeUtils.importESModule(aPhase.resource);
+ this._impl = new exports[this._name](this);
+ }
+
+ /**
+ * Load frameScript according to a phase object that contains possible keys,
+ *
+ * "frameScript": specify a content JS frame script to load for this module.
+ */
+ _loadFrameScript(aPhase) {
+ if (!aPhase || !aPhase.frameScript || this._contentModuleLoaded) {
+ return;
+ }
+
+ if (this._impl) {
+ this._impl.onLoadContentModule();
+ }
+ this._manager.messageManager.loadFrameScript(aPhase.frameScript, true);
+ this._contentModuleLoaded = true;
+ }
+
+ get manager() {
+ return this._manager;
+ }
+
+ get disableOnProcessSwitch() {
+ // Only disable while process switching if it has a frameScript
+ return (
+ !!this._onInitPhase?.frameScript || !!this._onEnablePhase?.frameScript
+ );
+ }
+
+ get name() {
+ return this._name;
+ }
+
+ get impl() {
+ return this._impl;
+ }
+
+ get enabled() {
+ return this._enabled;
+ }
+
+ set enabled(aEnabled) {
+ if (aEnabled === this._enabled) {
+ return;
+ }
+
+ if (!aEnabled && this._impl) {
+ this._impl.onDisable();
+ }
+
+ this._enabled = aEnabled;
+
+ if (aEnabled) {
+ this._loadResource(this._onEnablePhase);
+ this._loadFrameScript(this._onEnablePhase);
+ this._loadActors(this._onEnablePhase);
+ if (this._impl) {
+ this._impl.onEnable();
+ this._impl.onSettingsUpdate();
+ }
+ }
+
+ this._updateContentModuleState();
+ }
+
+ receiveMessage(aMessage) {
+ if (!this._impl) {
+ throw new Error(`No impl for message: ${aMessage.name}.`);
+ }
+
+ try {
+ this._impl.receiveMessage(aMessage);
+ } catch (error) {
+ warn`this._impl.receiveMessage failed ${aMessage.name}`;
+ throw error;
+ }
+ }
+
+ onContentModuleLoaded() {
+ this._updateContentModuleState();
+
+ if (this._impl) {
+ this._impl.onContentModuleLoaded();
+ }
+ }
+
+ _updateContentModuleState() {
+ this._manager.messageManager.sendAsyncMessage(
+ "GeckoView:UpdateModuleState",
+ {
+ module: this._name,
+ enabled: this.enabled,
+ }
+ );
+ }
+}
+
+function createBrowser() {
+ const browser = (window.browser = document.createXULElement("browser"));
+ // Identify this `<browser>` element uniquely to Marionette, devtools, etc.
+ // Use the JSM global to create the permanentKey, so that if the
+ // permanentKey is held by something after this window closes, it
+ // doesn't keep the window alive. See also Bug 1501789.
+ browser.permanentKey = new (Cu.getGlobalForObject(Services).Object)();
+
+ browser.setAttribute("nodefaultsrc", "true");
+ browser.setAttribute("type", "content");
+ browser.setAttribute("primary", "true");
+ browser.setAttribute("flex", "1");
+ browser.setAttribute("maychangeremoteness", "true");
+ browser.setAttribute("remote", "true");
+ browser.setAttribute("remoteType", E10SUtils.DEFAULT_REMOTE_TYPE);
+ browser.setAttribute("messagemanagergroup", "browsers");
+ browser.setAttribute("manualactiveness", "true");
+
+ // This is only needed for mochitests, so that they honor the
+ // prefers-color-scheme.content-override pref. GeckoView doesn't set this
+ // pref to anything other than the default value otherwise.
+ browser.setAttribute(
+ "style",
+ "color-scheme: env(-moz-content-preferred-color-scheme)"
+ );
+
+ return browser;
+}
+
+function InitLater(fn, object, name) {
+ return DelayedInit.schedule(fn, object, name, 15000 /* 15s max wait */);
+}
+
+function startup() {
+ GeckoViewUtils.initLogging("XUL", window);
+
+ const browser = createBrowser();
+ ModuleManager.init(browser, [
+ {
+ name: "GeckoViewContent",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewContent.sys.mjs",
+ actors: {
+ GeckoViewContent: {
+ parent: {
+ esModuleURI: "resource:///actors/GeckoViewContentParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewContentChild.sys.mjs",
+ events: {
+ mozcaretstatechanged: { capture: true, mozSystemGroup: true },
+ pageshow: { mozSystemGroup: true },
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ onEnable: {
+ actors: {
+ ContentDelegate: {
+ parent: {
+ esModuleURI: "resource:///actors/ContentDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/ContentDelegateChild.sys.mjs",
+ events: {
+ DOMContentLoaded: {},
+ DOMMetaViewportFitChanged: {},
+ "MozDOMFullscreen:Entered": {},
+ "MozDOMFullscreen:Exit": {},
+ "MozDOMFullscreen:Exited": {},
+ "MozDOMFullscreen:Request": {},
+ MozFirstContentfulPaint: {},
+ MozPaintStatusReset: {},
+ contextmenu: {},
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewNavigation",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewNavigation.sys.mjs",
+ },
+ },
+ {
+ name: "GeckoViewProcessHangMonitor",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewProcessHangMonitor.sys.mjs",
+ },
+ },
+ {
+ name: "GeckoViewProgress",
+ onEnable: {
+ resource: "resource://gre/modules/GeckoViewProgress.sys.mjs",
+ actors: {
+ ProgressDelegate: {
+ parent: {
+ esModuleURI: "resource:///actors/ProgressDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/ProgressDelegateChild.sys.mjs",
+ events: {
+ MozAfterPaint: { capture: false, mozSystemGroup: true },
+ DOMContentLoaded: { capture: false, mozSystemGroup: true },
+ pageshow: { capture: false, mozSystemGroup: true },
+ },
+ },
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewScroll",
+ onEnable: {
+ actors: {
+ ScrollDelegate: {
+ parent: {
+ esModuleURI: "resource:///actors/ScrollDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/ScrollDelegateChild.sys.mjs",
+ events: {
+ mozvisualscroll: { mozSystemGroup: true },
+ },
+ },
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewSelectionAction",
+ onEnable: {
+ resource: "resource://gre/modules/GeckoViewSelectionAction.sys.mjs",
+ actors: {
+ SelectionActionDelegate: {
+ parent: {
+ esModuleURI:
+ "resource:///actors/SelectionActionDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI:
+ "resource:///actors/SelectionActionDelegateChild.sys.mjs",
+ events: {
+ mozcaretstatechanged: { mozSystemGroup: true },
+ pagehide: { capture: true, mozSystemGroup: true },
+ deactivate: { mozSystemGroup: true },
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewSettings",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewSettings.sys.mjs",
+ actors: {
+ GeckoViewSettings: {
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewSettingsChild.sys.mjs",
+ },
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewTab",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewTab.sys.mjs",
+ },
+ },
+ {
+ name: "GeckoViewContentBlocking",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewContentBlocking.sys.mjs",
+ },
+ },
+ {
+ name: "SessionStateAggregator",
+ onInit: {
+ frameScript: "chrome://geckoview/content/SessionStateAggregator.js",
+ },
+ },
+ {
+ name: "GeckoViewAutofill",
+ onInit: {
+ actors: {
+ GeckoViewAutoFill: {
+ parent: {
+ esModuleURI: "resource:///actors/GeckoViewAutoFillParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewAutoFillChild.sys.mjs",
+ events: {
+ DOMFormHasPassword: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ DOMInputPasswordAdded: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ pagehide: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ pageshow: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ focusin: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ focusout: {
+ mozSystemGroup: true,
+ capture: false,
+ },
+ "PasswordManager:ShowDoorhanger": {},
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewMediaControl",
+ onEnable: {
+ resource: "resource://gre/modules/GeckoViewMediaControl.sys.mjs",
+ actors: {
+ MediaControlDelegate: {
+ parent: {
+ esModuleURI:
+ "resource:///actors/MediaControlDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI:
+ "resource:///actors/MediaControlDelegateChild.sys.mjs",
+ events: {
+ "MozDOMFullscreen:Entered": {},
+ "MozDOMFullscreen:Exited": {},
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewAutocomplete",
+ onInit: {
+ actors: {
+ FormAutofill: {
+ parent: {
+ esModuleURI: "resource://autofill/FormAutofillParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource://autofill/FormAutofillChild.sys.mjs",
+ events: {
+ focusin: {},
+ DOMFormBeforeSubmit: {},
+ },
+ },
+ allFrames: true,
+ messageManagerGroups: ["browsers"],
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewPrompter",
+ onInit: {
+ actors: {
+ GeckoViewPrompter: {
+ parent: {
+ esModuleURI: "resource:///actors/GeckoViewPrompterParent.sys.mjs",
+ },
+ child: {
+ esModuleURI: "resource:///actors/GeckoViewPrompterChild.sys.mjs",
+ },
+ allFrames: true,
+ includeChrome: true,
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewPrintDelegate",
+ onInit: {
+ actors: {
+ GeckoViewPrintDelegate: {
+ parent: {
+ esModuleURI:
+ "resource:///actors/GeckoViewPrintDelegateParent.sys.mjs",
+ },
+ child: {
+ esModuleURI:
+ "resource:///actors/GeckoViewPrintDelegateChild.sys.mjs",
+ },
+ allFrames: true,
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewExperimentDelegate",
+ onInit: {
+ actors: {
+ GeckoViewExperimentDelegate: {
+ parent: {
+ esModuleURI:
+ "resource:///actors/GeckoViewExperimentDelegateParent.sys.mjs",
+ },
+ allFrames: true,
+ },
+ },
+ },
+ },
+ {
+ name: "GeckoViewTranslations",
+ onInit: {
+ resource: "resource://gre/modules/GeckoViewTranslations.sys.mjs",
+ },
+ },
+ ]);
+
+ if (!Services.appinfo.sessionHistoryInParent) {
+ browser.prepareToChangeRemoteness = () =>
+ ModuleManager.prepareToChangeRemoteness();
+ browser.afterChangeRemoteness = switchId =>
+ ModuleManager.afterBrowserRemotenessChange(switchId);
+ }
+
+ browser.addEventListener("WillChangeBrowserRemoteness", event =>
+ ModuleManager.willChangeBrowserRemoteness()
+ );
+
+ browser.addEventListener("DidChangeBrowserRemoteness", event =>
+ ModuleManager.didChangeBrowserRemoteness()
+ );
+
+ // Allows actors to access ModuleManager.
+ window.moduleManager = ModuleManager;
+
+ window.prompts = () => {
+ return window.ModuleManager.getActor("GeckoViewPrompter").getPrompts();
+ };
+
+ Services.tm.dispatchToMainThread(() => {
+ // This should always be the first thing we do here - any additional delayed
+ // initialisation tasks should be added between "browser-delayed-startup-finished"
+ // and "browser-idle-startup-tasks-finished".
+
+ // Bug 1496684: Various bits of platform stuff depend on this notification
+ // to learn when a browser window has finished its initial (chrome)
+ // initialisation, especially with regards to the very first window that is
+ // created. Therefore, GeckoView "windows" need to send this, too.
+ InitLater(() =>
+ Services.obs.notifyObservers(window, "browser-delayed-startup-finished")
+ );
+
+ // Let the extension code know it can start loading things that were delayed
+ // while GeckoView started up.
+ InitLater(() => {
+ Services.obs.notifyObservers(window, "extensions-late-startup");
+ });
+
+ InitLater(() => {
+ // TODO bug 1730026: this runs too often. It should run once.
+ RemoteSecuritySettings.init();
+ });
+
+ InitLater(() => {
+ // Initialize safe browsing module. This is required for content
+ // blocking features and manages blocklist downloads and updates.
+ SafeBrowsing.init();
+ });
+
+ InitLater(() => {
+ // It's enough to run this once to set up FOG.
+ // (See also bug 1730026.)
+ Services.fog.registerCustomPings();
+ });
+
+ InitLater(() => {
+ // Initialize the blocklist module.
+ // TODO bug 1730026: this runs too often. It should run once.
+ Blocklist.loadBlocklistAsync();
+ });
+
+ // This should always go last, since the idle tasks (except for the ones with
+ // timeouts) should execute in order. Note that this observer notification is
+ // not guaranteed to fire, since the window could close before we get here.
+
+ // This notification in particular signals the ScriptPreloader that we have
+ // finished startup, so it can now stop recording script usage and start
+ // updating the startup cache for faster script loading.
+ InitLater(() =>
+ Services.obs.notifyObservers(
+ window,
+ "browser-idle-startup-tasks-finished"
+ )
+ );
+ });
+
+ // Move focus to the content window at the end of startup,
+ // so things like text selection can work properly.
+ browser.focus();
+
+ InitializationTracker.onInitialized(performance.now());
+}
diff --git a/mobile/android/chrome/geckoview/geckoview.xhtml b/mobile/android/chrome/geckoview/geckoview.xhtml
new file mode 100644
index 0000000000..6f328dcc18
--- /dev/null
+++ b/mobile/android/chrome/geckoview/geckoview.xhtml
@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!-- 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/. -->
+
+<window
+ id="main-window"
+ windowtype="navigator:geckoview"
+ xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+>
+ <script
+ type="application/javascript"
+ src="chrome://geckoview/content/geckoview.js"
+ />
+ <script>
+ /* import-globals-from geckoview.js */
+ window.addEventListener("DOMContentLoaded", startup, { once: true });
+ </script>
+</window>
diff --git a/mobile/android/chrome/geckoview/jar.mn b/mobile/android/chrome/geckoview/jar.mn
new file mode 100644
index 0000000000..c2905f6fc4
--- /dev/null
+++ b/mobile/android/chrome/geckoview/jar.mn
@@ -0,0 +1,14 @@
+# 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/.
+
+geckoview.jar:
+% content geckoview %content/
+
+ content/config.xhtml
+ content/config.js
+ content/geckoview.xhtml
+ content/geckoview.js
+ content/SessionStateAggregator.js
+
+% content branding %content/branding/
diff --git a/mobile/android/chrome/geckoview/moz.build b/mobile/android/chrome/geckoview/moz.build
new file mode 100644
index 0000000000..d988c0ff9b
--- /dev/null
+++ b/mobile/android/chrome/geckoview/moz.build
@@ -0,0 +1,7 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+JAR_MANIFESTS += ["jar.mn"]
diff --git a/mobile/android/chrome/moz.build b/mobile/android/chrome/moz.build
new file mode 100644
index 0000000000..bb28efc488
--- /dev/null
+++ b/mobile/android/chrome/moz.build
@@ -0,0 +1,17 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+# NOTE: I think there are a few other possible components in this directory
+with Files("**"):
+ BUG_COMPONENT = ("GeckoView", "General")
+
+DIRS += ["geckoview"]
+
+DEFINES["AB_CD"] = CONFIG["MOZ_UI_LOCALE"]
+DEFINES["PACKAGE"] = "browser"
+DEFINES["MOZ_APP_VERSION"] = CONFIG["MOZ_APP_VERSION"]
+DEFINES["MOZ_APP_VERSION_DISPLAY"] = CONFIG["MOZ_APP_VERSION_DISPLAY"]
+DEFINES["ANDROID_PACKAGE_NAME"] = CONFIG["ANDROID_PACKAGE_NAME"]