mirror of
https://github.com/flutter/flutter.git
synced 2026-02-20 02:29:02 +08:00
41796985bc
This doesn't fully separate v8_inspector from core, but it does lay the path. The next steps to removing v8_inspector is to remove all the # FIXME: Remove lines in the deps section of v8_inspector/BUILD.gn. gn check out/Debug v8_inspector will tell us if we've successfully removed all the dependencies. It's unclear if we want to remove the wtf dependency, but definitely all of the engine/core dependencies should be removed and presumably replaced with abstract interfaces which can be provided to v8_inspector by its host. Given the size of this patch (and that it's largely mechanical) I plan to TBR it. Most of this was done with tools/git/move_source_file.py TBR=yurys@chromium.org Review URL: https://codereview.chromium.org/772563003
1732 lines
56 KiB
JavaScript
1732 lines
56 KiB
JavaScript
/*
|
|
* Copyright (C) 2007 Apple Inc. All rights reserved.
|
|
* Copyright (C) 2013 Google Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
|
|
* its contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
|
|
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
/**
|
|
* @param {InjectedScriptHost} InjectedScriptHost
|
|
* @param {Window} inspectedWindow
|
|
* @param {number} injectedScriptId
|
|
*/
|
|
(function (InjectedScriptHost, inspectedWindow, injectedScriptId) {
|
|
|
|
/**
|
|
* Protect against Object overwritten by the user code.
|
|
* @suppress {duplicate}
|
|
*/
|
|
var Object = /** @type {function(new:Object, *=)} */ ({}.constructor);
|
|
|
|
/**
|
|
* @param {!Array.<T>} array
|
|
* @param {...} var_args
|
|
* @template T
|
|
*/
|
|
function push(array, var_args)
|
|
{
|
|
for (var i = 1; i < arguments.length; ++i)
|
|
array[array.length] = arguments[i];
|
|
}
|
|
|
|
/**
|
|
* @param {!Arguments.<T>} array
|
|
* @param {number=} index
|
|
* @return {!Array.<T>}
|
|
* @template T
|
|
*/
|
|
function slice(array, index)
|
|
{
|
|
var result = [];
|
|
for (var i = index || 0, j = 0; i < array.length; ++i, ++j)
|
|
result[j] = array[i];
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param {!Array.<T>} array1
|
|
* @param {!Array.<T>} array2
|
|
* @return {!Array.<T>}
|
|
* @template T
|
|
*/
|
|
function concat(array1, array2)
|
|
{
|
|
var result = [];
|
|
for (var i = 0; i < array1.length; ++i)
|
|
push(result, array1[i]);
|
|
for (var i = 0; i < array2.length; ++i)
|
|
push(result, array2[i]);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* @param {*} obj
|
|
* @return {string}
|
|
*/
|
|
function toString(obj)
|
|
{
|
|
// We don't use String(obj) because it could be overriden.
|
|
return "" + obj;
|
|
}
|
|
|
|
/**
|
|
* @param {*} obj
|
|
* @return {string}
|
|
*/
|
|
function toStringDescription(obj)
|
|
{
|
|
if (typeof obj === "number" && obj === 0 && 1 / obj < 0)
|
|
return "-0"; // Negative zero.
|
|
return "" + obj;
|
|
}
|
|
|
|
/**
|
|
* Please use this bind, not the one from Function.prototype
|
|
* @param {function(...)} func
|
|
* @param {?Object} thisObject
|
|
* @param {...} var_args
|
|
* @return {function(...)}
|
|
*/
|
|
function bind(func, thisObject, var_args)
|
|
{
|
|
var args = slice(arguments, 2);
|
|
|
|
/**
|
|
* @param {...} var_args
|
|
*/
|
|
function bound(var_args)
|
|
{
|
|
return InjectedScriptHost.callFunction(func, thisObject, concat(args, slice(arguments)));
|
|
}
|
|
bound.toString = function()
|
|
{
|
|
return "bound: " + func;
|
|
};
|
|
return bound;
|
|
}
|
|
|
|
/**
|
|
* @param {T} obj
|
|
* @return {T}
|
|
* @template T
|
|
*/
|
|
function nullifyObjectProto(obj)
|
|
{
|
|
if (obj && typeof obj === "object")
|
|
obj.__proto__ = null;
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* @param {*} obj
|
|
* @return {boolean}
|
|
*/
|
|
function isUInt32(obj)
|
|
{
|
|
return typeof obj === "number" && obj >>> 0 === obj && (obj > 0 || 1 / obj > 0);
|
|
}
|
|
|
|
/**
|
|
* FireBug's array detection.
|
|
* @param {*} obj
|
|
* @return {boolean}
|
|
*/
|
|
function isArrayLike(obj)
|
|
{
|
|
if (typeof obj !== "object")
|
|
return false;
|
|
try {
|
|
if (typeof obj.splice === "function")
|
|
return isUInt32(obj.length);
|
|
} catch (e) {
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {number} a
|
|
* @param {number} b
|
|
* @return {number}
|
|
*/
|
|
function max(a, b)
|
|
{
|
|
return a > b ? a : b;
|
|
}
|
|
|
|
/**
|
|
* FIXME: Remove once ES6 is supported natively by JS compiler.
|
|
* @param {*} obj
|
|
* @return {boolean}
|
|
*/
|
|
function isSymbol(obj)
|
|
{
|
|
var type = typeof obj;
|
|
return (type === "symbol");
|
|
}
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
var InjectedScript = function()
|
|
{
|
|
/** @type {number} */
|
|
this._lastBoundObjectId = 1;
|
|
/** @type {!Object.<number, (!Object|symbol)>} */
|
|
this._idToWrappedObject = { __proto__: null };
|
|
/** @type {!Object.<number, string>} */
|
|
this._idToObjectGroupName = { __proto__: null };
|
|
/** @type {!Object.<string, !Array.<number>>} */
|
|
this._objectGroups = { __proto__: null };
|
|
/** @type {!Object.<string, !Object>} */
|
|
this._modules = { __proto__: null };
|
|
}
|
|
|
|
/**
|
|
* @type {!Object.<string, boolean>}
|
|
* @const
|
|
*/
|
|
InjectedScript.primitiveTypes = {
|
|
"undefined": true,
|
|
"boolean": true,
|
|
"number": true,
|
|
"string": true,
|
|
__proto__: null
|
|
}
|
|
|
|
InjectedScript.prototype = {
|
|
/**
|
|
* @param {*} object
|
|
* @return {boolean}
|
|
*/
|
|
isPrimitiveValue: function(object)
|
|
{
|
|
// FIXME(33716): typeof document.all is always 'undefined'.
|
|
return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @param {string} groupName
|
|
* @param {boolean} canAccessInspectedWindow
|
|
* @param {boolean} generatePreview
|
|
* @return {!RuntimeAgent.RemoteObject}
|
|
*/
|
|
wrapObject: function(object, groupName, canAccessInspectedWindow, generatePreview)
|
|
{
|
|
if (canAccessInspectedWindow)
|
|
return this._wrapObject(object, groupName, false, generatePreview);
|
|
return this._fallbackWrapper(object);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @return {!RuntimeAgent.RemoteObject}
|
|
*/
|
|
_fallbackWrapper: function(object)
|
|
{
|
|
var result = { __proto__: null };
|
|
result.type = typeof object;
|
|
if (this.isPrimitiveValue(object))
|
|
result.value = object;
|
|
else
|
|
result.description = toString(object);
|
|
return /** @type {!RuntimeAgent.RemoteObject} */ (result);
|
|
},
|
|
|
|
/**
|
|
* @param {boolean} canAccessInspectedWindow
|
|
* @param {!Object} table
|
|
* @param {!Array.<string>|string|boolean} columns
|
|
* @return {!RuntimeAgent.RemoteObject}
|
|
*/
|
|
wrapTable: function(canAccessInspectedWindow, table, columns)
|
|
{
|
|
if (!canAccessInspectedWindow)
|
|
return this._fallbackWrapper(table);
|
|
var columnNames = null;
|
|
if (typeof columns === "string")
|
|
columns = [columns];
|
|
if (InjectedScriptHost.subtype(columns) === "array") {
|
|
columnNames = [];
|
|
for (var i = 0; i < columns.length; ++i)
|
|
columnNames[i] = toString(columns[i]);
|
|
}
|
|
return this._wrapObject(table, "console", false, true, columnNames, true);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
*/
|
|
inspectNode: function(object)
|
|
{
|
|
this._inspect(object);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @return {*}
|
|
*/
|
|
_inspect: function(object)
|
|
{
|
|
if (arguments.length === 0)
|
|
return;
|
|
|
|
var objectId = this._wrapObject(object, "");
|
|
var hints = { __proto__: null };
|
|
|
|
InjectedScriptHost.inspect(objectId, hints);
|
|
return object;
|
|
},
|
|
|
|
/**
|
|
* This method cannot throw.
|
|
* @param {*} object
|
|
* @param {string=} objectGroupName
|
|
* @param {boolean=} forceValueType
|
|
* @param {boolean=} generatePreview
|
|
* @param {?Array.<string>=} columnNames
|
|
* @param {boolean=} isTable
|
|
* @return {!RuntimeAgent.RemoteObject}
|
|
* @suppress {checkTypes}
|
|
*/
|
|
_wrapObject: function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
|
|
{
|
|
try {
|
|
return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable);
|
|
} catch (e) {
|
|
try {
|
|
var description = injectedScript._describe(e);
|
|
} catch (ex) {
|
|
var description = "<failed to convert exception to string>";
|
|
}
|
|
return new InjectedScript.RemoteObject(description);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {!Object|symbol} object
|
|
* @param {string=} objectGroupName
|
|
* @return {string}
|
|
*/
|
|
_bind: function(object, objectGroupName)
|
|
{
|
|
var id = this._lastBoundObjectId++;
|
|
this._idToWrappedObject[id] = object;
|
|
var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
|
|
if (objectGroupName) {
|
|
var group = this._objectGroups[objectGroupName];
|
|
if (!group) {
|
|
group = [];
|
|
this._objectGroups[objectGroupName] = group;
|
|
}
|
|
push(group, id);
|
|
this._idToObjectGroupName[id] = objectGroupName;
|
|
}
|
|
return objectId;
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @return {!Object}
|
|
*/
|
|
_parseObjectId: function(objectId)
|
|
{
|
|
return nullifyObjectProto(InjectedScriptHost.eval("(" + objectId + ")"));
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectGroupName
|
|
*/
|
|
releaseObjectGroup: function(objectGroupName)
|
|
{
|
|
if (objectGroupName === "console")
|
|
delete this._lastResult;
|
|
var group = this._objectGroups[objectGroupName];
|
|
if (!group)
|
|
return;
|
|
for (var i = 0; i < group.length; i++)
|
|
this._releaseObject(group[i]);
|
|
delete this._objectGroups[objectGroupName];
|
|
},
|
|
|
|
/**
|
|
* @param {string} methodName
|
|
* @param {string} args
|
|
* @return {*}
|
|
*/
|
|
dispatch: function(methodName, args)
|
|
{
|
|
var argsArray = InjectedScriptHost.eval("(" + args + ")");
|
|
var result = InjectedScriptHost.callFunction(this[methodName], this, argsArray);
|
|
if (typeof result === "undefined") {
|
|
inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
|
|
result = null;
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @param {boolean} ownProperties
|
|
* @param {boolean} accessorPropertiesOnly
|
|
* @return {!Array.<!RuntimeAgent.PropertyDescriptor>|boolean}
|
|
*/
|
|
getProperties: function(objectId, ownProperties, accessorPropertiesOnly)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
var object = this._objectForId(parsedObjectId);
|
|
var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
|
|
|
|
if (!this._isDefined(object) || isSymbol(object))
|
|
return false;
|
|
object = /** @type {!Object} */ (object);
|
|
var descriptors = this._propertyDescriptors(object, ownProperties, accessorPropertiesOnly);
|
|
|
|
// Go over properties, wrap object values.
|
|
for (var i = 0; i < descriptors.length; ++i) {
|
|
var descriptor = descriptors[i];
|
|
if ("get" in descriptor)
|
|
descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
|
|
if ("set" in descriptor)
|
|
descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
|
|
if ("value" in descriptor)
|
|
descriptor.value = this._wrapObject(descriptor.value, objectGroupName);
|
|
if (!("configurable" in descriptor))
|
|
descriptor.configurable = false;
|
|
if (!("enumerable" in descriptor))
|
|
descriptor.enumerable = false;
|
|
if ("symbol" in descriptor)
|
|
descriptor.symbol = this._wrapObject(descriptor.symbol, objectGroupName);
|
|
}
|
|
return descriptors;
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @return {!Array.<!Object>|boolean}
|
|
*/
|
|
getInternalProperties: function(objectId)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
var object = this._objectForId(parsedObjectId);
|
|
var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
|
|
if (!this._isDefined(object) || isSymbol(object))
|
|
return false;
|
|
object = /** @type {!Object} */ (object);
|
|
var descriptors = [];
|
|
var internalProperties = InjectedScriptHost.getInternalProperties(object);
|
|
if (internalProperties) {
|
|
for (var i = 0; i < internalProperties.length; i++) {
|
|
var property = internalProperties[i];
|
|
var descriptor = {
|
|
name: property.name,
|
|
value: this._wrapObject(property.value, objectGroupName),
|
|
__proto__: null
|
|
};
|
|
push(descriptors, descriptor);
|
|
}
|
|
}
|
|
return descriptors;
|
|
},
|
|
|
|
/**
|
|
* @param {string} functionId
|
|
* @return {!DebuggerAgent.FunctionDetails|string}
|
|
*/
|
|
getFunctionDetails: function(functionId)
|
|
{
|
|
var parsedFunctionId = this._parseObjectId(functionId);
|
|
var func = this._objectForId(parsedFunctionId);
|
|
if (typeof func !== "function")
|
|
return "Cannot resolve function by id.";
|
|
var details = nullifyObjectProto(InjectedScriptHost.functionDetails(func));
|
|
if ("rawScopes" in details) {
|
|
var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
|
|
var rawScopes = details.rawScopes;
|
|
delete details.rawScopes;
|
|
var scopes = [];
|
|
for (var i = 0; i < rawScopes.length; ++i)
|
|
scopes[i] = InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName);
|
|
details.scopeChain = scopes;
|
|
}
|
|
return details;
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @return {!Array.<!Object>|string}
|
|
*/
|
|
getCollectionEntries: function(objectId)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
var object = this._objectForId(parsedObjectId);
|
|
if (!object || typeof object !== "object")
|
|
return "Could not find object with given id";
|
|
var entries = InjectedScriptHost.collectionEntries(object);
|
|
if (!entries)
|
|
return "Object with given id is not a collection";
|
|
var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
|
|
for (var i = 0; i < entries.length; ++i) {
|
|
var entry = nullifyObjectProto(entries[i]);
|
|
if ("key" in entry)
|
|
entry.key = this._wrapObject(entry.key, objectGroupName);
|
|
entry.value = this._wrapObject(entry.value, objectGroupName);
|
|
entries[i] = entry;
|
|
}
|
|
return entries;
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
*/
|
|
releaseObject: function(objectId)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
this._releaseObject(parsedObjectId.id);
|
|
},
|
|
|
|
/**
|
|
* @param {number} id
|
|
*/
|
|
_releaseObject: function(id)
|
|
{
|
|
delete this._idToWrappedObject[id];
|
|
delete this._idToObjectGroupName[id];
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} object
|
|
* @param {boolean=} ownProperties
|
|
* @param {boolean=} accessorPropertiesOnly
|
|
* @return {!Array.<!Object>}
|
|
*/
|
|
_propertyDescriptors: function(object, ownProperties, accessorPropertiesOnly)
|
|
{
|
|
var descriptors = [];
|
|
var propertyProcessed = { __proto__: null };
|
|
|
|
/**
|
|
* @param {?Object} o
|
|
* @param {!Array.<string|symbol>} properties
|
|
*/
|
|
function process(o, properties)
|
|
{
|
|
for (var i = 0; i < properties.length; ++i) {
|
|
var property = properties[i];
|
|
if (propertyProcessed[property])
|
|
continue;
|
|
|
|
var name = property;
|
|
if (isSymbol(property))
|
|
name = injectedScript._describe(property);
|
|
|
|
try {
|
|
propertyProcessed[property] = true;
|
|
var descriptor = nullifyObjectProto(InjectedScriptHost.suppressWarningsAndCallFunction(Object.getOwnPropertyDescriptor, Object, [o, property]));
|
|
if (descriptor) {
|
|
if (accessorPropertiesOnly && !("get" in descriptor || "set" in descriptor))
|
|
continue;
|
|
} else {
|
|
// Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
|
|
if (accessorPropertiesOnly)
|
|
continue;
|
|
try {
|
|
descriptor = { name: name, value: o[property], writable: false, configurable: false, enumerable: false, __proto__: null };
|
|
if (o === object)
|
|
descriptor.isOwn = true;
|
|
push(descriptors, descriptor);
|
|
} catch (e) {
|
|
// Silent catch.
|
|
}
|
|
continue;
|
|
}
|
|
} catch (e) {
|
|
if (accessorPropertiesOnly)
|
|
continue;
|
|
var descriptor = { __proto__: null };
|
|
descriptor.value = e;
|
|
descriptor.wasThrown = true;
|
|
}
|
|
|
|
descriptor.name = name;
|
|
if (o === object)
|
|
descriptor.isOwn = true;
|
|
if (isSymbol(property))
|
|
descriptor.symbol = property;
|
|
push(descriptors, descriptor);
|
|
}
|
|
}
|
|
|
|
for (var o = object; this._isDefined(o); o = o.__proto__) {
|
|
// First call Object.keys() to enforce ordering of the property descriptors.
|
|
process(o, Object.keys(/** @type {!Object} */ (o)));
|
|
process(o, Object.getOwnPropertyNames(/** @type {!Object} */ (o)));
|
|
if (Object.getOwnPropertySymbols)
|
|
process(o, Object.getOwnPropertySymbols(/** @type {!Object} */ (o)));
|
|
|
|
if (ownProperties) {
|
|
if (object.__proto__ && !accessorPropertiesOnly)
|
|
push(descriptors, { name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false, isOwn: true, __proto__: null });
|
|
break;
|
|
}
|
|
}
|
|
|
|
return descriptors;
|
|
},
|
|
|
|
/**
|
|
* @param {string} expression
|
|
* @param {string} objectGroup
|
|
* @param {boolean} injectCommandLineAPI
|
|
* @param {boolean} returnByValue
|
|
* @param {boolean} generatePreview
|
|
* @return {*}
|
|
*/
|
|
evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
|
|
{
|
|
return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @param {string} expression
|
|
* @param {string} args
|
|
* @param {boolean} returnByValue
|
|
* @return {!Object|string}
|
|
*/
|
|
callFunctionOn: function(objectId, expression, args, returnByValue)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
var object = this._objectForId(parsedObjectId);
|
|
if (!this._isDefined(object))
|
|
return "Could not find object with given id";
|
|
|
|
if (args) {
|
|
var resolvedArgs = [];
|
|
args = InjectedScriptHost.eval(args);
|
|
for (var i = 0; i < args.length; ++i) {
|
|
try {
|
|
resolvedArgs[i] = this._resolveCallArgument(args[i]);
|
|
} catch (e) {
|
|
return toString(e);
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
|
|
var func = InjectedScriptHost.eval("(" + expression + ")");
|
|
if (typeof func !== "function")
|
|
return "Given expression does not evaluate to a function";
|
|
|
|
return { wasThrown: false,
|
|
result: this._wrapObject(InjectedScriptHost.callFunction(func, object, resolvedArgs), objectGroup, returnByValue),
|
|
__proto__: null };
|
|
} catch (e) {
|
|
return this._createThrownValue(e, objectGroup, false);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Resolves a value from CallArgument description.
|
|
* @param {!RuntimeAgent.CallArgument} callArgumentJson
|
|
* @return {*} resolved value
|
|
* @throws {string} error message
|
|
*/
|
|
_resolveCallArgument: function(callArgumentJson)
|
|
{
|
|
callArgumentJson = nullifyObjectProto(callArgumentJson);
|
|
var objectId = callArgumentJson.objectId;
|
|
if (objectId) {
|
|
var parsedArgId = this._parseObjectId(objectId);
|
|
if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
|
|
throw "Arguments should belong to the same JavaScript world as the target object.";
|
|
|
|
var resolvedArg = this._objectForId(parsedArgId);
|
|
if (!this._isDefined(resolvedArg))
|
|
throw "Could not find object with given id";
|
|
|
|
return resolvedArg;
|
|
} else if ("value" in callArgumentJson) {
|
|
var value = callArgumentJson.value;
|
|
if (callArgumentJson.type === "number" && typeof value !== "number")
|
|
value = Number(value);
|
|
return value;
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
/**
|
|
* @param {?function(string):*} evalFunction
|
|
* @param {?Object} object
|
|
* @param {string} expression
|
|
* @param {string} objectGroup
|
|
* @param {boolean} isEvalOnCallFrame
|
|
* @param {boolean} injectCommandLineAPI
|
|
* @param {boolean} returnByValue
|
|
* @param {boolean} generatePreview
|
|
* @param {!Array.<!Object>=} scopeChain
|
|
* @return {!Object}
|
|
*/
|
|
_evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)
|
|
{
|
|
var wrappedResult = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain);
|
|
if (!wrappedResult.exceptionDetails) {
|
|
return { wasThrown: false,
|
|
result: this._wrapObject(wrappedResult.result, objectGroup, returnByValue, generatePreview),
|
|
__proto__: null };
|
|
}
|
|
return this._createThrownValue(wrappedResult.result, objectGroup, generatePreview, wrappedResult.exceptionDetails);
|
|
},
|
|
|
|
/**
|
|
* @param {*} value
|
|
* @param {string} objectGroup
|
|
* @param {boolean} generatePreview
|
|
* @param {!DebuggerAgent.ExceptionDetails=} exceptionDetails
|
|
* @return {!Object}
|
|
*/
|
|
_createThrownValue: function(value, objectGroup, generatePreview, exceptionDetails)
|
|
{
|
|
var remoteObject = this._wrapObject(value, objectGroup, false, generatePreview && !(value instanceof Error));
|
|
if (!remoteObject.description){
|
|
try {
|
|
remoteObject.description = toStringDescription(value);
|
|
} catch (e) {}
|
|
}
|
|
return { wasThrown: true, result: remoteObject, exceptionDetails: exceptionDetails, __proto__: null };
|
|
},
|
|
|
|
/**
|
|
* @param {?function(string):*} evalFunction
|
|
* @param {?Object} object
|
|
* @param {string} objectGroup
|
|
* @param {string} expression
|
|
* @param {boolean} isEvalOnCallFrame
|
|
* @param {boolean} injectCommandLineAPI
|
|
* @param {!Array.<!Object>=} scopeChain
|
|
* @return {*}
|
|
*/
|
|
_evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain)
|
|
{
|
|
// Only install command line api object for the time of evaluation.
|
|
// Surround the expression in with statements to inject our command line API so that
|
|
// the window object properties still take more precedent than our API functions.
|
|
|
|
injectCommandLineAPI = injectCommandLineAPI && !("__commandLineAPI" in inspectedWindow);
|
|
var injectScopeChain = scopeChain && scopeChain.length && !("__scopeChainForEval" in inspectedWindow);
|
|
|
|
try {
|
|
var prefix = "";
|
|
var suffix = "";
|
|
if (injectCommandLineAPI) {
|
|
inspectedWindow.__commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
|
|
prefix = "with (__commandLineAPI || { __proto__: null }) {";
|
|
suffix = "}";
|
|
}
|
|
if (injectScopeChain) {
|
|
inspectedWindow.__scopeChainForEval = scopeChain;
|
|
for (var i = 0; i < scopeChain.length; ++i) {
|
|
prefix = "with (__scopeChainForEval[" + i + "] || { __proto__: null }) {" + (suffix ? " " : "") + prefix;
|
|
if (suffix)
|
|
suffix += " }";
|
|
else
|
|
suffix = "}";
|
|
}
|
|
}
|
|
|
|
if (prefix)
|
|
expression = prefix + "\n" + expression + "\n" + suffix;
|
|
var wrappedResult = evalFunction ? InjectedScriptHost.callFunction(evalFunction, object, [expression]) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
|
|
if (objectGroup === "console" && !wrappedResult.exceptionDetails)
|
|
this._lastResult = wrappedResult.result;
|
|
return wrappedResult;
|
|
} finally {
|
|
if (injectCommandLineAPI)
|
|
delete inspectedWindow.__commandLineAPI;
|
|
if (injectScopeChain)
|
|
delete inspectedWindow.__scopeChainForEval;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {?Object} callFrame
|
|
* @param {number} asyncOrdinal
|
|
* @return {!Array.<!InjectedScript.CallFrameProxy>|boolean}
|
|
*/
|
|
wrapCallFrames: function(callFrame, asyncOrdinal)
|
|
{
|
|
if (!callFrame)
|
|
return false;
|
|
|
|
var result = [];
|
|
var depth = 0;
|
|
do {
|
|
result[depth] = new InjectedScript.CallFrameProxy(depth, callFrame, asyncOrdinal);
|
|
callFrame = callFrame.caller;
|
|
++depth;
|
|
} while (callFrame);
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} topCallFrame
|
|
* @param {!Array.<!Object>} asyncCallStacks
|
|
* @param {string} callFrameId
|
|
* @param {string} expression
|
|
* @param {string} objectGroup
|
|
* @param {boolean} injectCommandLineAPI
|
|
* @param {boolean} returnByValue
|
|
* @param {boolean} generatePreview
|
|
* @return {*}
|
|
*/
|
|
evaluateOnCallFrame: function(topCallFrame, asyncCallStacks, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
|
|
{
|
|
var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.eval("(" + callFrameId + ")"));
|
|
var callFrame = this._callFrameForParsedId(topCallFrame, parsedCallFrameId, asyncCallStacks);
|
|
if (!callFrame)
|
|
return "Could not find call frame with given id";
|
|
if (parsedCallFrameId["asyncOrdinal"])
|
|
return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
|
|
return this._evaluateAndWrap(callFrame.evaluateWithExceptionDetails, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} topCallFrame
|
|
* @param {string} callFrameId
|
|
* @return {*}
|
|
*/
|
|
restartFrame: function(topCallFrame, callFrameId)
|
|
{
|
|
var callFrame = this._callFrameForId(topCallFrame, callFrameId);
|
|
if (!callFrame)
|
|
return "Could not find call frame with given id";
|
|
var result = callFrame.restart();
|
|
if (result === false)
|
|
result = "Restart frame is not supported";
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} topCallFrame
|
|
* @param {string} callFrameId
|
|
* @return {*} a stepIn position array ready for protocol JSON or a string error
|
|
*/
|
|
getStepInPositions: function(topCallFrame, callFrameId)
|
|
{
|
|
var callFrame = this._callFrameForId(topCallFrame, callFrameId);
|
|
if (!callFrame)
|
|
return "Could not find call frame with given id";
|
|
var stepInPositionsUnpacked = JSON.parse(callFrame.stepInPositions);
|
|
if (typeof stepInPositionsUnpacked !== "object")
|
|
return "Step in positions not available";
|
|
return stepInPositionsUnpacked;
|
|
},
|
|
|
|
/**
|
|
* Either callFrameId or functionObjectId must be specified.
|
|
* @param {!Object} topCallFrame
|
|
* @param {string|boolean} callFrameId or false
|
|
* @param {string|boolean} functionObjectId or false
|
|
* @param {number} scopeNumber
|
|
* @param {string} variableName
|
|
* @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string
|
|
* @return {string|undefined} undefined if success or an error message
|
|
*/
|
|
setVariableValue: function(topCallFrame, callFrameId, functionObjectId, scopeNumber, variableName, newValueJsonString)
|
|
{
|
|
var setter;
|
|
if (typeof callFrameId === "string") {
|
|
var callFrame = this._callFrameForId(topCallFrame, callFrameId);
|
|
if (!callFrame)
|
|
return "Could not find call frame with given id";
|
|
setter = bind(callFrame.setVariableValue, callFrame);
|
|
} else {
|
|
var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
|
|
var func = this._objectForId(parsedFunctionId);
|
|
if (typeof func !== "function")
|
|
return "Cannot resolve function by id.";
|
|
setter = bind(InjectedScriptHost.setFunctionVariableValue, InjectedScriptHost, func);
|
|
}
|
|
var newValueJson;
|
|
try {
|
|
newValueJson = InjectedScriptHost.eval("(" + newValueJsonString + ")");
|
|
} catch (e) {
|
|
return "Failed to parse new value JSON " + newValueJsonString + " : " + e;
|
|
}
|
|
var resolvedValue;
|
|
try {
|
|
resolvedValue = this._resolveCallArgument(newValueJson);
|
|
} catch (e) {
|
|
return toString(e);
|
|
}
|
|
try {
|
|
setter(scopeNumber, variableName, resolvedValue);
|
|
} catch (e) {
|
|
return "Failed to change variable value: " + e;
|
|
}
|
|
return undefined;
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} topCallFrame
|
|
* @param {string} callFrameId
|
|
* @return {?Object}
|
|
*/
|
|
_callFrameForId: function(topCallFrame, callFrameId)
|
|
{
|
|
var parsedCallFrameId = nullifyObjectProto(InjectedScriptHost.eval("(" + callFrameId + ")"));
|
|
return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} topCallFrame
|
|
* @param {!Object} parsedCallFrameId
|
|
* @param {!Array.<!Object>} asyncCallStacks
|
|
* @return {?Object}
|
|
*/
|
|
_callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
|
|
{
|
|
var asyncOrdinal = parsedCallFrameId["asyncOrdinal"]; // 1-based index
|
|
if (asyncOrdinal)
|
|
topCallFrame = asyncCallStacks[asyncOrdinal - 1];
|
|
var ordinal = parsedCallFrameId["ordinal"];
|
|
var callFrame = topCallFrame;
|
|
while (--ordinal >= 0 && callFrame)
|
|
callFrame = callFrame.caller;
|
|
return callFrame;
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} objectId
|
|
* @return {!Object|symbol}
|
|
*/
|
|
_objectForId: function(objectId)
|
|
{
|
|
return this._idToWrappedObject[objectId.id];
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @return {!Object|symbol}
|
|
*/
|
|
findObjectById: function(objectId)
|
|
{
|
|
var parsedObjectId = this._parseObjectId(objectId);
|
|
return this._objectForId(parsedObjectId);
|
|
},
|
|
|
|
/**
|
|
* @param {string} objectId
|
|
* @return {?Node}
|
|
*/
|
|
nodeForObjectId: function(objectId)
|
|
{
|
|
var object = this.findObjectById(objectId);
|
|
if (!object || this._subtype(object) !== "node")
|
|
return null;
|
|
return /** @type {!Node} */ (object);
|
|
},
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @return {!Object}
|
|
*/
|
|
module: function(name)
|
|
{
|
|
return this._modules[name];
|
|
},
|
|
|
|
/**
|
|
* @param {string} name
|
|
* @param {string} source
|
|
* @return {?Object}
|
|
*/
|
|
injectModule: function(name, source)
|
|
{
|
|
delete this._modules[name];
|
|
var moduleFunction = InjectedScriptHost.eval("(" + source + ")");
|
|
if (typeof moduleFunction !== "function") {
|
|
inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
|
|
return null;
|
|
}
|
|
var module = InjectedScriptHost.callFunction(moduleFunction, inspectedWindow, [InjectedScriptHost, inspectedWindow, injectedScriptId, this]);
|
|
this._modules[name] = module;
|
|
return module;
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @return {boolean}
|
|
*/
|
|
_isDefined: function(object)
|
|
{
|
|
return !!object || this._isHTMLAllCollection(object);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @return {boolean}
|
|
*/
|
|
_isHTMLAllCollection: function(object)
|
|
{
|
|
// document.all is reported as undefined, but we still want to process it.
|
|
return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
|
|
},
|
|
|
|
/**
|
|
* @param {*} obj
|
|
* @return {?string}
|
|
*/
|
|
_subtype: function(obj)
|
|
{
|
|
if (obj === null)
|
|
return "null";
|
|
|
|
if (this.isPrimitiveValue(obj))
|
|
return null;
|
|
|
|
var subtype = InjectedScriptHost.subtype(obj);
|
|
if (subtype)
|
|
return subtype;
|
|
|
|
if (isArrayLike(obj))
|
|
return "array";
|
|
|
|
// If owning frame has navigated to somewhere else window properties will be undefined.
|
|
return null;
|
|
},
|
|
|
|
/**
|
|
* @param {*} obj
|
|
* @return {?string}
|
|
*/
|
|
_describe: function(obj)
|
|
{
|
|
if (this.isPrimitiveValue(obj))
|
|
return null;
|
|
|
|
var subtype = this._subtype(obj);
|
|
|
|
if (subtype === "regexp")
|
|
return toString(obj);
|
|
|
|
if (subtype === "date")
|
|
return toString(obj);
|
|
|
|
if (subtype === "node") {
|
|
var description = obj.nodeName.toLowerCase();
|
|
switch (obj.nodeType) {
|
|
case 1 /* Node.ELEMENT_NODE */:
|
|
description += obj.id ? "#" + obj.id : "";
|
|
var className = obj.className;
|
|
description += (className && typeof className === "string") ? "." + className.trim().replace(/\s+/g, ".") : "";
|
|
break;
|
|
case 10 /*Node.DOCUMENT_TYPE_NODE */:
|
|
description = "<!DOCTYPE " + description + ">";
|
|
break;
|
|
}
|
|
return description;
|
|
}
|
|
|
|
var className = InjectedScriptHost.internalConstructorName(obj);
|
|
if (subtype === "array") {
|
|
if (typeof obj.length === "number")
|
|
className += "[" + obj.length + "]";
|
|
return className;
|
|
}
|
|
|
|
// NodeList in JSC is a function, check for array prior to this.
|
|
if (typeof obj === "function")
|
|
return toString(obj);
|
|
|
|
if (isSymbol(obj)) {
|
|
try {
|
|
return InjectedScriptHost.callFunction(Symbol.prototype.toString, obj) || "Symbol";
|
|
} catch (e) {
|
|
return "Symbol";
|
|
}
|
|
}
|
|
|
|
if (obj instanceof Error && !!obj.message)
|
|
return className + ": " + obj.message;
|
|
|
|
return className;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @type {!InjectedScript}
|
|
* @const
|
|
*/
|
|
var injectedScript = new InjectedScript();
|
|
|
|
/**
|
|
* @constructor
|
|
* @param {*} object
|
|
* @param {string=} objectGroupName
|
|
* @param {boolean=} forceValueType
|
|
* @param {boolean=} generatePreview
|
|
* @param {?Array.<string>=} columnNames
|
|
* @param {boolean=} isTable
|
|
*/
|
|
InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
|
|
{
|
|
this.type = typeof object;
|
|
if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
|
|
// We don't send undefined values over JSON.
|
|
if (this.type !== "undefined")
|
|
this.value = object;
|
|
|
|
// Null object is object with 'null' subtype.
|
|
if (object === null)
|
|
this.subtype = "null";
|
|
|
|
// Provide user-friendly number values.
|
|
if (this.type === "number") {
|
|
this.description = toStringDescription(object);
|
|
// Override "value" property for values that can not be JSON-stringified.
|
|
switch (this.description) {
|
|
case "NaN":
|
|
case "Infinity":
|
|
case "-Infinity":
|
|
case "-0":
|
|
this.value = this.description;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
object = /** @type {!Object} */ (object);
|
|
|
|
this.objectId = injectedScript._bind(object, objectGroupName);
|
|
var subtype = injectedScript._subtype(object);
|
|
if (subtype)
|
|
this.subtype = subtype;
|
|
var className = InjectedScriptHost.internalConstructorName(object);
|
|
if (className)
|
|
this.className = className;
|
|
this.description = injectedScript._describe(object);
|
|
|
|
if (generatePreview && (this.type === "object" || injectedScript._isHTMLAllCollection(object)))
|
|
this.preview = this._generatePreview(object, undefined, columnNames, isTable);
|
|
}
|
|
|
|
InjectedScript.RemoteObject.prototype = {
|
|
/**
|
|
* @param {!Object} object
|
|
* @param {?Array.<string>=} firstLevelKeys
|
|
* @param {?Array.<string>=} secondLevelKeys
|
|
* @param {boolean=} isTable
|
|
* @return {!RuntimeAgent.ObjectPreview} preview
|
|
*/
|
|
_generatePreview: function(object, firstLevelKeys, secondLevelKeys, isTable)
|
|
{
|
|
var preview = { __proto__: null };
|
|
preview.lossless = true;
|
|
preview.overflow = false;
|
|
preview.properties = [];
|
|
|
|
var firstLevelKeysCount = firstLevelKeys ? firstLevelKeys.length : 0;
|
|
|
|
var propertiesThreshold = {
|
|
properties: isTable ? 1000 : max(5, firstLevelKeysCount),
|
|
indexes: isTable ? 1000 : max(100, firstLevelKeysCount)
|
|
};
|
|
|
|
try {
|
|
var descriptors = injectedScript._propertyDescriptors(object);
|
|
|
|
if (firstLevelKeys) {
|
|
var nameToDescriptors = { __proto__: null };
|
|
for (var i = 0; i < descriptors.length; ++i) {
|
|
var descriptor = descriptors[i];
|
|
nameToDescriptors["#" + descriptor.name] = descriptor;
|
|
}
|
|
descriptors = [];
|
|
for (var i = 0; i < firstLevelKeys.length; ++i)
|
|
descriptors[i] = nameToDescriptors["#" + firstLevelKeys[i]];
|
|
}
|
|
|
|
this._appendPropertyDescriptors(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable);
|
|
if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
|
|
return preview;
|
|
|
|
// Add internal properties to preview.
|
|
var internalProperties = InjectedScriptHost.getInternalProperties(object) || [];
|
|
for (var i = 0; i < internalProperties.length; ++i) {
|
|
internalProperties[i] = nullifyObjectProto(internalProperties[i]);
|
|
internalProperties[i].enumerable = true;
|
|
}
|
|
this._appendPropertyDescriptors(preview, internalProperties, propertiesThreshold, secondLevelKeys, isTable);
|
|
|
|
} catch (e) {
|
|
preview.lossless = false;
|
|
}
|
|
|
|
return preview;
|
|
},
|
|
|
|
/**
|
|
* @param {!RuntimeAgent.ObjectPreview} preview
|
|
* @param {!Array.<!Object>} descriptors
|
|
* @param {!Object} propertiesThreshold
|
|
* @param {?Array.<string>=} secondLevelKeys
|
|
* @param {boolean=} isTable
|
|
*/
|
|
_appendPropertyDescriptors: function(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable)
|
|
{
|
|
for (var i = 0; i < descriptors.length; ++i) {
|
|
if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
|
|
break;
|
|
|
|
var descriptor = descriptors[i];
|
|
if (!descriptor)
|
|
continue;
|
|
if (descriptor.wasThrown) {
|
|
preview.lossless = false;
|
|
continue;
|
|
}
|
|
if (!descriptor.enumerable && !descriptor.isOwn)
|
|
continue;
|
|
|
|
var name = descriptor.name;
|
|
if (name === "__proto__")
|
|
continue;
|
|
if (this.subtype === "array" && name === "length")
|
|
continue;
|
|
|
|
if (!("value" in descriptor)) {
|
|
preview.lossless = false;
|
|
this._appendPropertyPreview(preview, { name: name, type: "accessor", __proto__: null }, propertiesThreshold);
|
|
continue;
|
|
}
|
|
|
|
var value = descriptor.value;
|
|
if (value === null) {
|
|
this._appendPropertyPreview(preview, { name: name, type: "object", subtype: "null", value: "null", __proto__: null }, propertiesThreshold);
|
|
continue;
|
|
}
|
|
|
|
var type = typeof value;
|
|
if (!descriptor.enumerable && type === "function")
|
|
continue;
|
|
if (type === "undefined" && injectedScript._isHTMLAllCollection(value))
|
|
type = "object";
|
|
|
|
var maxLength = 100;
|
|
if (InjectedScript.primitiveTypes[type]) {
|
|
if (type === "string" && value.length > maxLength) {
|
|
value = this._abbreviateString(value, maxLength, true);
|
|
preview.lossless = false;
|
|
}
|
|
this._appendPropertyPreview(preview, { name: name, type: type, value: toStringDescription(value), __proto__: null }, propertiesThreshold);
|
|
continue;
|
|
}
|
|
|
|
var property = { name: name, type: type, __proto__: null };
|
|
var subtype = injectedScript._subtype(value);
|
|
if (subtype)
|
|
property.subtype = subtype;
|
|
|
|
if (secondLevelKeys === null || secondLevelKeys) {
|
|
var subPreview = this._generatePreview(value, secondLevelKeys || undefined, undefined, isTable);
|
|
property.valuePreview = subPreview;
|
|
if (!subPreview.lossless)
|
|
preview.lossless = false;
|
|
if (subPreview.overflow)
|
|
preview.overflow = true;
|
|
} else {
|
|
var description = "";
|
|
if (type !== "function")
|
|
description = this._abbreviateString(/** @type {string} */ (injectedScript._describe(value)), maxLength, subtype === "regexp");
|
|
property.value = description;
|
|
preview.lossless = false;
|
|
}
|
|
this._appendPropertyPreview(preview, property, propertiesThreshold);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {!RuntimeAgent.ObjectPreview} preview
|
|
* @param {!Object} property
|
|
* @param {!Object} propertiesThreshold
|
|
*/
|
|
_appendPropertyPreview: function(preview, property, propertiesThreshold)
|
|
{
|
|
if (toString(property.name >>> 0) === property.name)
|
|
propertiesThreshold.indexes--;
|
|
else
|
|
propertiesThreshold.properties--;
|
|
if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0) {
|
|
preview.overflow = true;
|
|
preview.lossless = false;
|
|
} else {
|
|
push(preview.properties, property);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {string} string
|
|
* @param {number} maxLength
|
|
* @param {boolean=} middle
|
|
* @return {string}
|
|
*/
|
|
_abbreviateString: function(string, maxLength, middle)
|
|
{
|
|
if (string.length <= maxLength)
|
|
return string;
|
|
if (middle) {
|
|
var leftHalf = maxLength >> 1;
|
|
var rightHalf = maxLength - leftHalf - 1;
|
|
return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
|
|
}
|
|
return string.substr(0, maxLength) + "\u2026";
|
|
},
|
|
|
|
__proto__: null
|
|
}
|
|
/**
|
|
* @constructor
|
|
* @param {number} ordinal
|
|
* @param {!Object} callFrame
|
|
* @param {number} asyncOrdinal
|
|
*/
|
|
InjectedScript.CallFrameProxy = function(ordinal, callFrame, asyncOrdinal)
|
|
{
|
|
this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + (asyncOrdinal ? ",\"asyncOrdinal\":" + asyncOrdinal : "") + "}";
|
|
this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
|
|
this.location = { scriptId: toString(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column, __proto__: null };
|
|
this.scopeChain = this._wrapScopeChain(callFrame);
|
|
this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
|
|
if (callFrame.isAtReturn)
|
|
this.returnValue = injectedScript._wrapObject(callFrame.returnValue, "backtrace");
|
|
}
|
|
|
|
InjectedScript.CallFrameProxy.prototype = {
|
|
/**
|
|
* @param {!Object} callFrame
|
|
* @return {!Array.<!DebuggerAgent.Scope>}
|
|
*/
|
|
_wrapScopeChain: function(callFrame)
|
|
{
|
|
var scopeChain = callFrame.scopeChain;
|
|
var scopeChainProxy = [];
|
|
for (var i = 0; i < scopeChain.length; ++i)
|
|
scopeChainProxy[i] = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
|
|
return scopeChainProxy;
|
|
},
|
|
|
|
__proto__: null
|
|
}
|
|
|
|
/**
|
|
* @param {number} scopeTypeCode
|
|
* @param {*} scopeObject
|
|
* @param {string} groupId
|
|
* @return {!DebuggerAgent.Scope}
|
|
*/
|
|
InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId)
|
|
{
|
|
var GLOBAL_SCOPE = 0;
|
|
var LOCAL_SCOPE = 1;
|
|
var WITH_SCOPE = 2;
|
|
var CLOSURE_SCOPE = 3;
|
|
var CATCH_SCOPE = 4;
|
|
|
|
/** @type {!Object.<number, string>} */
|
|
var scopeTypeNames = { __proto__: null };
|
|
scopeTypeNames[GLOBAL_SCOPE] = "global";
|
|
scopeTypeNames[LOCAL_SCOPE] = "local";
|
|
scopeTypeNames[WITH_SCOPE] = "with";
|
|
scopeTypeNames[CLOSURE_SCOPE] = "closure";
|
|
scopeTypeNames[CATCH_SCOPE] = "catch";
|
|
|
|
return {
|
|
object: injectedScript._wrapObject(scopeObject, groupId),
|
|
type: /** @type {!DebuggerAgent.ScopeType} */ (scopeTypeNames[scopeTypeCode]),
|
|
__proto__: null
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @constructor
|
|
* @param {!CommandLineAPIImpl} commandLineAPIImpl
|
|
* @param {?Object} callFrame
|
|
*/
|
|
function CommandLineAPI(commandLineAPIImpl, callFrame)
|
|
{
|
|
/**
|
|
* @param {string} member
|
|
* @return {boolean}
|
|
*/
|
|
function inScopeVariables(member)
|
|
{
|
|
if (!callFrame)
|
|
return false;
|
|
|
|
var scopeChain = callFrame.scopeChain;
|
|
for (var i = 0; i < scopeChain.length; ++i) {
|
|
if (member in scopeChain[i])
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @param {string} name The name of the method for which a toString method should be generated.
|
|
* @return {function():string}
|
|
*/
|
|
function customToStringMethod(name)
|
|
{
|
|
return function()
|
|
{
|
|
var funcArgsSyntax = "";
|
|
try {
|
|
var funcSyntax = "" + commandLineAPIImpl[name];
|
|
funcSyntax = funcSyntax.replace(/\n/g, " ");
|
|
funcSyntax = funcSyntax.replace(/^function[^\(]*\(([^\)]*)\).*$/, "$1");
|
|
funcSyntax = funcSyntax.replace(/\s*,\s*/g, ", ");
|
|
funcSyntax = funcSyntax.replace(/\bopt_(\w+)\b/g, "[$1]");
|
|
funcArgsSyntax = funcSyntax.trim();
|
|
} catch (e) {
|
|
}
|
|
return "function " + name + "(" + funcArgsSyntax + ") { [Command Line API] }";
|
|
};
|
|
}
|
|
|
|
for (var i = 0; i < CommandLineAPI.members_.length; ++i) {
|
|
var member = CommandLineAPI.members_[i];
|
|
if (member in inspectedWindow || inScopeVariables(member))
|
|
continue;
|
|
|
|
this[member] = bind(commandLineAPIImpl[member], commandLineAPIImpl);
|
|
this[member].toString = customToStringMethod(member);
|
|
}
|
|
|
|
for (var i = 0; i < 5; ++i) {
|
|
var member = "$" + i;
|
|
if (member in inspectedWindow || inScopeVariables(member))
|
|
continue;
|
|
|
|
this.__defineGetter__("$" + i, bind(commandLineAPIImpl._inspectedObject, commandLineAPIImpl, i));
|
|
}
|
|
|
|
this.$_ = injectedScript._lastResult;
|
|
|
|
this.__proto__ = null;
|
|
}
|
|
|
|
// NOTE: Please keep the list of API methods below snchronized to that in WebInspector.RuntimeModel!
|
|
// NOTE: Argument names of these methods will be printed in the console, so use pretty names!
|
|
/**
|
|
* @type {!Array.<string>}
|
|
* @const
|
|
*/
|
|
CommandLineAPI.members_ = [
|
|
"$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
|
|
"monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
|
|
"debug", "undebug", "monitor", "unmonitor", "table"
|
|
];
|
|
|
|
/**
|
|
* @constructor
|
|
*/
|
|
function CommandLineAPIImpl()
|
|
{
|
|
}
|
|
|
|
CommandLineAPIImpl.prototype = {
|
|
/**
|
|
* @param {string} selector
|
|
* @param {!Node=} opt_startNode
|
|
* @return {*}
|
|
*/
|
|
$: function (selector, opt_startNode)
|
|
{
|
|
if (this._canQuerySelectorOnNode(opt_startNode))
|
|
return opt_startNode.querySelector(selector);
|
|
|
|
return inspectedWindow.document.querySelector(selector);
|
|
},
|
|
|
|
/**
|
|
* @param {string} selector
|
|
* @param {!Node=} opt_startNode
|
|
* @return {*}
|
|
*/
|
|
$$: function (selector, opt_startNode)
|
|
{
|
|
if (this._canQuerySelectorOnNode(opt_startNode))
|
|
return opt_startNode.querySelectorAll(selector);
|
|
return inspectedWindow.document.querySelectorAll(selector);
|
|
},
|
|
|
|
/**
|
|
* @param {!Node=} node
|
|
* @return {boolean}
|
|
*/
|
|
_canQuerySelectorOnNode: function(node)
|
|
{
|
|
return !!node && InjectedScriptHost.subtype(node) === "node" && (node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);
|
|
},
|
|
|
|
/**
|
|
* @param {string} xpath
|
|
* @param {!Node=} opt_startNode
|
|
* @return {*}
|
|
*/
|
|
$x: function(xpath, opt_startNode)
|
|
{
|
|
var doc = (opt_startNode && opt_startNode.ownerDocument) || inspectedWindow.document;
|
|
var result = doc.evaluate(xpath, opt_startNode || doc, null, XPathResult.ANY_TYPE, null);
|
|
switch (result.resultType) {
|
|
case XPathResult.NUMBER_TYPE:
|
|
return result.numberValue;
|
|
case XPathResult.STRING_TYPE:
|
|
return result.stringValue;
|
|
case XPathResult.BOOLEAN_TYPE:
|
|
return result.booleanValue;
|
|
default:
|
|
var nodes = [];
|
|
var node;
|
|
while (node = result.iterateNext())
|
|
push(nodes, node);
|
|
return nodes;
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @return {*}
|
|
*/
|
|
dir: function(var_args)
|
|
{
|
|
return InjectedScriptHost.callFunction(inspectedWindow.console.dir, inspectedWindow.console, slice(arguments));
|
|
},
|
|
|
|
/**
|
|
* @return {*}
|
|
*/
|
|
dirxml: function(var_args)
|
|
{
|
|
return InjectedScriptHost.callFunction(inspectedWindow.console.dirxml, inspectedWindow.console, slice(arguments));
|
|
},
|
|
|
|
/**
|
|
* @return {!Array.<string>}
|
|
*/
|
|
keys: function(object)
|
|
{
|
|
return Object.keys(object);
|
|
},
|
|
|
|
/**
|
|
* @return {!Array.<*>}
|
|
*/
|
|
values: function(object)
|
|
{
|
|
var result = [];
|
|
for (var key in object)
|
|
push(result, object[key]);
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @return {*}
|
|
*/
|
|
profile: function(opt_title)
|
|
{
|
|
return InjectedScriptHost.callFunction(inspectedWindow.console.profile, inspectedWindow.console, slice(arguments));
|
|
},
|
|
|
|
/**
|
|
* @return {*}
|
|
*/
|
|
profileEnd: function(opt_title)
|
|
{
|
|
return InjectedScriptHost.callFunction(inspectedWindow.console.profileEnd, inspectedWindow.console, slice(arguments));
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} object
|
|
* @param {!Array.<string>|string=} opt_types
|
|
*/
|
|
monitorEvents: function(object, opt_types)
|
|
{
|
|
if (!object || !object.addEventListener || !object.removeEventListener)
|
|
return;
|
|
var types = this._normalizeEventTypes(opt_types);
|
|
for (var i = 0; i < types.length; ++i) {
|
|
object.removeEventListener(types[i], this._logEvent, false);
|
|
object.addEventListener(types[i], this._logEvent, false);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* @param {!Object} object
|
|
* @param {!Array.<string>|string=} opt_types
|
|
*/
|
|
unmonitorEvents: function(object, opt_types)
|
|
{
|
|
if (!object || !object.addEventListener || !object.removeEventListener)
|
|
return;
|
|
var types = this._normalizeEventTypes(opt_types);
|
|
for (var i = 0; i < types.length; ++i)
|
|
object.removeEventListener(types[i], this._logEvent, false);
|
|
},
|
|
|
|
/**
|
|
* @param {*} object
|
|
* @return {*}
|
|
*/
|
|
inspect: function(object)
|
|
{
|
|
return injectedScript._inspect(object);
|
|
},
|
|
|
|
copy: function(object)
|
|
{
|
|
var string;
|
|
if (injectedScript._subtype(object) === "node") {
|
|
string = object.outerHTML;
|
|
} else if (injectedScript.isPrimitiveValue(object)) {
|
|
string = toString(object);
|
|
} else {
|
|
try {
|
|
string = JSON.stringify(object, null, " ");
|
|
} catch (e) {
|
|
string = toString(object);
|
|
}
|
|
}
|
|
|
|
var hints = { copyToClipboard: true, __proto__: null };
|
|
var remoteObject = injectedScript._wrapObject(string, "")
|
|
InjectedScriptHost.inspect(remoteObject, hints);
|
|
},
|
|
|
|
clear: function()
|
|
{
|
|
InjectedScriptHost.clearConsoleMessages();
|
|
},
|
|
|
|
/**
|
|
* @param {!Node} node
|
|
* @return {!{type: string, listener: function(), useCapture: boolean, remove: function()}|undefined}
|
|
*/
|
|
getEventListeners: function(node)
|
|
{
|
|
var result = nullifyObjectProto(InjectedScriptHost.getEventListeners(node));
|
|
if (!result)
|
|
return result;
|
|
/** @this {{type: string, listener: function(), useCapture: boolean}} */
|
|
var removeFunc = function()
|
|
{
|
|
node.removeEventListener(this.type, this.listener, this.useCapture);
|
|
}
|
|
for (var type in result) {
|
|
var listeners = result[type];
|
|
for (var i = 0, listener; listener = listeners[i]; ++i) {
|
|
listener["type"] = type;
|
|
listener["remove"] = removeFunc;
|
|
}
|
|
}
|
|
return result;
|
|
},
|
|
|
|
debug: function(fn)
|
|
{
|
|
InjectedScriptHost.debugFunction(fn);
|
|
},
|
|
|
|
undebug: function(fn)
|
|
{
|
|
InjectedScriptHost.undebugFunction(fn);
|
|
},
|
|
|
|
monitor: function(fn)
|
|
{
|
|
InjectedScriptHost.monitorFunction(fn);
|
|
},
|
|
|
|
unmonitor: function(fn)
|
|
{
|
|
InjectedScriptHost.unmonitorFunction(fn);
|
|
},
|
|
|
|
table: function(data, opt_columns)
|
|
{
|
|
InjectedScriptHost.callFunction(inspectedWindow.console.table, inspectedWindow.console, slice(arguments));
|
|
},
|
|
|
|
/**
|
|
* @param {number} num
|
|
*/
|
|
_inspectedObject: function(num)
|
|
{
|
|
return InjectedScriptHost.inspectedObject(num);
|
|
},
|
|
|
|
/**
|
|
* @param {!Array.<string>|string=} types
|
|
* @return {!Array.<string>}
|
|
*/
|
|
_normalizeEventTypes: function(types)
|
|
{
|
|
if (typeof types === "undefined")
|
|
types = ["mouse", "key", "touch", "control", "load", "unload", "abort", "error", "select", "change", "submit", "reset", "focus", "blur", "resize", "scroll", "search", "devicemotion", "deviceorientation"];
|
|
else if (typeof types === "string")
|
|
types = [types];
|
|
|
|
var result = [];
|
|
for (var i = 0; i < types.length; ++i) {
|
|
if (types[i] === "mouse")
|
|
push(result, "mousedown", "mouseup", "click", "dblclick", "mousemove", "mouseover", "mouseout", "mousewheel");
|
|
else if (types[i] === "key")
|
|
push(result, "keydown", "keyup", "keypress", "textInput");
|
|
else if (types[i] === "touch")
|
|
push(result, "touchstart", "touchmove", "touchend", "touchcancel");
|
|
else if (types[i] === "control")
|
|
push(result, "resize", "scroll", "zoom", "focus", "blur", "select", "change", "submit", "reset");
|
|
else
|
|
push(result, types[i]);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
/**
|
|
* @param {!Event} event
|
|
*/
|
|
_logEvent: function(event)
|
|
{
|
|
inspectedWindow.console.log(event.type, event);
|
|
}
|
|
}
|
|
|
|
injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
|
|
return injectedScript;
|
|
})
|