The Tor Browser: comparison toolkit/devtools/server/actors/webbrowser.js

comparison: toolkit/devtools/server/actors/webbrowser.js

toolkit/devtools/server/actors/webbrowser.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:ecc022c5e58f
+/* -*- Mode: javascript; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+"use strict";
+let {Ci,Cu} = require("chrome");
+let {createExtraActors, appendExtraActors} = require("devtools/server/actors/common");
+let DevToolsUtils = require("devtools/toolkit/DevToolsUtils");
+let {Promise: promise} = Cu.import("resource://gre/modules/Promise.jsm", {});
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "AddonManager", "resource://gre/modules/AddonManager.jsm");
+// Assumptions on events module:
+// events needs to be dispatched synchronously,
+// by calling the listeners in the order or registration.
+XPCOMUtils.defineLazyGetter(this, "events", () => {
+return devtools.require("sdk/event/core");
+});
+// Also depends on following symbols, shared by common scope with main.js:
+// DebuggerServer, CommonCreateExtraActors, CommonAppendExtraActors, ActorPool,
+// ThreadActor
+/**
+* Browser-specific actors.
+*/
+/**
+* Yield all windows of type |aWindowType|, from the oldest window to the
+* youngest, using nsIWindowMediator::getEnumerator. We're usually
+* interested in "navigator:browser" windows.
+*/
+function allAppShellDOMWindows(aWindowType)
+{
+let e = Services.wm.getEnumerator(aWindowType);
+while (e.hasMoreElements()) {
+yield e.getNext();
+}
+}
+/**
+* Retrieve the window type of the top-level window |aWindow|.
+*/
+function appShellDOMWindowType(aWindow) {
+/* This is what nsIWindowMediator's enumerator checks. */
+return aWindow.document.documentElement.getAttribute('windowtype');
+}
+/**
+* Send Debugger:Shutdown events to all "navigator:browser" windows.
+*/
+function sendShutdownEvent() {
+for (let win of allAppShellDOMWindows(DebuggerServer.chromeWindowType)) {
+let evt = win.document.createEvent("Event");
+evt.initEvent("Debugger:Shutdown", true, false);
+win.document.documentElement.dispatchEvent(evt);
+}
+}
+/**
+* Construct a root actor appropriate for use in a server running in a
+* browser. The returned root actor:
+* - respects the factories registered with DebuggerServer.addGlobalActor,
+* - uses a BrowserTabList to supply tab actors,
+* - sends all navigator:browser window documents a Debugger:Shutdown event
+*   when it exits.
+*
+* * @param aConnection DebuggerServerConnection
+*        The conection to the client.
+*/
+function createRootActor(aConnection)
+{
+return new RootActor(aConnection,
+{
+tabList: new BrowserTabList(aConnection),
+addonList: new BrowserAddonList(aConnection),
+globalActorFactories: DebuggerServer.globalActorFactories,
+onShutdown: sendShutdownEvent
+});
+}
+/**
+* A live list of BrowserTabActors representing the current browser tabs,
+* to be provided to the root actor to answer 'listTabs' requests.
+*
+* This object also takes care of listening for TabClose events and
+* onCloseWindow notifications, and exiting the BrowserTabActors concerned.
+*
+* (See the documentation for RootActor for the definition of the "live
+* list" interface.)
+*
+* @param aConnection DebuggerServerConnection
+*     The connection in which this list's tab actors may participate.
+*
+* Some notes:
+*
+* This constructor is specific to the desktop browser environment; it
+* maintains the tab list by tracking XUL windows and their XUL documents'
+* "tabbrowser", "tab", and "browser" elements. What's entailed in maintaining
+* an accurate list of open tabs in this context?
+*
+* - Opening and closing XUL windows:
+*
+* An nsIWindowMediatorListener is notified when new XUL windows (i.e., desktop
+* windows) are opened and closed. It is not notified of individual content
+* browser tabs coming and going within such a XUL window. That seems
+* reasonable enough; it's concerned with XUL windows, not tab elements in the
+* window's XUL document.
+*
+* However, even if we attach TabOpen and TabClose event listeners to each XUL
+* window as soon as it is created:
+*
+* - we do not receive a TabOpen event for the initial empty tab of a new XUL
+*   window; and
+*
+* - we do not receive TabClose events for the tabs of a XUL window that has
+*   been closed.
+*
+* This means that TabOpen and TabClose events alone are not sufficient to
+* maintain an accurate list of live tabs and mark tab actors as closed
+* promptly. Our nsIWindowMediatorListener onCloseWindow handler must find and
+* exit all actors for tabs that were in the closing window.
+*
+* Since this is a bit hairy, we don't make each individual attached tab actor
+* responsible for noticing when it has been closed; we watch for that, and
+* promise to call each actor's 'exit' method when it's closed, regardless of
+* how we learn the news.
+*
+* - nsIWindowMediator locks
+*
+* nsIWindowMediator holds a lock protecting its list of top-level windows
+* while it calls nsIWindowMediatorListener methods. nsIWindowMediator's
+* GetEnumerator method also tries to acquire that lock. Thus, enumerating
+* windows from within a listener method deadlocks (bug 873589). Rah. One
+* can sometimes work around this by leaving the enumeration for a later
+* tick.
+*
+* - Dragging tabs between windows:
+*
+* When a tab is dragged from one desktop window to another, we receive a
+* TabOpen event for the new tab, and a TabClose event for the old tab; tab XUL
+* elements do not really move from one document to the other (although their
+* linked browser's content window objects do).
+*
+* However, while we could thus assume that each tab stays with the XUL window
+* it belonged to when it was created, I'm not sure this is behavior one should
+* rely upon. When a XUL window is closed, we take the less efficient, more
+* conservative approach of simply searching the entire table for actors that
+* belong to the closing XUL window, rather than trying to somehow track which
+* XUL window each tab belongs to.
+*/
+function BrowserTabList(aConnection)
+{
+this._connection = aConnection;
+/*
+* The XUL document of a tabbed browser window has "tab" elements, whose
+* 'linkedBrowser' JavaScript properties are "browser" elements; those
+* browsers' 'contentWindow' properties are wrappers on the tabs' content
+* window objects.
+*
+* This map's keys are "browser" XUL elements; it maps each browser element
+* to the tab actor we've created for its content window, if we've created
+* one. This map serves several roles:
+*
+* - During iteration, we use it to find actors we've created previously.
+*
+* - On a TabClose event, we use it to find the tab's actor and exit it.
+*
+* - When the onCloseWindow handler is called, we iterate over it to find all
+*   tabs belonging to the closing XUL window, and exit them.
+*
+* - When it's empty, and the onListChanged hook is null, we know we can
+*   stop listening for events and notifications.
+*
+* We listen for TabClose events and onCloseWindow notifications in order to
+* send onListChanged notifications, but also to tell actors when their
+* referent has gone away and remove entries for dead browsers from this map.
+* If that code is working properly, neither this map nor the actors in it
+* should ever hold dead tabs alive.
+*/
+this._actorByBrowser = new Map();
+/* The current onListChanged handler, or null. */
+this._onListChanged = null;
+/*
+* True if we've been iterated over since we last called our onListChanged
+* hook.
+*/
+this._mustNotify = false;
+/* True if we're testing, and should throw if consistency checks fail. */
+this._testing = false;
+}
+BrowserTabList.prototype.constructor = BrowserTabList;
+/**
+* Get the selected browser for the given navigator:browser window.
+* @private
+* @param aWindow nsIChromeWindow
+*        The navigator:browser window for which you want the selected browser.
+* @return nsIDOMElement|null
+*         The currently selected xul:browser element, if any. Note that the
+*         browser window might not be loaded yet - the function will return
+*         |null| in such cases.
+*/
+BrowserTabList.prototype._getSelectedBrowser = function(aWindow) {
+return aWindow.gBrowser ? aWindow.gBrowser.selectedBrowser : null;
+};
+BrowserTabList.prototype._getChildren = function(aWindow) {
+return aWindow.gBrowser.browsers;
+};
+BrowserTabList.prototype.getList = function() {
+let topXULWindow = Services.wm.getMostRecentWindow(DebuggerServer.chromeWindowType);
+// As a sanity check, make sure all the actors presently in our map get
+// picked up when we iterate over all windows' tabs.
+let initialMapSize = this._actorByBrowser.size;
+let foundCount = 0;
+// To avoid mysterious behavior if tabs are closed or opened mid-iteration,
+// we update the map first, and then make a second pass over it to yield
+// the actors. Thus, the sequence yielded is always a snapshot of the
+// actors that were live when we began the iteration.
+let actorPromises = [];
+// Iterate over all navigator:browser XUL windows.
+for (let win of allAppShellDOMWindows(DebuggerServer.chromeWindowType)) {
+let selectedBrowser = this._getSelectedBrowser(win);
+if (!selectedBrowser) {
+continue;
+}
+// For each tab in this XUL window, ensure that we have an actor for
+// it, reusing existing actors where possible. We actually iterate
+// over 'browser' XUL elements, and BrowserTabActor uses
+// browser.contentWindow as the debuggee global.
+for (let browser of this._getChildren(win)) {
+// Do we have an existing actor for this browser? If not, create one.
+let actor = this._actorByBrowser.get(browser);
+if (actor) {
+actorPromises.push(promise.resolve(actor));
+foundCount++;
+} else if (browser.isRemoteBrowser) {
+actor = new RemoteBrowserTabActor(this._connection, browser);
+this._actorByBrowser.set(browser, actor);
+let promise = actor.connect().then((form) => {
+actor._form = form;
+return actor;
+});
+actorPromises.push(promise);
+} else {
+actor = new BrowserTabActor(this._connection, browser, win.gBrowser);
+this._actorByBrowser.set(browser, actor);
+actorPromises.push(promise.resolve(actor));
+}
+// Set the 'selected' properties on all actors correctly.
+actor.selected = (win === topXULWindow && browser === selectedBrowser);
+}
+}
+if (this._testing && initialMapSize !== foundCount)
+throw Error("_actorByBrowser map contained actors for dead tabs");
+this._mustNotify = true;
+this._checkListening();
+return promise.all(actorPromises);
+};
+Object.defineProperty(BrowserTabList.prototype, 'onListChanged', {
+enumerable: true, configurable:true,
+get: function() { return this._onListChanged; },
+set: function(v) {
+if (v !== null && typeof v !== 'function') {
+throw Error("onListChanged property may only be set to 'null' or a function");
+}
+this._onListChanged = v;
+this._checkListening();
+}
+});
+/**
+* The set of tabs has changed somehow. Call our onListChanged handler, if
+* one is set, and if we haven't already called it since the last iteration.
+*/
+BrowserTabList.prototype._notifyListChanged = function() {
+if (!this._onListChanged)
+return;
+if (this._mustNotify) {
+this._onListChanged();
+this._mustNotify = false;
+}
+};
+/**
+* Exit |aActor|, belonging to |aBrowser|, and notify the onListChanged
+* handle if needed.
+*/
+BrowserTabList.prototype._handleActorClose = function(aActor, aBrowser) {
+if (this._testing) {
+if (this._actorByBrowser.get(aBrowser) !== aActor) {
+throw Error("BrowserTabActor not stored in map under given browser");
+}
+if (aActor.browser !== aBrowser) {
+throw Error("actor's browser and map key don't match");
+}
+}
+this._actorByBrowser.delete(aBrowser);
+aActor.exit();
+this._notifyListChanged();
+this._checkListening();
+};
+/**
+* Make sure we are listening or not listening for activity elsewhere in
+* the browser, as appropriate. Other than setting up newly created XUL
+* windows, all listener / observer connection and disconnection should
+* happen here.
+*/
+BrowserTabList.prototype._checkListening = function() {
+/*
+* If we have an onListChanged handler that we haven't sent an announcement
+* to since the last iteration, we need to watch for tab creation.
+*
+* Oddly, we don't need to watch for 'close' events here. If our actor list
+* is empty, then either it was empty the last time we iterated, and no
+* close events are possible, or it was not empty the last time we
+* iterated, but all the actors have since been closed, and we must have
+* sent a notification already when they closed.
+*/
+this._listenForEventsIf(this._onListChanged && this._mustNotify,
+"_listeningForTabOpen", ["TabOpen", "TabSelect"]);
+/* If we have live actors, we need to be ready to mark them dead. */
+this._listenForEventsIf(this._actorByBrowser.size > 0,
+"_listeningForTabClose", ["TabClose"]);
+/*
+* We must listen to the window mediator in either case, since that's the
+* only way to find out about tabs that come and go when top-level windows
+* are opened and closed.
+*/
+this._listenToMediatorIf((this._onListChanged && this._mustNotify) ||
+(this._actorByBrowser.size > 0));
+};
+/*
+* Add or remove event listeners for all XUL windows.
+*
+* @param aShouldListen boolean
+*    True if we should add event handlers; false if we should remove them.
+* @param aGuard string
+*    The name of a guard property of 'this', indicating whether we're
+*    already listening for those events.
+* @param aEventNames array of strings
+*    An array of event names.
+*/
+BrowserTabList.prototype._listenForEventsIf = function(aShouldListen, aGuard, aEventNames) {
+if (!aShouldListen !== !this[aGuard]) {
+let op = aShouldListen ? "addEventListener" : "removeEventListener";
+for (let win of allAppShellDOMWindows(DebuggerServer.chromeWindowType)) {
+for (let name of aEventNames) {
+win[op](name, this, false);
+}
+}
+this[aGuard] = aShouldListen;
+}
+};
+/**
+* Implement nsIDOMEventListener.
+*/
+BrowserTabList.prototype.handleEvent = DevToolsUtils.makeInfallible(function(aEvent) {
+switch (aEvent.type) {
+case "TabOpen":
+case "TabSelect":
+/* Don't create a new actor; iterate will take care of that. Just notify. */
+this._notifyListChanged();
+this._checkListening();
+break;
+case "TabClose":
+let browser = aEvent.target.linkedBrowser;
+let actor = this._actorByBrowser.get(browser);
+if (actor) {
+this._handleActorClose(actor, browser);
+}
+break;
+}
+}, "BrowserTabList.prototype.handleEvent");
+/*
+* If |aShouldListen| is true, ensure we've registered a listener with the
+* window mediator. Otherwise, ensure we haven't registered a listener.
+*/
+BrowserTabList.prototype._listenToMediatorIf = function(aShouldListen) {
+if (!aShouldListen !== !this._listeningToMediator) {
+let op = aShouldListen ? "addListener" : "removeListener";
+Services.wm[op](this);
+this._listeningToMediator = aShouldListen;
+}
+};
+/**
+* nsIWindowMediatorListener implementation.
+*
+* See _onTabClosed for explanation of why we needn't actually tweak any
+* actors or tables here.
+*
+* An nsIWindowMediatorListener's methods get passed all sorts of windows; we
+* only care about the tab containers. Those have 'getBrowser' methods.
+*/
+BrowserTabList.prototype.onWindowTitleChange = () => { };
+BrowserTabList.prototype.onOpenWindow = DevToolsUtils.makeInfallible(function(aWindow) {
+let handleLoad = DevToolsUtils.makeInfallible(() => {
+/* We don't want any further load events from this window. */
+aWindow.removeEventListener("load", handleLoad, false);
+if (appShellDOMWindowType(aWindow) !== DebuggerServer.chromeWindowType)
+return;
+// Listen for future tab activity.
+if (this._listeningForTabOpen) {
+aWindow.addEventListener("TabOpen", this, false);
+aWindow.addEventListener("TabSelect", this, false);
+}
+if (this._listeningForTabClose) {
+aWindow.addEventListener("TabClose", this, false);
+}
+// As explained above, we will not receive a TabOpen event for this
+// document's initial tab, so we must notify our client of the new tab
+// this will have.
+this._notifyListChanged();
+});
+/*
+* You can hardly do anything at all with a XUL window at this point; it
+* doesn't even have its document yet. Wait until its document has
+* loaded, and then see what we've got. This also avoids
+* nsIWindowMediator enumeration from within listeners (bug 873589).
+*/
+aWindow = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindow);
+aWindow.addEventListener("load", handleLoad, false);
+}, "BrowserTabList.prototype.onOpenWindow");
+BrowserTabList.prototype.onCloseWindow = DevToolsUtils.makeInfallible(function(aWindow) {
+aWindow = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindow);
+if (appShellDOMWindowType(aWindow) !== DebuggerServer.chromeWindowType)
+return;
+/*
+* nsIWindowMediator deadlocks if you call its GetEnumerator method from
+* a nsIWindowMediatorListener's onCloseWindow hook (bug 873589), so
+* handle the close in a different tick.
+*/
+Services.tm.currentThread.dispatch(DevToolsUtils.makeInfallible(() => {
+/*
+* Scan the entire map for actors representing tabs that were in this
+* top-level window, and exit them.
+*/
+for (let [browser, actor] of this._actorByBrowser) {
+/* The browser document of a closed window has no default view. */
+if (!browser.ownerDocument.defaultView) {
+this._handleActorClose(actor, browser);
+}
+}
+}, "BrowserTabList.prototype.onCloseWindow's delayed body"), 0);
+}, "BrowserTabList.prototype.onCloseWindow");
+/**
+* Creates a tab actor for handling requests to a browser tab, like
+* attaching and detaching. TabActor respects the actor factories
+* registered with DebuggerServer.addTabActor.
+*
+* This class is subclassed by BrowserTabActor and
+* ContentActor. Subclasses are expected to implement a getter
+* the docShell properties.
+*
+* @param aConnection DebuggerServerConnection
+*        The conection to the client.
+* @param aChromeEventHandler
+*        An object on which listen for DOMWindowCreated and pageshow events.
+*/
+function TabActor(aConnection)
+{
+this.conn = aConnection;
+this._tabActorPool = null;
+// A map of actor names to actor instances provided by extensions.
+this._extraActors = {};
+this._exited = false;
+this.traits = { reconfigure: true };
+}
+// XXX (bug 710213): TabActor attach/detach/exit/disconnect is a
+// *complete* mess, needs to be rethought asap.
+TabActor.prototype = {
+traits: null,
+get exited() { return this._exited; },
+get attached() { return !!this._attached; },
+_tabPool: null,
+get tabActorPool() { return this._tabPool; },
+_contextPool: null,
+get contextActorPool() { return this._contextPool; },
+_pendingNavigation: null,
+// A constant prefix that will be used to form the actor ID by the server.
+actorPrefix: "tab",
+/**
+* An object on which listen for DOMWindowCreated and pageshow events.
+*/
+get chromeEventHandler() {
+// TODO: bug 992778, fix docShell.chromeEventHandler in child processes
+return this.docShell.chromeEventHandler ||
+this.docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIContentFrameMessageManager);
+},
+/**
+* Getter for the nsIMessageManager associated to the tab.
+*/
+get messageManager() {
+return this.docShell
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIContentFrameMessageManager);
+},
+/**
+* Getter for the tab's doc shell.
+*/
+get docShell() {
+throw "The docShell getter should be implemented by a subclass of TabActor";
+},
+/**
+* Getter for the tab content's DOM window.
+*/
+get window() {
+return this.docShell
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindow);
+},
+/**
+* Getter for the nsIWebProgress for watching this window.
+*/
+get webProgress() {
+return this.docShell
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebProgress);
+},
+/**
+* Getter for the nsIWebNavigation for the tab.
+*/
+get webNavigation() {
+return this.docShell
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebNavigation);
+},
+/**
+* Getter for the tab's document.
+*/
+get contentDocument() {
+return this.webNavigation.document;
+},
+/**
+* Getter for the tab title.
+* @return string
+*         Tab title.
+*/
+get title() {
+return this.contentDocument.contentTitle;
+},
+/**
+* Getter for the tab URL.
+* @return string
+*         Tab URL.
+*/
+get url() {
+if (this.webNavigation.currentURI) {
+return this.webNavigation.currentURI.spec;
+}
+// Abrupt closing of the browser window may leave callbacks without a
+// currentURI.
+return null;
+},
+form: function BTA_form() {
+dbg_assert(!this.exited,
+"grip() shouldn't be called on exited browser actor.");
+dbg_assert(this.actorID,
+"tab should have an actorID.");
+let windowUtils = this.window
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils);
+let response = {
+actor: this.actorID,
+title: this.title,
+url: this.url,
+outerWindowID: windowUtils.outerWindowID
+};
+// Walk over tab actors added by extensions and add them to a new ActorPool.
+let actorPool = new ActorPool(this.conn);
+this._createExtraActors(DebuggerServer.tabActorFactories, actorPool);
+if (!actorPool.isEmpty()) {
+this._tabActorPool = actorPool;
+this.conn.addActorPool(this._tabActorPool);
+}
+this._appendExtraActors(response);
+return response;
+},
+/**
+* Called when the actor is removed from the connection.
+*/
+disconnect: function BTA_disconnect() {
+this._detach();
+this._extraActors = null;
+this._exited = true;
+},
+/**
+* Called by the root actor when the underlying tab is closed.
+*/
+exit: function BTA_exit() {
+if (this.exited) {
+return;
+}
+if (this._detach()) {
+this.conn.send({ from: this.actorID,
+type: "tabDetached" });
+}
+this._exited = true;
+},
+/* Support for DebuggerServer.addTabActor. */
+_createExtraActors: createExtraActors,
+_appendExtraActors: appendExtraActors,
+/**
+* Does the actual work of attching to a tab.
+*/
+_attach: function BTA_attach() {
+if (this._attached) {
+return;
+}
+// Create a pool for tab-lifetime actors.
+dbg_assert(!this._tabPool, "Shouldn't have a tab pool if we weren't attached.");
+this._tabPool = new ActorPool(this.conn);
+this.conn.addActorPool(this._tabPool);
+// ... and a pool for context-lifetime actors.
+this._pushContext();
+this._progressListener = new DebuggerProgressListener(this);
+this._progressListener.watch(this.docShell);
+this._attached = true;
+},
+/**
+* Creates a thread actor and a pool for context-lifetime actors. It then sets
+* up the content window for debugging.
+*/
+_pushContext: function BTA_pushContext() {
+dbg_assert(!this._contextPool, "Can't push multiple contexts");
+this._contextPool = new ActorPool(this.conn);
+this.conn.addActorPool(this._contextPool);
+this.threadActor = new ThreadActor(this, this.window);
+this._contextPool.addActor(this.threadActor);
+},
+/**
+* Exits the current thread actor and removes the context-lifetime actor pool.
+* The content window is no longer being debugged after this call.
+*/
+_popContext: function BTA_popContext() {
+dbg_assert(!!this._contextPool, "No context to pop.");
+this.conn.removeActorPool(this._contextPool);
+this._contextPool = null;
+this.threadActor.exit();
+this.threadActor = null;
+},
+/**
+* Does the actual work of detaching from a tab.
+*
+* @returns false if the tab wasn't attached or true of detahing succeeds.
+*/
+_detach: function BTA_detach() {
+if (!this.attached) {
+return false;
+}
+// Check for docShell availability, as it can be already gone
+// during Firefox shutdown.
+if (this.docShell) {
+this._progressListener.unwatch(this.docShell);
+}
+this._progressListener = null;
+this._popContext();
+// Shut down actors that belong to this tab's pool.
+this.conn.removeActorPool(this._tabPool);
+this._tabPool = null;
+if (this._tabActorPool) {
+this.conn.removeActorPool(this._tabActorPool);
+this._tabActorPool = null;
+}
+this._attached = false;
+return true;
+},
+// Protocol Request Handlers
+onAttach: function BTA_onAttach(aRequest) {
+if (this.exited) {
+return { type: "exited" };
+}
+this._attach();
+return {
+type: "tabAttached",
+threadActor: this.threadActor.actorID,
+cacheEnabled: this._getCacheEnabled(),
+javascriptEnabled: this._getJavascriptEnabled(),
+traits: this.traits,
+};
+},
+onDetach: function BTA_onDetach(aRequest) {
+if (!this._detach()) {
+return { error: "wrongState" };
+}
+return { type: "detached" };
+},
+/**
+* Reload the page in this tab.
+*/
+onReload: function(aRequest) {
+// Wait a tick so that the response packet can be dispatched before the
+// subsequent navigation event packet.
+Services.tm.currentThread.dispatch(DevToolsUtils.makeInfallible(() => {
+this.window.location.reload();
+}, "TabActor.prototype.onReload's delayed body"), 0);
+return {};
+},
+/**
+* Navigate this tab to a new location
+*/
+onNavigateTo: function(aRequest) {
+// Wait a tick so that the response packet can be dispatched before the
+// subsequent navigation event packet.
+Services.tm.currentThread.dispatch(DevToolsUtils.makeInfallible(() => {
+this.window.location = aRequest.url;
+}, "TabActor.prototype.onNavigateTo's delayed body"), 0);
+return {};
+},
+/**
+* Reconfigure options.
+*/
+onReconfigure: function (aRequest) {
+let options = aRequest.options || {};
+this._toggleJsOrCache(options);
+return {};
+},
+/**
+* Handle logic to enable/disable JS/cache.
+*/
+_toggleJsOrCache: function(options) {
+// Wait a tick so that the response packet can be dispatched before the
+// subsequent navigation event packet.
+let reload = false;
+if (typeof options.javascriptEnabled !== "undefined" &&
+options.javascriptEnabled !== this._getJavascriptEnabled()) {
+this._setJavascriptEnabled(options.javascriptEnabled);
+reload = true;
+}
+if (typeof options.cacheEnabled !== "undefined" &&
+options.cacheEnabled !== this._getCacheEnabled()) {
+this._setCacheEnabled(options.cacheEnabled);
+reload = true;
+}
+// Reload if:
+//  - there's an explicit `performReload` flag and it's true
+//  - there's no `performReload` flag, but it makes sense to do so
+let hasExplicitReloadFlag = "performReload" in options;
+if ((hasExplicitReloadFlag && options.performReload) ||
+(!hasExplicitReloadFlag && reload)) {
+this.onReload();
+}
+},
+/**
+* Disable or enable the cache via docShell.
+*/
+_setCacheEnabled: function(allow) {
+let enable =  Ci.nsIRequest.LOAD_NORMAL;
+let disable = Ci.nsIRequest.LOAD_BYPASS_CACHE |
+Ci.nsIRequest.INHIBIT_CACHING;
+if (this.docShell) {
+this.docShell.defaultLoadFlags = allow ? enable : disable;
+}
+},
+/**
+* Disable or enable JS via docShell.
+*/
+_setJavascriptEnabled: function(allow) {
+if (this.docShell) {
+this.docShell.allowJavascript = allow;
+}
+},
+/**
+* Return cache allowed status.
+*/
+_getCacheEnabled: function() {
+if (!this.docShell) {
+// The tab is already closed.
+return null;
+}
+let disable = Ci.nsIRequest.LOAD_BYPASS_CACHE |
+Ci.nsIRequest.INHIBIT_CACHING;
+return this.docShell.defaultLoadFlags !== disable;
+},
+/**
+* Return JS allowed status.
+*/
+_getJavascriptEnabled: function() {
+if (!this.docShell) {
+// The tab is already closed.
+return null;
+}
+return this.docShell.allowJavascript;
+},
+/**
+* Prepare to enter a nested event loop by disabling debuggee events.
+*/
+preNest: function BTA_preNest() {
+if (!this.window) {
+// The tab is already closed.
+return;
+}
+let windowUtils = this.window
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils);
+windowUtils.suppressEventHandling(true);
+windowUtils.suspendTimeouts();
+},
+/**
+* Prepare to exit a nested event loop by enabling debuggee events.
+*/
+postNest: function BTA_postNest(aNestData) {
+if (!this.window) {
+// The tab is already closed.
+return;
+}
+let windowUtils = this.window
+.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils);
+windowUtils.resumeTimeouts();
+windowUtils.suppressEventHandling(false);
+if (this._pendingNavigation) {
+this._pendingNavigation.resume();
+this._pendingNavigation = null;
+}
+},
+/**
+* Handle location changes, by clearing the previous debuggees and enabling
+* debugging, which may have been disabled temporarily by the
+* DebuggerProgressListener.
+*/
+_windowReady: function (window) {
+let isTopLevel = window == this.window;
+dumpn("window-ready: " + window.location + " isTopLevel:" + isTopLevel);
+events.emit(this, "window-ready", {
+window: window,
+isTopLevel: isTopLevel
+});
+// TODO bug 997119: move that code to ThreadActor by listening to window-ready
+let threadActor = this.threadActor;
+if (isTopLevel) {
+threadActor.clearDebuggees();
+if (threadActor.dbg) {
+threadActor.dbg.enabled = true;
+threadActor.global = window;
+threadActor.maybePauseOnExceptions();
+}
+}
+// Refresh the debuggee list when a new window object appears (top window or
+// iframe).
+if (threadActor.attached) {
+threadActor.findGlobals();
+}
+},
+/**
+* Start notifying server codebase and client about a new document
+* being loaded in the currently targeted context.
+*/
+_willNavigate: function (window, newURI, request) {
+let isTopLevel = window == this.window;
+// will-navigate event needs to be dispatched synchronously,
+// by calling the listeners in the order or registration.
+// This event fires once navigation starts,
+// (all pending user prompts are dealt with),
+// but before the first request starts.
+events.emit(this, "will-navigate", {
+window: window,
+isTopLevel: isTopLevel,
+newURI: newURI,
+request: request
+});
+// We don't do anything for inner frames in TabActor.
+// (we will only update thread actor on window-ready)
+if (!isTopLevel) {
+return;
+}
+// Proceed normally only if the debuggee is not paused.
+// TODO bug 997119: move that code to ThreadActor by listening to will-navigate
+let threadActor = this.threadActor;
+if (request && threadActor.state == "paused") {
+request.suspend();
+threadActor.onResume();
+threadActor.dbg.enabled = false;
+this._pendingNavigation = request;
+}
+threadActor.disableAllBreakpoints();
+this.conn.send({
+from: this.actorID,
+type: "tabNavigated",
+url: newURI,
+nativeConsoleAPI: true,
+state: "start"
+});
+},
+/**
+* Notify server and client about a new document done loading in the current
+* targeted context.
+*/
+_navigate: function (window) {
+let isTopLevel = window == this.window;
+// navigate event needs to be dispatched synchronously,
+// by calling the listeners in the order or registration.
+// This event is fired once the document is loaded,
+// after the load event, it's document ready-state is 'complete'.
+events.emit(this, "navigate", {
+window: window,
+isTopLevel: isTopLevel
+});
+// We don't do anything for inner frames in TabActor.
+// (we will only update thread actor on window-ready)
+if (!isTopLevel) {
+return;
+}
+// TODO bug 997119: move that code to ThreadActor by listening to navigate
+let threadActor = this.threadActor;
+if (threadActor.state == "running") {
+threadActor.dbg.enabled = true;
+}
+this.conn.send({
+from: this.actorID,
+type: "tabNavigated",
+url: this.url,
+title: this.title,
+nativeConsoleAPI: this.hasNativeConsoleAPI(this.window),
+state: "stop"
+});
+},
+/**
+* Tells if the window.console object is native or overwritten by script in
+* the page.
+*
+* @param nsIDOMWindow aWindow
+*        The window object you want to check.
+* @return boolean
+*         True if the window.console object is native, or false otherwise.
+*/
+hasNativeConsoleAPI: function BTA_hasNativeConsoleAPI(aWindow) {
+let isNative = false;
+try {
+// We are very explicitly examining the "console" property of
+// the non-Xrayed object here.
+let console = aWindow.wrappedJSObject.console;
+isNative = console instanceof aWindow.Console;
+}
+catch (ex) { }
+return isNative;
+}
+};
+/**
+* The request types this actor can handle.
+*/
+TabActor.prototype.requestTypes = {
+"attach": TabActor.prototype.onAttach,
+"detach": TabActor.prototype.onDetach,
+"reload": TabActor.prototype.onReload,
+"navigateTo": TabActor.prototype.onNavigateTo,
+"reconfigure": TabActor.prototype.onReconfigure
+};
+/**
+* Creates a tab actor for handling requests to a single in-process
+* <browser> tab. Most of the implementation comes from TabActor.
+*
+* @param aConnection DebuggerServerConnection
+*        The conection to the client.
+* @param aBrowser browser
+*        The browser instance that contains this tab.
+* @param aTabBrowser tabbrowser
+*        The tabbrowser that can receive nsIWebProgressListener events.
+*/
+function BrowserTabActor(aConnection, aBrowser, aTabBrowser)
+{
+TabActor.call(this, aConnection, aBrowser);
+this._browser = aBrowser;
+this._tabbrowser = aTabBrowser;
+}
+BrowserTabActor.prototype = Object.create(TabActor.prototype);
+BrowserTabActor.prototype.constructor = BrowserTabActor;
+Object.defineProperty(BrowserTabActor.prototype, "docShell", {
+get: function() {
+return this._browser.docShell;
+},
+enumerable: true,
+configurable: false
+});
+Object.defineProperty(BrowserTabActor.prototype, "title", {
+get: function() {
+let title = this.contentDocument.title || this._browser.contentTitle;
+// If contentTitle is empty (e.g. on a not-yet-restored tab), but there is a
+// tabbrowser (i.e. desktop Firefox, but not Fennec), we can use the label
+// as the title.
+if (!title && this._tabbrowser) {
+let tab = this._tabbrowser._getTabForContentWindow(this.window);
+if (tab) {
+title = tab.label;
+}
+}
+return title;
+},
+enumerable: true,
+configurable: false
+});
+Object.defineProperty(BrowserTabActor.prototype, "browser", {
+get: function() {
+return this._browser;
+},
+enumerable: true,
+configurable: false
+});
+BrowserTabActor.prototype.disconnect = function() {
+TabActor.prototype.disconnect.call(this);
+this._browser = null;
+this._tabbrowser = null;
+};
+BrowserTabActor.prototype.exit = function() {
+TabActor.prototype.exit.call(this);
+this._browser = null;
+this._tabbrowser = null;
+};
+/**
+* This actor is a shim that connects to a ContentActor in a remote
+* browser process. All RDP packets get forwarded using the message
+* manager.
+*
+* @param aConnection The main RDP connection.
+* @param aBrowser XUL <browser> element to connect to.
+*/
+function RemoteBrowserTabActor(aConnection, aBrowser)
+{
+this._conn = aConnection;
+this._browser = aBrowser;
+this._form = null;
+}
+RemoteBrowserTabActor.prototype = {
+connect: function() {
+return DebuggerServer.connectToChild(this._conn, this._browser);
+},
+form: function() {
+return this._form;
+},
+exit: function() {
+this._browser = null;
+},
+};
+function BrowserAddonList(aConnection)
+{
+this._connection = aConnection;
+this._actorByAddonId = new Map();
+this._onListChanged = null;
+}
+BrowserAddonList.prototype.getList = function() {
+var deferred = promise.defer();
+AddonManager.getAllAddons((addons) => {
+for (let addon of addons) {
+let actor = this._actorByAddonId.get(addon.id);
+if (!actor) {
+actor = new BrowserAddonActor(this._connection, addon);
+this._actorByAddonId.set(addon.id, actor);
+}
+}
+deferred.resolve([actor for ([_, actor] of this._actorByAddonId)]);
+});
+return deferred.promise;
+}
+Object.defineProperty(BrowserAddonList.prototype, "onListChanged", {
+enumerable: true, configurable: true,
+get: function() { return this._onListChanged; },
+set: function(v) {
+if (v !== null && typeof v != "function") {
+throw Error("onListChanged property may only be set to 'null' or a function");
+}
+this._onListChanged = v;
+if (this._onListChanged) {
+AddonManager.addAddonListener(this);
+} else {
+AddonManager.removeAddonListener(this);
+}
+}
+});
+BrowserAddonList.prototype.onInstalled = function (aAddon) {
+this._onListChanged();
+};
+BrowserAddonList.prototype.onUninstalled = function (aAddon) {
+this._actorByAddonId.delete(aAddon.id);
+this._onListChanged();
+};
+function BrowserAddonActor(aConnection, aAddon) {
+this.conn = aConnection;
+this._addon = aAddon;
+this._contextPool = null;
+this._threadActor = null;
+this._global = null;
+AddonManager.addAddonListener(this);
+}
+BrowserAddonActor.prototype = {
+actorPrefix: "addon",
+get exited() {
+return !this._addon;
+},
+get id() {
+return this._addon.id;
+},
+get url() {
+return this._addon.sourceURI ? this._addon.sourceURI.spec : undefined;
+},
+get attached() {
+return this._threadActor;
+},
+get global() {
+return this._global;
+},
+form: function BAA_form() {
+dbg_assert(this.actorID, "addon should have an actorID.");
+return {
+actor: this.actorID,
+id: this.id,
+name: this._addon.name,
+url: this.url,
+debuggable: this._addon.isDebuggable,
+};
+},
+disconnect: function BAA_disconnect() {
+this._addon = null;
+this._global = null;
+AddonManager.removeAddonListener(this);
+},
+setOptions: function BAA_setOptions(aOptions) {
+if ("global" in aOptions) {
+this._global = aOptions.global;
+}
+},
+onDisabled: function BAA_onDisabled(aAddon) {
+if (aAddon != this._addon) {
+return;
+}
+this._global = null;
+},
+onUninstalled: function BAA_onUninstalled(aAddon) {
+if (aAddon != this._addon) {
+return;
+}
+if (this.attached) {
+this.onDetach();
+this.conn.send({ from: this.actorID, type: "tabDetached" });
+}
+this.disconnect();
+},
+onAttach: function BAA_onAttach() {
+if (this.exited) {
+return { type: "exited" };
+}
+if (!this.attached) {
+this._contextPool = new ActorPool(this.conn);
+this.conn.addActorPool(this._contextPool);
+this._threadActor = new AddonThreadActor(this.conn, this,
+this._addon.id);
+this._contextPool.addActor(this._threadActor);
+}
+return { type: "tabAttached", threadActor: this._threadActor.actorID };
+},
+onDetach: function BAA_onDetach() {
+if (!this.attached) {
+return { error: "wrongState" };
+}
+this.conn.removeActorPool(this._contextPool);
+this._contextPool = null;
+this._threadActor = null;
+return { type: "detached" };
+},
+preNest: function() {
+let e = Services.wm.getEnumerator(null);
+while (e.hasMoreElements()) {
+let win = e.getNext();
+let windowUtils = win.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils);
+windowUtils.suppressEventHandling(true);
+windowUtils.suspendTimeouts();
+}
+},
+postNest: function() {
+let e = Services.wm.getEnumerator(null);
+while (e.hasMoreElements()) {
+let win = e.getNext();
+let windowUtils = win.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIDOMWindowUtils);
+windowUtils.resumeTimeouts();
+windowUtils.suppressEventHandling(false);
+}
+}
+};
+BrowserAddonActor.prototype.requestTypes = {
+"attach": BrowserAddonActor.prototype.onAttach,
+"detach": BrowserAddonActor.prototype.onDetach
+};
+/**
+* The DebuggerProgressListener object is an nsIWebProgressListener which
+* handles onStateChange events for the inspected browser. If the user tries to
+* navigate away from a paused page, the listener makes sure that the debuggee
+* is resumed before the navigation begins.
+*
+* @param TabActor aTabActor
+*        The tab actor associated with this listener.
+*/
+function DebuggerProgressListener(aTabActor) {
+this._tabActor = aTabActor;
+this._onWindowCreated = this.onWindowCreated.bind(this);
+}
+DebuggerProgressListener.prototype = {
+QueryInterface: XPCOMUtils.generateQI([
+Ci.nsIWebProgressListener,
+Ci.nsISupportsWeakReference,
+Ci.nsISupports,
+]),
+watch: function DPL_watch(docShell) {
+let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebProgress);
+webProgress.addProgressListener(this, Ci.nsIWebProgress.NOTIFY_STATUS |
+Ci.nsIWebProgress.NOTIFY_STATE_WINDOW |
+Ci.nsIWebProgress.NOTIFY_STATE_DOCUMENT);
+// TODO: fix docShell.chromeEventHandler in child processes!
+let chromeEventHandler = docShell.chromeEventHandler ||
+docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIContentFrameMessageManager);
+// Watch for globals being created in this docshell tree.
+chromeEventHandler.addEventListener("DOMWindowCreated",
+this._onWindowCreated, true);
+chromeEventHandler.addEventListener("pageshow",
+this._onWindowCreated, true);
+},
+unwatch: function DPL_unwatch(docShell) {
+let webProgress = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIWebProgress);
+webProgress.removeProgressListener(this);
+// TODO: fix docShell.chromeEventHandler in child processes!
+let chromeEventHandler = docShell.chromeEventHandler ||
+docShell.QueryInterface(Ci.nsIInterfaceRequestor)
+.getInterface(Ci.nsIContentFrameMessageManager);
+chromeEventHandler.removeEventListener("DOMWindowCreated",
+this._onWindowCreated, true);
+chromeEventHandler.removeEventListener("pageshow",
+this._onWindowCreated, true);
+},
+onWindowCreated:
+DevToolsUtils.makeInfallible(function DPL_onWindowCreated(evt) {
+// Ignore any event if the tab actor isn't attached.
+if (!this._tabActor.attached) {
+return;
+}
+// pageshow events for non-persisted pages have already been handled by a
+// prior DOMWindowCreated event.
+if (evt.type == "pageshow" && !evt.persisted) {
+return;
+}
+let window = evt.target.defaultView;
+this._tabActor._windowReady(window);
+}, "DebuggerProgressListener.prototype.onWindowCreated"),
+onStateChange:
+DevToolsUtils.makeInfallible(function DPL_onStateChange(aProgress, aRequest, aFlag, aStatus) {
+// Ignore any event if the tab actor isn't attached.
+if (!this._tabActor.attached) {
+return;
+}
+let isStart = aFlag & Ci.nsIWebProgressListener.STATE_START;
+let isStop = aFlag & Ci.nsIWebProgressListener.STATE_STOP;
+let isDocument = aFlag & Ci.nsIWebProgressListener.STATE_IS_DOCUMENT;
+let isWindow = aFlag & Ci.nsIWebProgressListener.STATE_IS_WINDOW;
+let window = aProgress.DOMWindow;
+if (isDocument && isStart) {
+let newURI = aRequest instanceof Ci.nsIChannel ? aRequest.URI.spec : null;
+this._tabActor._willNavigate(window, newURI, aRequest);
+}
+if (isWindow && isStop) {
+this._tabActor._navigate(window);
+}
+}, "DebuggerProgressListener.prototype.onStateChange")
+};