Merge branch 'move-basilisk'

1 files changed, 943 insertions, 0 deletions

diff --git a/application/basilisk/base/content/tab-content.js b/application/basilisk/base/content/tab-content.js
new file mode 100644
index 000000000..11a9fabce
--- /dev/null
+++ b/application/basilisk/base/content/tab-content.js
@@ -0,0 +1,943 @@
+/* -*- 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/. */
+
+/* This content script contains code that requires a tab browser. */
+
+var {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+#ifdef MOZ_WEBEXTENSIONS
+Cu.import("resource://gre/modules/ExtensionContent.jsm");
+#endif
+
+XPCOMUtils.defineLazyModuleGetter(this, "E10SUtils",
+  "resource:///modules/E10SUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "BrowserUtils",
+  "resource://gre/modules/BrowserUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",
+  "resource://gre/modules/PrivateBrowsingUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AboutReader",
+  "resource://gre/modules/AboutReader.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "ReaderMode",
+  "resource://gre/modules/ReaderMode.jsm");
+XPCOMUtils.defineLazyGetter(this, "SimpleServiceDiscovery", function() {
+  let ssdp = Cu.import("resource://gre/modules/SimpleServiceDiscovery.jsm", {}).SimpleServiceDiscovery;
+  // Register targets
+  ssdp.registerDevice({
+    id: "roku:ecp",
+    target: "roku:ecp",
+    factory: function(aService) {
+      Cu.import("resource://gre/modules/RokuApp.jsm");
+      return new RokuApp(aService);
+    },
+    types: ["video/mp4"],
+    extensions: ["mp4"]
+  });
+  return ssdp;
+});
+
+// TabChildGlobal
+var global = this;
+
+
+addEventListener("MozDOMPointerLock:Entered", function(aEvent) {
+  sendAsyncMessage("PointerLock:Entered", {
+    originNoSuffix: aEvent.target.nodePrincipal.originNoSuffix
+  });
+});
+
+addEventListener("MozDOMPointerLock:Exited", function(aEvent) {
+  sendAsyncMessage("PointerLock:Exited");
+});
+
+
+addMessageListener("Browser:HideSessionRestoreButton", function (message) {
+  // Hide session restore button on about:home
+  let doc = content.document;
+  let container;
+  if (doc.documentURI.toLowerCase() == "about:home" &&
+      (container = doc.getElementById("sessionRestoreContainer"))) {
+    container.hidden = true;
+  }
+});
+
+
+addMessageListener("Browser:Reload", function(message) {
+  /* First, we'll try to use the session history object to reload so
+   * that framesets are handled properly. If we're in a special
+   * window (such as view-source) that has no session history, fall
+   * back on using the web navigation's reload method.
+   */
+
+  let webNav = docShell.QueryInterface(Ci.nsIWebNavigation);
+  try {
+    let sh = webNav.sessionHistory;
+    if (sh)
+      webNav = sh.QueryInterface(Ci.nsIWebNavigation);
+  } catch (e) {
+  }
+
+  let reloadFlags = message.data.flags;
+  try {
+    E10SUtils.wrapHandlingUserInput(content, message.data.handlingUserInput,
+                                    () => webNav.reload(reloadFlags));
+  } catch (e) {
+  }
+});
+
+addMessageListener("MixedContent:ReenableProtection", function() {
+  docShell.mixedContentChannel = null;
+});
+
+addMessageListener("SecondScreen:tab-mirror", function(message) {
+  if (!Services.prefs.getBoolPref("browser.casting.enabled")) {
+    return;
+  }
+  let app = SimpleServiceDiscovery.findAppForService(message.data.service);
+  if (app) {
+    let width = content.innerWidth;
+    let height = content.innerHeight;
+    let viewport = {cssWidth: width, cssHeight: height, width: width, height: height};
+    app.mirror(function() {}, content, viewport, function() {}, content);
+  }
+});
+
+var AboutHomeListener = {
+  init: function(chromeGlobal) {
+    chromeGlobal.addEventListener('AboutHomeLoad', this, false, true);
+  },
+
+  get isAboutHome() {
+    return content.document.documentURI.toLowerCase() == "about:home";
+  },
+
+  handleEvent: function(aEvent) {
+    if (!this.isAboutHome) {
+      return;
+    }
+    switch (aEvent.type) {
+      case "AboutHomeLoad":
+        this.onPageLoad();
+        break;
+      case "click":
+        this.onClick(aEvent);
+        break;
+      case "pagehide":
+        this.onPageHide(aEvent);
+        break;
+    }
+  },
+
+  receiveMessage: function(aMessage) {
+    if (!this.isAboutHome) {
+      return;
+    }
+    switch (aMessage.name) {
+      case "AboutHome:Update":
+        this.onUpdate(aMessage.data);
+        break;
+    }
+  },
+
+  onUpdate: function(aData) {
+    let doc = content.document;
+    if (aData.showRestoreLastSession && !PrivateBrowsingUtils.isContentWindowPrivate(content))
+      doc.getElementById("launcher").setAttribute("session", "true");
+
+    // Inject search engine URL.
+    let docElt = doc.documentElement;
+    if (aData.showKnowYourRights)
+      docElt.setAttribute("showKnowYourRights", "true");
+  },
+
+  onPageLoad: function() {
+    addMessageListener("AboutHome:Update", this);
+    addEventListener("click", this, true);
+    addEventListener("pagehide", this, true);
+
+    sendAsyncMessage("AboutHome:MaybeShowAutoMigrationUndoNotification");
+    sendAsyncMessage("AboutHome:RequestUpdate");
+  },
+
+  onClick: function(aEvent) {
+    if (!aEvent.isTrusted || // Don't trust synthetic events
+        aEvent.button == 2 || aEvent.target.localName != "button") {
+      return;
+    }
+
+    let originalTarget = aEvent.originalTarget;
+    let ownerDoc = originalTarget.ownerDocument;
+    if (ownerDoc.documentURI != "about:home") {
+      // This shouldn't happen, but we're being defensive.
+      return;
+    }
+
+    let elmId = originalTarget.getAttribute("id");
+
+    switch (elmId) {
+      case "restorePreviousSession":
+        sendAsyncMessage("AboutHome:RestorePreviousSession");
+        ownerDoc.getElementById("launcher").removeAttribute("session");
+        break;
+
+      case "downloads":
+        sendAsyncMessage("AboutHome:Downloads");
+        break;
+
+      case "bookmarks":
+        sendAsyncMessage("AboutHome:Bookmarks");
+        break;
+
+      case "history":
+        sendAsyncMessage("AboutHome:History");
+        break;
+
+      case "addons":
+        sendAsyncMessage("AboutHome:Addons");
+        break;
+
+      case "sync":
+        sendAsyncMessage("AboutHome:Sync");
+        break;
+
+      case "settings":
+        sendAsyncMessage("AboutHome:Settings");
+        break;
+    }
+  },
+
+  onPageHide: function(aEvent) {
+    if (aEvent.target.defaultView.frameElement) {
+      return;
+    }
+    removeMessageListener("AboutHome:Update", this);
+    removeEventListener("click", this, true);
+    removeEventListener("pagehide", this, true);
+  },
+};
+AboutHomeListener.init(this);
+
+var AboutPrivateBrowsingListener = {
+  init(chromeGlobal) {
+    chromeGlobal.addEventListener("AboutPrivateBrowsingOpenWindow", this,
+                                  false, true);
+    chromeGlobal.addEventListener("AboutPrivateBrowsingToggleTrackingProtection", this,
+                                  false, true);
+  },
+
+  get isAboutPrivateBrowsing() {
+    return content.document.documentURI.toLowerCase() == "about:privatebrowsing";
+  },
+
+  handleEvent(aEvent) {
+    if (!this.isAboutPrivateBrowsing) {
+      return;
+    }
+    switch (aEvent.type) {
+      case "AboutPrivateBrowsingOpenWindow":
+        sendAsyncMessage("AboutPrivateBrowsing:OpenPrivateWindow");
+        break;
+      case "AboutPrivateBrowsingToggleTrackingProtection":
+        sendAsyncMessage("AboutPrivateBrowsing:ToggleTrackingProtection");
+        break;
+    }
+  },
+};
+AboutPrivateBrowsingListener.init(this);
+
+var AboutReaderListener = {
+
+  _articlePromise: null,
+
+  _isLeavingReaderMode: false,
+
+  init: function() {
+    addEventListener("AboutReaderContentLoaded", this, false, true);
+    addEventListener("DOMContentLoaded", this, false);
+    addEventListener("pageshow", this, false);
+    addEventListener("pagehide", this, false);
+    addMessageListener("Reader:ToggleReaderMode", this);
+    addMessageListener("Reader:PushState", this);
+  },
+
+  receiveMessage: function(message) {
+    switch (message.name) {
+      case "Reader:ToggleReaderMode":
+        if (!this.isAboutReader) {
+          this._articlePromise = ReaderMode.parseDocument(content.document).catch(Cu.reportError);
+          ReaderMode.enterReaderMode(docShell, content);
+        } else {
+          this._isLeavingReaderMode = true;
+          ReaderMode.leaveReaderMode(docShell, content);
+        }
+        break;
+
+      case "Reader:PushState":
+        this.updateReaderButton(!!(message.data && message.data.isArticle));
+        break;
+    }
+  },
+
+  get isAboutReader() {
+    if (!content) {
+      return false;
+    }
+    return content.document.documentURI.startsWith("about:reader");
+  },
+
+  handleEvent: function(aEvent) {
+    if (aEvent.originalTarget.defaultView != content) {
+      return;
+    }
+
+    switch (aEvent.type) {
+      case "AboutReaderContentLoaded":
+        if (!this.isAboutReader) {
+          return;
+        }
+
+        if (content.document.body) {
+          // Update the toolbar icon to show the "reader active" icon.
+          sendAsyncMessage("Reader:UpdateReaderButton");
+          new AboutReader(content, this._articlePromise);
+          this._articlePromise = null;
+        }
+        break;
+
+      case "pagehide":
+        this.cancelPotentialPendingReadabilityCheck();
+        // this._isLeavingReaderMode is used here to keep the Reader Mode icon
+        // visible in the location bar when transitioning from reader-mode page
+        // back to the source page.
+        sendAsyncMessage("Reader:UpdateReaderButton", { isArticle: this._isLeavingReaderMode });
+        if (this._isLeavingReaderMode) {
+          this._isLeavingReaderMode = false;
+        }
+        break;
+
+      case "pageshow":
+        // If a page is loaded from the bfcache, we won't get a "DOMContentLoaded"
+        // event, so we need to rely on "pageshow" in this case.
+        if (aEvent.persisted) {
+          this.updateReaderButton();
+        }
+        break;
+      case "DOMContentLoaded":
+        this.updateReaderButton();
+        break;
+
+    }
+  },
+
+  /**
+   * NB: this function will update the state of the reader button asynchronously
+   * after the next mozAfterPaint call (assuming reader mode is enabled and
+   * this is a suitable document). Calling it on things which won't be
+   * painted is not going to work.
+   */
+  updateReaderButton: function(forceNonArticle) {
+    if (!ReaderMode.isEnabledForParseOnLoad || this.isAboutReader ||
+        !content || !(content.document instanceof content.HTMLDocument) ||
+        content.document.mozSyntheticDocument) {
+      return;
+    }
+
+    this.scheduleReadabilityCheckPostPaint(forceNonArticle);
+  },
+
+  cancelPotentialPendingReadabilityCheck: function() {
+    if (this._pendingReadabilityCheck) {
+      removeEventListener("MozAfterPaint", this._pendingReadabilityCheck);
+      delete this._pendingReadabilityCheck;
+    }
+  },
+
+  scheduleReadabilityCheckPostPaint: function(forceNonArticle) {
+    if (this._pendingReadabilityCheck) {
+      // We need to stop this check before we re-add one because we don't know
+      // if forceNonArticle was true or false last time.
+      this.cancelPotentialPendingReadabilityCheck();
+    }
+    this._pendingReadabilityCheck = this.onPaintWhenWaitedFor.bind(this, forceNonArticle);
+    addEventListener("MozAfterPaint", this._pendingReadabilityCheck);
+  },
+
+  onPaintWhenWaitedFor: function(forceNonArticle, event) {
+    // In non-e10s, we'll get called for paints other than ours, and so it's
+    // possible that this page hasn't been laid out yet, in which case we
+    // should wait until we get an event that does relate to our layout. We
+    // determine whether any of our content got painted by checking if there
+    // are any painted rects.
+    if (!event.clientRects.length) {
+      return;
+    }
+
+    this.cancelPotentialPendingReadabilityCheck();
+    // Only send updates when there are articles; there's no point updating with
+    // |false| all the time.
+    if (ReaderMode.isProbablyReaderable(content.document)) {
+      sendAsyncMessage("Reader:UpdateReaderButton", { isArticle: true });
+    } else if (forceNonArticle) {
+      sendAsyncMessage("Reader:UpdateReaderButton", { isArticle: false });
+    }
+  },
+};
+AboutReaderListener.init();
+
+
+var ContentSearchMediator = {
+
+  whitelist: new Set([
+    "about:home",
+    "about:newtab",
+  ]),
+
+  init: function (chromeGlobal) {
+    chromeGlobal.addEventListener("ContentSearchClient", this, true, true);
+    addMessageListener("ContentSearch", this);
+  },
+
+  handleEvent: function (event) {
+    if (this._contentWhitelisted) {
+      this._sendMsg(event.detail.type, event.detail.data);
+    }
+  },
+
+  receiveMessage: function (msg) {
+    if (msg.data.type == "AddToWhitelist") {
+      for (let uri of msg.data.data) {
+        this.whitelist.add(uri);
+      }
+      this._sendMsg("AddToWhitelistAck");
+      return;
+    }
+    if (this._contentWhitelisted) {
+      this._fireEvent(msg.data.type, msg.data.data);
+    }
+  },
+
+  get _contentWhitelisted() {
+    return this.whitelist.has(content.document.documentURI);
+  },
+
+  _sendMsg: function (type, data=null) {
+    sendAsyncMessage("ContentSearch", {
+      type: type,
+      data: data,
+    });
+  },
+
+  _fireEvent: function (type, data=null) {
+    let event = Cu.cloneInto({
+      detail: {
+        type: type,
+        data: data,
+      },
+    }, content);
+    content.dispatchEvent(new content.CustomEvent("ContentSearchService",
+                                                  event));
+  },
+};
+ContentSearchMediator.init(this);
+
+var PageStyleHandler = {
+  init: function() {
+    addMessageListener("PageStyle:Switch", this);
+    addMessageListener("PageStyle:Disable", this);
+    addEventListener("pageshow", () => this.sendStyleSheetInfo());
+  },
+
+  get markupDocumentViewer() {
+    return docShell.contentViewer;
+  },
+
+  sendStyleSheetInfo: function() {
+    let filteredStyleSheets = this._filterStyleSheets(this.getAllStyleSheets());
+
+    sendAsyncMessage("PageStyle:StyleSheets", {
+      filteredStyleSheets: filteredStyleSheets,
+      authorStyleDisabled: this.markupDocumentViewer.authorStyleDisabled,
+      preferredStyleSheetSet: content.document.preferredStyleSheetSet
+    });
+  },
+
+  getAllStyleSheets: function(frameset = content) {
+    let selfSheets = Array.slice(frameset.document.styleSheets);
+    let subSheets = Array.map(frameset.frames, frame => this.getAllStyleSheets(frame));
+    return selfSheets.concat(...subSheets);
+  },
+
+  receiveMessage: function(msg) {
+    switch (msg.name) {
+      case "PageStyle:Switch":
+        this.markupDocumentViewer.authorStyleDisabled = false;
+        this._stylesheetSwitchAll(content, msg.data.title);
+        break;
+
+      case "PageStyle:Disable":
+        this.markupDocumentViewer.authorStyleDisabled = true;
+        break;
+    }
+
+    this.sendStyleSheetInfo();
+  },
+
+  _stylesheetSwitchAll: function (frameset, title) {
+    if (!title || this._stylesheetInFrame(frameset, title)) {
+      this._stylesheetSwitchFrame(frameset, title);
+    }
+
+    for (let i = 0; i < frameset.frames.length; i++) {
+      // Recurse into sub-frames.
+      this._stylesheetSwitchAll(frameset.frames[i], title);
+    }
+  },
+
+  _stylesheetSwitchFrame: function (frame, title) {
+    var docStyleSheets = frame.document.styleSheets;
+
+    for (let i = 0; i < docStyleSheets.length; ++i) {
+      let docStyleSheet = docStyleSheets[i];
+      if (docStyleSheet.title) {
+        docStyleSheet.disabled = (docStyleSheet.title != title);
+      } else if (docStyleSheet.disabled) {
+        docStyleSheet.disabled = false;
+      }
+    }
+  },
+
+  _stylesheetInFrame: function (frame, title) {
+    return Array.some(frame.document.styleSheets, (styleSheet) => styleSheet.title == title);
+  },
+
+  _filterStyleSheets: function(styleSheets) {
+    let result = [];
+
+    for (let currentStyleSheet of styleSheets) {
+      if (!currentStyleSheet.title)
+        continue;
+
+      // Skip any stylesheets that don't match the screen media type.
+      if (currentStyleSheet.media.length > 0) {
+        let mediaQueryList = currentStyleSheet.media.mediaText;
+        if (!content.matchMedia(mediaQueryList).matches) {
+          continue;
+        }
+      }
+
+      let URI;
+      try {
+        if (!currentStyleSheet.ownerNode ||
+            // special-case style nodes, which have no href
+            currentStyleSheet.ownerNode.nodeName.toLowerCase() != "style") {
+          URI = Services.io.newURI(currentStyleSheet.href, null, null);
+        }
+      } catch (e) {
+        if (e.result != Cr.NS_ERROR_MALFORMED_URI) {
+          throw e;
+        }
+        continue;
+      }
+
+      // We won't send data URIs all of the way up to the parent, as these
+      // can be arbitrarily large.
+      let sentURI = (!URI || URI.scheme == "data") ? null : URI.spec;
+
+      result.push({
+        title: currentStyleSheet.title,
+        disabled: currentStyleSheet.disabled,
+        href: sentURI,
+      });
+    }
+
+    return result;
+  },
+};
+PageStyleHandler.init();
+
+// Keep a reference to the translation content handler to avoid it it being GC'ed.
+var trHandler = null;
+if (Services.prefs.getBoolPref("browser.translation.detectLanguage")) {
+  Cu.import("resource:///modules/translation/TranslationContentHandler.jsm");
+  trHandler = new TranslationContentHandler(global, docShell);
+}
+
+function gKeywordURIFixup(fixupInfo) {
+  fixupInfo.QueryInterface(Ci.nsIURIFixupInfo);
+  if (!fixupInfo.consumer) {
+    return;
+  }
+
+  // Ignore info from other docshells
+  let parent = fixupInfo.consumer.QueryInterface(Ci.nsIDocShellTreeItem).sameTypeRootTreeItem;
+  if (parent != docShell)
+    return;
+
+  let data = {};
+  for (let f of Object.keys(fixupInfo)) {
+    if (f == "consumer" || typeof fixupInfo[f] == "function")
+      continue;
+
+    if (fixupInfo[f] && fixupInfo[f] instanceof Ci.nsIURI) {
+      data[f] = fixupInfo[f].spec;
+    } else {
+      data[f] = fixupInfo[f];
+    }
+  }
+
+  sendAsyncMessage("Browser:URIFixup", data);
+}
+Services.obs.addObserver(gKeywordURIFixup, "keyword-uri-fixup", false);
+addEventListener("unload", () => {
+  Services.obs.removeObserver(gKeywordURIFixup, "keyword-uri-fixup");
+}, false);
+
+addMessageListener("Browser:AppTab", function(message) {
+  if (docShell) {
+    docShell.isAppTab = message.data.isAppTab;
+  }
+});
+
+var WebBrowserChrome = {
+  onBeforeLinkTraversal: function(originalTarget, linkURI, linkNode, isAppTab) {
+    return BrowserUtils.onBeforeLinkTraversal(originalTarget, linkURI, linkNode, isAppTab);
+  },
+
+  // Check whether this URI should load in the current process
+  shouldLoadURI: function(aDocShell, aURI, aReferrer) {
+    if (!E10SUtils.shouldLoadURI(aDocShell, aURI, aReferrer)) {
+      E10SUtils.redirectLoad(aDocShell, aURI, aReferrer);
+      return false;
+    }
+
+    return true;
+  },
+
+  // Try to reload the currently active or currently loading page in a new process.
+  reloadInFreshProcess: function(aDocShell, aURI, aReferrer) {
+    E10SUtils.redirectLoad(aDocShell, aURI, aReferrer, true);
+    return true;
+  }
+};
+
+if (Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT) {
+  let tabchild = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                         .getInterface(Ci.nsITabChild);
+  tabchild.webBrowserChrome = WebBrowserChrome;
+}
+
+
+var DOMFullscreenHandler = {
+
+  init: function() {
+    addMessageListener("DOMFullscreen:Entered", this);
+    addMessageListener("DOMFullscreen:CleanUp", this);
+    addEventListener("MozDOMFullscreen:Request", this);
+    addEventListener("MozDOMFullscreen:Entered", this);
+    addEventListener("MozDOMFullscreen:NewOrigin", this);
+    addEventListener("MozDOMFullscreen:Exit", this);
+    addEventListener("MozDOMFullscreen:Exited", this);
+  },
+
+  get _windowUtils() {
+    if (!content) {
+      return null;
+    }
+    return content.QueryInterface(Ci.nsIInterfaceRequestor)
+                  .getInterface(Ci.nsIDOMWindowUtils);
+  },
+
+  receiveMessage: function(aMessage) {
+    let windowUtils = this._windowUtils;
+    switch (aMessage.name) {
+      case "DOMFullscreen:Entered": {
+        this._lastTransactionId = windowUtils.lastTransactionId;
+        if (!windowUtils.handleFullscreenRequests() &&
+            !content.document.fullscreenElement) {
+          // If we don't actually have any pending fullscreen request
+          // to handle, neither we have been in fullscreen, tell the
+          // parent to just exit.
+          sendAsyncMessage("DOMFullscreen:Exit");
+        }
+        break;
+      }
+      case "DOMFullscreen:CleanUp": {
+        // If we've exited fullscreen at this point, no need to record
+        // transaction id or call exit fullscreen. This is especially
+        // important for non-e10s, since in that case, it is possible
+        // that no more paint would be triggered after this point.
+        if (content.document.fullscreenElement && windowUtils) {
+          this._lastTransactionId = windowUtils.lastTransactionId;
+          windowUtils.exitFullscreen();
+        }
+        break;
+      }
+    }
+  },
+
+  handleEvent: function(aEvent) {
+    switch (aEvent.type) {
+      case "MozDOMFullscreen:Request": {
+        sendAsyncMessage("DOMFullscreen:Request");
+        break;
+      }
+      case "MozDOMFullscreen:NewOrigin": {
+        sendAsyncMessage("DOMFullscreen:NewOrigin", {
+          originNoSuffix: aEvent.target.nodePrincipal.originNoSuffix,
+        });
+        break;
+      }
+      case "MozDOMFullscreen:Exit": {
+        sendAsyncMessage("DOMFullscreen:Exit");
+        break;
+      }
+      case "MozDOMFullscreen:Entered":
+      case "MozDOMFullscreen:Exited": {
+        addEventListener("MozAfterPaint", this);
+        if (!content || !content.document.fullscreenElement) {
+          // If we receive any fullscreen change event, and find we are
+          // actually not in fullscreen, also ask the parent to exit to
+          // ensure that the parent always exits fullscreen when we do.
+          sendAsyncMessage("DOMFullscreen:Exit");
+        }
+        break;
+      }
+      case "MozAfterPaint": {
+        // Only send Painted signal after we actually finish painting
+        // the transition for the fullscreen change.
+        // Note that this._lastTransactionId is not set when in non-e10s
+        // mode, so we need to check that explicitly.
+        if (!this._lastTransactionId ||
+            aEvent.transactionId > this._lastTransactionId) {
+          removeEventListener("MozAfterPaint", this);
+          sendAsyncMessage("DOMFullscreen:Painted");
+        }
+        break;
+      }
+    }
+  }
+};
+DOMFullscreenHandler.init();
+
+var RefreshBlocker = {
+  PREF: "accessibility.blockautorefresh",
+
+  // Bug 1247100 - When a refresh is caused by an HTTP header,
+  // onRefreshAttempted will be fired before onLocationChange.
+  // When a refresh is caused by a <meta> tag in the document,
+  // onRefreshAttempted will be fired after onLocationChange.
+  //
+  // We only ever want to send a message to the parent after
+  // onLocationChange has fired, since the parent uses the
+  // onLocationChange update to clear transient notifications.
+  // Sending the message before onLocationChange will result in
+  // us creating the notification, and then clearing it very
+  // soon after.
+  //
+  // To account for both cases (onRefreshAttempted before
+  // onLocationChange, and onRefreshAttempted after onLocationChange),
+  // we'll hold a mapping of DOM Windows that we see get
+  // sent through both onLocationChange and onRefreshAttempted.
+  // When either run, they'll check the WeakMap for the existence
+  // of the DOM Window. If it doesn't exist, it'll add it. If
+  // it finds it, it'll know that it's safe to send the message
+  // to the parent, since we know that both have fired.
+  //
+  // The DOM Window is removed from blockedWindows when we notice
+  // the nsIWebProgress change state to STATE_STOP for the
+  // STATE_IS_WINDOW case.
+  //
+  // DOM Windows are mapped to a JS object that contains the data
+  // to be sent to the parent to show the notification. Since that
+  // data is only known when onRefreshAttempted is fired, it's only
+  // ever stashed in the map if onRefreshAttempted fires first -
+  // otherwise, null is set as the value of the mapping.
+  blockedWindows: new WeakMap(),
+
+  init() {
+    if (Services.prefs.getBoolPref(this.PREF)) {
+      this.enable();
+    }
+
+    Services.prefs.addObserver(this.PREF, this, false);
+  },
+
+  uninit() {
+    if (Services.prefs.getBoolPref(this.PREF)) {
+      this.disable();
+    }
+
+    Services.prefs.removeObserver(this.PREF, this);
+  },
+
+  observe(subject, topic, data) {
+    if (topic == "nsPref:changed" && data == this.PREF) {
+      if (Services.prefs.getBoolPref(this.PREF)) {
+        this.enable();
+      } else {
+        this.disable();
+      }
+    }
+  },
+
+  enable() {
+    this._filter = Cc["@mozilla.org/appshell/component/browser-status-filter;1"]
+                     .createInstance(Ci.nsIWebProgress);
+    this._filter.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_ALL);
+
+    let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                              .getInterface(Ci.nsIWebProgress);
+    webProgress.addProgressListener(this._filter, Ci.nsIWebProgress.NOTIFY_ALL);
+
+    addMessageListener("RefreshBlocker:Refresh", this);
+  },
+
+  disable() {
+    let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+                              .getInterface(Ci.nsIWebProgress);
+    webProgress.removeProgressListener(this._filter);
+
+    this._filter.removeProgressListener(this);
+    this._filter = null;
+
+    removeMessageListener("RefreshBlocker:Refresh", this);
+  },
+
+  send(data) {
+    sendAsyncMessage("RefreshBlocker:Blocked", data);
+  },
+
+  /**
+   * Notices when the nsIWebProgress transitions to STATE_STOP for
+   * the STATE_IS_WINDOW case, which will clear any mappings from
+   * blockedWindows.
+   */
+  onStateChange(aWebProgress, aRequest, aStateFlags, aStatus) {
+    if (aStateFlags & Ci.nsIWebProgressListener.STATE_IS_WINDOW &&
+        aStateFlags & Ci.nsIWebProgressListener.STATE_STOP) {
+      this.blockedWindows.delete(aWebProgress.DOMWindow);
+    }
+  },
+
+  /**
+   * Notices when the location has changed. If, when running,
+   * onRefreshAttempted has already fired for this DOM Window, will
+   * send the appropriate refresh blocked data to the parent.
+   */
+  onLocationChange(aWebProgress, aRequest, aLocation, aFlags) {
+    let win = aWebProgress.DOMWindow;
+    if (this.blockedWindows.has(win)) {
+      let data = this.blockedWindows.get(win);
+      if (data) {
+        // We saw onRefreshAttempted before onLocationChange, so
+        // send the message to the parent to show the notification.
+        this.send(data);
+      }
+    } else {
+      this.blockedWindows.set(win, null);
+    }
+  },
+
+  /**
+   * Notices when a refresh / reload was attempted. If, when running,
+   * onLocationChange has not yet run, will stash the appropriate data
+   * into the blockedWindows map to be sent when onLocationChange fires.
+   */
+  onRefreshAttempted(aWebProgress, aURI, aDelay, aSameURI) {
+    let win = aWebProgress.DOMWindow;
+    let outerWindowID = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                           .getInterface(Ci.nsIDOMWindowUtils)
+                           .outerWindowID;
+
+    let data = {
+      URI: aURI.spec,
+      originCharset: aURI.originCharset,
+      delay: aDelay,
+      sameURI: aSameURI,
+      outerWindowID,
+    };
+
+    if (this.blockedWindows.has(win)) {
+      // onLocationChange must have fired before, so we can tell the
+      // parent to show the notification.
+      this.send(data);
+    } else {
+      // onLocationChange hasn't fired yet, so stash the data in the
+      // map so that onLocationChange can send it when it fires.
+      this.blockedWindows.set(win, data);
+    }
+
+    return false;
+  },
+
+  receiveMessage(message) {
+    let data = message.data;
+
+    if (message.name == "RefreshBlocker:Refresh") {
+      let win = Services.wm.getOuterWindowWithId(data.outerWindowID);
+      let refreshURI = win.QueryInterface(Ci.nsIInterfaceRequestor)
+                          .getInterface(Ci.nsIDocShell)
+                          .QueryInterface(Ci.nsIRefreshURI);
+
+      let URI = BrowserUtils.makeURI(data.URI, data.originCharset, null);
+
+      refreshURI.forceRefreshURI(URI, data.delay, true);
+    }
+  },
+
+  QueryInterface: XPCOMUtils.generateQI([Ci.nsIWebProgressListener2,
+                                         Ci.nsIWebProgressListener,
+                                         Ci.nsISupportsWeakReference,
+                                         Ci.nsISupports]),
+};
+
+RefreshBlocker.init();
+
+var UserContextIdNotifier = {
+  init() {
+    addEventListener("DOMWindowCreated", this);
+  },
+
+  uninit() {
+    removeEventListener("DOMWindowCreated", this);
+  },
+
+  handleEvent(aEvent) {
+    // When the window is created, we want to inform the tabbrowser about
+    // the userContextId in use in order to update the UI correctly.
+    // Just because we cannot change the userContextId from an active docShell,
+    // we don't need to check DOMContentLoaded again.
+    this.uninit();
+
+    // We use the docShell because content.document can have been loaded before
+    // setting the originAttributes.
+    let loadContext = docShell.QueryInterface(Ci.nsILoadContext);
+    let userContextId = loadContext.originAttributes.userContextId;
+
+    sendAsyncMessage("Browser:WindowCreated", { userContextId });
+  }
+};
+
+UserContextIdNotifier.init();
+
+#ifdef MOZ_WEBEXTENSIONS
+ExtensionContent.init(this);
+addEventListener("unload", () => {
+  ExtensionContent.uninit(this);
+  RefreshBlocker.uninit();
+});
+#endif
+
+addMessageListener("AllowScriptsToClose", () => {
+  content.QueryInterface(Ci.nsIInterfaceRequestor)
+         .getInterface(Ci.nsIDOMWindowUtils)
+         .allowScriptsToClose();
+});
+
+addEventListener("MozAfterPaint", function onFirstPaint() {
+  removeEventListener("MozAfterPaint", onFirstPaint);
+  sendAsyncMessage("Browser:FirstPaint");
+});