The Tor Browser: comparison toolkit/devtools/server/actors/call-watcher.js

comparison: toolkit/devtools/server/actors/call-watcher.js

toolkit/devtools/server/actors/call-watcher.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:2a2c224c1e63
+/* 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";
+const {Cc, Ci, Cu, Cr} = require("chrome");
+const events = require("sdk/event/core");
+const {Promise: promise} = Cu.import("resource://gre/modules/Promise.jsm", {});
+const protocol = require("devtools/server/protocol");
+const {ContentObserver} = require("devtools/content-observer");
+const {on, once, off, emit} = events;
+const {method, Arg, Option, RetVal} = protocol;
+exports.register = function(handle) {
+handle.addTabActor(CallWatcherActor, "callWatcherActor");
+};
+exports.unregister = function(handle) {
+handle.removeTabActor(CallWatcherActor);
+};
+/**
+* Type describing a single function call in a stack trace.
+*/
+protocol.types.addDictType("call-stack-item", {
+name: "string",
+file: "string",
+line: "number"
+});
+/**
+* Type describing an overview of a function call.
+*/
+protocol.types.addDictType("call-details", {
+type: "number",
+name: "string",
+stack: "array:call-stack-item"
+});
+/**
+* This actor contains information about a function call, like the function
+* type, name, stack, arguments, returned value etc.
+*/
+let FunctionCallActor = protocol.ActorClass({
+typeName: "function-call",
+/**
+* Creates the function call actor.
+*
+* @param DebuggerServerConnection conn
+*        The server connection.
+* @param DOMWindow window
+*        The content window.
+* @param string global
+*        The name of the global object owning this function, like
+*        "CanvasRenderingContext2D" or "WebGLRenderingContext".
+* @param object caller
+*        The object owning the function when it was called.
+*        For example, in `foo.bar()`, the caller is `foo`.
+* @param number type
+*        Either METHOD_FUNCTION, METHOD_GETTER or METHOD_SETTER.
+* @param string name
+*        The called function's name.
+* @param array stack
+*        The called function's stack, as a list of { name, file, line } objects.
+* @param array args
+*        The called function's arguments.
+* @param any result
+*        The value returned by the function call.
+*/
+initialize: function(conn, [window, global, caller, type, name, stack, args, result]) {
+protocol.Actor.prototype.initialize.call(this, conn);
+this.details = {
+window: window,
+caller: caller,
+type: type,
+name: name,
+stack: stack,
+args: args,
+result: result
+};
+this.meta = {
+global: -1,
+previews: { caller: "", args: "" }
+};
+if (global == "WebGLRenderingContext") {
+this.meta.global = CallWatcherFront.CANVAS_WEBGL_CONTEXT;
+} else if (global == "CanvasRenderingContext2D") {
+this.meta.global = CallWatcherFront.CANVAS_2D_CONTEXT;
+} else if (global == "window") {
+this.meta.global = CallWatcherFront.UNKNOWN_SCOPE;
+} else {
+this.meta.global = CallWatcherFront.GLOBAL_SCOPE;
+}
+this.meta.previews.caller = this._generateCallerPreview();
+this.meta.previews.args = this._generateArgsPreview();
+},
+/**
+* Customize the marshalling of this actor to provide some generic information
+* directly on the Front instance.
+*/
+form: function() {
+return {
+actor: this.actorID,
+type: this.details.type,
+name: this.details.name,
+file: this.details.stack[0].file,
+line: this.details.stack[0].line,
+callerPreview: this.meta.previews.caller,
+argsPreview: this.meta.previews.args
+};
+},
+/**
+* Gets more information about this function call, which is not necessarily
+* available on the Front instance.
+*/
+getDetails: method(function() {
+let { type, name, stack } = this.details;
+// Since not all calls on the stack have corresponding owner files (e.g.
+// callbacks of a requestAnimationFrame etc.), there's no benefit in
+// returning them, as the user can't jump to the Debugger from them.
+for (let i = stack.length - 1;;) {
+if (stack[i].file) {
+break;
+}
+stack.pop();
+i--;
+}
+// XXX: Use grips for objects and serialize them properly, in order
+// to add the function's caller, arguments and return value. Bug 978957.
+return {
+type: type,
+name: name,
+stack: stack
+};
+}, {
+response: { info: RetVal("call-details") }
+}),
+/**
+* Serializes the caller's name so that it can be easily be transferred
+* as a string, but still be useful when displayed in a potential UI.
+*
+* @return string
+*         The caller's name as a string.
+*/
+_generateCallerPreview: function() {
+let global = this.meta.global;
+if (global == CallWatcherFront.CANVAS_WEBGL_CONTEXT) {
+return "gl";
+}
+if (global == CallWatcherFront.CANVAS_2D_CONTEXT) {
+return "ctx";
+}
+return "";
+},
+/**
+* Serializes the arguments so that they can be easily be transferred
+* as a string, but still be useful when displayed in a potential UI.
+*
+* @return string
+*         The arguments as a string.
+*/
+_generateArgsPreview: function() {
+let { caller, args } = this.details;
+let { global } = this.meta;
+// XXX: All of this sucks. Make this smarter, so that the frontend
+// can inspect each argument, be it object or primitive. Bug 978960.
+let serializeArgs = () => args.map(arg => {
+if (typeof arg == "undefined") {
+return "undefined";
+}
+if (typeof arg == "function") {
+return "Function";
+}
+if (typeof arg == "object") {
+return "Object";
+}
+if (global == CallWatcherFront.CANVAS_WEBGL_CONTEXT) {
+// XXX: This doesn't handle combined bitmasks. Bug 978964.
+return getEnumsLookupTable("webgl", caller)[arg] || arg;
+}
+if (global == CallWatcherFront.CANVAS_2D_CONTEXT) {
+return getEnumsLookupTable("2d", caller)[arg] || arg;
+}
+return arg;
+});
+return serializeArgs().join(", ");
+}
+});
+/**
+* The corresponding Front object for the FunctionCallActor.
+*/
+let FunctionCallFront = protocol.FrontClass(FunctionCallActor, {
+initialize: function(client, form) {
+protocol.Front.prototype.initialize.call(this, client, form);
+},
+/**
+* Adds some generic information directly to this instance,
+* to avoid extra roundtrips.
+*/
+form: function(form) {
+this.actorID = form.actor;
+this.type = form.type;
+this.name = form.name;
+this.file = form.file;
+this.line = form.line;
+this.callerPreview = form.callerPreview;
+this.argsPreview = form.argsPreview;
+}
+});
+/**
+* This actor observes function calls on certain objects or globals.
+*/
+let CallWatcherActor = exports.CallWatcherActor = protocol.ActorClass({
+typeName: "call-watcher",
+initialize: function(conn, tabActor) {
+protocol.Actor.prototype.initialize.call(this, conn);
+this.tabActor = tabActor;
+this._onGlobalCreated = this._onGlobalCreated.bind(this);
+this._onGlobalDestroyed = this._onGlobalDestroyed.bind(this);
+this._onContentFunctionCall = this._onContentFunctionCall.bind(this);
+},
+destroy: function(conn) {
+protocol.Actor.prototype.destroy.call(this, conn);
+this.finalize();
+},
+/**
+* Starts waiting for the current tab actor's document global to be
+* created, in order to instrument the specified objects and become
+* aware of everything the content does with them.
+*/
+setup: method(function({ tracedGlobals, tracedFunctions, startRecording, performReload }) {
+if (this._initialized) {
+return;
+}
+this._initialized = true;
+this._functionCalls = [];
+this._tracedGlobals = tracedGlobals || [];
+this._tracedFunctions = tracedFunctions || [];
+this._contentObserver = new ContentObserver(this.tabActor);
+on(this._contentObserver, "global-created", this._onGlobalCreated);
+on(this._contentObserver, "global-destroyed", this._onGlobalDestroyed);
+if (startRecording) {
+this.resumeRecording();
+}
+if (performReload) {
+this.tabActor.window.location.reload();
+}
+}, {
+request: {
+tracedGlobals: Option(0, "nullable:array:string"),
+tracedFunctions: Option(0, "nullable:array:string"),
+startRecording: Option(0, "boolean"),
+performReload: Option(0, "boolean")
+},
+oneway: true
+}),
+/**
+* Stops listening for document global changes and puts this actor
+* to hibernation. This method is called automatically just before the
+* actor is destroyed.
+*/
+finalize: method(function() {
+if (!this._initialized) {
+return;
+}
+this._initialized = false;
+this._contentObserver.stopListening();
+off(this._contentObserver, "global-created", this._onGlobalCreated);
+off(this._contentObserver, "global-destroyed", this._onGlobalDestroyed);
+this._tracedGlobals = null;
+this._tracedFunctions = null;
+this._contentObserver = null;
+}, {
+oneway: true
+}),
+/**
+* Returns whether the instrumented function calls are currently recorded.
+*/
+isRecording: method(function() {
+return this._recording;
+}, {
+response: RetVal("boolean")
+}),
+/**
+* Starts recording function calls.
+*/
+resumeRecording: method(function() {
+this._recording = true;
+}),
+/**
+* Stops recording function calls.
+*/
+pauseRecording: method(function() {
+this._recording = false;
+return this._functionCalls;
+}, {
+response: { calls: RetVal("array:function-call") }
+}),
+/**
+* Erases all the recorded function calls.
+* Calling `resumeRecording` or `pauseRecording` does not erase history.
+*/
+eraseRecording: method(function() {
+this._functionCalls = [];
+}),
+/**
+* Lightweight listener invoked whenever an instrumented function is called
+* while recording. We're doing this to avoid the event emitter overhead,
+* since this is expected to be a very hot function.
+*/
+onCall: function() {},
+/**
+* Invoked whenever the current tab actor's document global is created.
+*/
+_onGlobalCreated: function(window) {
+let self = this;
+this._tracedWindowId = ContentObserver.GetInnerWindowID(window);
+let unwrappedWindow = XPCNativeWrapper.unwrap(window);
+let callback = this._onContentFunctionCall;
+for (let global of this._tracedGlobals) {
+let prototype = unwrappedWindow[global].prototype;
+let properties = Object.keys(prototype);
+properties.forEach(name => overrideSymbol(global, prototype, name, callback));
+}
+for (let name of this._tracedFunctions) {
+overrideSymbol("window", unwrappedWindow, name, callback);
+}
+/**
+* Instruments a method, getter or setter on the specified target object to
+* invoke a callback whenever it is called.
+*/
+function overrideSymbol(global, target, name, callback) {
+let propertyDescriptor = Object.getOwnPropertyDescriptor(target, name);
+if (propertyDescriptor.get || propertyDescriptor.set) {
+overrideAccessor(global, target, name, propertyDescriptor, callback);
+return;
+}
+if (propertyDescriptor.writable && typeof propertyDescriptor.value == "function") {
+overrideFunction(global, target, name, propertyDescriptor, callback);
+return;
+}
+}
+/**
+* Instruments a function on the specified target object.
+*/
+function overrideFunction(global, target, name, descriptor, callback) {
+let originalFunc = target[name];
+Object.defineProperty(target, name, {
+value: function(...args) {
+let result = originalFunc.apply(this, args);
+if (self._recording) {
+let stack = getStack(name);
+let type = CallWatcherFront.METHOD_FUNCTION;
+callback(unwrappedWindow, global, this, type, name, stack, args, result);
+}
+return result;
+},
+configurable: descriptor.configurable,
+enumerable: descriptor.enumerable,
+writable: true
+});
+}
+/**
+* Instruments a getter or setter on the specified target object.
+*/
+function overrideAccessor(global, target, name, descriptor, callback) {
+let originalGetter = target.__lookupGetter__(name);
+let originalSetter = target.__lookupSetter__(name);
+Object.defineProperty(target, name, {
+get: function(...args) {
+if (!originalGetter) return undefined;
+let result = originalGetter.apply(this, args);
+if (self._recording) {
+let stack = getStack(name);
+let type = CallWatcherFront.GETTER_FUNCTION;
+callback(unwrappedWindow, global, this, type, name, stack, args, result);
+}
+return result;
+},
+set: function(...args) {
+if (!originalSetter) return;
+originalSetter.apply(this, args);
+if (self._recording) {
+let stack = getStack(name);
+let type = CallWatcherFront.SETTER_FUNCTION;
+callback(unwrappedWindow, global, this, type, name, stack, args, undefined);
+}
+},
+configurable: descriptor.configurable,
+enumerable: descriptor.enumerable
+});
+}
+/**
+* Stores the relevant information about calls on the stack when
+* a function is called.
+*/
+function getStack(caller) {
+try {
+// Using Components.stack wouldn't be a better idea, since it's
+// much slower because it attempts to retrieve the C++ stack as well.
+throw new Error();
+} catch (e) {
+var stack = e.stack;
+}
+// Of course, using a simple regex like /(.*?)@(.*):(\d*):\d*/ would be
+// much prettier, but this is a very hot function, so let's sqeeze
+// every drop of performance out of it.
+let calls = [];
+let callIndex = 0;
+let currNewLinePivot = stack.indexOf("\n") + 1;
+let nextNewLinePivot = stack.indexOf("\n", currNewLinePivot);
+while (nextNewLinePivot > 0) {
+let nameDelimiterIndex = stack.indexOf("@", currNewLinePivot);
+let columnDelimiterIndex = stack.lastIndexOf(":", nextNewLinePivot - 1);
+let lineDelimiterIndex = stack.lastIndexOf(":", columnDelimiterIndex - 1);
+if (!calls[callIndex]) {
+calls[callIndex] = { name: "", file: "", line: 0 };
+}
+if (!calls[callIndex + 1]) {
+calls[callIndex + 1] = { name: "", file: "", line: 0 };
+}
+if (callIndex > 0) {
+let file = stack.substring(nameDelimiterIndex + 1, lineDelimiterIndex);
+let line = stack.substring(lineDelimiterIndex + 1, columnDelimiterIndex);
+let name = stack.substring(currNewLinePivot, nameDelimiterIndex);
+calls[callIndex].name = name;
+calls[callIndex - 1].file = file;
+calls[callIndex - 1].line = line;
+} else {
+// Since the topmost stack frame is actually our overwritten function,
+// it will not have the expected name.
+calls[0].name = caller;
+}
+currNewLinePivot = nextNewLinePivot + 1;
+nextNewLinePivot = stack.indexOf("\n", currNewLinePivot);
+callIndex++;
+}
+return calls;
+}
+},
+/**
+* Invoked whenever the current tab actor's inner window is destroyed.
+*/
+_onGlobalDestroyed: function(id) {
+if (this._tracedWindowId == id) {
+this.pauseRecording();
+this.eraseRecording();
+}
+},
+/**
+* Invoked whenever an instrumented function is called.
+*/
+_onContentFunctionCall: function(...details) {
+let functionCall = new FunctionCallActor(this.conn, details);
+this._functionCalls.push(functionCall);
+this.onCall(functionCall);
+}
+});
+/**
+* The corresponding Front object for the CallWatcherActor.
+*/
+let CallWatcherFront = exports.CallWatcherFront = protocol.FrontClass(CallWatcherActor, {
+initialize: function(client, { callWatcherActor }) {
+protocol.Front.prototype.initialize.call(this, client, { actor: callWatcherActor });
+client.addActorPool(this);
+this.manage(this);
+}
+});
+/**
+* Constants.
+*/
+CallWatcherFront.METHOD_FUNCTION = 0;
+CallWatcherFront.GETTER_FUNCTION = 1;
+CallWatcherFront.SETTER_FUNCTION = 2;
+CallWatcherFront.GLOBAL_SCOPE = 0;
+CallWatcherFront.UNKNOWN_SCOPE = 1;
+CallWatcherFront.CANVAS_WEBGL_CONTEXT = 2;
+CallWatcherFront.CANVAS_2D_CONTEXT = 3;
+/**
+* A lookup table for cross-referencing flags or properties with their name
+* assuming they look LIKE_THIS most of the time.
+*
+* For example, when gl.clear(gl.COLOR_BUFFER_BIT) is called, the actual passed
+* argument's value is 16384, which we want identified as "COLOR_BUFFER_BIT".
+*/
+var gEnumRegex = /^[A-Z_]+$/;
+var gEnumsLookupTable = {};
+function getEnumsLookupTable(type, object) {
+let cachedEnum = gEnumsLookupTable[type];
+if (cachedEnum) {
+return cachedEnum;
+}
+let table = gEnumsLookupTable[type] = {};
+for (let key in object) {
+if (key.match(gEnumRegex)) {
+table[object[key]] = key;
+}
+}
+return table;
+}