The Tor Browser: toolkit/devtools/server/actors/string.js@6474c204b198 (annotated)

toolkit/devtools/server/actors/string.js@6474c204b198 (annotated)

toolkit/devtools/server/actors/string.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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);
   }
 });