Bug 937172 - Rename ContentAppActor to ContentActor (r=ochameau,past)
authorBill McCloskey <wmccloskey@mozilla.com>
Mon, 10 Mar 2014 09:38:17 -0700
changeset 191036 6d99499b74b6497e702a598edb9f04b7c7c9cb3a
parent 191035 7d9a9a8d653bf1512df368428d1bd4c8fd1d0ee6
child 191037 36f64670a41f7df72aa1480e30002560920c8c26
push id474
push userasasaki@mozilla.com
push dateMon, 02 Jun 2014 21:01:02 +0000
treeherdermozilla-release@967f4cf1b31c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersochameau, past
bugs937172
milestone30.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 937172 - Rename ContentAppActor to ContentActor (r=ochameau,past)
toolkit/devtools/apps/app-actor-front.js
toolkit/devtools/server/actors/childtab.js
toolkit/devtools/server/actors/highlighter.js
toolkit/devtools/server/actors/webapps.js
toolkit/devtools/server/child.js
toolkit/devtools/server/main.js
--- a/toolkit/devtools/apps/app-actor-front.js
+++ b/toolkit/devtools/apps/app-actor-front.js
@@ -254,17 +254,17 @@ function getTargetForApp(client, webapps
 exports.getTargetForApp = getTargetForApp;
 
 function reloadApp(client, webappsActor, manifestURL) {
   let deferred = promise.defer();
   getTargetForApp(client,
                   webappsActor,
                   manifestURL).
     then((target) => {
-      // Request the ContentAppActor to reload the app
+      // Request the ContentActor to reload the app
       let request = {
         to: target.form.actor,
         type: "reload",
         manifestURL: manifestURL
       };
       client.request(request, (res) => {
         deferred.resolve();
       });
--- a/toolkit/devtools/server/actors/childtab.js
+++ b/toolkit/devtools/server/actors/childtab.js
@@ -7,62 +7,62 @@
 /**
  * Tab actor for documents living in a child process.
  *
  * Depends on BrowserTabActor, defined in webbrowser.js actor.
  */
 
 /**
  * Creates a tab actor for handling requests to the single tab, like
- * attaching and detaching. ContentAppActor respects the actor factories
+ * attaching and detaching. ContentActor respects the actor factories
  * registered with DebuggerServer.addTabActor.
  *
  * @param connection DebuggerServerConnection
  *        The conection to the client.
  * @param browser browser
  *        The browser instance that contains this tab.
  */
-function ContentAppActor(connection, browser)
+function ContentActor(connection, browser)
 {
   BrowserTabActor.call(this, connection, browser);
 }
 
-ContentAppActor.prototype = Object.create(BrowserTabActor.prototype);
+ContentActor.prototype = Object.create(BrowserTabActor.prototype);
 
-ContentAppActor.prototype.constructor = ContentAppActor;
+ContentActor.prototype.constructor = ContentActor;
 
-Object.defineProperty(ContentAppActor.prototype, "title", {
+Object.defineProperty(ContentActor.prototype, "title", {
   get: function() {
     return this.browser.title;
   },
   enumerable: true,
   configurable: false
 });
 
-Object.defineProperty(ContentAppActor.prototype, "url", {
+Object.defineProperty(ContentActor.prototype, "url", {
   get: function() {
     return this.browser.document.documentURI;
   },
   enumerable: true,
   configurable: false
 });
 
-Object.defineProperty(ContentAppActor.prototype, "window", {
+Object.defineProperty(ContentActor.prototype, "window", {
   get: function() {
     return this.browser;
   },
   enumerable: true,
   configurable: false
 });
 
 // Override grip just to rename this._tabActorPool to this._tabActorPool2
 // in order to prevent it to be cleaned on detach.
-// We have to keep tab actors alive as we keep the ContentAppActor
+// We have to keep tab actors alive as we keep the ContentActor
 // alive after detach and reuse it for multiple debug sessions.
-ContentAppActor.prototype.grip = function () {
+ContentActor.prototype.grip = function () {
   let response = {
     'actor': this.actorID,
     'title': this.title,
     'url': this.url
   };
 
   // Walk over tab actors added by extensions and add them to a new ActorPool.
   let actorPool = new ActorPool(this.conn);
--- a/toolkit/devtools/server/actors/highlighter.js
+++ b/toolkit/devtools/server/actors/highlighter.js
@@ -182,17 +182,17 @@ let HighlighterActor = protocol.ActorCla
     return this._walker.attachElement(node);
   },
 
   /**
    * Get the right target for listening to mouse events while in pick mode.
    * - On a firefox desktop content page: tabActor is a BrowserTabActor from
    *   which the browser property will give us a target we can use to listen to
    *   events, even in nested iframes.
-   * - On B2G: tabActor is a ContentAppActor which doesn't have a browser but
+   * - On B2G: tabActor is a ContentActor which doesn't have a browser but
    *   since it overrides BrowserTabActor, it does get a browser property
    *   anyway, which points to its window object.
    * - When using the Browser Toolbox (to inspect firefox desktop): tabActor is
    *   the RootActor, in which case, the window property can be used to listen
    *   to events
    */
   _getPickerListenerTarget: function() {
     let actor = this._tabActor;
--- a/toolkit/devtools/server/actors/webapps.js
+++ b/toolkit/devtools/server/actors/webapps.js
@@ -115,17 +115,17 @@ function WebappsActor(aConnection) {
 
   Cu.import("resource://gre/modules/Webapps.jsm");
   Cu.import("resource://gre/modules/AppsUtils.jsm");
   Cu.import("resource://gre/modules/FileUtils.jsm");
   Cu.import('resource://gre/modules/Services.jsm');
   promise = Cu.import("resource://gre/modules/commonjs/sdk/core/promise.js").Promise;
 
   // Keep reference of already created app actors.
-  // key: app frame message manager, value: ContentTabActor's grip() value
+  // key: app frame message manager, value: ContentActor's grip() value
   this._appActorsMap = new Map();
 
   this.conn = aConnection;
   this._uploads = [];
   this._actorPool = new ActorPool(this.conn);
   this.conn.addActorPool(this._actorPool);
 }
 
--- a/toolkit/devtools/server/child.js
+++ b/toolkit/devtools/server/child.js
@@ -23,17 +23,17 @@
 
   let onConnect = DevToolsUtils.makeInfallible(function (msg) {
     removeMessageListener("debug:connect", onConnect);
 
     let mm = msg.target;
 
     let conn = DebuggerServer.connectToParent(msg.data.prefix, mm);
 
-    let actor = new DebuggerServer.ContentAppActor(conn, content);
+    let actor = new DebuggerServer.ContentActor(conn, content);
     let actorPool = new ActorPool(conn);
     actorPool.addActor(actor);
     conn.addActorPool(actorPool);
 
     sendAsyncMessage("debug:actor", {actor: actor.grip()});
   });
 
   addMessageListener("debug:connect", onConnect);
--- a/toolkit/devtools/server/main.js
+++ b/toolkit/devtools/server/main.js
@@ -371,17 +371,17 @@ var DebuggerServer = {
     // but childtab.js hasn't been loaded yet.
     if (!("WebConsoleActor" in this)) {
       this.addTabActors();
     }
     // But webbrowser.js and childtab.js aren't loaded from shell.js.
     if (!("BrowserTabActor" in this)) {
       this.addActors("resource://gre/modules/devtools/server/actors/webbrowser.js");
     }
-    if (!("ContentAppActor" in this)) {
+    if (!("ContentActor" in this)) {
       this.addActors("resource://gre/modules/devtools/server/actors/childtab.js");
     }
   },
 
   /**
    * Install tab actors.
    */
   addTabActors: function() {
@@ -565,17 +565,17 @@ var DebuggerServer = {
           aConnection.cancelForwarding(prefix);
         } else {
           // Otherwise, the app has been closed before the actor
           // had a chance to be created, so we are not able to create
           // the actor.
           deferred.resolve(null);
         }
         if (actor) {
-          // The ContentAppActor within the child process doesn't necessary
+          // The ContentActor within the child process doesn't necessary
           // have to time to uninitialize itself when the app is closed/killed.
           // So ensure telling the client that the related actor is detached.
           aConnection.send({ from: actor.actor, type: "tabDetached" });
           actor = null;
         }
 
         if (aOnDisconnect) {
           aOnDisconnect(mm);