The Tor Browser / file revision

 # -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/.

 let Ci = Components.interfaces;

 let Cu = Components.utils;

 Cu.import("resource://gre/modules/XPCOMUtils.jsm");

 Cu.import("resource://gre/modules/NotificationDB.jsm");

 Cu.import("resource:///modules/RecentWindow.jsm");

 Cu.import("resource://gre/modules/WindowsPrefSync.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "BrowserUtils",

                                   "resource://gre/modules/BrowserUtils.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "Task",

                                   "resource://gre/modules/Task.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "CharsetMenu",

                                   "resource://gre/modules/CharsetMenu.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "ShortcutUtils",

                                   "resource://gre/modules/ShortcutUtils.jsm");

 const nsIWebNavigation = Ci.nsIWebNavigation;

 var gLastBrowserCharset = null;

 var gPrevCharset = null;

 var gProxyFavIcon = null;

 var gLastValidURLStr = "";

 var gInPrintPreviewMode = false;

 var gContextMenu = null; // nsContextMenu instance

 var gMultiProcessBrowser = false;

 #ifndef XP_MACOSX

 var gEditUIVisible = true;

 #endif

 [

   ["gBrowser",            "content"],

   ["gNavToolbox",         "navigator-toolbox"],

   ["gURLBar",             "urlbar"],

   ["gNavigatorBundle",    "bundle_browser"]

 ].forEach(function (elementGlobal) {

   var [name, id] = elementGlobal;

   window.__defineGetter__(name, function () {

     var element = document.getElementById(id);

     if (!element)

       return null;

     delete window[name];

     return window[name] = element;

   });

   window.__defineSetter__(name, function (val) {

     delete window[name];

     return window[name] = val;

   });

 });

 // Smart getter for the findbar.  If you don't wish to force the creation of

 // the findbar, check gFindBarInitialized first.

 this.__defineGetter__("gFindBar", function() {

   return window.gBrowser.getFindBar();

 });

 this.__defineGetter__("gFindBarInitialized", function() {

   return window.gBrowser.isFindBarInitialized();

 });

 XPCOMUtils.defineLazyGetter(this, "gPrefService", function() {

   return Services.prefs;

 });

 this.__defineGetter__("AddonManager", function() {

   let tmp = {};

   Cu.import("resource://gre/modules/AddonManager.jsm", tmp);

   return this.AddonManager = tmp.AddonManager;

 });

 this.__defineSetter__("AddonManager", function (val) {

   delete this.AddonManager;

   return this.AddonManager = val;

 });

 XPCOMUtils.defineLazyModuleGetter(this, "PluralForm",

   "resource://gre/modules/PluralForm.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "TelemetryStopwatch",

   "resource://gre/modules/TelemetryStopwatch.jsm");

 XPCOMUtils.defineLazyGetter(this, "gCustomizeMode", function() {

   let scope = {};

   Cu.import("resource:///modules/CustomizeMode.jsm", scope);

   return new scope.CustomizeMode(window);

 });

 #ifdef MOZ_SERVICES_SYNC

 XPCOMUtils.defineLazyModuleGetter(this, "Weave",

   "resource://services-sync/main.js");

 #endif

 XPCOMUtils.defineLazyGetter(this, "PopupNotifications", function () {

   let tmp = {};

   Cu.import("resource://gre/modules/PopupNotifications.jsm", tmp);

   try {

     return new tmp.PopupNotifications(gBrowser,

                                       document.getElementById("notification-popup"),

                                       document.getElementById("notification-popup-box"));

   } catch (ex) {

     Cu.reportError(ex);

     return null;

   }

 });

 XPCOMUtils.defineLazyGetter(this, "DeveloperToolbar", function() {

   let tmp = {};

   Cu.import("resource:///modules/devtools/DeveloperToolbar.jsm", tmp);

   return new tmp.DeveloperToolbar(window, document.getElementById("developer-toolbar"));

 });

 XPCOMUtils.defineLazyGetter(this, "BrowserToolboxProcess", function() {

   let tmp = {};

   Cu.import("resource:///modules/devtools/ToolboxProcess.jsm", tmp);

   return tmp.BrowserToolboxProcess;

 });

 XPCOMUtils.defineLazyModuleGetter(this, "Social",

   "resource:///modules/Social.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "PageThumbs",

   "resource://gre/modules/PageThumbs.jsm");

 #ifdef MOZ_SAFE_BROWSING

 XPCOMUtils.defineLazyModuleGetter(this, "SafeBrowsing",

   "resource://gre/modules/SafeBrowsing.jsm");

 #endif

 XPCOMUtils.defineLazyModuleGetter(this, "gBrowserNewTabPreloader",

   "resource:///modules/BrowserNewTabPreloader.jsm", "BrowserNewTabPreloader");

 XPCOMUtils.defineLazyModuleGetter(this, "gCustomizationTabPreloader",

   "resource:///modules/CustomizationTabPreloader.jsm", "CustomizationTabPreloader");

 XPCOMUtils.defineLazyModuleGetter(this, "PrivateBrowsingUtils",

   "resource://gre/modules/PrivateBrowsingUtils.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "Translation",

   "resource:///modules/translation/Translation.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "SitePermissions",

   "resource:///modules/SitePermissions.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "SessionStore",

   "resource:///modules/sessionstore/SessionStore.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "fxAccounts",

   "resource://gre/modules/FxAccounts.jsm");

 #ifdef MOZ_CRASHREPORTER

 XPCOMUtils.defineLazyModuleGetter(this, "TabCrashReporter",

   "resource:///modules/TabCrashReporter.jsm");

 #endif

 let gInitialPages = [

   "about:blank",

   "about:newtab",

   "about:home",

   "about:privatebrowsing",

   "about:welcomeback",

   "about:sessionrestore"

 ];

 #include browser-addons.js

 #include browser-customization.js

 #include browser-feeds.js

 #include browser-fullScreen.js

 #include browser-fullZoom.js

 #include browser-places.js

 #include browser-plugins.js

 #include browser-safebrowsing.js

 #include browser-social.js

 #include browser-tabPreviews.js

 #include browser-tabview.js

 #include browser-thumbnails.js

 #include browser-webrtcUI.js

 #include browser-gestureSupport.js

 #ifdef MOZ_DATA_REPORTING

 #include browser-data-submission-info-bar.js

 #endif

 #ifdef MOZ_SERVICES_SYNC

 #include browser-syncui.js

 #endif

 #include browser-fxaccounts.js

 XPCOMUtils.defineLazyGetter(this, "Win7Features", function () {

 #ifdef XP_WIN

   // Bug 666808 - AeroPeek support for e10s

   if (gMultiProcessBrowser)

     return null;

   const WINTASKBAR_CONTRACTID = "@mozilla.org/windows-taskbar;1";

   if (WINTASKBAR_CONTRACTID in Cc &&

       Cc[WINTASKBAR_CONTRACTID].getService(Ci.nsIWinTaskbar).available) {

     let AeroPeek = Cu.import("resource:///modules/WindowsPreviewPerTab.jsm", {}).AeroPeek;

     return {

       onOpenWindow: function () {

         AeroPeek.onOpenWindow(window);

       },

       onCloseWindow: function () {

         AeroPeek.onCloseWindow(window);

       }

     };

   }

 #endif

   return null;

 });

 #ifdef MOZ_CRASHREPORTER

 XPCOMUtils.defineLazyServiceGetter(this, "gCrashReporter",

                                    "@mozilla.org/xre/app-info;1",

                                    "nsICrashReporter");

 #endif

 XPCOMUtils.defineLazyGetter(this, "PageMenu", function() {

   let tmp = {};

   Cu.import("resource://gre/modules/PageMenu.jsm", tmp);

   return new tmp.PageMenu();

 });

 /**

 * We can avoid adding multiple load event listeners and save some time by adding

 * one listener that calls all real handlers.

 */

 function pageShowEventHandlers(persisted) {

   charsetLoadListener();

   XULBrowserWindow.asyncUpdateUI();

   // The PluginClickToPlay events are not fired when navigating using the

   // BF cache. |persisted| is true when the page is loaded from the

   // BF cache, so this code reshows the notification if necessary.

   if (persisted)

     gPluginHandler.reshowClickToPlayNotification();

 }

 function UpdateBackForwardCommands(aWebNavigation) {

   var backBroadcaster = document.getElementById("Browser:Back");

   var forwardBroadcaster = document.getElementById("Browser:Forward");

   // Avoid setting attributes on broadcasters if the value hasn't changed!

   // Remember, guys, setting attributes on elements is expensive!  They

   // get inherited into anonymous content, broadcast to other widgets, etc.!

   // Don't do it if the value hasn't changed! - dwh

   var backDisabled = backBroadcaster.hasAttribute("disabled");

   var forwardDisabled = forwardBroadcaster.hasAttribute("disabled");

   if (backDisabled == aWebNavigation.canGoBack) {

     if (backDisabled)

       backBroadcaster.removeAttribute("disabled");

     else

       backBroadcaster.setAttribute("disabled", true);

   }

   if (forwardDisabled == aWebNavigation.canGoForward) {

     if (forwardDisabled)

       forwardBroadcaster.removeAttribute("disabled");

     else

       forwardBroadcaster.setAttribute("disabled", true);

   }

 }

 /**

  * Click-and-Hold implementation for the Back and Forward buttons

  * XXXmano: should this live in toolbarbutton.xml?

  */

 function SetClickAndHoldHandlers() {

   var timer;

   function openMenu(aButton) {

     cancelHold(aButton);

     aButton.firstChild.hidden = false;

     aButton.open = true;

   }

   function mousedownHandler(aEvent) {

     if (aEvent.button != 0 ||

         aEvent.currentTarget.open ||

         aEvent.currentTarget.disabled)

       return;

     // Prevent the menupopup from opening immediately

     aEvent.currentTarget.firstChild.hidden = true;

     aEvent.currentTarget.addEventListener("mouseout", mouseoutHandler, false);

     aEvent.currentTarget.addEventListener("mouseup", mouseupHandler, false);

     timer = setTimeout(openMenu, 500, aEvent.currentTarget);

   }

   function mouseoutHandler(aEvent) {

     let buttonRect = aEvent.currentTarget.getBoundingClientRect();

     if (aEvent.clientX >= buttonRect.left &&

         aEvent.clientX <= buttonRect.right &&

         aEvent.clientY >= buttonRect.bottom)

       openMenu(aEvent.currentTarget);

     else

       cancelHold(aEvent.currentTarget);

   }

   function mouseupHandler(aEvent) {

     cancelHold(aEvent.currentTarget);

   }

   function cancelHold(aButton) {

     clearTimeout(timer);

     aButton.removeEventListener("mouseout", mouseoutHandler, false);

     aButton.removeEventListener("mouseup", mouseupHandler, false);

   }

   function clickHandler(aEvent) {

     if (aEvent.button == 0 &&

         aEvent.target == aEvent.currentTarget &&

         !aEvent.currentTarget.open &&

         !aEvent.currentTarget.disabled) {

       let cmdEvent = document.createEvent("xulcommandevent");

       cmdEvent.initCommandEvent("command", true, true, window, 0,

                                 aEvent.ctrlKey, aEvent.altKey, aEvent.shiftKey,

                                 aEvent.metaKey, null);

       aEvent.currentTarget.dispatchEvent(cmdEvent);

     }

   }

   function _addClickAndHoldListenersOnElement(aElm) {

     aElm.addEventListener("mousedown", mousedownHandler, true);

     aElm.addEventListener("click", clickHandler, true);

   }

   // Bug 414797: Clone the back/forward buttons' context menu into both buttons.

   let popup = document.getElementById("backForwardMenu").cloneNode(true);

   popup.removeAttribute("id");

   // Prevent the back/forward buttons' context attributes from being inherited.

   popup.setAttribute("context", "");

   let backButton = document.getElementById("back-button");

   backButton.setAttribute("type", "menu");

   backButton.appendChild(popup);

   _addClickAndHoldListenersOnElement(backButton);

   let forwardButton = document.getElementById("forward-button");

   popup = popup.cloneNode(true);

   forwardButton.setAttribute("type", "menu");

   forwardButton.appendChild(popup);

   _addClickAndHoldListenersOnElement(forwardButton);

 }

 const gSessionHistoryObserver = {

   observe: function(subject, topic, data)

   {

     if (topic != "browser:purge-session-history")

       return;

     var backCommand = document.getElementById("Browser:Back");

     backCommand.setAttribute("disabled", "true");

     var fwdCommand = document.getElementById("Browser:Forward");

     fwdCommand.setAttribute("disabled", "true");

     // Hide session restore button on about:home

     window.messageManager.broadcastAsyncMessage("Browser:HideSessionRestoreButton");

     if (gURLBar) {

       // Clear undo history of the URL bar

       gURLBar.editor.transactionManager.clear()

     }

   }

 };

 /**

  * Given a starting docshell and a URI to look up, find the docshell the URI

  * is loaded in.

  * @param   aDocument

  *          A document to find instead of using just a URI - this is more specific.

  * @param   aDocShell

  *          The doc shell to start at

  * @param   aSoughtURI

  *          The URI that we're looking for

  * @returns The doc shell that the sought URI is loaded in. Can be in

  *          subframes.

  */

 function findChildShell(aDocument, aDocShell, aSoughtURI) {

   aDocShell.QueryInterface(Components.interfaces.nsIWebNavigation);

   aDocShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor);

   var doc = aDocShell.getInterface(Components.interfaces.nsIDOMDocument);

   if ((aDocument && doc == aDocument) ||

       (aSoughtURI && aSoughtURI.spec == aDocShell.currentURI.spec))

     return aDocShell;

   var node = aDocShell.QueryInterface(Components.interfaces.nsIDocShellTreeItem);

   for (var i = 0; i < node.childCount; ++i) {

     var docShell = node.getChildAt(i);

     docShell = findChildShell(aDocument, docShell, aSoughtURI);

     if (docShell)

       return docShell;

   }

   return null;

 }

 var gPopupBlockerObserver = {

   _reportButton: null,

   onReportButtonClick: function (aEvent)

   {

     if (aEvent.button != 0 || aEvent.target != this._reportButton)

       return;

     document.getElementById("blockedPopupOptions")

             .openPopup(this._reportButton, "after_end", 0, 2, false, false, aEvent);

   },

   handleEvent: function (aEvent)

   {

     if (aEvent.originalTarget != gBrowser.selectedBrowser)

       return;

     if (!this._reportButton && gURLBar)

       this._reportButton = document.getElementById("page-report-button");

     if (!gBrowser.selectedBrowser.blockedPopups) {

       // Hide the icon in the location bar (if the location bar exists)

       if (gURLBar)

         this._reportButton.hidden = true;

       return;

     }

     if (gURLBar)

       this._reportButton.hidden = false;

     // Only show the notification again if we've not already shown it. Since

     // notifications are per-browser, we don't need to worry about re-adding

     // it.

     if (!gBrowser.selectedBrowser.blockedPopups.reported) {

       if (gPrefService.getBoolPref("privacy.popups.showBrowserMessage")) {

         var brandBundle = document.getElementById("bundle_brand");

         var brandShortName = brandBundle.getString("brandShortName");

         var popupCount = gBrowser.selectedBrowser.blockedPopups.length;

 #ifdef XP_WIN

         var popupButtonText = gNavigatorBundle.getString("popupWarningButton");

         var popupButtonAccesskey = gNavigatorBundle.getString("popupWarningButton.accesskey");

 #else

         var popupButtonText = gNavigatorBundle.getString("popupWarningButtonUnix");

         var popupButtonAccesskey = gNavigatorBundle.getString("popupWarningButtonUnix.accesskey");

 #endif

         var messageBase = gNavigatorBundle.getString("popupWarning.message");

         var message = PluralForm.get(popupCount, messageBase)

                                 .replace("#1", brandShortName)

                                 .replace("#2", popupCount);

         var notificationBox = gBrowser.getNotificationBox();

         var notification = notificationBox.getNotificationWithValue("popup-blocked");

         if (notification) {

           notification.label = message;

         }

         else {

           var buttons = [{

             label: popupButtonText,

             accessKey: popupButtonAccesskey,

             popup: "blockedPopupOptions",

             callback: null

           }];

           const priority = notificationBox.PRIORITY_WARNING_MEDIUM;

           notificationBox.appendNotification(message, "popup-blocked",

                                              "chrome://browser/skin/Info.png",

                                              priority, buttons);

         }

       }

       // Record the fact that we've reported this blocked popup, so we don't

       // show it again.

       gBrowser.selectedBrowser.blockedPopups.reported = true;

     }

   },

   toggleAllowPopupsForSite: function (aEvent)

   {

     var pm = Services.perms;

     var shouldBlock = aEvent.target.getAttribute("block") == "true";

     var perm = shouldBlock ? pm.DENY_ACTION : pm.ALLOW_ACTION;

     pm.add(gBrowser.currentURI, "popup", perm);

     gBrowser.getNotificationBox().removeCurrentNotification();

   },

   fillPopupList: function (aEvent)

   {

     // XXXben - rather than using |currentURI| here, which breaks down on multi-framed sites

     //          we should really walk the blockedPopups and create a list of "allow for <host>"

     //          menuitems for the common subset of hosts present in the report, this will

     //          make us frame-safe.

     //

     // XXXjst - Note that when this is fixed to work with multi-framed sites,

     //          also back out the fix for bug 343772 where

     //          nsGlobalWindow::CheckOpenAllow() was changed to also

     //          check if the top window's location is whitelisted.

     let browser = gBrowser.selectedBrowser;

     var uri = browser.currentURI;

     var blockedPopupAllowSite = document.getElementById("blockedPopupAllowSite");

     try {

       blockedPopupAllowSite.removeAttribute("hidden");

       var pm = Services.perms;

       if (pm.testPermission(uri, "popup") == pm.ALLOW_ACTION) {

         // Offer an item to block popups for this site, if a whitelist entry exists

         // already for it.

         let blockString = gNavigatorBundle.getFormattedString("popupBlock", [uri.host || uri.spec]);

         blockedPopupAllowSite.setAttribute("label", blockString);

         blockedPopupAllowSite.setAttribute("block", "true");

       }

       else {

         // Offer an item to allow popups for this site

         let allowString = gNavigatorBundle.getFormattedString("popupAllow", [uri.host || uri.spec]);

         blockedPopupAllowSite.setAttribute("label", allowString);

         blockedPopupAllowSite.removeAttribute("block");

       }

     }

     catch (e) {

       blockedPopupAllowSite.setAttribute("hidden", "true");

     }

     if (PrivateBrowsingUtils.isWindowPrivate(window))

       blockedPopupAllowSite.setAttribute("disabled", "true");

     else

       blockedPopupAllowSite.removeAttribute("disabled");

     var foundUsablePopupURI = false;

     var blockedPopups = browser.blockedPopups;

     if (blockedPopups) {

       for (let i = 0; i < blockedPopups.length; i++) {

         let blockedPopup = blockedPopups[i];

         // popupWindowURI will be null if the file picker popup is blocked.

         // xxxdz this should make the option say "Show file picker" and do it (Bug 590306)

         if (!blockedPopup.popupWindowURI)

           continue;

         var popupURIspec = blockedPopup.popupWindowURI;

         // Sometimes the popup URI that we get back from the blockedPopup

         // isn't useful (for instance, netscape.com's popup URI ends up

         // being "http://www.netscape.com", which isn't really the URI of

         // the popup they're trying to show).  This isn't going to be

         // useful to the user, so we won't create a menu item for it.

         if (popupURIspec == "" || popupURIspec == "about:blank" ||

             popupURIspec == uri.spec)

           continue;

         // Because of the short-circuit above, we may end up in a situation

         // in which we don't have any usable popup addresses to show in

         // the menu, and therefore we shouldn't show the separator.  However,

         // since we got past the short-circuit, we must've found at least

         // one usable popup URI and thus we'll turn on the separator later.

         foundUsablePopupURI = true;

         var menuitem = document.createElement("menuitem");

         var label = gNavigatorBundle.getFormattedString("popupShowPopupPrefix",

                                                         [popupURIspec]);

         menuitem.setAttribute("label", label);

         menuitem.setAttribute("popupWindowURI", popupURIspec);

         menuitem.setAttribute("popupWindowFeatures", blockedPopup.popupWindowFeatures);

         menuitem.setAttribute("popupWindowName", blockedPopup.popupWindowName);

         menuitem.setAttribute("oncommand", "gPopupBlockerObserver.showBlockedPopup(event);");

         menuitem.setAttribute("popupReportIndex", i);

         menuitem.popupReportBrowser = browser;

         aEvent.target.appendChild(menuitem);

       }

     }

     // Show or hide the separator, depending on whether we added any

     // showable popup addresses to the menu.

     var blockedPopupsSeparator =

       document.getElementById("blockedPopupsSeparator");

     if (foundUsablePopupURI)

       blockedPopupsSeparator.removeAttribute("hidden");

     else

       blockedPopupsSeparator.setAttribute("hidden", true);

     var blockedPopupDontShowMessage = document.getElementById("blockedPopupDontShowMessage");

     var showMessage = gPrefService.getBoolPref("privacy.popups.showBrowserMessage");

     blockedPopupDontShowMessage.setAttribute("checked", !showMessage);

     if (aEvent.target.anchorNode.id == "page-report-button") {

       aEvent.target.anchorNode.setAttribute("open", "true");

       blockedPopupDontShowMessage.setAttribute("label", gNavigatorBundle.getString("popupWarningDontShowFromLocationbar"));

     } else

       blockedPopupDontShowMessage.setAttribute("label", gNavigatorBundle.getString("popupWarningDontShowFromMessage"));

   },

   onPopupHiding: function (aEvent) {

     if (aEvent.target.anchorNode.id == "page-report-button")

       aEvent.target.anchorNode.removeAttribute("open");

     let item = aEvent.target.lastChild;

     while (item && item.getAttribute("observes") != "blockedPopupsSeparator") {

       let next = item.previousSibling;

       item.parentNode.removeChild(item);

       item = next;

     }

   },

   showBlockedPopup: function (aEvent)

   {

     var target = aEvent.target;

     var popupReportIndex = target.getAttribute("popupReportIndex");

     let browser = target.popupReportBrowser;

     browser.unblockPopup(popupReportIndex);

   },

   editPopupSettings: function ()

   {

     var host = "";

     try {

       host = gBrowser.currentURI.host;

     }

     catch (e) { }

     var bundlePreferences = document.getElementById("bundle_preferences");

     var params = { blockVisible   : false,

                    sessionVisible : false,

                    allowVisible   : true,

                    prefilledHost  : host,

                    permissionType : "popup",

                    windowTitle    : bundlePreferences.getString("popuppermissionstitle"),

                    introText      : bundlePreferences.getString("popuppermissionstext") };

     var existingWindow = Services.wm.getMostRecentWindow("Browser:Permissions");

     if (existingWindow) {

       existingWindow.initWithParams(params);

       existingWindow.focus();

     }

     else

       window.openDialog("chrome://browser/content/preferences/permissions.xul",

                         "_blank", "resizable,dialog=no,centerscreen", params);

   },

   dontShowMessage: function ()

   {

     var showMessage = gPrefService.getBoolPref("privacy.popups.showBrowserMessage");

     gPrefService.setBoolPref("privacy.popups.showBrowserMessage", !showMessage);

     gBrowser.getNotificationBox().removeCurrentNotification();

   }

 };

 const gFormSubmitObserver = {

   QueryInterface : XPCOMUtils.generateQI([Ci.nsIFormSubmitObserver]),

   panel: null,

   init: function()

   {

     this.panel = document.getElementById('invalid-form-popup');

   },

   notifyInvalidSubmit : function (aFormElement, aInvalidElements)

   {

     // We are going to handle invalid form submission attempt by focusing the

     // first invalid element and show the corresponding validation message in a

     // panel attached to the element.

     if (!aInvalidElements.length) {

       return;

     }

     // Don't show the popup if the current tab doesn't contain the invalid form.

     if (gBrowser.contentDocument !=

         aFormElement.ownerDocument.defaultView.top.document) {

       return;

     }

     let element = aInvalidElements.queryElementAt(0, Ci.nsISupports);

     if (!(element instanceof HTMLInputElement ||

           element instanceof HTMLTextAreaElement ||

           element instanceof HTMLSelectElement ||

           element instanceof HTMLButtonElement)) {

       return;

     }

     this.panel.firstChild.textContent = element.validationMessage;

     element.focus();

     // If the user interacts with the element and makes it valid or leaves it,

     // we want to remove the popup.

     // We could check for clicks but a click is already removing the popup.

     function blurHandler() {

       gFormSubmitObserver.panel.hidePopup();

     };

     function inputHandler(e) {

       if (e.originalTarget.validity.valid) {

         gFormSubmitObserver.panel.hidePopup();

       } else {

         // If the element is now invalid for a new reason, we should update the

         // error message.

         if (gFormSubmitObserver.panel.firstChild.textContent !=

             e.originalTarget.validationMessage) {

           gFormSubmitObserver.panel.firstChild.textContent =

             e.originalTarget.validationMessage;

         }

       }

     };

     element.addEventListener("input", inputHandler, false);

     element.addEventListener("blur", blurHandler, false);

     // One event to bring them all and in the darkness bind them.

     this.panel.addEventListener("popuphiding", function onPopupHiding(aEvent) {

       aEvent.target.removeEventListener("popuphiding", onPopupHiding, false);

       element.removeEventListener("input", inputHandler, false);

       element.removeEventListener("blur", blurHandler, false);

     }, false);

     this.panel.hidden = false;

     // We want to show the popup at the middle of checkbox and radio buttons

     // and where the content begin for the other elements.

     let offset = 0;

     let position = "";

     if (element.tagName == 'INPUT' &&

         (element.type == 'radio' || element.type == 'checkbox')) {

       position = "bottomcenter topleft";

     } else {

       let win = element.ownerDocument.defaultView;

       let style = win.getComputedStyle(element, null);

       let utils = win.QueryInterface(Components.interfaces.nsIInterfaceRequestor)

                      .getInterface(Components.interfaces.nsIDOMWindowUtils);

       if (style.direction == 'rtl') {

         offset = parseInt(style.paddingRight) + parseInt(style.borderRightWidth);

       } else {

         offset = parseInt(style.paddingLeft) + parseInt(style.borderLeftWidth);

       }

       offset = Math.round(offset * utils.fullZoom);

       position = "after_start";

     }

     this.panel.openPopup(element, position, offset, 0);

   }

 };

 var gBrowserInit = {

   delayedStartupFinished: false,

   onLoad: function() {

     gMultiProcessBrowser =

       window.QueryInterface(Ci.nsIInterfaceRequestor)

       .getInterface(Ci.nsIWebNavigation)

       .QueryInterface(Ci.nsILoadContext)

       .useRemoteTabs;

     var mustLoadSidebar = false;

     if (!gMultiProcessBrowser) {

       // There is a Content:Click message manually sent from content.

       Cc["@mozilla.org/eventlistenerservice;1"]

         .getService(Ci.nsIEventListenerService)

         .addSystemEventListener(gBrowser, "click", contentAreaClick, true);

     }

     gBrowser.addEventListener("DOMUpdatePageReport", gPopupBlockerObserver, false);

     // Note that the XBL binding is untrusted

     gBrowser.addEventListener("PluginBindingAttached", gPluginHandler, true, true);

     gBrowser.addEventListener("PluginCrashed",         gPluginHandler, true);

     gBrowser.addEventListener("PluginOutdated",        gPluginHandler, true);

     gBrowser.addEventListener("PluginInstantiated",    gPluginHandler, true);

     gBrowser.addEventListener("PluginRemoved",         gPluginHandler, true);

     gBrowser.addEventListener("NewPluginInstalled", gPluginHandler.newPluginInstalled, true);

     Services.obs.addObserver(gPluginHandler.pluginCrashed, "plugin-crashed", false);

     window.addEventListener("AppCommand", HandleAppCommandEvent, true);

     // These routines add message listeners. They must run before

     // loading the frame script to ensure that we don't miss any

     // message sent between when the frame script is loaded and when

     // the listener is registered.

     DOMLinkHandler.init();

     gPageStyleMenu.init();

     LanguageDetectionListener.init();

     messageManager.loadFrameScript("chrome://browser/content/content.js", true);

     // initialize observers and listeners

     // and give C++ access to gBrowser

     XULBrowserWindow.init();

     window.QueryInterface(Ci.nsIInterfaceRequestor)

           .getInterface(nsIWebNavigation)

           .QueryInterface(Ci.nsIDocShellTreeItem).treeOwner

           .QueryInterface(Ci.nsIInterfaceRequestor)

           .getInterface(Ci.nsIXULWindow)

           .XULBrowserWindow = window.XULBrowserWindow;

     window.QueryInterface(Ci.nsIDOMChromeWindow).browserDOMWindow =

       new nsBrowserAccess();

     // hook up UI through progress listener

     gBrowser.addProgressListener(window.XULBrowserWindow);

     gBrowser.addTabsProgressListener(window.TabsProgressListener);

     // setup simple gestures support

     gGestureSupport.init(true);

     // setup history swipe animation

     gHistorySwipeAnimation.init();

     if (window.opener && !window.opener.closed &&

         PrivateBrowsingUtils.isWindowPrivate(window) == PrivateBrowsingUtils.isWindowPrivate(window.opener)) {

       let openerSidebarBox = window.opener.document.getElementById("sidebar-box");

       // If the opener had a sidebar, open the same sidebar in our window.

       // The opener can be the hidden window too, if we're coming from the state

       // where no windows are open, and the hidden window has no sidebar box.

       if (openerSidebarBox && !openerSidebarBox.hidden) {

         let sidebarCmd = openerSidebarBox.getAttribute("sidebarcommand");

         let sidebarCmdElem = document.getElementById(sidebarCmd);

         // dynamically generated sidebars will fail this check.

         if (sidebarCmdElem) {

           let sidebarBox = document.getElementById("sidebar-box");

           let sidebarTitle = document.getElementById("sidebar-title");

           sidebarTitle.setAttribute(

             "value", window.opener.document.getElementById("sidebar-title").getAttribute("value"));

           sidebarBox.setAttribute("width", openerSidebarBox.boxObject.width);

           sidebarBox.setAttribute("sidebarcommand", sidebarCmd);

           // Note: we're setting 'src' on sidebarBox, which is a <vbox>, not on

           // the <browser id="sidebar">. This lets us delay the actual load until

           // delayedStartup().

           sidebarBox.setAttribute(

             "src", window.opener.document.getElementById("sidebar").getAttribute("src"));

           mustLoadSidebar = true;

           sidebarBox.hidden = false;

           document.getElementById("sidebar-splitter").hidden = false;

           sidebarCmdElem.setAttribute("checked", "true");

         }

       }

     }

     else {

       let box = document.getElementById("sidebar-box");

       if (box.hasAttribute("sidebarcommand")) {

         let commandID = box.getAttribute("sidebarcommand");

         if (commandID) {

           let command = document.getElementById(commandID);

           if (command) {

             mustLoadSidebar = true;

             box.hidden = false;

             document.getElementById("sidebar-splitter").hidden = false;

             command.setAttribute("checked", "true");

           }

           else {

             // Remove the |sidebarcommand| attribute, because the element it

             // refers to no longer exists, so we should assume this sidebar

             // panel has been uninstalled. (249883)

             box.removeAttribute("sidebarcommand");

           }

         }

       }

     }

     // Certain kinds of automigration rely on this notification to complete their

     // tasks BEFORE the browser window is shown.

     Services.obs.notifyObservers(null, "browser-window-before-show", "");

     // Set a sane starting width/height for all resolutions on new profiles.

     if (!document.documentElement.hasAttribute("width")) {

       let defaultWidth;

       let defaultHeight;

       // Very small: maximize the window

       // Portrait  : use about full width and 3/4 height, to view entire pages

       //             at once (without being obnoxiously tall)

       // Widescreen: use about half width, to suggest side-by-side page view

       // Otherwise : use 3/4 height and width

       if (screen.availHeight <= 600) {

         document.documentElement.setAttribute("sizemode", "maximized");

         defaultWidth = 610;

         defaultHeight = 450;

       }

       else {

         if (screen.availWidth <= screen.availHeight) {

           defaultWidth = screen.availWidth * .9;

           defaultHeight = screen.availHeight * .75;

         }

         else if (screen.availWidth >= 2048) {

           defaultWidth = (screen.availWidth / 2) - 20;

           defaultHeight = screen.availHeight - 10;

         }

         else {

           defaultWidth = screen.availWidth * .75;

           defaultHeight = screen.availHeight * .75;

         }

 #if MOZ_WIDGET_GTK == 2

         // On X, we're not currently able to account for the size of the window

         // border.  Use 28px as a guess (titlebar + bottom window border)

         defaultHeight -= 28;

 #endif

       }

       document.documentElement.setAttribute("width", defaultWidth);

       document.documentElement.setAttribute("height", defaultHeight);

     }

     if (!window.toolbar.visible) {

       // adjust browser UI for popups

       if (gURLBar) {

         gURLBar.setAttribute("readonly", "true");

         gURLBar.setAttribute("enablehistory", "false");

       }

       goSetCommandEnabled("cmd_newNavigatorTab", false);

     }

     // Misc. inits.

     CombinedStopReload.init();

     gPrivateBrowsingUI.init();

     TabsInTitlebar.init();

 #ifdef XP_WIN

     if (window.matchMedia("(-moz-os-version: windows-win8)").matches &&

         window.matchMedia("(-moz-windows-default-theme)").matches) {

       let windowFrameColor = Cu.import("resource:///modules/Windows8WindowFrameColor.jsm", {})

                                .Windows8WindowFrameColor.get();

       // Formula from W3C's WCAG 2.0 spec's color ratio and relative luminance,

       // section 1.3.4, http://www.w3.org/TR/WCAG20/ .

       windowFrameColor = windowFrameColor.map((color) => {

         if (color <= 10) {

           return color / 255 / 12.92;

         }

         return Math.pow(((color / 255) + 0.055) / 1.055, 2.4);

       });

       let backgroundLuminance = windowFrameColor[0] * 0.2126 +

                                 windowFrameColor[1] * 0.7152 +

                                 windowFrameColor[2] * 0.0722;

       let foregroundLuminance = 0; // Default to black for foreground text.

       let contrastRatio = (backgroundLuminance + 0.05) / (foregroundLuminance + 0.05);

       if (contrastRatio < 3) {

         document.documentElement.setAttribute("darkwindowframe", "true");

       }

     }

 #endif

     ToolbarIconColor.init();

     // Wait until chrome is painted before executing code not critical to making the window visible

     this._boundDelayedStartup = this._delayedStartup.bind(this, mustLoadSidebar);

     window.addEventListener("MozAfterPaint", this._boundDelayedStartup);

     this._loadHandled = true;

   },

   _cancelDelayedStartup: function () {

     window.removeEventListener("MozAfterPaint", this._boundDelayedStartup);

     this._boundDelayedStartup = null;

   },

   _delayedStartup: function(mustLoadSidebar) {

     let tmp = {};

     Cu.import("resource://gre/modules/TelemetryTimestamps.jsm", tmp);

     let TelemetryTimestamps = tmp.TelemetryTimestamps;

     TelemetryTimestamps.add("delayedStartupStarted");

     this._cancelDelayedStartup();

     // We need to set the MozApplicationManifest event listeners up

     // before we start loading the home pages in case a document has

     // a "manifest" attribute, in which the MozApplicationManifest event

     // will be fired.

     gBrowser.addEventListener("MozApplicationManifest",

                               OfflineApps, false);

     // listen for offline apps on social

     let socialBrowser = document.getElementById("social-sidebar-browser");

     socialBrowser.addEventListener("MozApplicationManifest",

                               OfflineApps, false);

     let uriToLoad = this._getUriToLoad();

     var isLoadingBlank = isBlankPageURL(uriToLoad);

     // This pageshow listener needs to be registered before we may call

     // swapBrowsersAndCloseOther() to receive pageshow events fired by that.

     gBrowser.addEventListener("pageshow", function(event) {

       // Filter out events that are not about the document load we are interested in

       if (content && event.target == content.document)

         setTimeout(pageShowEventHandlers, 0, event.persisted);

     }, true);

     if (uriToLoad && uriToLoad != "about:blank") {

       if (uriToLoad instanceof Ci.nsISupportsArray) {

         let count = uriToLoad.Count();

         let specs = [];

         for (let i = 0; i < count; i++) {

           let urisstring = uriToLoad.GetElementAt(i).QueryInterface(Ci.nsISupportsString);

           specs.push(urisstring.data);

         }

         // This function throws for certain malformed URIs, so use exception handling

         // so that we don't disrupt startup

         try {

           gBrowser.loadTabs(specs, false, true);

         } catch (e) {}

       }

       else if (uriToLoad instanceof XULElement) {

         // swap the given tab with the default about:blank tab and then close

         // the original tab in the other window.

         // Stop the about:blank load

         gBrowser.stop();

         // make sure it has a docshell

         gBrowser.docShell;

         gBrowser.swapBrowsersAndCloseOther(gBrowser.selectedTab, uriToLoad);

       }

       // window.arguments[2]: referrer (nsIURI)

       //                 [3]: postData (nsIInputStream)

       //                 [4]: allowThirdPartyFixup (bool)

       else if (window.arguments.length >= 3) {

         loadURI(uriToLoad, window.arguments[2], window.arguments[3] || null,

                 window.arguments[4] || false);

         window.focus();

       }

       // Note: loadOneOrMoreURIs *must not* be called if window.arguments.length >= 3.

       // Such callers expect that window.arguments[0] is handled as a single URI.

       else {

         if (uriToLoad == "about:newtab" &&

             Services.prefs.getBoolPref("browser.newtabpage.enabled")) {

           Services.telemetry.getHistogramById("NEWTAB_PAGE_SHOWN").add(true);

         }

         loadOneOrMoreURIs(uriToLoad);

       }

     }

 #ifdef MOZ_SAFE_BROWSING

     // Bug 778855 - Perf regression if we do this here. To be addressed in bug 779008.

     setTimeout(function() { SafeBrowsing.init(); }, 2000);

 #endif

     Services.obs.addObserver(gSessionHistoryObserver, "browser:purge-session-history", false);

     Services.obs.addObserver(gXPInstallObserver, "addon-install-disabled", false);

     Services.obs.addObserver(gXPInstallObserver, "addon-install-started", false);

     Services.obs.addObserver(gXPInstallObserver, "addon-install-blocked", false);

     Services.obs.addObserver(gXPInstallObserver, "addon-install-failed", false);

     Services.obs.addObserver(gXPInstallObserver, "addon-install-complete", false);

     Services.obs.addObserver(gFormSubmitObserver, "invalidformsubmit", false);

     BrowserOffline.init();

     OfflineApps.init();

     IndexedDBPromptHelper.init();

     CanvasPermissionPromptHelper.init();

     gFormSubmitObserver.init();

     gRemoteTabsUI.init();

     // Initialize the full zoom setting.

     // We do this before the session restore service gets initialized so we can

     // apply full zoom settings to tabs restored by the session restore service.

     FullZoom.init();

     PanelUI.init();

     LightweightThemeListener.init();

     WebrtcIndicator.init();

     // Ensure login manager is up and running.

     Services.logins;

 #ifdef MOZ_CRASHREPORTER

     if (gMultiProcessBrowser)

       TabCrashReporter.init();

 #endif

     if (mustLoadSidebar) {

       let sidebar = document.getElementById("sidebar");

       let sidebarBox = document.getElementById("sidebar-box");

       sidebar.setAttribute("src", sidebarBox.getAttribute("src"));

     }

     UpdateUrlbarSearchSplitterState();

     if (!isLoadingBlank || !focusAndSelectUrlBar())

       gBrowser.selectedBrowser.focus();

     // Set up Sanitize Item

     this._initializeSanitizer();

     // Enable/Disable auto-hide tabbar

     gBrowser.tabContainer.updateVisibility();

     BookmarkingUI.init();

     gPrefService.addObserver(gHomeButton.prefDomain, gHomeButton, false);

     var homeButton = document.getElementById("home-button");

     gHomeButton.updateTooltip(homeButton);

     gHomeButton.updatePersonalToolbarStyle(homeButton);

     // BiDi UI

     gBidiUI = isBidiEnabled();

     if (gBidiUI) {

       document.getElementById("documentDirection-separator").hidden = false;

       document.getElementById("documentDirection-swap").hidden = false;

       document.getElementById("textfieldDirection-separator").hidden = false;

       document.getElementById("textfieldDirection-swap").hidden = false;

     }

     // Setup click-and-hold gestures access to the session history

     // menus if global click-and-hold isn't turned on

     if (!getBoolPref("ui.click_hold_context_menus", false))

       SetClickAndHoldHandlers();

     let NP = {};

     Cu.import("resource:///modules/NetworkPrioritizer.jsm", NP);

     NP.trackBrowserWindow(window);

     PlacesToolbarHelper.init();

     ctrlTab.readPref();

     gPrefService.addObserver(ctrlTab.prefName, ctrlTab, false);

     // Initialize the download manager some time after the app starts so that

     // auto-resume downloads begin (such as after crashing or quitting with

     // active downloads) and speeds up the first-load of the download manager UI.

     // If the user manually opens the download manager before the timeout, the

     // downloads will start right away, and initializing again won't hurt.

     setTimeout(function() {

       try {

         Cu.import("resource:///modules/DownloadsCommon.jsm", {})

           .DownloadsCommon.initializeAllDataLinks();

         Cu.import("resource:///modules/DownloadsTaskbar.jsm", {})

           .DownloadsTaskbar.registerIndicator(window);

       } catch (ex) {

         Cu.reportError(ex);

       }

     }, 10000);

     // The object handling the downloads indicator is also initialized here in the

     // delayed startup function, but the actual indicator element is not loaded

     // unless there are downloads to be displayed.

     DownloadsButton.initializeIndicator();

 #ifndef XP_MACOSX

     updateEditUIVisibility();

     let placesContext = document.getElementById("placesContext");

     placesContext.addEventListener("popupshowing", updateEditUIVisibility, false);

     placesContext.addEventListener("popuphiding", updateEditUIVisibility, false);

 #endif

     gBrowser.mPanelContainer.addEventListener("InstallBrowserTheme", LightWeightThemeWebInstaller, false, true);

     gBrowser.mPanelContainer.addEventListener("PreviewBrowserTheme", LightWeightThemeWebInstaller, false, true);

     gBrowser.mPanelContainer.addEventListener("ResetBrowserThemePreview", LightWeightThemeWebInstaller, false, true);

     if (Win7Features)

       Win7Features.onOpenWindow();

    // called when we go into full screen, even if initiated by a web page script

     window.addEventListener("fullscreen", onFullScreen, true);

     // Called when we enter DOM full-screen mode. Note we can already be in browser

     // full-screen mode when we enter DOM full-screen mode.

     window.addEventListener("MozEnteredDomFullscreen", onMozEnteredDomFullscreen, true);

     if (window.fullScreen)

       onFullScreen();

     if (document.mozFullScreen)

       onMozEnteredDomFullscreen();

 #ifdef MOZ_SERVICES_SYNC

     // initialize the sync UI

     gSyncUI.init();

     gFxAccounts.init();

 #endif

 #ifdef MOZ_DATA_REPORTING

     gDataNotificationInfoBar.init();

 #endif

     gBrowserThumbnails.init();

     // Add Devtools menuitems and listeners

     gDevToolsBrowser.registerBrowserWindow(window);

     window.addEventListener("mousemove", MousePosTracker, false);

     window.addEventListener("dragover", MousePosTracker, false);

     gNavToolbox.addEventListener("customizationstarting", CustomizationHandler);

     gNavToolbox.addEventListener("customizationchange", CustomizationHandler);

     gNavToolbox.addEventListener("customizationending", CustomizationHandler);

     // End startup crash tracking after a delay to catch crashes while restoring

     // tabs and to postpone saving the pref to disk.

     try {

       const startupCrashEndDelay = 30 * 1000;

       setTimeout(Services.startup.trackStartupCrashEnd, startupCrashEndDelay);

     } catch (ex) {

       Cu.reportError("Could not end startup crash tracking: " + ex);

     }

     if (typeof WindowsPrefSync !== 'undefined') {

       // Pulls in Metro controlled prefs and pushes out Desktop controlled prefs

       WindowsPrefSync.init();

     }

     SessionStore.promiseInitialized.then(() => {

       // Bail out if the window has been closed in the meantime.

       if (window.closed) {

         return;

       }

       // Enable the Restore Last Session command if needed

       RestoreLastSessionObserver.init();

       SocialUI.init();

       TabView.init();

       setTimeout(function () { BrowserChromeTest.markAsReady(); }, 0);

     });

     this.delayedStartupFinished = true;

     Services.obs.notifyObservers(window, "browser-delayed-startup-finished", "");

     TelemetryTimestamps.add("delayedStartupFinished");

   },

   // Returns the URI(s) to load at startup.

   _getUriToLoad: function () {

     // window.arguments[0]: URI to load (string), or an nsISupportsArray of

     //                      nsISupportsStrings to load, or a xul:tab of

     //                      a tabbrowser, which will be replaced by this

     //                      window (for this case, all other arguments are

     //                      ignored).

     if (!window.arguments || !window.arguments[0])

       return null;

     let uri = window.arguments[0];

     let sessionStartup = Cc["@mozilla.org/browser/sessionstartup;1"]

                            .getService(Ci.nsISessionStartup);

     let defaultArgs = Cc["@mozilla.org/browser/clh;1"]

                         .getService(Ci.nsIBrowserHandler)

                         .defaultArgs;

     // If the given URI matches defaultArgs (the default homepage) we want

     // to block its load if we're going to restore a session anyway.

     if (uri == defaultArgs && sessionStartup.willOverrideHomepage)

       return null;

     return uri;

   },

   onUnload: function() {

     // In certain scenarios it's possible for unload to be fired before onload,

     // (e.g. if the window is being closed after browser.js loads but before the

     // load completes). In that case, there's nothing to do here.

     if (!this._loadHandled)

       return;

     gDevToolsBrowser.forgetBrowserWindow(window);

     let desc = Object.getOwnPropertyDescriptor(window, "DeveloperToolbar");

     if (desc && !desc.get) {

       DeveloperToolbar.destroy();

     }

     // First clean up services initialized in gBrowserInit.onLoad (or those whose

     // uninit methods don't depend on the services having been initialized).

     CombinedStopReload.uninit();

     gGestureSupport.init(false);

     gHistorySwipeAnimation.uninit();

     FullScreen.cleanup();

 #ifdef MOZ_SERVICES_SYNC

     gFxAccounts.uninit();

 #endif

     Services.obs.removeObserver(gPluginHandler.pluginCrashed, "plugin-crashed");

     try {

       gBrowser.removeProgressListener(window.XULBrowserWindow);

       gBrowser.removeTabsProgressListener(window.TabsProgressListener);

     } catch (ex) {

     }

     PlacesToolbarHelper.uninit();

     BookmarkingUI.uninit();

     TabsInTitlebar.uninit();

     ToolbarIconColor.uninit();

     var enumerator = Services.wm.getEnumerator(null);

     enumerator.getNext();

     if (!enumerator.hasMoreElements()) {

       document.persist("sidebar-box", "sidebarcommand");

       document.persist("sidebar-box", "width");

       document.persist("sidebar-box", "src");

       document.persist("sidebar-title", "value");

     }

     // Now either cancel delayedStartup, or clean up the services initialized from

     // it.

     if (this._boundDelayedStartup) {

       this._cancelDelayedStartup();

     } else {

       if (Win7Features)

         Win7Features.onCloseWindow();

       gPrefService.removeObserver(ctrlTab.prefName, ctrlTab);

       ctrlTab.uninit();

       TabView.uninit();

       SocialUI.uninit();

       gBrowserThumbnails.uninit();

       FullZoom.destroy();

       Services.obs.removeObserver(gSessionHistoryObserver, "browser:purge-session-history");

       Services.obs.removeObserver(gXPInstallObserver, "addon-install-disabled");

       Services.obs.removeObserver(gXPInstallObserver, "addon-install-started");

       Services.obs.removeObserver(gXPInstallObserver, "addon-install-blocked");

       Services.obs.removeObserver(gXPInstallObserver, "addon-install-failed");

       Services.obs.removeObserver(gXPInstallObserver, "addon-install-complete");

       Services.obs.removeObserver(gFormSubmitObserver, "invalidformsubmit");

       try {

         gPrefService.removeObserver(gHomeButton.prefDomain, gHomeButton);

       } catch (ex) {

         Cu.reportError(ex);

       }

       if (typeof WindowsPrefSync !== 'undefined') {

         WindowsPrefSync.uninit();

       }

       BrowserOffline.uninit();

       OfflineApps.uninit();

       IndexedDBPromptHelper.uninit();

       CanvasPermissionPromptHelper.uninit();

       LightweightThemeListener.uninit();

       PanelUI.uninit();

     }

     // Final window teardown, do this last.

     window.XULBrowserWindow = null;

     window.QueryInterface(Ci.nsIInterfaceRequestor)

           .getInterface(Ci.nsIWebNavigation)

           .QueryInterface(Ci.nsIDocShellTreeItem).treeOwner

           .QueryInterface(Ci.nsIInterfaceRequestor)

           .getInterface(Ci.nsIXULWindow)

           .XULBrowserWindow = null;

     window.QueryInterface(Ci.nsIDOMChromeWindow).browserDOMWindow = null;

   },

 #ifdef XP_MACOSX

   // nonBrowserWindowStartup(), nonBrowserWindowDelayedStartup(), and

   // nonBrowserWindowShutdown() are used for non-browser windows in

   // macBrowserOverlay

   nonBrowserWindowStartup: function() {

     // Disable inappropriate commands / submenus

     var disabledItems = ['Browser:SavePage',

                          'Browser:SendLink', 'cmd_pageSetup', 'cmd_print', 'cmd_find', 'cmd_findAgain',

                          'viewToolbarsMenu', 'viewSidebarMenuMenu', 'Browser:Reload',

                          'viewFullZoomMenu', 'pageStyleMenu', 'charsetMenu', 'View:PageSource', 'View:FullScreen',

                          'viewHistorySidebar', 'Browser:AddBookmarkAs', 'Browser:BookmarkAllTabs',

                          'View:PageInfo', 'Browser:ToggleTabView'];

     var element;

     for (let disabledItem of disabledItems) {

       element = document.getElementById(disabledItem);

       if (element)

         element.setAttribute("disabled", "true");

     }

     // If no windows are active (i.e. we're the hidden window), disable the close, minimize

     // and zoom menu commands as well

     if (window.location.href == "chrome://browser/content/hiddenWindow.xul") {

       var hiddenWindowDisabledItems = ['cmd_close', 'minimizeWindow', 'zoomWindow'];

       for (let hiddenWindowDisabledItem of hiddenWindowDisabledItems) {

         element = document.getElementById(hiddenWindowDisabledItem);

         if (element)

           element.setAttribute("disabled", "true");

       }

       // also hide the window-list separator

       element = document.getElementById("sep-window-list");

       element.setAttribute("hidden", "true");

       // Setup the dock menu.

       let dockMenuElement = document.getElementById("menu_mac_dockmenu");

       if (dockMenuElement != null) {

         let nativeMenu = Cc["@mozilla.org/widget/standalonenativemenu;1"]

                          .createInstance(Ci.nsIStandaloneNativeMenu);

         try {

           nativeMenu.init(dockMenuElement);

           let dockSupport = Cc["@mozilla.org/widget/macdocksupport;1"]

                             .getService(Ci.nsIMacDockSupport);

           dockSupport.dockMenu = nativeMenu;

         }

         catch (e) {

         }

       }

     }

     if (PrivateBrowsingUtils.permanentPrivateBrowsing) {

       document.getElementById("macDockMenuNewWindow").hidden = true;

     }

     this._delayedStartupTimeoutId = setTimeout(this.nonBrowserWindowDelayedStartup.bind(this), 0);

   },

   nonBrowserWindowDelayedStartup: function() {

     this._delayedStartupTimeoutId = null;

     // initialise the offline listener

     BrowserOffline.init();

     // Set up Sanitize Item

     this._initializeSanitizer();

     // initialize the private browsing UI

     gPrivateBrowsingUI.init();

 #ifdef MOZ_SERVICES_SYNC

     // initialize the sync UI

     gSyncUI.init();

 #endif

   },

   nonBrowserWindowShutdown: function() {

     // If nonBrowserWindowDelayedStartup hasn't run yet, we have no work to do -

     // just cancel the pending timeout and return;

     if (this._delayedStartupTimeoutId) {

       clearTimeout(this._delayedStartupTimeoutId);

       return;

     }

     BrowserOffline.uninit();

   },

 #endif

   _initializeSanitizer: function() {

     const kDidSanitizeDomain = "privacy.sanitize.didShutdownSanitize";

     if (gPrefService.prefHasUserValue(kDidSanitizeDomain)) {

       gPrefService.clearUserPref(kDidSanitizeDomain);

       // We need to persist this preference change, since we want to

       // check it at next app start even if the browser exits abruptly

       gPrefService.savePrefFile(null);

     }

     /**

      * Migrate Firefox 3.0 privacy.item prefs under one of these conditions:

      *

      * a) User has customized any privacy.item prefs

      * b) privacy.sanitize.sanitizeOnShutdown is set

      */

     if (!gPrefService.getBoolPref("privacy.sanitize.migrateFx3Prefs")) {

       let itemBranch = gPrefService.getBranch("privacy.item.");

       let itemArray = itemBranch.getChildList("");

       // See if any privacy.item prefs are set

       let doMigrate = itemArray.some(function (name) itemBranch.prefHasUserValue(name));

       // Or if sanitizeOnShutdown is set

       if (!doMigrate)

         doMigrate = gPrefService.getBoolPref("privacy.sanitize.sanitizeOnShutdown");

       if (doMigrate) {

         let cpdBranch = gPrefService.getBranch("privacy.cpd.");

         let clearOnShutdownBranch = gPrefService.getBranch("privacy.clearOnShutdown.");

         for (let name of itemArray) {

           try {

             // don't migrate password or offlineApps clearing in the CRH dialog since

             // there's no UI for those anymore. They default to false. bug 497656

             if (name != "passwords" && name != "offlineApps")

               cpdBranch.setBoolPref(name, itemBranch.getBoolPref(name));

             clearOnShutdownBranch.setBoolPref(name, itemBranch.getBoolPref(name));

           }

           catch(e) {

             Cu.reportError("Exception thrown during privacy pref migration: " + e);

           }

         }

       }

       gPrefService.setBoolPref("privacy.sanitize.migrateFx3Prefs", true);

     }

   },

 }

 /* Legacy global init functions */

 var BrowserStartup        = gBrowserInit.onLoad.bind(gBrowserInit);

 var BrowserShutdown       = gBrowserInit.onUnload.bind(gBrowserInit);

 #ifdef XP_MACOSX

 var nonBrowserWindowStartup        = gBrowserInit.nonBrowserWindowStartup.bind(gBrowserInit);

 var nonBrowserWindowDelayedStartup = gBrowserInit.nonBrowserWindowDelayedStartup.bind(gBrowserInit);

 var nonBrowserWindowShutdown       = gBrowserInit.nonBrowserWindowShutdown.bind(gBrowserInit);

 #endif

 function HandleAppCommandEvent(evt) {

   switch (evt.command) {

   case "Back":

     BrowserBack();

     break;

   case "Forward":

     BrowserForward();

     break;

   case "Reload":

     BrowserReloadSkipCache();

     break;

   case "Stop":

     if (XULBrowserWindow.stopCommand.getAttribute("disabled") != "true")

       BrowserStop();

     break;

   case "Search":

     BrowserSearch.webSearch();

     break;

   case "Bookmarks":

     toggleSidebar('viewBookmarksSidebar');

     break;

   case "Home":

     BrowserHome();

     break;

   case "New":

     BrowserOpenTab();

     break;

   case "Close":

     BrowserCloseTabOrWindow();

     break;

   case "Find":

     gFindBar.onFindCommand();

     break;

   case "Help":

     openHelpLink('firefox-help');

     break;

   case "Open":

     BrowserOpenFileWindow();

     break;

   case "Print":

     PrintUtils.print();

     break;

   case "Save":

     saveDocument(window.content.document);

     break;

   case "SendMail":

     MailIntegration.sendLinkForWindow(window.content);

     break;

   default:

     return;

   }

   evt.stopPropagation();

   evt.preventDefault();

 }

 function gotoHistoryIndex(aEvent) {

   let index = aEvent.target.getAttribute("index");

   if (!index)

     return false;

   let where = whereToOpenLink(aEvent);

   if (where == "current") {

     // Normal click. Go there in the current tab and update session history.

     try {

       gBrowser.gotoIndex(index);

     }

     catch(ex) {

       return false;

     }

     return true;

   }

   // Modified click. Go there in a new tab/window.

   duplicateTabIn(gBrowser.selectedTab, where, index - gBrowser.sessionHistory.index);

   return true;

 }

 function BrowserForward(aEvent) {

   let where = whereToOpenLink(aEvent, false, true);

   if (where == "current") {

     try {

       gBrowser.goForward();

     }

     catch(ex) {

     }

   }

   else {

     duplicateTabIn(gBrowser.selectedTab, where, 1);

   }

 }

 function BrowserBack(aEvent) {

   let where = whereToOpenLink(aEvent, false, true);

   if (where == "current") {

     try {

       gBrowser.goBack();

     }

     catch(ex) {

     }

   }

   else {

     duplicateTabIn(gBrowser.selectedTab, where, -1);

   }

 }

 function BrowserHandleBackspace()

 {

   switch (gPrefService.getIntPref("browser.backspace_action")) {

   case 0:

     BrowserBack();

     break;

   case 1:

     goDoCommand("cmd_scrollPageUp");

     break;

   }

 }

 function BrowserHandleShiftBackspace()

 {

   switch (gPrefService.getIntPref("browser.backspace_action")) {

   case 0:

     BrowserForward();

     break;

   case 1:

     goDoCommand("cmd_scrollPageDown");

     break;

   }

 }

 function BrowserStop() {

   const stopFlags = nsIWebNavigation.STOP_ALL;

   gBrowser.webNavigation.stop(stopFlags);

 }

 function BrowserReloadOrDuplicate(aEvent) {

   var backgroundTabModifier = aEvent.button == 1 ||

 #ifdef XP_MACOSX

     aEvent.metaKey;

 #else

     aEvent.ctrlKey;

 #endif

   if (aEvent.shiftKey && !backgroundTabModifier) {

     BrowserReloadSkipCache();

     return;

   }

   let where = whereToOpenLink(aEvent, false, true);

   if (where == "current")

     BrowserReload();

   else

     duplicateTabIn(gBrowser.selectedTab, where);

 }

 function BrowserReload() {

   const reloadFlags = nsIWebNavigation.LOAD_FLAGS_NONE;

   BrowserReloadWithFlags(reloadFlags);

 }

 function BrowserReloadSkipCache() {

   // Bypass proxy and cache.

   const reloadFlags = nsIWebNavigation.LOAD_FLAGS_BYPASS_PROXY | nsIWebNavigation.LOAD_FLAGS_BYPASS_CACHE;

   BrowserReloadWithFlags(reloadFlags);

 }

 var BrowserHome = BrowserGoHome;

 function BrowserGoHome(aEvent) {

   if (aEvent && "button" in aEvent &&

       aEvent.button == 2) // right-click: do nothing

     return;

   var homePage = gHomeButton.getHomePage();

   var where = whereToOpenLink(aEvent, false, true);

   var urls;

   // Home page should open in a new tab when current tab is an app tab

   if (where == "current" &&

       gBrowser &&

       gBrowser.selectedTab.pinned)

     where = "tab";

   // openUILinkIn in utilityOverlay.js doesn't handle loading multiple pages

   switch (where) {

   case "current":

     loadOneOrMoreURIs(homePage);

     break;

   case "tabshifted":

   case "tab":

     urls = homePage.split("|");

     var loadInBackground = getBoolPref("browser.tabs.loadBookmarksInBackground", false);

     gBrowser.loadTabs(urls, loadInBackground);

     break;

   case "window":

     OpenBrowserWindow();

     break;

   }

 }

 function loadOneOrMoreURIs(aURIString)

 {

 #ifdef XP_MACOSX

   // we're not a browser window, pass the URI string to a new browser window

   if (window.location.href != getBrowserURL())

   {

     window.openDialog(getBrowserURL(), "_blank", "all,dialog=no", aURIString);

     return;

   }

 #endif

   // This function throws for certain malformed URIs, so use exception handling

   // so that we don't disrupt startup

   try {

     gBrowser.loadTabs(aURIString.split("|"), false, true);

   }

   catch (e) {

   }

 }

 function focusAndSelectUrlBar() {

   if (gURLBar) {

     if (window.fullScreen)

       FullScreen.mouseoverToggle(true);

     gURLBar.select();

     if (document.activeElement == gURLBar.inputField)

       return true;

   }

   return false;

 }

 function openLocation() {

   if (focusAndSelectUrlBar())

     return;

 #ifdef XP_MACOSX

   if (window.location.href != getBrowserURL()) {

     var win = getTopWin();

     if (win) {

       // If there's an open browser window, it should handle this command

       win.focus()

       win.openLocation();

     }

     else {

       // If there are no open browser windows, open a new one

       window.openDialog("chrome://browser/content/", "_blank",

                         "chrome,all,dialog=no", BROWSER_NEW_TAB_URL);

     }

   }

 #endif

 }

 function BrowserOpenTab()

 {

   openUILinkIn(BROWSER_NEW_TAB_URL, "tab");

 }

 /* Called from the openLocation dialog. This allows that dialog to instruct

    its opener to open a new window and then step completely out of the way.

    Anything less byzantine is causing horrible crashes, rather believably,

    though oddly only on Linux. */

 function delayedOpenWindow(chrome, flags, href, postData)

 {

   // The other way to use setTimeout,

   // setTimeout(openDialog, 10, chrome, "_blank", flags, url),

   // doesn't work here.  The extra "magic" extra argument setTimeout adds to

   // the callback function would confuse gBrowserInit.onLoad() by making

   // window.arguments[1] be an integer instead of null.

   setTimeout(function() { openDialog(chrome, "_blank", flags, href, null, null, postData); }, 10);

 }

 /* Required because the tab needs time to set up its content viewers and get the load of

    the URI kicked off before becoming the active content area. */

 function delayedOpenTab(aUrl, aReferrer, aCharset, aPostData, aAllowThirdPartyFixup)

 {

   gBrowser.loadOneTab(aUrl, {

                       referrerURI: aReferrer,

                       charset: aCharset,

                       postData: aPostData,

                       inBackground: false,

                       allowThirdPartyFixup: aAllowThirdPartyFixup});

 }

 var gLastOpenDirectory = {

   _lastDir: null,

   get path() {

     if (!this._lastDir || !this._lastDir.exists()) {

       try {

         this._lastDir = gPrefService.getComplexValue("browser.open.lastDir",

                                                      Ci.nsILocalFile);

         if (!this._lastDir.exists())

           this._lastDir = null;

       }

       catch(e) {}

     }

     return this._lastDir;

   },

   set path(val) {

     try {

       if (!val || !val.isDirectory())

         return;

     } catch(e) {

       return;

     }

     this._lastDir = val.clone();

     // Don't save the last open directory pref inside the Private Browsing mode

     if (!PrivateBrowsingUtils.isWindowPrivate(window))

       gPrefService.setComplexValue("browser.open.lastDir", Ci.nsILocalFile,

                                    this._lastDir);

   },

   reset: function() {

     this._lastDir = null;

   }

 };

 function BrowserOpenFileWindow()

 {

   // Get filepicker component.

   try {

     const nsIFilePicker = Ci.nsIFilePicker;

     let fp = Cc["@mozilla.org/filepicker;1"].createInstance(nsIFilePicker);

     let fpCallback = function fpCallback_done(aResult) {

       if (aResult == nsIFilePicker.returnOK) {

         try {

           if (fp.file) {

             gLastOpenDirectory.path =

               fp.file.parent.QueryInterface(Ci.nsILocalFile);

           }

         } catch (ex) {

         }

         openUILinkIn(fp.fileURL.spec, "current");

       }

     };

     fp.init(window, gNavigatorBundle.getString("openFile"),

             nsIFilePicker.modeOpen);

     fp.appendFilters(nsIFilePicker.filterAll | nsIFilePicker.filterText |

                      nsIFilePicker.filterImages | nsIFilePicker.filterXML |

                      nsIFilePicker.filterHTML);

     fp.displayDirectory = gLastOpenDirectory.path;

     fp.open(fpCallback);

   } catch (ex) {

   }

 }

 function BrowserCloseTabOrWindow() {

 #ifdef XP_MACOSX

   // If we're not a browser window, just close the window

   if (window.location.href != getBrowserURL()) {

     closeWindow(true);

     return;

   }

 #endif

   // If the current tab is the last one, this will close the window.

   gBrowser.removeCurrentTab({animate: true});

 }

 function BrowserTryToCloseWindow()

 {

   if (WindowIsClosing())

     window.close();     // WindowIsClosing does all the necessary checks

 }

 function loadURI(uri, referrer, postData, allowThirdPartyFixup) {

   if (postData === undefined)

     postData = null;

   var flags = nsIWebNavigation.LOAD_FLAGS_NONE;

   if (allowThirdPartyFixup) {

     flags |= nsIWebNavigation.LOAD_FLAGS_ALLOW_THIRD_PARTY_FIXUP;

     flags |= nsIWebNavigation.LOAD_FLAGS_FIXUP_SCHEME_TYPOS;

   }

   try {

     gBrowser.loadURIWithFlags(uri, flags, referrer, null, postData);

   } catch (e) {}

 }

 function getShortcutOrURIAndPostData(aURL, aCallback) {

   let mayInheritPrincipal = false;

   let postData = null;

   let shortcutURL = null;

   let keyword = aURL;

   let param = "";

   let offset = aURL.indexOf(" ");

   if (offset > 0) {

     keyword = aURL.substr(0, offset);

     param = aURL.substr(offset + 1);

   }

   let engine = Services.search.getEngineByAlias(keyword);

   if (engine) {

     let submission = engine.getSubmission(param);

     postData = submission.postData;

     aCallback({ postData: submission.postData, url: submission.uri.spec,

                 mayInheritPrincipal: mayInheritPrincipal });

     return;

   }

   [shortcutURL, postData] =

     PlacesUtils.getURLAndPostDataForKeyword(keyword);

   if (!shortcutURL) {

     aCallback({ postData: postData, url: aURL,

                 mayInheritPrincipal: mayInheritPrincipal });

     return;

   }

   let escapedPostData = "";

   if (postData)

     escapedPostData = unescape(postData);

   if (/%s/i.test(shortcutURL) || /%s/i.test(escapedPostData)) {

     let charset = "";

     const re = /^(.*)\&mozcharset=([a-zA-Z][_\-a-zA-Z0-9]+)\s*$/;

     let matches = shortcutURL.match(re);

     let continueOperation = function () {

       // encodeURIComponent produces UTF-8, and cannot be used for other charsets.

       // escape() works in those cases, but it doesn't uri-encode +, @, and /.

       // Therefore we need to manually replace these ASCII characters by their

       // encodeURIComponent result, to match the behavior of nsEscape() with

       // url_XPAlphas

       let encodedParam = "";

       if (charset && charset != "UTF-8")

         encodedParam = escape(convertFromUnicode(charset, param)).

                        replace(/[+@\/]+/g, encodeURIComponent);

       else // Default charset is UTF-8

         encodedParam = encodeURIComponent(param);

       shortcutURL = shortcutURL.replace(/%s/g, encodedParam).replace(/%S/g, param);

       if (/%s/i.test(escapedPostData)) // POST keyword

         postData = getPostDataStream(escapedPostData, param, encodedParam,

                                                "application/x-www-form-urlencoded");

       // This URL came from a bookmark, so it's safe to let it inherit the current

       // document's principal.

       mayInheritPrincipal = true;

       aCallback({ postData: postData, url: shortcutURL,

                   mayInheritPrincipal: mayInheritPrincipal });

     }

     if (matches) {

       [, shortcutURL, charset] = matches;

       continueOperation();

     } else {

       // Try to get the saved character-set.

       // makeURI throws if URI is invalid.

       // Will return an empty string if character-set is not found.

       try {

         PlacesUtils.getCharsetForURI(makeURI(shortcutURL))

                    .then(c => { charset = c; continueOperation(); });

       } catch (ex) {

         continueOperation();

       }

     }

   }

   else if (param) {

     // This keyword doesn't take a parameter, but one was provided. Just return

     // the original URL.

     postData = null;

     aCallback({ postData: postData, url: aURL,

                 mayInheritPrincipal: mayInheritPrincipal });

   } else {

     // This URL came from a bookmark, so it's safe to let it inherit the current

     // document's principal.

     mayInheritPrincipal = true;

     aCallback({ postData: postData, url: shortcutURL,

                 mayInheritPrincipal: mayInheritPrincipal });

   }

 }

 function getPostDataStream(aStringData, aKeyword, aEncKeyword, aType) {

   var dataStream = Cc["@mozilla.org/io/string-input-stream;1"].

                    createInstance(Ci.nsIStringInputStream);

   aStringData = aStringData.replace(/%s/g, aEncKeyword).replace(/%S/g, aKeyword);

   dataStream.data = aStringData;

   var mimeStream = Cc["@mozilla.org/network/mime-input-stream;1"].

                    createInstance(Ci.nsIMIMEInputStream);

   mimeStream.addHeader("Content-Type", aType);

   mimeStream.addContentLength = true;

   mimeStream.setData(dataStream);

   return mimeStream.QueryInterface(Ci.nsIInputStream);

 }

 function getLoadContext() {

   return window.QueryInterface(Ci.nsIInterfaceRequestor)

                .getInterface(Ci.nsIWebNavigation)

                .QueryInterface(Ci.nsILoadContext);

 }

 function readFromClipboard()

 {

   var url;

   try {

     // Create transferable that will transfer the text.

     var trans = Components.classes["@mozilla.org/widget/transferable;1"]

                           .createInstance(Components.interfaces.nsITransferable);

     trans.init(getLoadContext());

     trans.addDataFlavor("text/unicode");

     // If available, use selection clipboard, otherwise global one

     if (Services.clipboard.supportsSelectionClipboard())

       Services.clipboard.getData(trans, Services.clipboard.kSelectionClipboard);

     else

       Services.clipboard.getData(trans, Services.clipboard.kGlobalClipboard);

     var data = {};

     var dataLen = {};

     trans.getTransferData("text/unicode", data, dataLen);

     if (data) {

       data = data.value.QueryInterface(Components.interfaces.nsISupportsString);

       url = data.data.substring(0, dataLen.value / 2);

     }

   } catch (ex) {

   }

   return url;

 }

 function BrowserViewSourceOfDocument(aDocument)

 {

   var pageCookie;

   var webNav;

   // Get the document charset

   var docCharset = "charset=" + aDocument.characterSet;

   // Get the nsIWebNavigation associated with the document

   try {

       var win;

       var ifRequestor;

       // Get the DOMWindow for the requested document.  If the DOMWindow

       // cannot be found, then just use the content window...

       //

       // XXX:  This is a bit of a hack...

       win = aDocument.defaultView;

       if (win == window) {

         win = content;

       }

       ifRequestor = win.QueryInterface(Components.interfaces.nsIInterfaceRequestor);

       webNav = ifRequestor.getInterface(nsIWebNavigation);

   } catch(err) {

       // If nsIWebNavigation cannot be found, just get the one for the whole

       // window...

       webNav = gBrowser.webNavigation;

   }

   //

   // Get the 'PageDescriptor' for the current document. This allows the

   // view-source to access the cached copy of the content rather than

   // refetching it from the network...

   //

   try{

     var PageLoader = webNav.QueryInterface(Components.interfaces.nsIWebPageDescriptor);

     pageCookie = PageLoader.currentDescriptor;

   } catch(err) {

     // If no page descriptor is available, just use the view-source URL...

   }

   top.gViewSourceUtils.viewSource(webNav.currentURI.spec, pageCookie, aDocument);

 }

 // doc - document to use for source, or null for this window's document

 // initialTab - name of the initial tab to display, or null for the first tab

 // imageElement - image to load in the Media Tab of the Page Info window; can be null/omitted

 function BrowserPageInfo(doc, initialTab, imageElement) {

   var args = {doc: doc, initialTab: initialTab, imageElement: imageElement};

   var windows = Services.wm.getEnumerator("Browser:page-info");

   var documentURL = doc ? doc.location : window.content.document.location;

   // Check for windows matching the url

   while (windows.hasMoreElements()) {

     var currentWindow = windows.getNext();

     if (currentWindow.closed) {

       continue;

     }

     if (currentWindow.document.documentElement.getAttribute("relatedUrl") == documentURL) {

       currentWindow.focus();

       currentWindow.resetPageInfo(args);

       return currentWindow;

     }

   }

   // We didn't find a matching window, so open a new one.

   return openDialog("chrome://browser/content/pageinfo/pageInfo.xul", "",

                     "chrome,toolbar,dialog=no,resizable", args);

 }

 function URLBarSetURI(aURI) {

   var value = gBrowser.userTypedValue;

   var valid = false;

   if (value == null) {

     let uri = aURI || gBrowser.currentURI;

     // Strip off "wyciwyg://" and passwords for the location bar

     try {

       uri = Services.uriFixup.createExposableURI(uri);

     } catch (e) {}

     // Replace initial page URIs with an empty string

     // only if there's no opener (bug 370555).

     // Bug 863515 - Make content.opener checks work in electrolysis.

     if (gInitialPages.indexOf(uri.spec) != -1)

       value = !gMultiProcessBrowser && content.opener ? uri.spec : "";

     else

       value = losslessDecodeURI(uri);

     valid = !isBlankPageURL(uri.spec);

   }

   gURLBar.value = value;

   gURLBar.valueIsTyped = !valid;

   SetPageProxyState(valid ? "valid" : "invalid");

 }

 function losslessDecodeURI(aURI) {

   var value = aURI.spec;

   // Try to decode as UTF-8 if there's no encoding sequence that we would break.

   if (!/%25(?:3B|2F|3F|3A|40|26|3D|2B|24|2C|23)/i.test(value))

     try {

       value = decodeURI(value)

                 // 1. decodeURI decodes %25 to %, which creates unintended

                 //    encoding sequences. Re-encode it, unless it's part of

                 //    a sequence that survived decodeURI, i.e. one for:

                 //    ';', '/', '?', ':', '@', '&', '=', '+', '$', ',', '#'

                 //    (RFC 3987 section 3.2)

                 // 2. Re-encode whitespace so that it doesn't get eaten away

                 //    by the location bar (bug 410726).

                 .replace(/%(?!3B|2F|3F|3A|40|26|3D|2B|24|2C|23)|[\r\n\t]/ig,

                          encodeURIComponent);

     } catch (e) {}

   // Encode invisible characters (C0/C1 control characters, U+007F [DEL],

   // U+00A0 [no-break space], line and paragraph separator,

   // object replacement character) (bug 452979, bug 909264)

   value = value.replace(/[\u0000-\u001f\u007f-\u00a0\u2028\u2029\ufffc]/g,

                         encodeURIComponent);

   // Encode default ignorable characters (bug 546013)

   // except ZWNJ (U+200C) and ZWJ (U+200D) (bug 582186).

   // This includes all bidirectional formatting characters.

   // (RFC 3987 sections 3.2 and 4.1 paragraph 6)

   value = value.replace(/[\u00ad\u034f\u061c\u115f-\u1160\u17b4-\u17b5\u180b-\u180d\u200b\u200e-\u200f\u202a-\u202e\u2060-\u206f\u3164\ufe00-\ufe0f\ufeff\uffa0\ufff0-\ufff8]|\ud834[\udd73-\udd7a]|[\udb40-\udb43][\udc00-\udfff]/g,

                         encodeURIComponent);

   return value;

 }

 function UpdateUrlbarSearchSplitterState()

 {

   var splitter = document.getElementById("urlbar-search-splitter");

   var urlbar = document.getElementById("urlbar-container");

   var searchbar = document.getElementById("search-container");

   if (document.documentElement.getAttribute("customizing") == "true") {

     if (splitter) {

       splitter.remove();

     }

     return;

   }

   // If the splitter is already in the right place, we don't need to do anything:

   if (splitter &&

       ((splitter.nextSibling == searchbar && splitter.previousSibling == urlbar) ||

        (splitter.nextSibling == urlbar && splitter.previousSibling == searchbar))) {

     return;

   }

   var ibefore = null;

   if (urlbar && searchbar) {

     if (urlbar.nextSibling == searchbar)

       ibefore = searchbar;

     else if (searchbar.nextSibling == urlbar)

       ibefore = urlbar;

   }

   if (ibefore) {

     if (!splitter) {

       splitter = document.createElement("splitter");

       splitter.id = "urlbar-search-splitter";

       splitter.setAttribute("resizebefore", "flex");

       splitter.setAttribute("resizeafter", "flex");

       splitter.setAttribute("skipintoolbarset", "true");

       splitter.setAttribute("overflows", "false");

       splitter.className = "chromeclass-toolbar-additional";

     }

     urlbar.parentNode.insertBefore(splitter, ibefore);

   } else if (splitter)

     splitter.parentNode.removeChild(splitter);

 }

 function UpdatePageProxyState()

 {

   if (gURLBar && gURLBar.value != gLastValidURLStr)

     SetPageProxyState("invalid");

 }

 function SetPageProxyState(aState)

 {

   BookmarkingUI.onPageProxyStateChanged(aState);

   if (!gURLBar)

     return;

   if (!gProxyFavIcon)

     gProxyFavIcon = document.getElementById("page-proxy-favicon");

   gURLBar.setAttribute("pageproxystate", aState);

   gProxyFavIcon.setAttribute("pageproxystate", aState);

   // the page proxy state is set to valid via OnLocationChange, which

   // gets called when we switch tabs.

   if (aState == "valid") {

     gLastValidURLStr = gURLBar.value;

     gURLBar.addEventListener("input", UpdatePageProxyState, false);

   } else if (aState == "invalid") {

     gURLBar.removeEventListener("input", UpdatePageProxyState, false);

   }

 }

 function PageProxyClickHandler(aEvent)

 {

   if (aEvent.button == 1 && gPrefService.getBoolPref("middlemouse.paste"))

     middleMousePaste(aEvent);

 }

 /**

  * Handle command events bubbling up from error page content

  * or from about:newtab

  */

 let BrowserOnClick = {

   handleEvent: function BrowserOnClick_handleEvent(aEvent) {

     if (!aEvent.isTrusted || // Don't trust synthetic events

         aEvent.button == 2) {

       return;

     }

     let originalTarget = aEvent.originalTarget;

     let ownerDoc = originalTarget.ownerDocument;

     // If the event came from an ssl error page, it is probably either the "Add

     // Exception…" or "Get me out of here!" button

     if (ownerDoc.documentURI.startsWith("about:certerror")) {

       this.onAboutCertError(originalTarget, ownerDoc);

     }

     else if (ownerDoc.documentURI.startsWith("about:blocked")) {

       this.onAboutBlocked(originalTarget, ownerDoc);

     }

     else if (ownerDoc.documentURI.startsWith("about:neterror")) {

       this.onAboutNetError(originalTarget, ownerDoc);

     }

     else if (gMultiProcessBrowser &&

              ownerDoc.documentURI.toLowerCase() == "about:newtab") {

       this.onE10sAboutNewTab(aEvent, ownerDoc);

     }

     else if (ownerDoc.documentURI.startsWith("about:tabcrashed")) {

       this.onAboutTabCrashed(aEvent, ownerDoc);

     }

   },

   onAboutCertError: function BrowserOnClick_onAboutCertError(aTargetElm, aOwnerDoc) {

     let elmId = aTargetElm.getAttribute("id");

     let secHistogram = Services.telemetry.getHistogramById("SECURITY_UI");

     let isTopFrame = (aOwnerDoc.defaultView.parent === aOwnerDoc.defaultView);

     switch (elmId) {

       case "exceptionDialogButton":

         if (isTopFrame) {

           secHistogram.add(Ci.nsISecurityUITelemetry.WARNING_BAD_CERT_TOP_CLICK_ADD_EXCEPTION);

         }

         let params = { exceptionAdded : false };

         try {

           switch (Services.prefs.getIntPref("browser.ssl_override_behavior")) {

             case 2 : // Pre-fetch & pre-populate

               params.prefetchCert = true;

             case 1 : // Pre-populate

               params.location = aOwnerDoc.location.href;

           }

         } catch (e) {

           Components.utils.reportError("Couldn't get ssl_override pref: " + e);

         }

         window.openDialog('chrome://pippki/content/exceptionDialog.xul',

                           '','chrome,centerscreen,modal', params);

         // If the user added the exception cert, attempt to reload the page

         if (params.exceptionAdded) {

           aOwnerDoc.location.reload();

         }

         break;

       case "getMeOutOfHereButton":

         if (isTopFrame) {

           secHistogram.add(Ci.nsISecurityUITelemetry.WARNING_BAD_CERT_TOP_GET_ME_OUT_OF_HERE);

         }

         getMeOutOfHere();

         break;

       case "technicalContent":

         if (isTopFrame) {

           secHistogram.add(Ci.nsISecurityUITelemetry.WARNING_BAD_CERT_TOP_TECHNICAL_DETAILS);

         }

         break;

       case "expertContent":

         if (isTopFrame) {

           secHistogram.add(Ci.nsISecurityUITelemetry.WARNING_BAD_CERT_TOP_UNDERSTAND_RISKS);

         }

         break;

     }

   },

   onAboutBlocked: function BrowserOnClick_onAboutBlocked(aTargetElm, aOwnerDoc) {

     let elmId = aTargetElm.getAttribute("id");

     let secHistogram = Services.telemetry.getHistogramById("SECURITY_UI");

     // The event came from a button on a malware/phishing block page

     // First check whether it's malware or phishing, so that we can

     // use the right strings/links

     let isMalware = /e=malwareBlocked/.test(aOwnerDoc.documentURI);

     let bucketName = isMalware ? "WARNING_MALWARE_PAGE_":"WARNING_PHISHING_PAGE_";

     let nsISecTel = Ci.nsISecurityUITelemetry;

     let isIframe = (aOwnerDoc.defaultView.parent === aOwnerDoc.defaultView);

     bucketName += isIframe ? "TOP_" : "FRAME_";

     switch (elmId) {

       case "getMeOutButton":

         secHistogram.add(nsISecTel[bucketName + "GET_ME_OUT_OF_HERE"]);

         getMeOutOfHere();

         break;

       case "reportButton":

         // This is the "Why is this site blocked" button.  For malware,

         // we can fetch a site-specific report, for phishing, we redirect

         // to the generic page describing phishing protection.

         // We log even if malware/phishing info URL couldn't be found:

         // the measurement is for how many users clicked the WHY BLOCKED button

         secHistogram.add(nsISecTel[bucketName + "WHY_BLOCKED"]);

         if (isMalware) {

           // Get the stop badware "why is this blocked" report url,

           // append the current url, and go there.

           try {

             let reportURL = formatURL("browser.safebrowsing.malware.reportURL", true);

             reportURL += aOwnerDoc.location.href;

             content.location = reportURL;

           } catch (e) {

             Components.utils.reportError("Couldn't get malware report URL: " + e);

           }

         }

         else { // It's a phishing site, not malware

           openHelpLink("phishing-malware", false, "current");

         }

         break;

       case "ignoreWarningButton":

         secHistogram.add(nsISecTel[bucketName + "IGNORE_WARNING"]);

         this.ignoreWarningButton(isMalware);

         break;

     }

   },

   /**

    * This functions prevents navigation from happening directly through the <a>

    * link in about:newtab (which is loaded in the parent and therefore would load

    * the next page also in the parent) and instructs the browser to open the url

    * in the current tab which will make it update the remoteness of the tab.

    */

   onE10sAboutNewTab: function(aEvent, aOwnerDoc) {

     let isTopFrame = (aOwnerDoc.defaultView.parent === aOwnerDoc.defaultView);

     if (!isTopFrame || aEvent.button != 0) {

       return;

     }

     let anchorTarget = aEvent.originalTarget.parentNode;

     if (anchorTarget instanceof HTMLAnchorElement &&

         anchorTarget.classList.contains("newtab-link")) {

       aEvent.preventDefault();

       openUILinkIn(anchorTarget.href, "current");

     }

   },

   /**

    * The about:tabcrashed can't do window.reload() because that

    * would reload the page but not use a remote browser.

    */

   onAboutTabCrashed: function(aEvent, aOwnerDoc) {

     let isTopFrame = (aOwnerDoc.defaultView.parent === aOwnerDoc.defaultView);

     if (!isTopFrame) {

       return;

     }

     let button = aEvent.originalTarget;

     if (button.id == "tryAgain") {

 #ifdef MOZ_CRASHREPORTER

       if (aOwnerDoc.getElementById("checkSendReport").checked) {

         let browser = gBrowser.getBrowserForDocument(aOwnerDoc);

         TabCrashReporter.submitCrashReport(browser);

       }

 #endif

       openUILinkIn(button.getAttribute("url"), "current");

     }

   },

   ignoreWarningButton: function BrowserOnClick_ignoreWarningButton(aIsMalware) {

     // Allow users to override and continue through to the site,

     // but add a notify bar as a reminder, so that they don't lose

     // track after, e.g., tab switching.

     gBrowser.loadURIWithFlags(content.location.href,

                               nsIWebNavigation.LOAD_FLAGS_BYPASS_CLASSIFIER,

                               null, null, null);

     Services.perms.add(makeURI(content.location.href), "safe-browsing",

                        Ci.nsIPermissionManager.ALLOW_ACTION,

                        Ci.nsIPermissionManager.EXPIRE_SESSION);

     let buttons = [{

       label: gNavigatorBundle.getString("safebrowsing.getMeOutOfHereButton.label"),

       accessKey: gNavigatorBundle.getString("safebrowsing.getMeOutOfHereButton.accessKey"),

       callback: function() { getMeOutOfHere(); }

     }];

     let title;

     if (aIsMalware) {

       title = gNavigatorBundle.getString("safebrowsing.reportedAttackSite");

       buttons[1] = {

         label: gNavigatorBundle.getString("safebrowsing.notAnAttackButton.label"),

         accessKey: gNavigatorBundle.getString("safebrowsing.notAnAttackButton.accessKey"),

         callback: function() {

           openUILinkIn(gSafeBrowsing.getReportURL('MalwareError'), 'tab');

         }

       };

     } else {

       title = gNavigatorBundle.getString("safebrowsing.reportedWebForgery");

       buttons[1] = {

         label: gNavigatorBundle.getString("safebrowsing.notAForgeryButton.label"),

         accessKey: gNavigatorBundle.getString("safebrowsing.notAForgeryButton.accessKey"),

         callback: function() {

           openUILinkIn(gSafeBrowsing.getReportURL('Error'), 'tab');

         }

       };

     }

     let notificationBox = gBrowser.getNotificationBox();

     let value = "blocked-badware-page";

     let previousNotification = notificationBox.getNotificationWithValue(value);

     if (previousNotification) {

       notificationBox.removeNotification(previousNotification);

     }

     let notification = notificationBox.appendNotification(

       title,

       value,

       "chrome://global/skin/icons/blacklist_favicon.png",

       notificationBox.PRIORITY_CRITICAL_HIGH,

       buttons

     );

     // Persist the notification until the user removes so it

     // doesn't get removed on redirects.

     notification.persistence = -1;

   },

   onAboutNetError: function BrowserOnClick_onAboutNetError(aTargetElm, aOwnerDoc) {

     let elmId = aTargetElm.getAttribute("id");

     if (elmId != "errorTryAgain" || !/e=netOffline/.test(aOwnerDoc.documentURI))

       return;

     Services.io.offline = false;

   },

 };

 /**

  * Re-direct the browser to a known-safe page.  This function is

  * used when, for example, the user browses to a known malware page

  * and is presented with about:blocked.  The "Get me out of here!"

  * button should take the user to the default start page so that even

  * when their own homepage is infected, we can get them somewhere safe.

  */

 function getMeOutOfHere() {

   // Get the start page from the *default* pref branch, not the user's

   var prefs = Services.prefs.getDefaultBranch(null);

   var url = BROWSER_NEW_TAB_URL;

   try {

     url = prefs.getComplexValue("browser.startup.homepage",

                                 Ci.nsIPrefLocalizedString).data;

     // If url is a pipe-delimited set of pages, just take the first one.

     if (url.contains("|"))

       url = url.split("|")[0];

   } catch(e) {

     Components.utils.reportError("Couldn't get homepage pref: " + e);

   }

   content.location = url;

 }

 function BrowserFullScreen()

 {

   window.fullScreen = !window.fullScreen;

 }

 function _checkDefaultAndSwitchToMetro() {

 #ifdef HAVE_SHELL_SERVICE

 #ifdef XP_WIN

 #ifdef MOZ_METRO

   let shell = Components.classes["@mozilla.org/browser/shell-service;1"].

     getService(Components.interfaces.nsIShellService);

   let isDefault = shell.isDefaultBrowser(false, false);

   if (isDefault) {

     let appStartup = Components.classes["@mozilla.org/toolkit/app-startup;1"].

     getService(Components.interfaces.nsIAppStartup);

     Services.prefs.setBoolPref('browser.sessionstore.resume_session_once', true);

     let cancelQuit = Cc["@mozilla.org/supports-PRBool;1"]

                      .createInstance(Ci.nsISupportsPRBool);

     Services.obs.notifyObservers(cancelQuit, "quit-application-requested", "restart");

     if (!cancelQuit.data) {

       appStartup.quit(Components.interfaces.nsIAppStartup.eAttemptQuit |

                       Components.interfaces.nsIAppStartup.eRestartTouchEnvironment);

     }

     return true;

   }

   return false;

 #endif

 #endif

 #endif

 }

 function SwitchToMetro() {

 #ifdef HAVE_SHELL_SERVICE

 #ifdef XP_WIN

 #ifdef MOZ_METRO

   if (this._checkDefaultAndSwitchToMetro()) {

     return;

   }

   let shell = Components.classes["@mozilla.org/browser/shell-service;1"].

     getService(Components.interfaces.nsIShellService);

   shell.setDefaultBrowser(false, false);

   let intervalID = window.setInterval(this._checkDefaultAndSwitchToMetro, 1000);

   window.setTimeout(function() { window.clearInterval(intervalID); }, 10000);

 #endif

 #endif

 #endif

 }

 function onFullScreen(event) {

   FullScreen.toggle(event);

 }

 function onMozEnteredDomFullscreen(event) {

   FullScreen.enterDomFullscreen(event);

 }

 function getWebNavigation()

 {

   return gBrowser.webNavigation;

 }

 function BrowserReloadWithFlags(reloadFlags) {

   let url = gBrowser.currentURI.spec;

   if (gBrowser.updateBrowserRemoteness(gBrowser.selectedBrowser, url)) {

     // If the remoteness has changed, the new browser doesn't have any

     // information of what was loaded before, so we need to load the previous

     // URL again.

     gBrowser.loadURIWithFlags(url, reloadFlags);

     return;

   }

   /* 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.

    */

   var webNav = gBrowser.webNavigation;

   try {

     var sh = webNav.sessionHistory;

     if (sh)

       webNav = sh.QueryInterface(nsIWebNavigation);

   } catch (e) {

   }

   try {

     webNav.reload(reloadFlags);

   } catch (e) {

   }

 }

 var PrintPreviewListener = {

   _printPreviewTab: null,

   _tabBeforePrintPreview: null,

   getPrintPreviewBrowser: function () {

     if (!this._printPreviewTab) {

       this._tabBeforePrintPreview = gBrowser.selectedTab;

       this._printPreviewTab = gBrowser.loadOneTab("about:blank",

                                                   { inBackground: false });

       gBrowser.selectedTab = this._printPreviewTab;

     }

     return gBrowser.getBrowserForTab(this._printPreviewTab);

   },

   getSourceBrowser: function () {

     return this._tabBeforePrintPreview ?

       this._tabBeforePrintPreview.linkedBrowser : gBrowser.selectedBrowser;

   },

   getNavToolbox: function () {

     return gNavToolbox;

   },

   onEnter: function () {

     gInPrintPreviewMode = true;

     this._toggleAffectedChrome();

   },

   onExit: function () {

     gBrowser.selectedTab = this._tabBeforePrintPreview;

     this._tabBeforePrintPreview = null;

     gInPrintPreviewMode = false;

     this._toggleAffectedChrome();

     gBrowser.removeTab(this._printPreviewTab);

     this._printPreviewTab = null;

   },

   _toggleAffectedChrome: function () {

     gNavToolbox.collapsed = gInPrintPreviewMode;

     if (gInPrintPreviewMode)