diff -r 000000000000 -r 6474c204b198 toolkit/devtools/server/actors/string.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolkit/devtools/server/actors/string.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,145 @@
+/* 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 {Cu} = require("chrome");
+let {DebuggerServer} = require("devtools/server/main");
+
+let {Promise: promise} = Cu.import("resource://gre/modules/Promise.jsm", {});
+let {Class} = require("sdk/core/heritage");
+
+let protocol = require("devtools/server/protocol");
+let {method, Arg, Option, RetVal} = protocol;
+
+exports.LongStringActor = protocol.ActorClass({
+  typeName: "longstractor",
+
+  initialize: function(conn, str) {
+    protocol.Actor.prototype.initialize.call(this, conn);
+    this.str = str;
+    this.short = (this.str.length < DebuggerServer.LONG_STRING_LENGTH);
+  },
+
+  destroy: function() {
+    this.str = null;
+    protocol.Actor.prototype.destroy.call(this);
+  },
+
+  form: function() {
+    if (this.short) {
+      return this.str;
+    }
+    return {
+      type: "longString",
+      actor: this.actorID,
+      length: this.str.length,
+      initial: this.str.substring(0, DebuggerServer.LONG_STRING_INITIAL_LENGTH)
+    }
+  },
+
+  substring: method(function(start, end) {
+    return promise.resolve(this.str.substring(start, end));
+  }, {
+    request: {
+      start: Arg(0),
+      end: Arg(1)
+    },
+    response: { substring: RetVal() },
+  }),
+
+  release: method(function() { }, { release: true })
+});
+
+/**
+ * When a LongString on the server is short enough to be passed
+ * as a full string, the client will get a ShortLongString instead of
+ * a LongStringFront.  Its API should match.
+ *
+ * I'm very proud of this name.
+ */
+exports.ShortLongString = Class({
+  initialize: function(str) {
+    this.str = str;
+  },
+
+  get length() { return this.str.length; },
+  get initial() { return this.str; },
+  string: function() { return promise.resolve(this.str) },
+
+  substring: function(start, end) {
+    return promise.resolve(this.str.substring(start, end));
+  },
+
+  release: function() {
+    this.str = null;
+    return promise.resolve(undefined);
+  }
+})
+
+exports.LongStringFront = protocol.FrontClass(exports.LongStringActor, {
+  initialize: function(client, form) {
+    // Don't give the form by default, because we're being tricky and it might just
+    // be a string.
+    protocol.Front.prototype.initialize.call(this, client, null);
+    this.form(form);
+  },
+
+  destroy: function() {
+    this.initial = null;
+    this.length = null;
+    this.strPromise = null;
+    protocol.Front.prototype.destroy.call(this);
+  },
+
+  form: function(form) {
+    this.actorID = form.actorID;
+    this.initial = form.initial;
+    this.length = form.length;
+  },
+
+  string: function() {
+    if (!this.strPromise) {
+      let promiseRest = (thusFar) => {
+        if (thusFar.length === this.length)
+          return promise.resolve(thusFar);
+        else {
+          return this.substring(thusFar.length,
+                                thusFar.length + DebuggerServer.LONG_STRING_READ_LENGTH)
+            .then((next) => promiseRest(thusFar + next));
+        }
+      }
+
+      this.strPromise = promiseRest(this.initial);
+    }
+    return this.strPromise;
+  }
+});
+
+// The long string actor needs some custom marshalling, because it is sometimes
+// returned as a primitive rather than a complete form.
+
+let stringActorType = protocol.types.getType("longstractor");
+protocol.types.addType("longstring", {
+  _actor: true,
+  write: (value, context, detail) => {
+    if (!(context instanceof protocol.Actor)) {
+      throw Error("Passing a longstring as an argument isn't supported.");
+    }
+    if (value.short) {
+      return value.str;
+    } else {
+      return stringActorType.write(value, context, detail);
+    }
+  },
+  read: (value, context, detail) => {
+    if (context instanceof protocol.Actor) {
+      throw Error("Passing a longstring as an argument isn't supported.");
+    }
+    if (typeof(value) === "string") {
+      return exports.ShortLongString(value);
+    }
+    return stringActorType.read(value, context, detail);
+  }
+});