gecko/browser/devtools/profiler/controller.js

/* 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";

var isJSM = typeof require !== "function";

// This code is needed because, for whatever reason, mochitest can't
// find any requirejs module so we have to load it old school way. :(

if (isJSM) {
  var Cu = this["Components"].utils;
  let XPCOMUtils = Cu.import("resource://gre/modules/XPCOMUtils.jsm", {}).XPCOMUtils;
  this["loader"] = { lazyGetter: XPCOMUtils.defineLazyGetter.bind(XPCOMUtils) };
  this["require"] = Cu.import("resource://gre/modules/devtools/Loader.jsm", {}).devtools.require;
} else {
  var { Cu } = require("chrome");
}

const { L10N_BUNDLE } = require("devtools/profiler/consts");

var EventEmitter = require("devtools/toolkit/event-emitter");

Cu.import("resource://gre/modules/devtools/dbg-client.jsm");
Cu.import("resource://gre/modules/devtools/Console.jsm");
Cu.import("resource://gre/modules/AddonManager.jsm");
Cu.import("resource:///modules/devtools/ViewHelpers.jsm");

loader.lazyGetter(this, "L10N", () => new ViewHelpers.L10N(L10N_BUNDLE));

loader.lazyGetter(this, "gDevTools",
  () => Cu.import("resource:///modules/devtools/gDevTools.jsm", {}).gDevTools);

loader.lazyGetter(this, "DebuggerServer",
  () => Cu.import("resource:///modules/devtools/dbg-server.jsm", {}).DebuggerServer);

/**
 * Data structure that contains information that has
 * to be shared between separate ProfilerController
 * instances.
 */
const sharedData = {
  data: new WeakMap(),
  controllers: new WeakMap(),
};

/**
 * Makes a structure representing an individual profile.
 */
function makeProfile(name, def={}) {
  if (def.timeStarted == null)
    def.timeStarted = null;

  if (def.timeEnded == null)
    def.timeEnded = null;

  return {
    name: name,
    timeStarted: def.timeStarted,
    timeEnded: def.timeEnded,
    fromConsole: def.fromConsole || false
  };
}

// Three functions below all operate with sharedData
// structure defined above. They should be self-explanatory.

function addTarget(target) {
  sharedData.data.set(target, new Map());
}

function getProfiles(target) {
  return sharedData.data.get(target);
}

/**
 * Object to control the JavaScript Profiler over the remote
 * debugging protocol.
 *
 * @param Target target
 *        A target object as defined in Target.jsm
 */
function ProfilerController(target) {
  if (sharedData.controllers.has(target)) {
    return sharedData.controllers.get(target);
  }

  this.target = target;
  this.client = target.client;
  this.isConnected = false;
  this.consoleProfiles = [];
  this.reservedNames = {};

  addTarget(target);

  // Chrome debugging targets have already obtained a reference
  // to the profiler actor.
  if (target.chrome) {
    this.isConnected = true;
    this.actor = target.form.profilerActor;
  }

  sharedData.controllers.set(target, this);
  EventEmitter.decorate(this);
};

