mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
1771 lines
47 KiB
JavaScript
1771 lines
47 KiB
JavaScript
/* -*- js2-basic-offset: 2; indent-tabs-mode: nil; -*- */
|
||
/* vim: set ft=javascript ts=2 et sw=2 tw=80: */
|
||
/* 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, components} = require("chrome");
|
||
|
||
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
||
|
||
loader.lazyImporter(this, "Services", "resource://gre/modules/Services.jsm");
|
||
loader.lazyImporter(this, "LayoutHelpers", "resource://gre/modules/devtools/LayoutHelpers.jsm");
|
||
|
||
// TODO: Bug 842672 - toolkit/ imports modules from browser/.
|
||
// Note that these are only used in JSTermHelpers, see $0 and pprint().
|
||
loader.lazyImporter(this, "gDevTools", "resource:///modules/devtools/gDevTools.jsm");
|
||
loader.lazyImporter(this, "devtools", "resource://gre/modules/devtools/Loader.jsm");
|
||
loader.lazyImporter(this, "VariablesView", "resource:///modules/devtools/VariablesView.jsm");
|
||
loader.lazyImporter(this, "DevToolsUtils", "resource://gre/modules/devtools/DevToolsUtils.jsm");
|
||
|
||
// Match the function name from the result of toString() or toSource().
|
||
//
|
||
// Examples:
|
||
// (function foobar(a, b) { ...
|
||
// function foobar2(a) { ...
|
||
// function() { ...
|
||
const REGEX_MATCH_FUNCTION_NAME = /^\(?function\s+([^(\s]+)\s*\(/;
|
||
|
||
// Match the function arguments from the result of toString() or toSource().
|
||
const REGEX_MATCH_FUNCTION_ARGS = /^\(?function\s*[^\s(]*\s*\((.+?)\)/;
|
||
|
||
let WebConsoleUtils = {
|
||
/**
|
||
* Convenience function to unwrap a wrapped object.
|
||
*
|
||
* @param aObject the object to unwrap.
|
||
* @return aObject unwrapped.
|
||
*/
|
||
unwrap: function WCU_unwrap(aObject)
|
||
{
|
||
try {
|
||
return XPCNativeWrapper.unwrap(aObject);
|
||
}
|
||
catch (ex) {
|
||
return aObject;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Wrap a string in an nsISupportsString object.
|
||
*
|
||
* @param string aString
|
||
* @return nsISupportsString
|
||
*/
|
||
supportsString: function WCU_supportsString(aString)
|
||
{
|
||
let str = Cc["@mozilla.org/supports-string;1"].
|
||
createInstance(Ci.nsISupportsString);
|
||
str.data = aString;
|
||
return str;
|
||
},
|
||
|
||
/**
|
||
* Clone an object.
|
||
*
|
||
* @param object aObject
|
||
* The object you want cloned.
|
||
* @param boolean aRecursive
|
||
* Tells if you want to dig deeper into the object, to clone
|
||
* recursively.
|
||
* @param function [aFilter]
|
||
* Optional, filter function, called for every property. Three
|
||
* arguments are passed: key, value and object. Return true if the
|
||
* property should be added to the cloned object. Return false to skip
|
||
* the property.
|
||
* @return object
|
||
* The cloned object.
|
||
*/
|
||
cloneObject: function WCU_cloneObject(aObject, aRecursive, aFilter)
|
||
{
|
||
if (typeof aObject != "object") {
|
||
return aObject;
|
||
}
|
||
|
||
let temp;
|
||
|
||
if (Array.isArray(aObject)) {
|
||
temp = [];
|
||
Array.forEach(aObject, function(aValue, aIndex) {
|
||
if (!aFilter || aFilter(aIndex, aValue, aObject)) {
|
||
temp.push(aRecursive ? WCU_cloneObject(aValue) : aValue);
|
||
}
|
||
});
|
||
}
|
||
else {
|
||
temp = {};
|
||
for (let key in aObject) {
|
||
let value = aObject[key];
|
||
if (aObject.hasOwnProperty(key) &&
|
||
(!aFilter || aFilter(key, value, aObject))) {
|
||
temp[key] = aRecursive ? WCU_cloneObject(value) : value;
|
||
}
|
||
}
|
||
}
|
||
|
||
return temp;
|
||
},
|
||
|
||
/**
|
||
* Copies certain style attributes from one element to another.
|
||
*
|
||
* @param nsIDOMNode aFrom
|
||
* The target node.
|
||
* @param nsIDOMNode aTo
|
||
* The destination node.
|
||
*/
|
||
copyTextStyles: function WCU_copyTextStyles(aFrom, aTo)
|
||
{
|
||
let win = aFrom.ownerDocument.defaultView;
|
||
let style = win.getComputedStyle(aFrom);
|
||
aTo.style.fontFamily = style.getPropertyCSSValue("font-family").cssText;
|
||
aTo.style.fontSize = style.getPropertyCSSValue("font-size").cssText;
|
||
aTo.style.fontWeight = style.getPropertyCSSValue("font-weight").cssText;
|
||
aTo.style.fontStyle = style.getPropertyCSSValue("font-style").cssText;
|
||
},
|
||
|
||
/**
|
||
* Gets the ID of the inner window of this DOM window.
|
||
*
|
||
* @param nsIDOMWindow aWindow
|
||
* @return integer
|
||
* Inner ID for the given aWindow.
|
||
*/
|
||
getInnerWindowId: function WCU_getInnerWindowId(aWindow)
|
||
{
|
||
return aWindow.QueryInterface(Ci.nsIInterfaceRequestor).
|
||
getInterface(Ci.nsIDOMWindowUtils).currentInnerWindowID;
|
||
},
|
||
|
||
/**
|
||
* Recursively gather a list of inner window ids given a
|
||
* top level window.
|
||
*
|
||
* @param nsIDOMWindow aWindow
|
||
* @return Array
|
||
* list of inner window ids.
|
||
*/
|
||
getInnerWindowIDsForFrames: function WCU_getInnerWindowIDsForFrames(aWindow)
|
||
{
|
||
let innerWindowID = this.getInnerWindowId(aWindow);
|
||
let ids = [innerWindowID];
|
||
|
||
if (aWindow.frames) {
|
||
for (let i = 0; i < aWindow.frames.length; i++) {
|
||
let frame = aWindow.frames[i];
|
||
ids = ids.concat(this.getInnerWindowIDsForFrames(frame));
|
||
}
|
||
}
|
||
|
||
return ids;
|
||
},
|
||
|
||
|
||
/**
|
||
* Gets the ID of the outer window of this DOM window.
|
||
*
|
||
* @param nsIDOMWindow aWindow
|
||
* @return integer
|
||
* Outer ID for the given aWindow.
|
||
*/
|
||
getOuterWindowId: function WCU_getOuterWindowId(aWindow)
|
||
{
|
||
return aWindow.QueryInterface(Ci.nsIInterfaceRequestor).
|
||
getInterface(Ci.nsIDOMWindowUtils).outerWindowID;
|
||
},
|
||
|
||
/**
|
||
* Abbreviates the given source URL so that it can be displayed flush-right
|
||
* without being too distracting.
|
||
*
|
||
* @param string aSourceURL
|
||
* The source URL to shorten.
|
||
* @param object [aOptions]
|
||
* Options:
|
||
* - onlyCropQuery: boolean that tells if the URL abbreviation function
|
||
* should only remove the query parameters and the hash fragment from
|
||
* the given URL.
|
||
* @return string
|
||
* The abbreviated form of the source URL.
|
||
*/
|
||
abbreviateSourceURL:
|
||
function WCU_abbreviateSourceURL(aSourceURL, aOptions = {})
|
||
{
|
||
if (!aOptions.onlyCropQuery && aSourceURL.substr(0, 5) == "data:") {
|
||
let commaIndex = aSourceURL.indexOf(",");
|
||
if (commaIndex > -1) {
|
||
aSourceURL = "data:" + aSourceURL.substring(commaIndex + 1);
|
||
}
|
||
}
|
||
|
||
// Remove any query parameters.
|
||
let hookIndex = aSourceURL.indexOf("?");
|
||
if (hookIndex > -1) {
|
||
aSourceURL = aSourceURL.substring(0, hookIndex);
|
||
}
|
||
|
||
// Remove any hash fragments.
|
||
let hashIndex = aSourceURL.indexOf("#");
|
||
if (hashIndex > -1) {
|
||
aSourceURL = aSourceURL.substring(0, hashIndex);
|
||
}
|
||
|
||
// Remove a trailing "/".
|
||
if (aSourceURL[aSourceURL.length - 1] == "/") {
|
||
aSourceURL = aSourceURL.replace(/\/+$/, "");
|
||
}
|
||
|
||
// Remove all but the last path component.
|
||
if (!aOptions.onlyCropQuery) {
|
||
let slashIndex = aSourceURL.lastIndexOf("/");
|
||
if (slashIndex > -1) {
|
||
aSourceURL = aSourceURL.substring(slashIndex + 1);
|
||
}
|
||
}
|
||
|
||
return aSourceURL;
|
||
},
|
||
|
||
/**
|
||
* Tells if the given function is native or not.
|
||
*
|
||
* @param function aFunction
|
||
* The function you want to check if it is native or not.
|
||
* @return boolean
|
||
* True if the given function is native, false otherwise.
|
||
*/
|
||
isNativeFunction: function WCU_isNativeFunction(aFunction)
|
||
{
|
||
return typeof aFunction == "function" && !("prototype" in aFunction);
|
||
},
|
||
|
||
/**
|
||
* Tells if the given property of the provided object is a non-native getter or
|
||
* not.
|
||
*
|
||
* @param object aObject
|
||
* The object that contains the property.
|
||
* @param string aProp
|
||
* The property you want to check if it is a getter or not.
|
||
* @return boolean
|
||
* True if the given property is a getter, false otherwise.
|
||
*/
|
||
isNonNativeGetter: function WCU_isNonNativeGetter(aObject, aProp)
|
||
{
|
||
if (typeof aObject != "object") {
|
||
return false;
|
||
}
|
||
let desc = this.getPropertyDescriptor(aObject, aProp);
|
||
return desc && desc.get && !this.isNativeFunction(desc.get);
|
||
},
|
||
|
||
/**
|
||
* Get the property descriptor for the given object.
|
||
*
|
||
* @param object aObject
|
||
* The object that contains the property.
|
||
* @param string aProp
|
||
* The property you want to get the descriptor for.
|
||
* @return object
|
||
* Property descriptor.
|
||
*/
|
||
getPropertyDescriptor: function WCU_getPropertyDescriptor(aObject, aProp)
|
||
{
|
||
let desc = null;
|
||
while (aObject) {
|
||
try {
|
||
if ((desc = Object.getOwnPropertyDescriptor(aObject, aProp))) {
|
||
break;
|
||
}
|
||
}
|
||
catch (ex if (ex.name == "NS_ERROR_XPC_BAD_CONVERT_JS" ||
|
||
ex.name == "NS_ERROR_XPC_BAD_OP_ON_WN_PROTO" ||
|
||
ex.name == "TypeError")) {
|
||
// Native getters throw here. See bug 520882.
|
||
// null throws TypeError.
|
||
}
|
||
try {
|
||
aObject = Object.getPrototypeOf(aObject);
|
||
}
|
||
catch (ex if (ex.name == "TypeError")) {
|
||
return desc;
|
||
}
|
||
}
|
||
return desc;
|
||
},
|
||
|
||
/**
|
||
* Sort function for object properties.
|
||
*
|
||
* @param object a
|
||
* Property descriptor.
|
||
* @param object b
|
||
* Property descriptor.
|
||
* @return integer
|
||
* -1 if a.name < b.name,
|
||
* 1 if a.name > b.name,
|
||
* 0 otherwise.
|
||
*/
|
||
propertiesSort: function WCU_propertiesSort(a, b)
|
||
{
|
||
// Convert the pair.name to a number for later sorting.
|
||
let aNumber = parseFloat(a.name);
|
||
let bNumber = parseFloat(b.name);
|
||
|
||
// Sort numbers.
|
||
if (!isNaN(aNumber) && isNaN(bNumber)) {
|
||
return -1;
|
||
}
|
||
else if (isNaN(aNumber) && !isNaN(bNumber)) {
|
||
return 1;
|
||
}
|
||
else if (!isNaN(aNumber) && !isNaN(bNumber)) {
|
||
return aNumber - bNumber;
|
||
}
|
||
// Sort string.
|
||
else if (a.name < b.name) {
|
||
return -1;
|
||
}
|
||
else if (a.name > b.name) {
|
||
return 1;
|
||
}
|
||
else {
|
||
return 0;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Create a grip for the given value. If the value is an object,
|
||
* an object wrapper will be created.
|
||
*
|
||
* @param mixed aValue
|
||
* The value you want to create a grip for, before sending it to the
|
||
* client.
|
||
* @param function aObjectWrapper
|
||
* If the value is an object then the aObjectWrapper function is
|
||
* invoked to give us an object grip. See this.getObjectGrip().
|
||
* @return mixed
|
||
* The value grip.
|
||
*/
|
||
createValueGrip: function WCU_createValueGrip(aValue, aObjectWrapper)
|
||
{
|
||
switch (typeof aValue) {
|
||
case "boolean":
|
||
return aValue;
|
||
case "string":
|
||
return aObjectWrapper(aValue);
|
||
case "number":
|
||
if (aValue === Infinity) {
|
||
return { type: "Infinity" };
|
||
}
|
||
else if (aValue === -Infinity) {
|
||
return { type: "-Infinity" };
|
||
}
|
||
else if (Number.isNaN(aValue)) {
|
||
return { type: "NaN" };
|
||
}
|
||
else if (!aValue && 1 / aValue === -Infinity) {
|
||
return { type: "-0" };
|
||
}
|
||
return aValue;
|
||
case "undefined":
|
||
return { type: "undefined" };
|
||
case "object":
|
||
if (aValue === null) {
|
||
return { type: "null" };
|
||
}
|
||
case "function":
|
||
return aObjectWrapper(aValue);
|
||
default:
|
||
Cu.reportError("Failed to provide a grip for value of " + typeof aValue
|
||
+ ": " + aValue);
|
||
return null;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Check if the given object is an iterator or a generator.
|
||
*
|
||
* @param object aObject
|
||
* The object you want to check.
|
||
* @return boolean
|
||
* True if the given object is an iterator or a generator, otherwise
|
||
* false is returned.
|
||
*/
|
||
isIteratorOrGenerator: function WCU_isIteratorOrGenerator(aObject)
|
||
{
|
||
if (aObject === null) {
|
||
return false;
|
||
}
|
||
|
||
if (typeof aObject == "object") {
|
||
if (typeof aObject.__iterator__ == "function" ||
|
||
aObject.constructor && aObject.constructor.name == "Iterator") {
|
||
return true;
|
||
}
|
||
|
||
try {
|
||
let str = aObject.toString();
|
||
if (typeof aObject.next == "function" &&
|
||
str.indexOf("[object Generator") == 0) {
|
||
return true;
|
||
}
|
||
}
|
||
catch (ex) {
|
||
// window.history.next throws in the typeof check above.
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
},
|
||
|
||
/**
|
||
* Determine if the given request mixes HTTP with HTTPS content.
|
||
*
|
||
* @param string aRequest
|
||
* Location of the requested content.
|
||
* @param string aLocation
|
||
* Location of the current page.
|
||
* @return boolean
|
||
* True if the content is mixed, false if not.
|
||
*/
|
||
isMixedHTTPSRequest: function WCU_isMixedHTTPSRequest(aRequest, aLocation)
|
||
{
|
||
try {
|
||
let requestURI = Services.io.newURI(aRequest, null, null);
|
||
let contentURI = Services.io.newURI(aLocation, null, null);
|
||
return (contentURI.scheme == "https" && requestURI.scheme != "https");
|
||
}
|
||
catch (ex) {
|
||
return false;
|
||
}
|
||
},
|
||
|
||
/**
|
||
* Helper function to deduce the name of the provided function.
|
||
*
|
||
* @param funtion aFunction
|
||
* The function whose name will be returned.
|
||
* @return string
|
||
* Function name.
|
||
*/
|
||
getFunctionName: function WCF_getFunctionName(aFunction)
|
||
{
|
||
let name = null;
|
||
if (aFunction.name) {
|
||
name = aFunction.name;
|
||
}
|
||
else {
|
||
let desc;
|
||
try {
|
||
desc = aFunction.getOwnPropertyDescriptor("displayName");
|
||
}
|
||
catch (ex) { }
|
||
if (desc && typeof desc.value == "string") {
|
||
name = desc.value;
|
||
}
|
||
}
|
||
if (!name) {
|
||
try {
|
||
let str = (aFunction.toString() || aFunction.toSource()) + "";
|
||
name = (str.match(REGEX_MATCH_FUNCTION_NAME) || [])[1];
|
||
}
|
||
catch (ex) { }
|
||
}
|
||
return name;
|
||
},
|
||
|
||
/**
|
||
* Get the object class name. For example, the |window| object has the Window
|
||
* class name (based on [object Window]).
|
||
*
|
||
* @param object aObject
|
||
* The object you want to get the class name for.
|
||
* @return string
|
||
* The object class name.
|
||
*/
|
||
getObjectClassName: function WCU_getObjectClassName(aObject)
|
||
{
|
||
if (aObject === null) {
|
||
return "null";
|
||
}
|
||
if (aObject === undefined) {
|
||
return "undefined";
|
||
}
|
||
|
||
let type = typeof aObject;
|
||
if (type != "object") {
|
||
// Grip class names should start with an uppercase letter.
|
||
return type.charAt(0).toUpperCase() + type.substr(1);
|
||
}
|
||
|
||
let className;
|
||
|
||
try {
|
||
className = ((aObject + "").match(/^\[object (\S+)\]$/) || [])[1];
|
||
if (!className) {
|
||
className = ((aObject.constructor + "").match(/^\[object (\S+)\]$/) || [])[1];
|
||
}
|
||
if (!className && typeof aObject.constructor == "function") {
|
||
className = this.getFunctionName(aObject.constructor);
|
||
}
|
||
}
|
||
catch (ex) { }
|
||
|
||
return className;
|
||
},
|
||
|
||
/**
|
||
* Check if the given value is a grip with an actor.
|
||
*
|
||
* @param mixed aGrip
|
||
* Value you want to check if it is a grip with an actor.
|
||
* @return boolean
|
||
* True if the given value is a grip with an actor.
|
||
*/
|
||
isActorGrip: function WCU_isActorGrip(aGrip)
|
||
{
|
||
return aGrip && typeof(aGrip) == "object" && aGrip.actor;
|
||
},
|
||
};
|
||
exports.Utils = WebConsoleUtils;
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
// Localization
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
WebConsoleUtils.l10n = function WCU_l10n(aBundleURI)
|
||
{
|
||
this._bundleUri = aBundleURI;
|
||
};
|
||
|
||
WebConsoleUtils.l10n.prototype = {
|
||
_stringBundle: null,
|
||
|
||
get stringBundle()
|
||
{
|
||
if (!this._stringBundle) {
|
||
this._stringBundle = Services.strings.createBundle(this._bundleUri);
|
||
}
|
||
return this._stringBundle;
|
||
},
|
||
|
||
/**
|
||
* Generates a formatted timestamp string for displaying in console messages.
|
||
*
|
||
* @param integer [aMilliseconds]
|
||
* Optional, allows you to specify the timestamp in milliseconds since
|
||
* the UNIX epoch.
|
||
* @return string
|
||
* The timestamp formatted for display.
|
||
*/
|
||
timestampString: function WCU_l10n_timestampString(aMilliseconds)
|
||
{
|
||
let d = new Date(aMilliseconds ? aMilliseconds : null);
|
||
let hours = d.getHours(), minutes = d.getMinutes();
|
||
let seconds = d.getSeconds(), milliseconds = d.getMilliseconds();
|
||
let parameters = [hours, minutes, seconds, milliseconds];
|
||
return this.getFormatStr("timestampFormat", parameters);
|
||
},
|
||
|
||
/**
|
||
* Retrieve a localized string.
|
||
*
|
||
* @param string aName
|
||
* The string name you want from the Web Console string bundle.
|
||
* @return string
|
||
* The localized string.
|
||
*/
|
||
getStr: function WCU_l10n_getStr(aName)
|
||
{
|
||
let result;
|
||
try {
|
||
result = this.stringBundle.GetStringFromName(aName);
|
||
}
|
||
catch (ex) {
|
||
Cu.reportError("Failed to get string: " + aName);
|
||
throw ex;
|
||
}
|
||
return result;
|
||
},
|
||
|
||
/**
|
||
* Retrieve a localized string formatted with values coming from the given
|
||
* array.
|
||
*
|
||
* @param string aName
|
||
* The string name you want from the Web Console string bundle.
|
||
* @param array aArray
|
||
* The array of values you want in the formatted string.
|
||
* @return string
|
||
* The formatted local string.
|
||
*/
|
||
getFormatStr: function WCU_l10n_getFormatStr(aName, aArray)
|
||
{
|
||
let result;
|
||
try {
|
||
result = this.stringBundle.formatStringFromName(aName, aArray, aArray.length);
|
||
}
|
||
catch (ex) {
|
||
Cu.reportError("Failed to format string: " + aName);
|
||
throw ex;
|
||
}
|
||
return result;
|
||
},
|
||
};
|
||
|
||
|
||
//////////////////////////////////////////////////////////////////////////
|
||
// JS Completer
|
||
//////////////////////////////////////////////////////////////////////////
|
||
|
||
(function _JSPP(WCU) {
|
||
const STATE_NORMAL = 0;
|
||
const STATE_QUOTE = 2;
|
||
const STATE_DQUOTE = 3;
|
||
|
||
const OPEN_BODY = "{[(".split("");
|
||
const CLOSE_BODY = "}])".split("");
|
||
const OPEN_CLOSE_BODY = {
|
||
"{": "}",
|
||
"[": "]",
|
||
"(": ")",
|
||
};
|
||
|
||
const MAX_COMPLETIONS = 1500;
|
||
|
||
/**
|
||
* Analyses a given string to find the last statement that is interesting for
|
||
* later completion.
|
||
*
|
||
* @param string aStr
|
||
* A string to analyse.
|
||
*
|
||
* @returns object
|
||
* If there was an error in the string detected, then a object like
|
||
*
|
||
* { err: "ErrorMesssage" }
|
||
*
|
||
* is returned, otherwise a object like
|
||
*
|
||
* {
|
||
* state: STATE_NORMAL|STATE_QUOTE|STATE_DQUOTE,
|
||
* startPos: index of where the last statement begins
|
||
* }
|
||
*/
|
||
function findCompletionBeginning(aStr)
|
||
{
|
||
let bodyStack = [];
|
||
|
||
let state = STATE_NORMAL;
|
||
let start = 0;
|
||
let c;
|
||
for (let i = 0; i < aStr.length; i++) {
|
||
c = aStr[i];
|
||
|
||
switch (state) {
|
||
// Normal JS state.
|
||
case STATE_NORMAL:
|
||
if (c == '"') {
|
||
state = STATE_DQUOTE;
|
||
}
|
||
else if (c == "'") {
|
||
state = STATE_QUOTE;
|
||
}
|
||
else if (c == ";") {
|
||
start = i + 1;
|
||
}
|
||
else if (c == " ") {
|
||
start = i + 1;
|
||
}
|
||
else if (OPEN_BODY.indexOf(c) != -1) {
|
||
bodyStack.push({
|
||
token: c,
|
||
start: start
|
||
});
|
||
start = i + 1;
|
||
}
|
||
else if (CLOSE_BODY.indexOf(c) != -1) {
|
||
var last = bodyStack.pop();
|
||
if (!last || OPEN_CLOSE_BODY[last.token] != c) {
|
||
return {
|
||
err: "syntax error"
|
||
};
|
||
}
|
||
if (c == "}") {
|
||
start = i + 1;
|
||
}
|
||
else {
|
||
start = last.start;
|
||
}
|
||
}
|
||
break;
|
||
|
||
// Double quote state > " <
|
||
case STATE_DQUOTE:
|
||
if (c == "\\") {
|
||
i++;
|
||
}
|
||
else if (c == "\n") {
|
||
return {
|
||
err: "unterminated string literal"
|
||
};
|
||
}
|
||
else if (c == '"') {
|
||
state = STATE_NORMAL;
|
||
}
|
||
break;
|
||
|
||
// Single quote state > ' <
|
||
case STATE_QUOTE:
|
||
if (c == "\\") {
|
||
i++;
|
||
}
|
||
else if (c == "\n") {
|
||
return {
|
||
err: "unterminated string literal"
|
||
};
|
||
}
|
||
else if (c == "'") {
|
||
state = STATE_NORMAL;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return {
|
||
state: state,
|
||
startPos: start
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Provides a list of properties, that are possible matches based on the passed
|
||
* Debugger.Environment/Debugger.Object and inputValue.
|
||
*
|
||
* @param object aDbgObject
|
||
* When the debugger is not paused this Debugger.Object wraps the scope for autocompletion.
|
||
* It is null if the debugger is paused.
|
||
* @param object anEnvironment
|
||
* When the debugger is paused this Debugger.Environment is the scope for autocompletion.
|
||
* It is null if the debugger is not paused.
|
||
* @param string aInputValue
|
||
* Value that should be completed.
|
||
* @param number [aCursor=aInputValue.length]
|
||
* Optional offset in the input where the cursor is located. If this is
|
||
* omitted then the cursor is assumed to be at the end of the input
|
||
* value.
|
||
* @returns null or object
|
||
* If no completion valued could be computed, null is returned,
|
||
* otherwise a object with the following form is returned:
|
||
* {
|
||
* matches: [ string, string, string ],
|
||
* matchProp: Last part of the inputValue that was used to find
|
||
* the matches-strings.
|
||
* }
|
||
*/
|
||
function JSPropertyProvider(aDbgObject, anEnvironment, aInputValue, aCursor)
|
||
{
|
||
if (aCursor === undefined) {
|
||
aCursor = aInputValue.length;
|
||
}
|
||
|
||
let inputValue = aInputValue.substring(0, aCursor);
|
||
|
||
// Analyse the inputValue and find the beginning of the last part that
|
||
// should be completed.
|
||
let beginning = findCompletionBeginning(inputValue);
|
||
|
||
// There was an error analysing the string.
|
||
if (beginning.err) {
|
||
return null;
|
||
}
|
||
|
||
// If the current state is not STATE_NORMAL, then we are inside of an string
|
||
// which means that no completion is possible.
|
||
if (beginning.state != STATE_NORMAL) {
|
||
return null;
|
||
}
|
||
|
||
let completionPart = inputValue.substring(beginning.startPos);
|
||
|
||
// Don't complete on just an empty string.
|
||
if (completionPart.trim() == "") {
|
||
return null;
|
||
}
|
||
|
||
let lastDot = completionPart.lastIndexOf(".");
|
||
if (lastDot > 0 &&
|
||
(completionPart[0] == "'" || completionPart[0] == '"') &&
|
||
completionPart[lastDot - 1] == completionPart[0]) {
|
||
// We are completing a string literal.
|
||
let matchProp = completionPart.slice(lastDot + 1);
|
||
return getMatchedProps(String.prototype, matchProp);
|
||
}
|
||
|
||
// We are completing a variable / a property lookup.
|
||
let properties = completionPart.split(".");
|
||
let matchProp = properties.pop().trimLeft();
|
||
let obj = aDbgObject;
|
||
|
||
// The first property must be found in the environment if the debugger is
|
||
// paused.
|
||
if (anEnvironment) {
|
||
if (properties.length == 0) {
|
||
return getMatchedPropsInEnvironment(anEnvironment, matchProp);
|
||
}
|
||
obj = getVariableInEnvironment(anEnvironment, properties.shift());
|
||
}
|
||
|
||
if (!isObjectUsable(obj)) {
|
||
return null;
|
||
}
|
||
|
||
// We get the rest of the properties recursively starting from the Debugger.Object
|
||
// that wraps the first property
|
||
for (let prop of properties) {
|
||
prop = prop.trim();
|
||
if (!prop) {
|
||
return null;
|
||
}
|
||
|
||
if (/\[\d+\]$/.test(prop))Â {
|
||
// The property to autocomplete is a member of array. For example
|
||
// list[i][j]..[n]. Traverse the array to get the actual element.
|
||
obj = getArrayMemberProperty(obj, prop);
|
||
}
|
||
else {
|
||
obj = DevToolsUtils.getProperty(obj, prop);
|
||
}
|
||
|
||
if (!isObjectUsable(obj)) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
// If the final property is a primitive
|
||
if (typeof obj != "object") {
|
||
return getMatchedProps(obj, matchProp);
|
||
}
|
||
|
||
return getMatchedPropsInDbgObject(obj, matchProp);
|
||
}
|
||
|
||
/**
|
||
* Get the array member of aObj for the given aProp. For example, given
|
||
* aProp='list[0][1]' the element at [0][1] of aObj.list is returned.
|
||
*
|
||
* @param object aObj
|
||
* The object to operate on.
|
||
* @param string aProp
|
||
* The property to return.
|
||
* @return null or Object
|
||
* Returns null if the property couldn't be located. Otherwise the array
|
||
* member identified by aProp.
|
||
*/
|
||
function getArrayMemberProperty(aObj, aProp)
|
||
{
|
||
// First get the array.
|
||
let obj = aObj;
|
||
let propWithoutIndices = aProp.substr(0, aProp.indexOf("["));
|
||
obj = DevToolsUtils.getProperty(obj, propWithoutIndices);
|
||
if (!isObjectUsable(obj)) {
|
||
return null;
|
||
}
|
||
|
||
// Then traverse the list of indices to get the actual element.
|
||
let result;
|
||
let arrayIndicesRegex = /\[[^\]]*\]/g;
|
||
while ((result = arrayIndicesRegex.exec(aProp)) !== null) {
|
||
let indexWithBrackets = result[0];
|
||
let indexAsText = indexWithBrackets.substr(1, indexWithBrackets.length - 2);
|
||
let index = parseInt(indexAsText);
|
||
|
||
if (isNaN(index)) {
|
||
return null;
|
||
}
|
||
|
||
obj = DevToolsUtils.getProperty(obj, index);
|
||
|
||
if (!isObjectUsable(obj)) {
|
||
return null;
|
||
}
|
||
}
|
||
|
||
return obj;
|
||
}
|
||
|
||
/**
|
||
* Check if the given Debugger.Object can be used for autocomplete.
|
||
*
|
||
* @param Debugger.Object aObject
|
||
* The Debugger.Object to check.
|
||
* @return boolean
|
||
* True if further inspection into the object is possible, or false
|
||
* otherwise.
|
||
*/
|
||
function isObjectUsable(aObject)
|
||
{
|
||
if (aObject == null) {
|
||
return false;
|
||
}
|
||
|
||
if (typeof aObject == "object" && aObject.class == "DeadObject") {
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* @see getExactMatch_impl()
|
||
*/
|
||
function getVariableInEnvironment(anEnvironment, aName)
|
||
{
|
||
return getExactMatch_impl(anEnvironment, aName, DebuggerEnvironmentSupport);
|
||
}
|
||
|
||
/**
|
||
* @see getMatchedProps_impl()
|
||
*/
|
||
function getMatchedPropsInEnvironment(anEnvironment, aMatch)
|
||
{
|
||
return getMatchedProps_impl(anEnvironment, aMatch, DebuggerEnvironmentSupport);
|
||
}
|
||
|
||
/**
|
||
* @see getMatchedProps_impl()
|
||
*/
|
||
function getMatchedPropsInDbgObject(aDbgObject, aMatch)
|
||
{
|
||
return getMatchedProps_impl(aDbgObject, aMatch, DebuggerObjectSupport);
|
||
}
|
||
|
||
/**
|
||
* @see getMatchedProps_impl()
|
||
*/
|
||
function getMatchedProps(aObj, aMatch)
|
||
{
|
||
if (typeof aObj != "object") {
|
||
aObj = aObj.constructor.prototype;
|
||
}
|
||
return getMatchedProps_impl(aObj, aMatch, JSObjectSupport);
|
||
}
|
||
|
||
/**
|
||
* Get all properties in the given object (and its parent prototype chain) that
|
||
* match a given prefix.
|
||
*
|
||
* @param mixed aObj
|
||
* Object whose properties we want to filter.
|
||
* @param string aMatch
|
||
* Filter for properties that match this string.
|
||
* @return object
|
||
* Object that contains the matchProp and the list of names.
|
||
*/
|
||
function getMatchedProps_impl(aObj, aMatch, {chainIterator, getProperties})
|
||
{
|
||
let matches = new Set();
|
||
|
||
// We need to go up the prototype chain.
|
||
let iter = chainIterator(aObj);
|
||
for (let obj of iter) {
|
||
let props = getProperties(obj);
|
||
for (let prop of props) {
|
||
if (prop.indexOf(aMatch) != 0) {
|
||
continue;
|
||
}
|
||
|
||
// If it is an array index, we can't take it.
|
||
// This uses a trick: converting a string to a number yields NaN if
|
||
// the operation failed, and NaN is not equal to itself.
|
||
if (+prop != +prop) {
|
||
matches.add(prop);
|
||
}
|
||
|
||
if (matches.size > MAX_COMPLETIONS) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (matches.size > MAX_COMPLETIONS) {
|
||
break;
|
||
}
|
||
}
|
||
|
||
return {
|
||
matchProp: aMatch,
|
||
matches: [...matches],
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Returns a property value based on its name from the given object, by
|
||
* recursively checking the object's prototype.
|
||
*
|
||
* @param object aObj
|
||
* An object to look the property into.
|
||
* @param string aName
|
||
* The property that is looked up.
|
||
* @returns object|undefined
|
||
* A Debugger.Object if the property exists in the object's prototype
|
||
* chain, undefined otherwise.
|
||
*/
|
||
function getExactMatch_impl(aObj, aName, {chainIterator, getProperty})
|
||
{
|
||
// We need to go up the prototype chain.
|
||
let iter = chainIterator(aObj);
|
||
for (let obj of iter) {
|
||
let prop = getProperty(obj, aName, aObj);
|
||
if (prop) {
|
||
return prop.value;
|
||
}
|
||
}
|
||
return undefined;
|
||
}
|
||
|
||
|
||
let JSObjectSupport = {
|
||
chainIterator: function(aObj)
|
||
{
|
||
while (aObj) {
|
||
yield aObj;
|
||
aObj = Object.getPrototypeOf(aObj);
|
||
}
|
||
},
|
||
|
||
getProperties: function(aObj)
|
||
{
|
||
return Object.getOwnPropertyNames(aObj);
|
||
},
|
||
|
||
getProperty: function()
|
||
{
|
||
// getProperty is unsafe with raw JS objects.
|
||
throw "Unimplemented!";
|
||
},
|
||
};
|
||
|
||
let DebuggerObjectSupport = {
|
||
chainIterator: function(aObj)
|
||
{
|
||
while (aObj) {
|
||
yield aObj;
|
||
aObj = aObj.proto;
|
||
}
|
||
},
|
||
|
||
getProperties: function(aObj)
|
||
{
|
||
return aObj.getOwnPropertyNames();
|
||
},
|
||
|
||
getProperty: function(aObj, aName, aRootObj)
|
||
{
|
||
// This is left unimplemented in favor to DevToolsUtils.getProperty().
|
||
throw "Unimplemented!";
|
||
},
|
||
};
|
||
|
||
let DebuggerEnvironmentSupport = {
|
||
chainIterator: function(aObj)
|
||
{
|
||
while (aObj) {
|
||
yield aObj;
|
||
aObj = aObj.parent;
|
||
}
|
||
},
|
||
|
||
getProperties: function(aObj)
|
||
{
|
||
return aObj.names();
|
||
},
|
||
|
||
getProperty: function(aObj, aName)
|
||
{
|
||
// TODO: we should use getVariableDescriptor() here - bug 725815.
|
||
let result = undefined;
|
||
try {
|
||
result = aObj.getVariable(aName);
|
||
} catch (ex) {
|
||
// getVariable() throws for invalid identifiers.
|
||
}
|
||
return result === undefined ? null : { value: result };
|
||
},
|
||
};
|
||
|
||
|
||
exports.JSPropertyProvider = JSPropertyProvider;
|
||
})(WebConsoleUtils);
|
||
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
// The page errors listener
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
|
||
/**
|
||
* The nsIConsoleService listener. This is used to send all of the console
|
||
* messages (JavaScript, CSS and more) to the remote Web Console instance.
|
||
*
|
||
* @constructor
|
||
* @param nsIDOMWindow [aWindow]
|
||
* Optional - the window object for which we are created. This is used
|
||
* for filtering out messages that belong to other windows.
|
||
* @param object aListener
|
||
* The listener object must have one method:
|
||
* - onConsoleServiceMessage(). This method is invoked with one argument,
|
||
* the nsIConsoleMessage, whenever a relevant message is received.
|
||
*/
|
||
function ConsoleServiceListener(aWindow, aListener)
|
||
{
|
||
this.window = aWindow;
|
||
this.listener = aListener;
|
||
if (this.window) {
|
||
this.layoutHelpers = new LayoutHelpers(this.window);
|
||
}
|
||
}
|
||
exports.ConsoleServiceListener = ConsoleServiceListener;
|
||
|
||
ConsoleServiceListener.prototype =
|
||
{
|
||
QueryInterface: XPCOMUtils.generateQI([Ci.nsIConsoleListener]),
|
||
|
||
/**
|
||
* The content window for which we listen to page errors.
|
||
* @type nsIDOMWindow
|
||
*/
|
||
window: null,
|
||
|
||
/**
|
||
* The listener object which is notified of messages from the console service.
|
||
* @type object
|
||
*/
|
||
listener: null,
|
||
|
||
/**
|
||
* Initialize the nsIConsoleService listener.
|
||
*/
|
||
init: function CSL_init()
|
||
{
|
||
Services.console.registerListener(this);
|
||
},
|
||
|
||
/**
|
||
* The nsIConsoleService observer. This method takes all the script error
|
||
* messages belonging to the current window and sends them to the remote Web
|
||
* Console instance.
|
||
*
|
||
* @param nsIConsoleMessage aMessage
|
||
* The message object coming from the nsIConsoleService.
|
||
*/
|
||
observe: function CSL_observe(aMessage)
|
||
{
|
||
if (!this.listener) {
|
||
return;
|
||
}
|
||
|
||
if (this.window) {
|
||
if (!(aMessage instanceof Ci.nsIScriptError) ||
|
||
!aMessage.outerWindowID ||
|
||
!this.isCategoryAllowed(aMessage.category)) {
|
||
return;
|
||
}
|
||
|
||
let errorWindow = Services.wm.getOuterWindowWithId(aMessage.outerWindowID);
|
||
if (!errorWindow || !this.layoutHelpers.isIncludedInTopLevelWindow(errorWindow)) {
|
||
return;
|
||
}
|
||
}
|
||
|
||
this.listener.onConsoleServiceMessage(aMessage);
|
||
},
|
||
|
||
/**
|
||
* Check if the given message category is allowed to be tracked or not.
|
||
* We ignore chrome-originating errors as we only care about content.
|
||
*
|
||
* @param string aCategory
|
||
* The message category you want to check.
|
||
* @return boolean
|
||
* True if the category is allowed to be logged, false otherwise.
|
||
*/
|
||
isCategoryAllowed: function CSL_isCategoryAllowed(aCategory)
|
||
{
|
||
if (!aCategory) {
|
||
return false;
|
||
}
|
||
|
||
switch (aCategory) {
|
||
case "XPConnect JavaScript":
|
||
case "component javascript":
|
||
case "chrome javascript":
|
||
case "chrome registration":
|
||
case "XBL":
|
||
case "XBL Prototype Handler":
|
||
case "XBL Content Sink":
|
||
case "xbl javascript":
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
},
|
||
|
||
/**
|
||
* Get the cached page errors for the current inner window and its (i)frames.
|
||
*
|
||
* @param boolean [aIncludePrivate=false]
|
||
* Tells if you want to also retrieve messages coming from private
|
||
* windows. Defaults to false.
|
||
* @return array
|
||
* The array of cached messages. Each element is an nsIScriptError or
|
||
* an nsIConsoleMessage
|
||
*/
|
||
getCachedMessages: function CSL_getCachedMessages(aIncludePrivate = false)
|
||
{
|
||
let errors = Services.console.getMessageArray() || [];
|
||
|
||
// if !this.window, we're in a browser console. Still need to filter
|
||
// private messages.
|
||
if (!this.window) {
|
||
return errors.filter((aError) => {
|
||
if (aError instanceof Ci.nsIScriptError) {
|
||
if (!aIncludePrivate && aError.isFromPrivateWindow) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
});
|
||
}
|
||
|
||
let ids = WebConsoleUtils.getInnerWindowIDsForFrames(this.window);
|
||
|
||
return errors.filter((aError) => {
|
||
if (aError instanceof Ci.nsIScriptError) {
|
||
if (!aIncludePrivate && aError.isFromPrivateWindow) {
|
||
return false;
|
||
}
|
||
if (ids &&
|
||
(ids.indexOf(aError.innerWindowID) == -1 ||
|
||
!this.isCategoryAllowed(aError.category))) {
|
||
return false;
|
||
}
|
||
}
|
||
else if (ids && ids[0]) {
|
||
// If this is not an nsIScriptError and we need to do window-based
|
||
// filtering we skip this message.
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
});
|
||
},
|
||
|
||
/**
|
||
* Remove the nsIConsoleService listener.
|
||
*/
|
||
destroy: function CSL_destroy()
|
||
{
|
||
Services.console.unregisterListener(this);
|
||
this.listener = this.window = null;
|
||
},
|
||
};
|
||
|
||
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
// The window.console API observer
|
||
///////////////////////////////////////////////////////////////////////////////
|
||
|
||
/**
|
||
* The window.console API observer. This allows the window.console API messages
|
||
* to be sent to the remote Web Console instance.
|
||
*
|
||
* @constructor
|
||
* @param nsIDOMWindow aWindow
|
||
* Optional - the window object for which we are created. This is used
|
||
* for filtering out messages that belong to other windows.
|
||
* @param object aOwner
|
||
* The owner object must have the following methods:
|
||
* - onConsoleAPICall(). This method is invoked with one argument, the
|
||
* Console API message that comes from the observer service, whenever
|
||
* a relevant console API call is received.
|
||
*/
|
||
function ConsoleAPIListener(aWindow, aOwner)
|
||
{
|
||
this.window = aWindow;
|
||
this.owner = aOwner;
|
||
if (this.window) {
|
||
this.layoutHelpers = new LayoutHelpers(this.window);
|
||
}
|
||
}
|
||
exports.ConsoleAPIListener = ConsoleAPIListener;
|
||
|
||
ConsoleAPIListener.prototype =
|
||
{
|
||
QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver]),
|
||
|
||
/**
|
||
* The content window for which we listen to window.console API calls.
|
||
* @type nsIDOMWindow
|
||
*/
|
||
window: null,
|
||
|
||
/**
|
||
* The owner object which is notified of window.console API calls. It must
|
||
* have a onConsoleAPICall method which is invoked with one argument: the
|
||
* console API call object that comes from the observer service.
|
||
*
|
||
* @type object
|
||
* @see WebConsoleActor
|
||
*/
|
||
owner: null,
|
||
|
||
/**
|
||
* Initialize the window.console API observer.
|
||
*/
|
||
init: function CAL_init()
|
||
{
|
||
// Note that the observer is process-wide. We will filter the messages as
|
||
// needed, see CAL_observe().
|
||
Services.obs.addObserver(this, "console-api-log-event", false);
|
||
},
|
||
|
||
/**
|
||
* The console API message observer. When messages are received from the
|
||
* observer service we forward them to the remote Web Console instance.
|
||
*
|
||
* @param object aMessage
|
||
* The message object receives from the observer service.
|
||
* @param string aTopic
|
||
* The message topic received from the observer service.
|
||
*/
|
||
observe: function CAL_observe(aMessage, aTopic)
|
||
{
|
||
if (!this.owner) {
|
||
return;
|
||
}
|
||
|
||
let apiMessage = aMessage.wrappedJSObject;
|
||
if (this.window) {
|
||
let msgWindow = Services.wm.getOuterWindowWithId(apiMessage.ID);
|
||
if (!msgWindow || !this.layoutHelpers.isIncludedInTopLevelWindow(msgWindow)) {
|
||
// Not the same window!
|
||
return;
|
||
}
|
||
}
|
||
|
||
this.owner.onConsoleAPICall(apiMessage);
|
||
},
|
||
|
||
/**
|
||
* Get the cached messages for the current inner window and its (i)frames.
|
||
*
|
||
* @param boolean [aIncludePrivate=false]
|
||
* Tells if you want to also retrieve messages coming from private
|
||
* windows. Defaults to false.
|
||
* @return array
|
||
* The array of cached messages.
|
||
*/
|
||
getCachedMessages: function CAL_getCachedMessages(aIncludePrivate = false)
|
||
{
|
||
let messages = [];
|
||
let ConsoleAPIStorage = Cc["@mozilla.org/consoleAPI-storage;1"]
|
||
.getService(Ci.nsIConsoleAPIStorage);
|
||
|
||
// if !this.window, we're in a browser console. Retrieve all events
|
||
// for filtering based on privacy.
|
||
if (!this.window) {
|
||
messages = ConsoleAPIStorage.getEvents();
|
||
} else {
|
||
let ids = WebConsoleUtils.getInnerWindowIDsForFrames(this.window);
|
||
ids.forEach((id) => {
|
||
messages = messages.concat(ConsoleAPIStorage.getEvents(id));
|
||
});
|
||
}
|
||
|
||
if (aIncludePrivate) {
|
||
return messages;
|
||
}
|
||
|
||
return messages.filter((m) => !m.private);
|
||
},
|
||
|
||
/**
|
||
* Destroy the console API listener.
|
||
*/
|
||
destroy: function CAL_destroy()
|
||
{
|
||
Services.obs.removeObserver(this, "console-api-log-event");
|
||
this.window = this.owner = null;
|
||
},
|
||
};
|
||
|
||
|
||
|
||
/**
|
||
* JSTerm helper functions.
|
||
*
|
||
* Defines a set of functions ("helper functions") that are available from the
|
||
* Web Console but not from the web page.
|
||
*
|
||
* A list of helper functions used by Firebug can be found here:
|
||
* http://getfirebug.com/wiki/index.php/Command_Line_API
|
||
*
|
||
* @param object aOwner
|
||
* The owning object.
|
||
*/
|
||
function JSTermHelpers(aOwner)
|
||
{
|
||
/**
|
||
* Find a node by ID.
|
||
*
|
||
* @param string aId
|
||
* The ID of the element you want.
|
||
* @return nsIDOMNode or null
|
||
* The result of calling document.querySelector(aSelector).
|
||
*/
|
||
aOwner.sandbox.$ = function JSTH_$(aSelector)
|
||
{
|
||
return aOwner.window.document.querySelector(aSelector);
|
||
};
|
||
|
||
/**
|
||
* Find the nodes matching a CSS selector.
|
||
*
|
||
* @param string aSelector
|
||
* A string that is passed to window.document.querySelectorAll.
|
||
* @return nsIDOMNodeList
|
||
* Returns the result of document.querySelectorAll(aSelector).
|
||
*/
|
||
aOwner.sandbox.$$ = function JSTH_$$(aSelector)
|
||
{
|
||
return aOwner.window.document.querySelectorAll(aSelector);
|
||
};
|
||
|
||
/**
|
||
* Runs an xPath query and returns all matched nodes.
|
||
*
|
||
* @param string aXPath
|
||
* xPath search query to execute.
|
||
* @param [optional] nsIDOMNode aContext
|
||
* Context to run the xPath query on. Uses window.document if not set.
|
||
* @return array of nsIDOMNode
|
||
*/
|
||
aOwner.sandbox.$x = function JSTH_$x(aXPath, aContext)
|
||
{
|
||
let nodes = new aOwner.window.wrappedJSObject.Array();
|
||
let doc = aOwner.window.document;
|
||
aContext = aContext || doc;
|
||
|
||
let results = doc.evaluate(aXPath, aContext, null,
|
||
Ci.nsIDOMXPathResult.ANY_TYPE, null);
|
||
let node;
|
||
while ((node = results.iterateNext())) {
|
||
nodes.push(node);
|
||
}
|
||
|
||
return nodes;
|
||
};
|
||
|
||
/**
|
||
* Returns the currently selected object in the highlighter.
|
||
*
|
||
* TODO: this implementation crosses the client/server boundaries! This is not
|
||
* usable within a remote browser. To implement this feature correctly we need
|
||
* support for remote inspection capabilities within the Inspector as well.
|
||
* See bug 787975.
|
||
*
|
||
* @return nsIDOMElement|null
|
||
* The DOM element currently selected in the highlighter.
|
||
*/
|
||
Object.defineProperty(aOwner.sandbox, "$0", {
|
||
get: function() {
|
||
let window = aOwner.chromeWindow();
|
||
if (!window) {
|
||
return null;
|
||
}
|
||
|
||
let target = null;
|
||
try {
|
||
target = devtools.TargetFactory.forTab(window.gBrowser.selectedTab);
|
||
}
|
||
catch (ex) {
|
||
// If we report this exception the user will get it in the Browser
|
||
// Console every time when she evaluates any string.
|
||
}
|
||
|
||
if (!target) {
|
||
return null;
|
||
}
|
||
|
||
let toolbox = gDevTools.getToolbox(target);
|
||
let node = toolbox && toolbox.selection ? toolbox.selection.node : null;
|
||
|
||
return node ? aOwner.makeDebuggeeValue(node) : null;
|
||
},
|
||
enumerable: true,
|
||
configurable: false
|
||
});
|
||
|
||
/**
|
||
* Clears the output of the JSTerm.
|
||
*/
|
||
aOwner.sandbox.clear = function JSTH_clear()
|
||
{
|
||
aOwner.helperResult = {
|
||
type: "clearOutput",
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Returns the result of Object.keys(aObject).
|
||
*
|
||
* @param object aObject
|
||
* Object to return the property names from.
|
||
* @return array of strings
|
||
*/
|
||
aOwner.sandbox.keys = function JSTH_keys(aObject)
|
||
{
|
||
return aOwner.window.wrappedJSObject.Object.keys(WebConsoleUtils.unwrap(aObject));
|
||
};
|
||
|
||
/**
|
||
* Returns the values of all properties on aObject.
|
||
*
|
||
* @param object aObject
|
||
* Object to display the values from.
|
||
* @return array of string
|
||
*/
|
||
aOwner.sandbox.values = function JSTH_values(aObject)
|
||
{
|
||
let arrValues = new aOwner.window.wrappedJSObject.Array();
|
||
let obj = WebConsoleUtils.unwrap(aObject);
|
||
|
||
for (let prop in obj) {
|
||
arrValues.push(obj[prop]);
|
||
}
|
||
|
||
return arrValues;
|
||
};
|
||
|
||
/**
|
||
* Opens a help window in MDN.
|
||
*/
|
||
aOwner.sandbox.help = function JSTH_help()
|
||
{
|
||
aOwner.helperResult = { type: "help" };
|
||
};
|
||
|
||
/**
|
||
* Change the JS evaluation scope.
|
||
*
|
||
* @param DOMElement|string|window aWindow
|
||
* The window object to use for eval scope. This can be a string that
|
||
* is used to perform document.querySelector(), to find the iframe that
|
||
* you want to cd() to. A DOMElement can be given as well, the
|
||
* .contentWindow property is used. Lastly, you can directly pass
|
||
* a window object. If you call cd() with no arguments, the current
|
||
* eval scope is cleared back to its default (the top window).
|
||
*/
|
||
aOwner.sandbox.cd = function JSTH_cd(aWindow)
|
||
{
|
||
if (!aWindow) {
|
||
aOwner.consoleActor.evalWindow = null;
|
||
aOwner.helperResult = { type: "cd" };
|
||
return;
|
||
}
|
||
|
||
if (typeof aWindow == "string") {
|
||
aWindow = aOwner.window.document.querySelector(aWindow);
|
||
}
|
||
if (aWindow instanceof Ci.nsIDOMElement && aWindow.contentWindow) {
|
||
aWindow = aWindow.contentWindow;
|
||
}
|
||
if (!(aWindow instanceof Ci.nsIDOMWindow)) {
|
||
aOwner.helperResult = { type: "error", message: "cdFunctionInvalidArgument" };
|
||
return;
|
||
}
|
||
|
||
aOwner.consoleActor.evalWindow = aWindow;
|
||
aOwner.helperResult = { type: "cd" };
|
||
};
|
||
|
||
/**
|
||
* Inspects the passed aObject. This is done by opening the PropertyPanel.
|
||
*
|
||
* @param object aObject
|
||
* Object to inspect.
|
||
*/
|
||
aOwner.sandbox.inspect = function JSTH_inspect(aObject)
|
||
{
|
||
let dbgObj = aOwner.makeDebuggeeValue(aObject);
|
||
let grip = aOwner.createValueGrip(dbgObj);
|
||
aOwner.helperResult = {
|
||
type: "inspectObject",
|
||
input: aOwner.evalInput,
|
||
object: grip,
|
||
};
|
||
};
|
||
|
||
/**
|
||
* Prints aObject to the output.
|
||
*
|
||
* @param object aObject
|
||
* Object to print to the output.
|
||
* @return string
|
||
*/
|
||
aOwner.sandbox.pprint = function JSTH_pprint(aObject)
|
||
{
|
||
if (aObject === null || aObject === undefined || aObject === true ||
|
||
aObject === false) {
|
||
aOwner.helperResult = {
|
||
type: "error",
|
||
message: "helperFuncUnsupportedTypeError",
|
||
};
|
||
return null;
|
||
}
|
||
|
||
aOwner.helperResult = { rawOutput: true };
|
||
|
||
if (typeof aObject == "function") {
|
||
return aObject + "\n";
|
||
}
|
||
|
||
let output = [];
|
||
|
||
let obj = WebConsoleUtils.unwrap(aObject);
|
||
for (let name in obj) {
|
||
let desc = WebConsoleUtils.getPropertyDescriptor(obj, name) || {};
|
||
if (desc.get || desc.set) {
|
||
// TODO: Bug 842672 - toolkit/ imports modules from browser/.
|
||
let getGrip = VariablesView.getGrip(desc.get);
|
||
let setGrip = VariablesView.getGrip(desc.set);
|
||
let getString = VariablesView.getString(getGrip);
|
||
let setString = VariablesView.getString(setGrip);
|
||
output.push(name + ":", " get: " + getString, " set: " + setString);
|
||
}
|
||
else {
|
||
let valueGrip = VariablesView.getGrip(obj[name]);
|
||
let valueString = VariablesView.getString(valueGrip);
|
||
output.push(name + ": " + valueString);
|
||
}
|
||
}
|
||
|
||
return " " + output.join("\n ");
|
||
};
|
||
|
||
/**
|
||
* Print a string to the output, as-is.
|
||
*
|
||
* @param string aString
|
||
* A string you want to output.
|
||
* @return void
|
||
*/
|
||
aOwner.sandbox.print = function JSTH_print(aString)
|
||
{
|
||
aOwner.helperResult = { rawOutput: true };
|
||
return String(aString);
|
||
};
|
||
}
|
||
exports.JSTermHelpers = JSTermHelpers;
|
||
|
||
|
||
/**
|
||
* A ReflowObserver that listens for reflow events from the page.
|
||
* Implements nsIReflowObserver.
|
||
*
|
||
* @constructor
|
||
* @param object aWindow
|
||
* The window for which we need to track reflow.
|
||
* @param object aOwner
|
||
* The listener owner which needs to implement:
|
||
* - onReflowActivity(aReflowInfo)
|
||
*/
|
||
|
||
function ConsoleReflowListener(aWindow, aListener)
|
||
{
|
||
this.docshell = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
|
||
.getInterface(Ci.nsIWebNavigation)
|
||
.QueryInterface(Ci.nsIDocShell);
|
||
this.listener = aListener;
|
||
this.docshell.addWeakReflowObserver(this);
|
||
}
|
||
|
||
exports.ConsoleReflowListener = ConsoleReflowListener;
|
||
|
||
ConsoleReflowListener.prototype =
|
||
{
|
||
QueryInterface: XPCOMUtils.generateQI([Ci.nsIReflowObserver,
|
||
Ci.nsISupportsWeakReference]),
|
||
docshell: null,
|
||
listener: null,
|
||
|
||
/**
|
||
* Forward reflow event to listener.
|
||
*
|
||
* @param DOMHighResTimeStamp aStart
|
||
* @param DOMHighResTimeStamp aEnd
|
||
* @param boolean aInterruptible
|
||
*/
|
||
sendReflow: function CRL_sendReflow(aStart, aEnd, aInterruptible)
|
||
{
|
||
let frame = components.stack.caller.caller;
|
||
|
||
let filename = frame.filename;
|
||
|
||
if (filename) {
|
||
// Because filename could be of the form "xxx.js -> xxx.js -> xxx.js",
|
||
// we only take the last part.
|
||
filename = filename.split(" ").pop();
|
||
}
|
||
|
||
this.listener.onReflowActivity({
|
||
interruptible: aInterruptible,
|
||
start: aStart,
|
||
end: aEnd,
|
||
sourceURL: filename,
|
||
sourceLine: frame.lineNumber,
|
||
functionName: frame.name
|
||
});
|
||
},
|
||
|
||
/**
|
||
* On uninterruptible reflow
|
||
*
|
||
* @param DOMHighResTimeStamp aStart
|
||
* @param DOMHighResTimeStamp aEnd
|
||
*/
|
||
reflow: function CRL_reflow(aStart, aEnd)
|
||
{
|
||
this.sendReflow(aStart, aEnd, false);
|
||
},
|
||
|
||
/**
|
||
* On interruptible reflow
|
||
*
|
||
* @param DOMHighResTimeStamp aStart
|
||
* @param DOMHighResTimeStamp aEnd
|
||
*/
|
||
reflowInterruptible: function CRL_reflowInterruptible(aStart, aEnd)
|
||
{
|
||
this.sendReflow(aStart, aEnd, true);
|
||
},
|
||
|
||
/**
|
||
* Unregister listener.
|
||
*/
|
||
destroy: function CRL_destroy()
|
||
{
|
||
this.docshell.removeWeakReflowObserver(this);
|
||
this.listener = this.docshell = null;
|
||
},
|
||
};
|
||
|
||
function gSequenceId()
|
||
{
|
||
return gSequenceId.n++;
|
||
}
|
||
gSequenceId.n = 0;
|