diff -r 000000000000 -r 6474c204b198 toolkit/devtools/server/actors/stylesheets.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/toolkit/devtools/server/actors/stylesheets.js	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1055 @@
+/* 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 { components, Cc, Ci, Cu } = require("chrome");
+let Services = require("Services");
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/FileUtils.jsm");
+Cu.import("resource://gre/modules/devtools/SourceMap.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+
+const {Promise: promise} = Cu.import("resource://gre/modules/Promise.jsm", {});
+const events = require("sdk/event/core");
+const protocol = require("devtools/server/protocol");
+const {Arg, Option, method, RetVal, types} = protocol;
+const {LongStringActor, ShortLongString} = require("devtools/server/actors/string");
+
+loader.lazyGetter(this, "CssLogic", () => require("devtools/styleinspector/css-logic").CssLogic);
+
+let TRANSITION_CLASS = "moz-styleeditor-transitioning";
+let TRANSITION_DURATION_MS = 500;
+let TRANSITION_BUFFER_MS = 1000;
+let TRANSITION_RULE = "\
+:root.moz-styleeditor-transitioning, :root.moz-styleeditor-transitioning * {\
+transition-duration: " + TRANSITION_DURATION_MS + "ms !important; \
+transition-delay: 0ms !important;\
+transition-timing-function: ease-out !important;\
+transition-property: all !important;\
+}";
+
+let LOAD_ERROR = "error-load";
+
+exports.register = function(handle) {
+  handle.addTabActor(StyleSheetsActor, "styleSheetsActor");
+  handle.addGlobalActor(StyleSheetsActor, "styleSheetsActor");
+};
+
+exports.unregister = function(handle) {
+  handle.removeTabActor(StyleSheetsActor);
+  handle.removeGlobalActor(StyleSheetsActor);
+};
+
+types.addActorType("stylesheet");
+types.addActorType("originalsource");
+
+/**
+ * Creates a StyleSheetsActor. StyleSheetsActor provides remote access to the
+ * stylesheets of a document.
+ */
+let StyleSheetsActor = protocol.ActorClass({
+  typeName: "stylesheets",
+
+  /**
+   * The window we work with, taken from the parent actor.
+   */
+  get window() this.parentActor.window,
+
+  /**
+   * The current content document of the window we work with.
+   */
+  get document() this.window.document,
+
+  form: function()
+  {
+    return { actor: this.actorID };
+  },
+
+  initialize: function (conn, tabActor) {
+    protocol.Actor.prototype.initialize.call(this, null);
+
+    this.parentActor = tabActor;
+
+    // keep a map of sheets-to-actors so we don't create two actors for one sheet
+    this._sheets = new Map();
+  },
+
+  /**
+   * Destroy the current StyleSheetsActor instance.
+   */
+  destroy: function()
+  {
+    this._sheets.clear();
+  },
+
+  /**
+   * Protocol method for getting a list of StyleSheetActors representing
+   * all the style sheets in this document.
+   */
+  getStyleSheets: method(function() {
+    let deferred = promise.defer();
+
+    let window = this.window;
+    var domReady = () => {
+      window.removeEventListener("DOMContentLoaded", domReady, true);
+      this._addAllStyleSheets().then(deferred.resolve, Cu.reportError);
+    };
+
+    if (window.document.readyState === "loading") {
+      window.addEventListener("DOMContentLoaded", domReady, true);
+    } else {
+      domReady();
+    }
+
+    return deferred.promise;
+  }, {
+    request: {},
+    response: { styleSheets: RetVal("array:stylesheet") }
+  }),
+
+  /**
+   * Add all the stylesheets in this document and its subframes.
+   * Assumes the document is loaded.
+   *
+   * @return {Promise}
+   *         Promise that resolves with an array of StyleSheetActors
+   */
+  _addAllStyleSheets: function() {
+    return Task.spawn(function() {
+      let documents = [this.document];
+      let actors = [];
+
+      for (let doc of documents) {
+        let sheets = yield this._addStyleSheets(doc.styleSheets);
+        actors = actors.concat(sheets);
+
+        // Recursively handle style sheets of the documents in iframes.
+        for (let iframe of doc.getElementsByTagName("iframe")) {
+          if (iframe.contentDocument) {
+            // Sometimes, iframes don't have any document, like the
+            // one that are over deeply nested (bug 285395)
+            documents.push(iframe.contentDocument);
+          }
+        }
+      }
+      throw new Task.Result(actors);
+    }.bind(this));
+  },
+
+  /**
+   * Add all the stylesheets to the map and create an actor for each one
+   * if not already created.
+   *
+   * @param {[DOMStyleSheet]} styleSheets
+   *        Stylesheets to add
+   *
+   * @return {Promise}
+   *         Promise that resolves to an array of StyleSheetActors
+   */
+  _addStyleSheets: function(styleSheets)
+  {
+    return Task.spawn(function() {
+      let actors = [];
+      for (let i = 0; i < styleSheets.length; i++) {
+        let actor = this._createStyleSheetActor(styleSheets[i]);
+        actors.push(actor);
+
+        // Get all sheets, including imported ones
+        let imports = yield this._getImported(actor);
+        actors = actors.concat(imports);
+      }
+      throw new Task.Result(actors);
+    }.bind(this));
+  },
+
+  /**
+   * Get all the stylesheets @imported from a stylesheet.
+   *
+   * @param  {DOMStyleSheet} styleSheet
+   *         Style sheet to search
+   * @return {Promise}
+   *         A promise that resolves with an array of StyleSheetActors
+   */
+  _getImported: function(styleSheet) {
+    return Task.spawn(function() {
+      let rules = yield styleSheet.getCSSRules();
+      let imported = [];
+
+      for (let i = 0; i < rules.length; i++) {
+        let rule = rules[i];
+        if (rule.type == Ci.nsIDOMCSSRule.IMPORT_RULE) {
+          // Associated styleSheet may be null if it has already been seen due
+          // to duplicate @imports for the same URL.
+          if (!rule.styleSheet) {
+            continue;
+          }
+          let actor = this._createStyleSheetActor(rule.styleSheet);
+          imported.push(actor);
+
+          // recurse imports in this stylesheet as well
+          let children = yield this._getImported(actor);
+          imported = imported.concat(children);
+        }
+        else if (rule.type != Ci.nsIDOMCSSRule.CHARSET_RULE) {
+          // @import rules must precede all others except @charset
+          break;
+        }
+      }
+
+      throw new Task.Result(imported);
+    }.bind(this));
+  },
+
+  /**
+   * Create a new actor for a style sheet, if it hasn't already been created.
+   *
+   * @param  {DOMStyleSheet} styleSheet
+   *         The style sheet to create an actor for.
+   * @return {StyleSheetActor}
+   *         The actor for this style sheet
+   */
+  _createStyleSheetActor: function(styleSheet)
+  {
+    if (this._sheets.has(styleSheet)) {
+      return this._sheets.get(styleSheet);
+    }
+    let actor = new StyleSheetActor(styleSheet, this);
+
+    this.manage(actor);
+    this._sheets.set(styleSheet, actor);
+
+    return actor;
+  },
+
+  /**
+   * Clear all the current stylesheet actors in map.
+   */
+  _clearStyleSheetActors: function() {
+    for (let actor in this._sheets) {
+      this.unmanage(this._sheets[actor]);
+    }
+    this._sheets.clear();
+  },
+
+  /**
+   * Create a new style sheet in the document with the given text.
+   * Return an actor for it.
+   *
+   * @param  {object} request
+   *         Debugging protocol request object, with 'text property'
+   * @return {object}
+   *         Object with 'styelSheet' property for form on new actor.
+   */
+  addStyleSheet: method(function(text) {
+    let parent = this.document.documentElement;
+    let style = this.document.createElementNS("http://www.w3.org/1999/xhtml", "style");
+    style.setAttribute("type", "text/css");
+
+    if (text) {
+      style.appendChild(this.document.createTextNode(text));
+    }
+    parent.appendChild(style);
+
+    let actor = this._createStyleSheetActor(style.sheet);
+    return actor;
+  }, {
+    request: { text: Arg(0, "string") },
+    response: { styleSheet: RetVal("stylesheet") }
+  })
+});
+
+/**
+ * The corresponding Front object for the StyleSheetsActor.
+ */
+let StyleSheetsFront = protocol.FrontClass(StyleSheetsActor, {
+  initialize: function(client, tabForm) {
+    protocol.Front.prototype.initialize.call(this, client);
+    this.actorID = tabForm.styleSheetsActor;
+
+    client.addActorPool(this);
+    this.manage(this);
+  }
+});
+
+/**
+ * A StyleSheetActor represents a stylesheet on the server.
+ */
+let StyleSheetActor = protocol.ActorClass({
+  typeName: "stylesheet",
+
+  events: {
+    "property-change" : {
+      type: "propertyChange",
+      property: Arg(0, "string"),
+      value: Arg(1, "json")
+    },
+    "style-applied" : {
+      type: "styleApplied"
+    }
+  },
+
+  /* List of original sources that generated this stylesheet */
+  _originalSources: null,
+
+  toString: function() {
+    return "[StyleSheetActor " + this.actorID + "]";
+  },
+
+  /**
+   * Window of target
+   */
+  get window() this._window || this.parentActor.window,
+
+  /**
+   * Document of target.
+   */
+  get document() this.window.document,
+
+  /**
+   * URL of underlying stylesheet.
+   */
+  get href() this.rawSheet.href,
+
+  /**
+   * Retrieve the index (order) of stylesheet in the document.
+   *
+   * @return number
+   */
+  get styleSheetIndex()
+  {
+    if (this._styleSheetIndex == -1) {
+      for (let i = 0; i < this.document.styleSheets.length; i++) {
+        if (this.document.styleSheets[i] == this.rawSheet) {
+          this._styleSheetIndex = i;
+          break;
+        }
+      }
+    }
+    return this._styleSheetIndex;
+  },
+
+  initialize: function(aStyleSheet, aParentActor, aWindow) {
+    protocol.Actor.prototype.initialize.call(this, null);
+
+    this.rawSheet = aStyleSheet;
+    this.parentActor = aParentActor;
+    this.conn = this.parentActor.conn;
+
+    this._window = aWindow;
+
+    // text and index are unknown until source load
+    this.text = null;
+    this._styleSheetIndex = -1;
+
+    this._transitionRefCount = 0;
+  },
+
+  /**
+   * Get the raw stylesheet's cssRules once the sheet has been loaded.
+   *
+   * @return {Promise}
+   *         Promise that resolves with a CSSRuleList
+   */
+  getCSSRules: function() {
+    let rules;
+    try {
+      rules = this.rawSheet.cssRules;
+    }
+    catch (e) {
+      // sheet isn't loaded yet
+    }
+
+    if (rules) {
+      return promise.resolve(rules);
+    }
+
+    let ownerNode = this.rawSheet.ownerNode;
+    if (!ownerNode) {
+      return promise.resolve([]);
+    }
+
+    if (this._cssRules) {
+      return this._cssRules;
+    }
+
+    let deferred = promise.defer();
+
+    let onSheetLoaded = function(event) {
+      ownerNode.removeEventListener("load", onSheetLoaded, false);
+
+      deferred.resolve(this.rawSheet.cssRules);
+    }.bind(this);
+
+    ownerNode.addEventListener("load", onSheetLoaded, false);
+
+    // cache so we don't add many listeners if this is called multiple times.
+    this._cssRules = deferred.promise;
+
+    return this._cssRules;
+  },
+
+  /**
+   * Get the current state of the actor
+   *
+   * @return {object}
+   *         With properties of the underlying stylesheet, plus 'text',
+   *        'styleSheetIndex' and 'parentActor' if it's @imported
+   */
+  form: function(detail) {
+    if (detail === "actorid") {
+      return this.actorID;
+    }
+
+    let docHref;
+    let ownerNode = this.rawSheet.ownerNode;
+    if (ownerNode) {
+      if (ownerNode instanceof Ci.nsIDOMHTMLDocument) {
+        docHref = ownerNode.location.href;
+      }
+      else if (ownerNode.ownerDocument && ownerNode.ownerDocument.location) {
+        docHref = ownerNode.ownerDocument.location.href;
+      }
+    }
+
+    let form = {
+      actor: this.actorID,  // actorID is set when this actor is added to a pool
+      href: this.href,
+      nodeHref: docHref,
+      disabled: this.rawSheet.disabled,
+      title: this.rawSheet.title,
+      system: !CssLogic.isContentStylesheet(this.rawSheet),
+      styleSheetIndex: this.styleSheetIndex
+    }
+
+    try {
+      form.ruleCount = this.rawSheet.cssRules.length;
+    }
+    catch(e) {
+      // stylesheet had an @import rule that wasn't loaded yet
+      this.getCSSRules().then(() => {
+        this._notifyPropertyChanged("ruleCount");
+      });
+    }
+    return form;
+  },
+
+  /**
+   * Toggle the disabled property of the style sheet
+   *
+   * @return {object}
+   *         'disabled' - the disabled state after toggling.
+   */
+  toggleDisabled: method(function() {
+    this.rawSheet.disabled = !this.rawSheet.disabled;
+    this._notifyPropertyChanged("disabled");
+
+    return this.rawSheet.disabled;
+  }, {
+    response: { disabled: RetVal("boolean")}
+  }),
+
+  /**
+   * Send an event notifying that a property of the stylesheet
+   * has changed.
+   *
+   * @param  {string} property
+   *         Name of the changed property
+   */
+  _notifyPropertyChanged: function(property) {
+    events.emit(this, "property-change", property, this.form()[property]);
+  },
+
+  /**
+   * Protocol method to get the text of this stylesheet.
+   */
+  getText: method(function() {
+    return this._getText().then((text) => {
+      return new LongStringActor(this.conn, text || "");
+    });
+  }, {
+    response: {
+      text: RetVal("longstring")
+    }
+  }),
+
+  /**
+   * Fetch the text for this stylesheet from the cache or network. Return
+   * cached text if it's already been fetched.
+   *
+   * @return {Promise}
+   *         Promise that resolves with a string text of the stylesheet.
+   */
+  _getText: function() {
+    if (this.text) {
+      return promise.resolve(this.text);
+    }
+
+    if (!this.href) {
+      // this is an inline <style> sheet
+      let content = this.rawSheet.ownerNode.textContent;
+      this.text = content;
+      return promise.resolve(content);
+    }
+
+    let options = {
+      window: this.window,
+      charset: this._getCSSCharset()
+    };
+
+    return fetch(this.href, options).then(({ content }) => {
+      this.text = content;
+      return content;
+    });
+  },
+
+  /**
+   * Protocol method to get the original source (actors) for this
+   * stylesheet if it has uses source maps.
+   */
+  getOriginalSources: method(function() {
+    if (this._originalSources) {
+      return promise.resolve(this._originalSources);
+    }
+    return this._fetchOriginalSources();
+  }, {
+    request: {},
+    response: {
+      originalSources: RetVal("nullable:array:originalsource")
+    }
+  }),
+
+  /**
+   * Fetch the original sources (actors) for this style sheet using its
+   * source map. If they've already been fetched, returns cached array.
+   *
+   * @return {Promise}
+   *         Promise that resolves with an array of OriginalSourceActors
+   */
+  _fetchOriginalSources: function() {
+    this._clearOriginalSources();
+    this._originalSources = [];
+
+    return this.getSourceMap().then((sourceMap) => {
+      if (!sourceMap) {
+        return null;
+      }
+      for (let url of sourceMap.sources) {
+        let actor = new OriginalSourceActor(url, sourceMap, this);
+
+        this.manage(actor);
+        this._originalSources.push(actor);
+      }
+      return this._originalSources;
+    })
+  },
+
+  /**
+   * Get the SourceMapConsumer for this stylesheet's source map, if
+   * it exists. Saves the consumer for later queries.
+   *
+   * @return {Promise}
+   *         A promise that resolves with a SourceMapConsumer, or null.
+   */
+  getSourceMap: function() {
+    if (this._sourceMap) {
+      return this._sourceMap;
+    }
+    return this._fetchSourceMap();
+  },
+
+  /**
+   * Fetch the source map for this stylesheet.
+   *
+   * @return {Promise}
+   *         A promise that resolves with a SourceMapConsumer, or null.
+   */
+  _fetchSourceMap: function() {
+    let deferred = promise.defer();
+
+    this._getText().then((content) => {
+      let url = this._extractSourceMapUrl(content);
+      if (!url) {
+        // no source map for this stylesheet
+        deferred.resolve(null);
+        return;
+      };
+
+      url = normalize(url, this.href);
+
+      let map = fetch(url, { loadFromCache: false, window: this.window })
+        .then(({content}) => {
+          let map = new SourceMapConsumer(content);
+          this._setSourceMapRoot(map, url, this.href);
+          this._sourceMap = promise.resolve(map);
+
+          deferred.resolve(map);
+          return map;
+        }, deferred.reject);
+
+      this._sourceMap = map;
+    }, deferred.reject);
+
+    return deferred.promise;
+  },
+
+  /**
+   * Clear and unmanage the original source actors for this stylesheet.
+   */
+  _clearOriginalSources: function() {
+    for (actor in this._originalSources) {
+      this.unmanage(actor);
+    }
+    this._originalSources = null;
+  },
+
+  /**
+   * Sets the source map's sourceRoot to be relative to the source map url.
+   */
+  _setSourceMapRoot: function(aSourceMap, aAbsSourceMapURL, aScriptURL) {
+    const base = dirname(
+      aAbsSourceMapURL.startsWith("data:")
+        ? aScriptURL
+        : aAbsSourceMapURL);
+    aSourceMap.sourceRoot = aSourceMap.sourceRoot
+      ? normalize(aSourceMap.sourceRoot, base)
+      : base;
+  },
+
+  /**
+   * Get the source map url specified in the text of a stylesheet.
+   *
+   * @param  {string} content
+   *         The text of the style sheet.
+   * @return {string}
+   *         Url of source map.
+   */
+  _extractSourceMapUrl: function(content) {
+    var matches = /sourceMappingURL\=([^\s\*]*)/.exec(content);
+    if (matches) {
+      return matches[1];
+    }
+    return null;
+  },
+
+  /**
+   * Protocol method that gets the location in the original source of a
+   * line, column pair in this stylesheet, if its source mapped, otherwise
+   * a promise of the same location.
+   */
+  getOriginalLocation: method(function(line, column) {
+    return this.getSourceMap().then((sourceMap) => {
+      if (sourceMap) {
+        return sourceMap.originalPositionFor({ line: line, column: column });
+      }
+      return {
+        source: this.href,
+        line: line,
+        column: column
+      }
+    });
+  }, {
+    request: {
+      line: Arg(0, "number"),
+      column: Arg(1, "number")
+    },
+    response: RetVal(types.addDictType("originallocationresponse", {
+      source: "string",
+      line: "number",
+      column: "number"
+    }))
+  }),
+
+  /**
+   * Get the charset of the stylesheet according to the character set rules
+   * defined in <http://www.w3.org/TR/CSS2/syndata.html#charset>.
+   *
+   * @param string channelCharset
+   *        Charset of the source string if set by the HTTP channel.
+   */
+  _getCSSCharset: function(channelCharset)
+  {
+    // StyleSheet's charset can be specified from multiple sources
+    if (channelCharset && channelCharset.length > 0) {
+      // step 1 of syndata.html: charset given in HTTP header.
+      return channelCharset;
+    }
+
+    let sheet = this.rawSheet;
+    if (sheet) {
+      // Do we have a @charset rule in the stylesheet?
+      // step 2 of syndata.html (without the BOM check).
+      if (sheet.cssRules) {
+        let rules = sheet.cssRules;
+        if (rules.length
+            && rules.item(0).type == Ci.nsIDOMCSSRule.CHARSET_RULE) {
+          return rules.item(0).encoding;
+        }
+      }
+
+      // step 3: charset attribute of <link> or <style> element, if it exists
+      if (sheet.ownerNode && sheet.ownerNode.getAttribute) {
+        let linkCharset = sheet.ownerNode.getAttribute("charset");
+        if (linkCharset != null) {
+          return linkCharset;
+        }
+      }
+
+      // step 4 (1 of 2): charset of referring stylesheet.
+      let parentSheet = sheet.parentStyleSheet;
+      if (parentSheet && parentSheet.cssRules &&
+          parentSheet.cssRules[0].type == Ci.nsIDOMCSSRule.CHARSET_RULE) {
+        return parentSheet.cssRules[0].encoding;
+      }
+
+      // step 4 (2 of 2): charset of referring document.
+      if (sheet.ownerNode && sheet.ownerNode.ownerDocument.characterSet) {
+        return sheet.ownerNode.ownerDocument.characterSet;
+      }
+    }
+
+    // step 5: default to utf-8.
+    return "UTF-8";
+  },
+
+  /**
+   * Update the style sheet in place with new text.
+   *
+   * @param  {object} request
+   *         'text' - new text
+   *         'transition' - whether to do CSS transition for change.
+   */
+  update: method(function(text, transition) {
+    DOMUtils.parseStyleSheet(this.rawSheet, text);
+
+    this.text = text;
+
+    this._notifyPropertyChanged("ruleCount");
+
+    if (transition) {
+      this._insertTransistionRule();
+    }
+    else {
+      this._notifyStyleApplied();
+    }
+  }, {
+    request: {
+      text: Arg(0, "string"),
+      transition: Arg(1, "boolean")
+    }
+  }),
+
+  /**
+   * Insert a catch-all transition rule into the document. Set a timeout
+   * to remove the rule after a certain time.
+   */
+  _insertTransistionRule: function() {
+    // Insert the global transition rule
+    // Use a ref count to make sure we do not add it multiple times.. and remove
+    // it only when all pending StyleSheets-generated transitions ended.
+    if (this._transitionRefCount == 0) {
+      this.rawSheet.insertRule(TRANSITION_RULE, this.rawSheet.cssRules.length);
+      this.document.documentElement.classList.add(TRANSITION_CLASS);
+    }
+
+    this._transitionRefCount++;
+
+    // Set up clean up and commit after transition duration (+buffer)
+    // @see _onTransitionEnd
+    this.window.setTimeout(this._onTransitionEnd.bind(this),
+                           TRANSITION_DURATION_MS + TRANSITION_BUFFER_MS);
+  },
+
+  /**
+   * This cleans up class and rule added for transition effect and then
+   * notifies that the style has been applied.
+   */
+  _onTransitionEnd: function()
+  {
+    if (--this._transitionRefCount == 0) {
+      this.document.documentElement.classList.remove(TRANSITION_CLASS);
+      this.rawSheet.deleteRule(this.rawSheet.cssRules.length - 1);
+    }
+
+    events.emit(this, "style-applied");
+  }
+})
+
+/**
+ * StyleSheetFront is the client-side counterpart to a StyleSheetActor.
+ */
+var StyleSheetFront = protocol.FrontClass(StyleSheetActor, {
+  initialize: function(conn, form) {
+    protocol.Front.prototype.initialize.call(this, conn, form);
+
+    this._onPropertyChange = this._onPropertyChange.bind(this);
+    events.on(this, "property-change", this._onPropertyChange);
+  },
+
+  destroy: function() {
+    events.off(this, "property-change", this._onPropertyChange);
+
+    protocol.Front.prototype.destroy.call(this);
+  },
+
+  _onPropertyChange: function(property, value) {
+    this._form[property] = value;
+  },
+
+  form: function(form, detail) {
+    if (detail === "actorid") {
+      this.actorID = form;
+      return;
+    }
+    this.actorID = form.actor;
+    this._form = form;
+  },
+
+  get href() this._form.href,
+  get nodeHref() this._form.nodeHref,
+  get disabled() !!this._form.disabled,
+  get title() this._form.title,
+  get isSystem() this._form.system,
+  get styleSheetIndex() this._form.styleSheetIndex,
+  get ruleCount() this._form.ruleCount
+});
+
+/**
+ * Actor representing an original source of a style sheet that was specified
+ * in a source map.
+ */
+let OriginalSourceActor = protocol.ActorClass({
+  typeName: "originalsource",
+
+  initialize: function(aUrl, aSourceMap, aParentActor) {
+    protocol.Actor.prototype.initialize.call(this, null);
+
+    this.url = aUrl;
+    this.sourceMap = aSourceMap;
+    this.parentActor = aParentActor;
+    this.conn = this.parentActor.conn;
+
+    this.text = null;
+  },
+
+  form: function() {
+    return {
+      actor: this.actorID, // actorID is set when it's added to a pool
+      url: this.url,
+      relatedStyleSheet: this.parentActor.form()
+    };
+  },
+
+  _getText: function() {
+    if (this.text) {
+      return promise.resolve(this.text);
+    }
+    let content = this.sourceMap.sourceContentFor(this.url);
+    if (content) {
+      this.text = content;
+      return promise.resolve(content);
+    }
+    return fetch(this.url, { window: this.window }).then(({content}) => {
+      this.text = content;
+      return content;
+    });
+  },
+
+  /**
+   * Protocol method to get the text of this source.
+   */
+  getText: method(function() {
+    return this._getText().then((text) => {
+      return new LongStringActor(this.conn, text || "");
+    });
+  }, {
+    response: {
+      text: RetVal("longstring")
+    }
+  })
+})
+
+/**
+ * The client-side counterpart for an OriginalSourceActor.
+ */
+let OriginalSourceFront = protocol.FrontClass(OriginalSourceActor, {
+  initialize: function(client, form) {
+    protocol.Front.prototype.initialize.call(this, client, form);
+
+    this.isOriginalSource = true;
+  },
+
+  form: function(form, detail) {
+    if (detail === "actorid") {
+      this.actorID = form;
+      return;
+    }
+    this.actorID = form.actor;
+    this._form = form;
+  },
+
+  get href() this._form.url,
+  get url() this._form.url
+});
+
+
+XPCOMUtils.defineLazyGetter(this, "DOMUtils", function () {
+  return Cc["@mozilla.org/inspector/dom-utils;1"].getService(Ci.inIDOMUtils);
+});
+
+exports.StyleSheetsActor = StyleSheetsActor;
+exports.StyleSheetsFront = StyleSheetsFront;
+
+exports.StyleSheetActor = StyleSheetActor;
+exports.StyleSheetFront = StyleSheetFront;
+
+
+/**
+ * Performs a request to load the desired URL and returns a promise.
+ *
+ * @param aURL String
+ *        The URL we will request.
+ * @returns Promise
+ *        A promise of the document at that URL, as a string.
+ */
+function fetch(aURL, aOptions={ loadFromCache: true, window: null,
+                                charset: null}) {
+  let deferred = promise.defer();
+  let scheme;
+  let url = aURL.split(" -> ").pop();
+  let charset;
+  let contentType;
+
+  try {
+    scheme = Services.io.extractScheme(url);
+  } catch (e) {
+    // In the xpcshell tests, the script url is the absolute path of the test
+    // file, which will make a malformed URI error be thrown. Add the file
+    // scheme prefix ourselves.
+    url = "file://" + url;
+    scheme = Services.io.extractScheme(url);
+  }
+
+  switch (scheme) {
+    case "file":
+    case "chrome":
+    case "resource":
+      try {
+        NetUtil.asyncFetch(url, function onFetch(aStream, aStatus, aRequest) {
+          if (!components.isSuccessCode(aStatus)) {
+            deferred.reject(new Error("Request failed with status code = "
+                                      + aStatus
+                                      + " after NetUtil.asyncFetch for url = "
+                                      + url));
+            return;
+          }
+
+          let source = NetUtil.readInputStreamToString(aStream, aStream.available());
+          contentType = aRequest.contentType;
+          deferred.resolve(source);
+          aStream.close();
+        });
+      } catch (ex) {
+        deferred.reject(ex);
+      }
+      break;
+
+    default:
+      let channel;
+      try {
+        channel = Services.io.newChannel(url, null, null);
+      } catch (e if e.name == "NS_ERROR_UNKNOWN_PROTOCOL") {
+        // On Windows xpcshell tests, c:/foo/bar can pass as a valid URL, but
+        // newChannel won't be able to handle it.
+        url = "file:///" + url;
+        channel = Services.io.newChannel(url, null, null);
+      }
+      let chunks = [];
+      let streamListener = {
+        onStartRequest: function(aRequest, aContext, aStatusCode) {
+          if (!components.isSuccessCode(aStatusCode)) {
+            deferred.reject(new Error("Request failed with status code = "
+                                      + aStatusCode
+                                      + " in onStartRequest handler for url = "
+                                      + url));
+          }
+        },
+        onDataAvailable: function(aRequest, aContext, aStream, aOffset, aCount) {
+          chunks.push(NetUtil.readInputStreamToString(aStream, aCount));
+        },
+        onStopRequest: function(aRequest, aContext, aStatusCode) {
+          if (!components.isSuccessCode(aStatusCode)) {
+            deferred.reject(new Error("Request failed with status code = "
+                                      + aStatusCode
+                                      + " in onStopRequest handler for url = "
+                                      + url));
+            return;
+          }
+
+          charset = channel.contentCharset || charset;
+          contentType = channel.contentType;
+          deferred.resolve(chunks.join(""));
+        }
+      };
+
+      if (aOptions.window) {
+        // respect private browsing
+        channel.loadGroup = aOptions.window.QueryInterface(Ci.nsIInterfaceRequestor)
+                              .getInterface(Ci.nsIWebNavigation)
+                              .QueryInterface(Ci.nsIDocumentLoader)
+                              .loadGroup;
+      }
+      channel.loadFlags = aOptions.loadFromCache
+        ? channel.LOAD_FROM_CACHE
+        : channel.LOAD_BYPASS_CACHE;
+      channel.asyncOpen(streamListener, null);
+      break;
+  }
+
+  return deferred.promise.then(source => {
+    return {
+      content: convertToUnicode(source, charset),
+      contentType: contentType
+    };
+  });
+}
+
+/**
+ * Convert a given string, encoded in a given character set, to unicode.
+ *
+ * @param string aString
+ *        A string.
+ * @param string aCharset
+ *        A character set.
+ */
+function convertToUnicode(aString, aCharset=null) {
+  // Decoding primitives.
+  let converter = Cc["@mozilla.org/intl/scriptableunicodeconverter"]
+    .createInstance(Ci.nsIScriptableUnicodeConverter);
+  try {
+    converter.charset = aCharset || "UTF-8";
+    return converter.ConvertToUnicode(aString);
+  } catch(e) {
+    return aString;
+  }
+}
+
+/**
+ * Normalize multiple relative paths towards the base paths on the right.
+ */
+function normalize(...aURLs) {
+  let base = Services.io.newURI(aURLs.pop(), null, null);
+  let url;
+  while ((url = aURLs.pop())) {
+    base = Services.io.newURI(url, null, base);
+  }
+  return base.spec;
+}
+
+function dirname(aPath) {
+  return Services.io.newURI(
+    ".", null, Services.io.newURI(aPath, null, null)).spec;
+}