ProfilerController.prototype = {
  target:          null,
  client:          null,
  isConnected:     null,
  consoleProfiles: null,
  reservedNames:   null,

  /**
   * Return a map of profile results for the current target.
   *
   * @return Map
   */
  get profiles() {
    return getProfiles(this.target);
  },

  /**
   * Checks whether the profile is currently recording.
   *
   * @param object profile
   *        An object made by calling makeProfile function.
   * @return boolean
   */
  isProfileRecording: function PC_isProfileRecording(profile) {
    return profile.timeStarted !== null && profile.timeEnded === null;
  },

  getProfileName: function PC_getProfileName() {
    let num = 1;
    let name = L10N.getFormatStr("profiler.profileName", [num]);

    while (this.reservedNames[name]) {
      num += 1;
      name = L10N.getFormatStr("profiler.profileName", [num]);
    }

    this.reservedNames[name] = true;
    return name;
  },

  /**
   * A listener that fires whenever console.profile or console.profileEnd
   * is called.
   *
   * @param string type
   *        Type of a call. Either 'profile' or 'profileEnd'.
   * @param object data
   *        Event data.
   */
  onConsoleEvent: function (type, data) {
    let name = data.extra.name;

    let profileStart = () => {
      if (name && this.profiles.has(name))
        return;

      // Add profile structure to shared data.
      let profile = makeProfile(name || this.getProfileName(), {
        timeStarted: data.extra.currentTime,
        fromConsole: true
      });

      this.profiles.set(profile.name, profile);
      this.consoleProfiles.push(profile.name);
      this.emit("profileStart", profile);
    };

    let profileEnd = () => {
      if (!name && !this.consoleProfiles.length)
        return;

      if (!name)
        name = this.consoleProfiles.pop();
      else
        this.consoleProfiles.filter((n) => n !== name);

      if (!this.profiles.has(name))
        return;

      let profile = this.profiles.get(name);
      if (!this.isProfileRecording(profile))
        return;

      let profileData = data.extra.profile;
      profileData.threads = profileData.threads.map((thread) => {
        let samples = thread.samples.filter((sample) => {
          return sample.time >= profile.timeStarted;
        });

        return { samples: samples };
      });

      profile.timeEnded = data.extra.currentTime;
      profile.data = profileData;

      this.emit("profileEnd", profile);
    };

    if (type === "profile")
      profileStart();

    if (type === "profileEnd")
      profileEnd();
  },

  /**
   * Connects to the client unless we're already connected.
   *
   * @param function cb
   *        Function to be called once we're connected. If
   *        the controller is already connected, this function
   *        will be called immediately (synchronously).
   */
  connect: function (cb=function(){}) {
    if (this.isConnected) {
      return void cb();
    }

    // Check if we already have a grip to the listTabs response object
    // and, if we do, use it to get to the profilerActor. Otherwise,
    // call listTabs. The problem is that if we call listTabs twice
    // webconsole tests fail (see bug 872826).

    let register = () => {
      let data = { events: ["console-api-profiler"] };

      // Check if Gecko Profiler Addon [1] is installed and, if it is,
      // don't register our own console event listeners. Gecko Profiler
      // Addon takes care of console.profile and console.profileEnd methods
      // and we don't want to break it.
      //
      // [1] - https://github.com/bgirard/Gecko-Profiler-Addon/

      AddonManager.getAddonByID("jid0-edalmuivkozlouyij0lpdx548bc@jetpack", (addon) => {
        if (addon && !addon.userDisabled && !addon.softDisabled)
          return void cb();

        this.request("registerEventNotifications", data, (resp) => {
          this.client.addListener("eventNotification", (type, resp) => {
            let toolbox = gDevTools.getToolbox(this.target);
            if (toolbox == null)
              return;

            this.onConsoleEvent(resp.subject.action, resp.data);
          });
        });

        cb();
      });
    };

    if (this.target.root) {
      this.actor = this.target.root.profilerActor;
      this.isConnected = true;
      return void register();
    }

    this.client.listTabs((resp) => {
      this.actor = resp.profilerActor;
      this.isConnected = true;
      register();
    });
  },

  /**
   * Adds actor and type information to data and sends the request over
   * the remote debugging protocol.
   *
   * @param string type
   *        Method to call on the other side
   * @param object data
   *        Data to send with the request
   * @param function cb
   *        A callback function
   */
  request: function (type, data, cb) {
    data.to = this.actor;
    data.type = type;
    this.client.request(data, cb);
  },

  /**
   * Checks whether the profiler is active.
   *
   * @param function cb
   *        Function to be called with a response from the
   *        client. It will be called with two arguments:
   *        an error object (may be null) and a boolean
   *        value indicating if the profiler is active or not.
   */
  isActive: function (cb) {
    this.request("isActive", {}, (resp) => {
      cb(resp.error, resp.isActive, resp.currentTime);
    });
  },

  /**
   * Creates a new profile and starts the profiler, if needed.
   *
   * @param string name
   *        Name of the profile.
   * @param function cb
   *        Function to be called once the profiler is started
   *        or we get an error. It will be called with a single
   *        argument: an error object (may be null).
   */
  start: function PC_start(name, cb) {
    if (this.profiles.has(name)) {
      return;
    }

    let profile = makeProfile(name);
    this.consoleProfiles.push(name);
    this.profiles.set(name, profile);

    // If profile is already running, no need to do anything.
    if (this.isProfileRecording(profile)) {
      return void cb();
    }

    this.isActive((err, isActive, currentTime) => {
      if (isActive) {
        profile.timeStarted = currentTime;
        return void cb();
      }

      let params = {
        entries: 1000000,
        interval: 1,
        features: ["js"],
      };

      this.request("startProfiler", params, (resp) => {
        if (resp.error) {
          return void cb(resp.error);
        }

        profile.timeStarted = 0;
        cb();
      });
    });
  },

  /**
   * Stops the profiler. NOTE, that we don't stop the actual
   * SPS Profiler here. It will be stopped as soon as all
   * clients disconnect from the profiler actor.
   *
   * @param string name
   *        Name of the profile that needs to be stopped.
   * @param function cb
   *        Function to be called once the profiler is stopped
   *        or we get an error. It will be called with a single
   *        argument: an error object (may be null).
   */
  stop: function PC_stop(name, cb) {
    if (!this.profiles.has(name)) {
      return;
    }

    let profile = this.profiles.get(name);
    if (!this.isProfileRecording(profile)) {
      return;
    }

    this.request("getProfile", {}, (resp) => {
      if (resp.error) {
        Cu.reportError("Failed to fetch profile data.");
        return void cb(resp.error, null);
      }

      let data = resp.profile;
      profile.timeEnded = resp.currentTime;

      // Filter out all samples that fall out of current
      // profile's range.

      data.threads = data.threads.map((thread) => {
        let samples = thread.samples.filter((sample) => {
          return sample.time >= profile.timeStarted;
        });

        return { samples: samples };
      });

      cb(null, data);
    });
  },

  /**
   * Cleanup.
   */
  destroy: function PC_destroy() {
    this.client = null;
    this.target = null;
    this.actor = null;
  }
};

if (isJSM) {
  var EXPORTED_SYMBOLS = ["ProfilerController"];
} else {
  module.exports = ProfilerController;
}