1/*
2 * Copyright (C) 2007 Apple Inc.  All rights reserved.
3 * Copyright (C) 2013 Google Inc. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1.  Redistributions of source code must retain the above copyright
10 *     notice, this list of conditions and the following disclaimer.
11 * 2.  Redistributions in binary form must reproduce the above copyright
12 *     notice, this list of conditions and the following disclaimer in the
13 *     documentation and/or other materials provided with the distribution.
14 * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
15 *     its contributors may be used to endorse or promote products derived
16 *     from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/**
31 * @param {!InjectedScriptHostClass} InjectedScriptHost
32 * @param {!Window} inspectedWindow
33 * @param {number} injectedScriptId
34 */
35(function (InjectedScriptHost, inspectedWindow, injectedScriptId) {
36
37/**
38 * Protect against Object overwritten by the user code.
39 * @suppress {duplicate}
40 */
41var Object = /** @type {function(new:Object, *=)} */ ({}.constructor);
42
43/**
44 * @param {!Array.<T>} array
45 * @param {...} var_args
46 * @template T
47 */
48function push(array, var_args)
49{
50    for (var i = 1; i < arguments.length; ++i)
51        array[array.length] = arguments[i];
52}
53
54/**
55 * @param {!Arguments.<T>} array
56 * @param {number=} index
57 * @return {!Array.<T>}
58 * @template T
59 */
60function slice(array, index)
61{
62    var result = [];
63    for (var i = index || 0, j = 0; i < array.length; ++i, ++j)
64        result[j] = array[i];
65    return result;
66}
67
68/**
69 * @param {!Array.<T>} array1
70 * @param {!Array.<T>} array2
71 * @return {!Array.<T>}
72 * @template T
73 */
74function concat(array1, array2)
75{
76    var result = [];
77    for (var i = 0; i < array1.length; ++i)
78        push(result, array1[i]);
79    for (var i = 0; i < array2.length; ++i)
80        push(result, array2[i]);
81    return result;
82}
83
84/**
85 * @param {*} obj
86 * @return {string}
87 */
88function toString(obj)
89{
90    // We don't use String(obj) because it could be overriden.
91    return "" + obj;
92}
93
94/**
95 * @param {*} obj
96 * @return {string}
97 */
98function toStringDescription(obj)
99{
100    if (typeof obj === "number" && obj === 0 && 1 / obj < 0)
101        return "-0"; // Negative zero.
102    return "" + obj;
103}
104
105/**
106 * Please use this bind, not the one from Function.prototype
107 * @param {function(...)} func
108 * @param {?Object} thisObject
109 * @param {...} var_args
110 * @return {function(...)}
111 */
112function bind(func, thisObject, var_args)
113{
114    var args = slice(arguments, 2);
115
116    /**
117     * @param {...} var_args
118     */
119    function bound(var_args)
120    {
121        return InjectedScriptHost.callFunction(func, thisObject, concat(args, slice(arguments)));
122    }
123    bound.toString = function()
124    {
125        return "bound: " + func;
126    };
127    return bound;
128}
129
130/**
131 * @param {T} obj
132 * @return {T}
133 * @template T
134 */
135function nullifyObjectProto(obj)
136{
137    if (obj && typeof obj === "object")
138        obj.__proto__ = null;
139    return obj;
140}
141
142/**
143 * @param {*} obj
144 * @return {boolean}
145 */
146function isUInt32(obj)
147{
148    return typeof obj === "number" && obj >>> 0 === obj && (obj > 0 || 1 / obj > 0);
149}
150
151/**
152 * FireBug's array detection.
153 * @param {*} obj
154 * @return {boolean}
155 */
156function isArrayLike(obj)
157{
158    if (typeof obj !== "object")
159        return false;
160    try {
161        if (typeof obj.splice === "function")
162            return isUInt32(obj.length);
163    } catch (e) {
164    }
165    return false;
166}
167
168/**
169 * @param {number} a
170 * @param {number} b
171 * @return {number}
172 */
173function max(a, b)
174{
175    return a > b ? a : b;
176}
177
178/**
179 * FIXME: Remove once ES6 is supported natively by JS compiler.
180 * @param {*} obj
181 * @return {boolean}
182 */
183function isSymbol(obj)
184{
185    var type = typeof obj;
186    return (type === "symbol");
187}
188
189/**
190 * @constructor
191 */
192var InjectedScript = function()
193{
194    /** @type {number} */
195    this._lastBoundObjectId = 1;
196    /** @type {!Object.<number, (!Object|symbol)>} */
197    this._idToWrappedObject = { __proto__: null };
198    /** @type {!Object.<number, string>} */
199    this._idToObjectGroupName = { __proto__: null };
200    /** @type {!Object.<string, !Array.<number>>} */
201    this._objectGroups = { __proto__: null };
202    /** @type {!Object.<string, !Object>} */
203    this._modules = { __proto__: null };
204}
205
206/**
207 * @type {!Object.<string, boolean>}
208 * @const
209 */
210InjectedScript.primitiveTypes = {
211    "undefined": true,
212    "boolean": true,
213    "number": true,
214    "string": true,
215    __proto__: null
216}
217
218InjectedScript.prototype = {
219    /**
220     * @param {*} object
221     * @return {boolean}
222     */
223    isPrimitiveValue: function(object)
224    {
225        // FIXME(33716): typeof document.all is always 'undefined'.
226        return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
227    },
228
229    /**
230     * @param {*} object
231     * @param {string} groupName
232     * @param {boolean} canAccessInspectedWindow
233     * @param {boolean} generatePreview
234     * @return {!RuntimeAgent.RemoteObject}
235     */
236    wrapObject: function(object, groupName, canAccessInspectedWindow, generatePreview)
237    {
238        if (canAccessInspectedWindow)
239            return this._wrapObject(object, groupName, false, generatePreview);
240        return this._fallbackWrapper(object);
241    },
242
243    /**
244     * @param {*} object
245     * @return {!RuntimeAgent.RemoteObject}
246     */
247    _fallbackWrapper: function(object)
248    {
249        var result = { __proto__: null };
250        result.type = typeof object;
251        if (this.isPrimitiveValue(object))
252            result.value = object;
253        else
254            result.description = toString(object);
255        return /** @type {!RuntimeAgent.RemoteObject} */ (result);
256    },
257
258    /**
259     * @param {boolean} canAccessInspectedWindow
260     * @param {!Object} table
261     * @param {!Array.<string>|string|boolean} columns
262     * @return {!RuntimeAgent.RemoteObject}
263     */
264    wrapTable: function(canAccessInspectedWindow, table, columns)
265    {
266        if (!canAccessInspectedWindow)
267            return this._fallbackWrapper(table);
268        var columnNames = null;
269        if (typeof columns === "string")
270            columns = [columns];
271        if (InjectedScriptHost.subtype(columns) === "array") {
272            columnNames = [];
273            for (var i = 0; i < columns.length; ++i)
274                columnNames[i] = toString(columns[i]);
275        }
276        return this._wrapObject(table, "console", false, true, columnNames, true);
277    },
278
279    /**
280     * @param {*} object
281     */
282    inspectNode: function(object)
283    {
284        this._inspect(object);
285    },
286
287    /**
288     * @param {*} object
289     * @return {*}
290     */
291    _inspect: function(object)
292    {
293        if (arguments.length === 0)
294            return;
295
296        var objectId = this._wrapObject(object, "");
297        var hints = { __proto__: null };
298
299        InjectedScriptHost.inspect(objectId, hints);
300        return object;
301    },
302
303    /**
304     * This method cannot throw.
305     * @param {*} object
306     * @param {string=} objectGroupName
307     * @param {boolean=} forceValueType
308     * @param {boolean=} generatePreview
309     * @param {?Array.<string>=} columnNames
310     * @param {boolean=} isTable
311     * @return {!RuntimeAgent.RemoteObject}
312     * @suppress {checkTypes}
313     */
314    _wrapObject: function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable)
315    {
316        try {
317            return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable);
318        } catch (e) {
319            try {
320                var description = injectedScript._describe(e);
321            } catch (ex) {
322                var description = "<failed to convert exception to string>";
323            }
324            return new InjectedScript.RemoteObject(description);
325        }
326    },
327
328    /**
329     * @param {!Object|symbol} object
330     * @param {string=} objectGroupName
331     * @return {string}
332     */
333    _bind: function(object, objectGroupName)
334    {
335        var id = this._lastBoundObjectId++;
336        this._idToWrappedObject[id] = object;
337        var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
338        if (objectGroupName) {
339            var group = this._objectGroups[objectGroupName];
340            if (!group) {
341                group = [];
342                this._objectGroups[objectGroupName] = group;
343            }
344            push(group, id);
345            this._idToObjectGroupName[id] = objectGroupName;
346        }
347        return objectId;
348    },
349
350    /**
351     * @param {string} objectId
352     * @return {!Object}
353     */
354    _parseObjectId: function(objectId)
355    {
356        return nullifyObjectProto(/** @type {!Object} */ (InjectedScriptHost.eval("(" + objectId + ")")));
357    },
358
359    /**
360     * @param {string} objectGroupName
361     */
362    releaseObjectGroup: function(objectGroupName)
363    {
364        if (objectGroupName === "console")
365            delete this._lastResult;
366        var group = this._objectGroups[objectGroupName];
367        if (!group)
368            return;
369        for (var i = 0; i < group.length; i++)
370            this._releaseObject(group[i]);
371        delete this._objectGroups[objectGroupName];
372    },
373
374    /**
375     * @param {string} methodName
376     * @param {string} args
377     * @return {*}
378     */
379    dispatch: function(methodName, args)
380    {
381        var argsArray = /** @type {!Array.<*>} */ (InjectedScriptHost.eval("(" + args + ")"));
382        var result = InjectedScriptHost.callFunction(this[methodName], this, argsArray);
383        if (typeof result === "undefined") {
384            inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
385            result = null;
386        }
387        return result;
388    },
389
390    /**
391     * @param {string} objectId
392     * @param {boolean} ownProperties
393     * @param {boolean} accessorPropertiesOnly
394     * @return {!Array.<!RuntimeAgent.PropertyDescriptor>|boolean}
395     */
396    getProperties: function(objectId, ownProperties, accessorPropertiesOnly)
397    {
398        var parsedObjectId = this._parseObjectId(objectId);
399        var object = this._objectForId(parsedObjectId);
400        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
401
402        if (!this._isDefined(object) || isSymbol(object))
403            return false;
404        object = /** @type {!Object} */ (object);
405        var descriptors = this._propertyDescriptors(object, ownProperties, accessorPropertiesOnly);
406
407        // Go over properties, wrap object values.
408        for (var i = 0; i < descriptors.length; ++i) {
409            var descriptor = descriptors[i];
410            if ("get" in descriptor)
411                descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
412            if ("set" in descriptor)
413                descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
414            if ("value" in descriptor)
415                descriptor.value = this._wrapObject(descriptor.value, objectGroupName);
416            if (!("configurable" in descriptor))
417                descriptor.configurable = false;
418            if (!("enumerable" in descriptor))
419                descriptor.enumerable = false;
420            if ("symbol" in descriptor)
421                descriptor.symbol = this._wrapObject(descriptor.symbol, objectGroupName);
422        }
423        return descriptors;
424    },
425
426    /**
427     * @param {string} objectId
428     * @return {!Array.<!Object>|boolean}
429     */
430    getInternalProperties: function(objectId)
431    {
432        var parsedObjectId = this._parseObjectId(objectId);
433        var object = this._objectForId(parsedObjectId);
434        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
435        if (!this._isDefined(object) || isSymbol(object))
436            return false;
437        object = /** @type {!Object} */ (object);
438        var descriptors = [];
439        var internalProperties = InjectedScriptHost.getInternalProperties(object);
440        if (internalProperties) {
441            for (var i = 0; i < internalProperties.length; i++) {
442                var property = internalProperties[i];
443                var descriptor = {
444                    name: property.name,
445                    value: this._wrapObject(property.value, objectGroupName),
446                    __proto__: null
447                };
448                push(descriptors, descriptor);
449            }
450        }
451        return descriptors;
452    },
453
454    /**
455     * @param {string} functionId
456     * @return {!DebuggerAgent.FunctionDetails|string}
457     */
458    getFunctionDetails: function(functionId)
459    {
460        var parsedFunctionId = this._parseObjectId(functionId);
461        var func = this._objectForId(parsedFunctionId);
462        if (typeof func !== "function")
463            return "Cannot resolve function by id.";
464        var details = nullifyObjectProto(/** @type {!DebuggerAgent.FunctionDetails} */ (InjectedScriptHost.functionDetails(func)));
465        if ("rawScopes" in details) {
466            var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
467            var rawScopes = details["rawScopes"];
468            delete details["rawScopes"];
469            var scopes = [];
470            for (var i = 0; i < rawScopes.length; ++i)
471                scopes[i] = InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName);
472            details.scopeChain = scopes;
473        }
474        return details;
475    },
476
477    /**
478     * @param {string} objectId
479     * @return {!Array.<!Object>|string}
480     */
481    getCollectionEntries: function(objectId)
482    {
483        var parsedObjectId = this._parseObjectId(objectId);
484        var object = this._objectForId(parsedObjectId);
485        if (!object || typeof object !== "object")
486            return "Could not find object with given id";
487        var entries = InjectedScriptHost.collectionEntries(object);
488        if (!entries)
489            return "Object with given id is not a collection";
490        var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
491        for (var i = 0; i < entries.length; ++i) {
492            var entry = nullifyObjectProto(entries[i]);
493            if ("key" in entry)
494                entry.key = this._wrapObject(entry.key, objectGroupName);
495            entry.value = this._wrapObject(entry.value, objectGroupName);
496            entries[i] = entry;
497        }
498        return entries;
499    },
500
501    /**
502     * @param {string} objectId
503     */
504    releaseObject: function(objectId)
505    {
506        var parsedObjectId = this._parseObjectId(objectId);
507        this._releaseObject(parsedObjectId.id);
508    },
509
510    /**
511     * @param {number} id
512     */
513    _releaseObject: function(id)
514    {
515        delete this._idToWrappedObject[id];
516        delete this._idToObjectGroupName[id];
517    },
518
519    /**
520     * @param {!Object} object
521     * @param {boolean=} ownProperties
522     * @param {boolean=} accessorPropertiesOnly
523     * @return {!Array.<!Object>}
524     */
525    _propertyDescriptors: function(object, ownProperties, accessorPropertiesOnly)
526    {
527        var descriptors = [];
528        var propertyProcessed = { __proto__: null };
529
530        /**
531         * @param {?Object} o
532         * @param {!Array.<string|symbol>} properties
533         */
534        function process(o, properties)
535        {
536            for (var i = 0; i < properties.length; ++i) {
537                var property = properties[i];
538                if (propertyProcessed[property])
539                    continue;
540
541                var name = property;
542                if (isSymbol(property))
543                    name = injectedScript._describe(property);
544
545                try {
546                    propertyProcessed[property] = true;
547                    var descriptor = nullifyObjectProto(InjectedScriptHost.suppressWarningsAndCallFunction(Object.getOwnPropertyDescriptor, Object, [o, property]));
548                    if (descriptor) {
549                        if (accessorPropertiesOnly && !("get" in descriptor || "set" in descriptor))
550                            continue;
551                    } else {
552                        // Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
553                        if (accessorPropertiesOnly)
554                            continue;
555                        try {
556                            descriptor = { name: name, value: o[property], writable: false, configurable: false, enumerable: false, __proto__: null };
557                            if (o === object)
558                                descriptor.isOwn = true;
559                            push(descriptors, descriptor);
560                        } catch (e) {
561                            // Silent catch.
562                        }
563                        continue;
564                    }
565                } catch (e) {
566                    if (accessorPropertiesOnly)
567                        continue;
568                    var descriptor = { __proto__: null };
569                    descriptor.value = e;
570                    descriptor.wasThrown = true;
571                }
572
573                descriptor.name = name;
574                if (o === object)
575                    descriptor.isOwn = true;
576                if (isSymbol(property))
577                    descriptor.symbol = property;
578                push(descriptors, descriptor);
579            }
580        }
581
582        for (var o = object; this._isDefined(o); o = o.__proto__) {
583            // First call Object.keys() to enforce ordering of the property descriptors.
584            process(o, Object.keys(/** @type {!Object} */ (o)));
585            process(o, Object.getOwnPropertyNames(/** @type {!Object} */ (o)));
586            if (Object.getOwnPropertySymbols)
587                process(o, Object.getOwnPropertySymbols(/** @type {!Object} */ (o)));
588
589            if (ownProperties) {
590                if (object.__proto__ && !accessorPropertiesOnly)
591                    push(descriptors, { name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false, isOwn: true, __proto__: null });
592                break;
593            }
594        }
595
596        return descriptors;
597    },
598
599    /**
600     * @param {string} expression
601     * @param {string} objectGroup
602     * @param {boolean} injectCommandLineAPI
603     * @param {boolean} returnByValue
604     * @param {boolean} generatePreview
605     * @return {*}
606     */
607    evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
608    {
609        return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview);
610    },
611
612    /**
613     * @param {string} objectId
614     * @param {string} expression
615     * @param {string} args
616     * @param {boolean} returnByValue
617     * @return {!Object|string}
618     */
619    callFunctionOn: function(objectId, expression, args, returnByValue)
620    {
621        var parsedObjectId = this._parseObjectId(objectId);
622        var object = this._objectForId(parsedObjectId);
623        if (!this._isDefined(object))
624            return "Could not find object with given id";
625
626        if (args) {
627            var resolvedArgs = [];
628            var callArgs = /** @type {!Array.<!RuntimeAgent.CallArgument>} */ (InjectedScriptHost.eval(args));
629            for (var i = 0; i < callArgs.length; ++i) {
630                try {
631                    resolvedArgs[i] = this._resolveCallArgument(callArgs[i]);
632                } catch (e) {
633                    return toString(e);
634                }
635            }
636        }
637
638        try {
639            var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
640            var func = InjectedScriptHost.eval("(" + expression + ")");
641            if (typeof func !== "function")
642                return "Given expression does not evaluate to a function";
643
644            return { wasThrown: false,
645                     result: this._wrapObject(InjectedScriptHost.callFunction(func, object, resolvedArgs), objectGroup, returnByValue),
646                     __proto__: null };
647        } catch (e) {
648            return this._createThrownValue(e, objectGroup, false);
649        }
650    },
651
652    /**
653     * Resolves a value from CallArgument description.
654     * @param {!RuntimeAgent.CallArgument} callArgumentJson
655     * @return {*} resolved value
656     * @throws {string} error message
657     */
658    _resolveCallArgument: function(callArgumentJson)
659    {
660        callArgumentJson = nullifyObjectProto(callArgumentJson);
661        var objectId = callArgumentJson.objectId;
662        if (objectId) {
663            var parsedArgId = this._parseObjectId(objectId);
664            if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
665                throw "Arguments should belong to the same JavaScript world as the target object.";
666
667            var resolvedArg = this._objectForId(parsedArgId);
668            if (!this._isDefined(resolvedArg))
669                throw "Could not find object with given id";
670
671            return resolvedArg;
672        } else if ("value" in callArgumentJson) {
673            var value = callArgumentJson.value;
674            if (callArgumentJson.type === "number" && typeof value !== "number")
675                value = Number(value);
676            return value;
677        }
678        return undefined;
679    },
680
681    /**
682     * @param {?function(string):*} evalFunction
683     * @param {?Object} object
684     * @param {string} expression
685     * @param {string} objectGroup
686     * @param {boolean} isEvalOnCallFrame
687     * @param {boolean} injectCommandLineAPI
688     * @param {boolean} returnByValue
689     * @param {boolean} generatePreview
690     * @param {!Array.<!Object>=} scopeChain
691     * @return {!Object}
692     */
693    _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, scopeChain)
694    {
695        var wrappedResult = this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain);
696        if (!wrappedResult.exceptionDetails) {
697            return { wasThrown: false,
698                     result: this._wrapObject(wrappedResult.result, objectGroup, returnByValue, generatePreview),
699                     __proto__: null };
700        }
701        return this._createThrownValue(wrappedResult.result, objectGroup, generatePreview, wrappedResult.exceptionDetails);
702    },
703
704    /**
705     * @param {*} value
706     * @param {string} objectGroup
707     * @param {boolean} generatePreview
708     * @param {!DebuggerAgent.ExceptionDetails=} exceptionDetails
709     * @return {!Object}
710     */
711    _createThrownValue: function(value, objectGroup, generatePreview, exceptionDetails)
712    {
713        var remoteObject = this._wrapObject(value, objectGroup, false, generatePreview && !(value instanceof Error));
714        if (!remoteObject.description){
715            try {
716                remoteObject.description = toStringDescription(value);
717            } catch (e) {}
718        }
719        return { wasThrown: true, result: remoteObject, exceptionDetails: exceptionDetails, __proto__: null };
720    },
721
722    /**
723     * @param {?function(string):*} evalFunction
724     * @param {?Object} object
725     * @param {string} objectGroup
726     * @param {string} expression
727     * @param {boolean} isEvalOnCallFrame
728     * @param {boolean} injectCommandLineAPI
729     * @param {!Array.<!Object>=} scopeChain
730     * @return {*}
731     */
732    _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, scopeChain)
733    {
734        // Only install command line api object for the time of evaluation.
735        // Surround the expression in with statements to inject our command line API so that
736        // the window object properties still take more precedent than our API functions.
737
738        injectCommandLineAPI = injectCommandLineAPI && !("__commandLineAPI" in inspectedWindow);
739        var injectScopeChain = scopeChain && scopeChain.length && !("__scopeChainForEval" in inspectedWindow);
740
741        try {
742            var prefix = "";
743            var suffix = "";
744            if (injectCommandLineAPI) {
745                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__commandLineAPI", new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null));
746                prefix = "with (__commandLineAPI || { __proto__: null }) {";
747                suffix = "}";
748            }
749            if (injectScopeChain) {
750                InjectedScriptHost.setNonEnumProperty(inspectedWindow, "__scopeChainForEval", scopeChain);
751                for (var i = 0; i < scopeChain.length; ++i) {
752                    prefix = "with (__scopeChainForEval[" + i + "] || { __proto__: null }) {" + (suffix ? " " : "") + prefix;
753                    if (suffix)
754                        suffix += " }";
755                    else
756                        suffix = "}";
757                }
758            }
759
760            if (prefix)
761                expression = prefix + "\n" + expression + "\n" + suffix;
762            var wrappedResult = evalFunction ? InjectedScriptHost.callFunction(evalFunction, object, [expression]) : InjectedScriptHost.evaluateWithExceptionDetails(expression);
763            if (objectGroup === "console" && !wrappedResult.exceptionDetails)
764                this._lastResult = wrappedResult.result;
765            return wrappedResult;
766        } finally {
767            if (injectCommandLineAPI)
768                delete inspectedWindow["__commandLineAPI"];
769            if (injectScopeChain)
770                delete inspectedWindow["__scopeChainForEval"];
771        }
772    },
773
774    /**
775     * @param {?Object} callFrame
776     * @param {number} asyncOrdinal
777     * @return {!Array.<!InjectedScript.CallFrameProxy>|boolean}
778     */
779    wrapCallFrames: function(callFrame, asyncOrdinal)
780    {
781        if (!callFrame)
782            return false;
783
784        var result = [];
785        var depth = 0;
786        do {
787            result[depth] = new InjectedScript.CallFrameProxy(depth, callFrame, asyncOrdinal);
788            callFrame = callFrame.caller;
789            ++depth;
790        } while (callFrame);
791        return result;
792    },
793
794    /**
795     * @param {!Object} topCallFrame
796     * @param {!Array.<!Object>} asyncCallStacks
797     * @param {string} callFrameId
798     * @param {string} expression
799     * @param {string} objectGroup
800     * @param {boolean} injectCommandLineAPI
801     * @param {boolean} returnByValue
802     * @param {boolean} generatePreview
803     * @return {*}
804     */
805    evaluateOnCallFrame: function(topCallFrame, asyncCallStacks, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview)
806    {
807        var parsedCallFrameId = nullifyObjectProto(/** @type {!Object} */ (InjectedScriptHost.eval("(" + callFrameId + ")")));
808        var callFrame = this._callFrameForParsedId(topCallFrame, parsedCallFrameId, asyncCallStacks);
809        if (!callFrame)
810            return "Could not find call frame with given id";
811        if (parsedCallFrameId["asyncOrdinal"])
812            return this._evaluateAndWrap(null, null, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, callFrame.scopeChain);
813        return this._evaluateAndWrap(callFrame.evaluateWithExceptionDetails, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview);
814    },
815
816    /**
817     * @param {!Object} topCallFrame
818     * @param {string} callFrameId
819     * @return {*}
820     */
821    restartFrame: function(topCallFrame, callFrameId)
822    {
823        var callFrame = this._callFrameForId(topCallFrame, callFrameId);
824        if (!callFrame)
825            return "Could not find call frame with given id";
826        var result = callFrame.restart();
827        if (result === false)
828            result = "Restart frame is not supported";
829        return result;
830    },
831
832    /**
833     * @param {!Object} topCallFrame
834     * @param {string} callFrameId
835     * @return {*} a stepIn position array ready for protocol JSON or a string error
836     */
837    getStepInPositions: function(topCallFrame, callFrameId)
838    {
839        var callFrame = this._callFrameForId(topCallFrame, callFrameId);
840        if (!callFrame)
841            return "Could not find call frame with given id";
842        var stepInPositionsUnpacked = JSON.parse(callFrame.stepInPositions);
843        if (typeof stepInPositionsUnpacked !== "object")
844            return "Step in positions not available";
845        return stepInPositionsUnpacked;
846    },
847
848    /**
849     * Either callFrameId or functionObjectId must be specified.
850     * @param {!Object} topCallFrame
851     * @param {string|boolean} callFrameId or false
852     * @param {string|boolean} functionObjectId or false
853     * @param {number} scopeNumber
854     * @param {string} variableName
855     * @param {string} newValueJsonString RuntimeAgent.CallArgument structure serialized as string
856     * @return {string|undefined} undefined if success or an error message
857     */
858    setVariableValue: function(topCallFrame, callFrameId, functionObjectId, scopeNumber, variableName, newValueJsonString)
859    {
860        try {
861            var newValueJson = /** @type {!RuntimeAgent.CallArgument} */ (InjectedScriptHost.eval("(" + newValueJsonString + ")"));
862            var resolvedValue = this._resolveCallArgument(newValueJson);
863            if (typeof callFrameId === "string") {
864                var callFrame = this._callFrameForId(topCallFrame, callFrameId);
865                if (!callFrame)
866                    return "Could not find call frame with given id";
867                callFrame.setVariableValue(scopeNumber, variableName, resolvedValue)
868            } else {
869                var parsedFunctionId = this._parseObjectId(/** @type {string} */ (functionObjectId));
870                var func = this._objectForId(parsedFunctionId);
871                if (typeof func !== "function")
872                    return "Could not resolve function by id";
873                InjectedScriptHost.setFunctionVariableValue(func, scopeNumber, variableName, resolvedValue);
874            }
875        } catch (e) {
876            return toString(e);
877        }
878        return undefined;
879    },
880
881    /**
882     * @param {!Object} topCallFrame
883     * @param {string} callFrameId
884     * @return {?Object}
885     */
886    _callFrameForId: function(topCallFrame, callFrameId)
887    {
888        var parsedCallFrameId = nullifyObjectProto(/** @type {!Object} */ (InjectedScriptHost.eval("(" + callFrameId + ")")));
889        return this._callFrameForParsedId(topCallFrame, parsedCallFrameId, []);
890    },
891
892    /**
893     * @param {!Object} topCallFrame
894     * @param {!Object} parsedCallFrameId
895     * @param {!Array.<!Object>} asyncCallStacks
896     * @return {?Object}
897     */
898    _callFrameForParsedId: function(topCallFrame, parsedCallFrameId, asyncCallStacks)
899    {
900        var asyncOrdinal = parsedCallFrameId["asyncOrdinal"]; // 1-based index
901        if (asyncOrdinal)
902            topCallFrame = asyncCallStacks[asyncOrdinal - 1];
903        var ordinal = parsedCallFrameId["ordinal"];
904        var callFrame = topCallFrame;
905        while (--ordinal >= 0 && callFrame)
906            callFrame = callFrame.caller;
907        return callFrame;
908    },
909
910    /**
911     * @param {!Object} objectId
912     * @return {!Object|symbol}
913     */
914    _objectForId: function(objectId)
915    {
916        return this._idToWrappedObject[objectId.id];
917    },
918
919    /**
920     * @param {string} objectId
921     * @return {!Object|symbol}
922     */
923    findObjectById: function(objectId)
924    {
925        var parsedObjectId = this._parseObjectId(objectId);
926        return this._objectForId(parsedObjectId);
927    },
928
929    /**
930     * @param {string} objectId
931     * @return {?Node}
932     */
933    nodeForObjectId: function(objectId)
934    {
935        var object = this.findObjectById(objectId);
936        if (!object || this._subtype(object) !== "node")
937            return null;
938        return /** @type {!Node} */ (object);
939    },
940
941    /**
942     * @param {string} name
943     * @return {!Object}
944     */
945    module: function(name)
946    {
947        return this._modules[name];
948    },
949
950    /**
951     * @param {string} name
952     * @param {string} source
953     * @return {?Object}
954     */
955    injectModule: function(name, source)
956    {
957        delete this._modules[name];
958        var moduleFunction = InjectedScriptHost.eval("(" + source + ")");
959        if (typeof moduleFunction !== "function") {
960            inspectedWindow.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
961            return null;
962        }
963        var module = /** @type {!Object} */ (InjectedScriptHost.callFunction(moduleFunction, inspectedWindow, [InjectedScriptHost, inspectedWindow, injectedScriptId, this]));
964        this._modules[name] = module;
965        return module;
966    },
967
968    /**
969     * @param {*} object
970     * @return {boolean}
971     */
972    _isDefined: function(object)
973    {
974        return !!object || this._isHTMLAllCollection(object);
975    },
976
977    /**
978     * @param {*} object
979     * @return {boolean}
980     */
981    _isHTMLAllCollection: function(object)
982    {
983        // document.all is reported as undefined, but we still want to process it.
984        return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
985    },
986
987    /**
988     * @param {*} obj
989     * @return {?string}
990     */
991    _subtype: function(obj)
992    {
993        if (obj === null)
994            return "null";
995
996        if (this.isPrimitiveValue(obj))
997            return null;
998
999        var subtype = InjectedScriptHost.subtype(obj);
1000        if (subtype)
1001            return subtype;
1002
1003        if (isArrayLike(obj))
1004            return "array";
1005
1006        // If owning frame has navigated to somewhere else window properties will be undefined.
1007        return null;
1008    },
1009
1010    /**
1011     * @param {*} obj
1012     * @return {?string}
1013     */
1014    _describe: function(obj)
1015    {
1016        if (this.isPrimitiveValue(obj))
1017            return null;
1018
1019        var subtype = this._subtype(obj);
1020
1021        if (subtype === "regexp")
1022            return toString(obj);
1023
1024        if (subtype === "date")
1025            return toString(obj);
1026
1027        if (subtype === "node") {
1028            var description = obj.nodeName.toLowerCase();
1029            switch (obj.nodeType) {
1030            case 1 /* Node.ELEMENT_NODE */:
1031                description += obj.id ? "#" + obj.id : "";
1032                var className = obj.className;
1033                description += (className && typeof className === "string") ? "." + className.trim().replace(/\s+/g, ".") : "";
1034                break;
1035            case 10 /*Node.DOCUMENT_TYPE_NODE */:
1036                description = "<!DOCTYPE " + description + ">";
1037                break;
1038            }
1039            return description;
1040        }
1041
1042        var className = InjectedScriptHost.internalConstructorName(obj);
1043        if (subtype === "array") {
1044            if (typeof obj.length === "number")
1045                className += "[" + obj.length + "]";
1046            return className;
1047        }
1048
1049        // NodeList in JSC is a function, check for array prior to this.
1050        if (typeof obj === "function")
1051            return toString(obj);
1052
1053        if (isSymbol(obj)) {
1054            try {
1055                return /** @type {string} */ (InjectedScriptHost.callFunction(Symbol.prototype.toString, obj)) || "Symbol";
1056            } catch (e) {
1057                return "Symbol";
1058            }
1059        }
1060
1061        if (obj instanceof Error && !!obj.message)
1062            return className + ": " + obj.message;
1063
1064        return className;
1065    }
1066}
1067
1068/**
1069 * @type {!InjectedScript}
1070 * @const
1071 */
1072var injectedScript = new InjectedScript();
1073
1074/**
1075 * @constructor
1076 * @param {*} object
1077 * @param {string=} objectGroupName
1078 * @param {boolean=} forceValueType
1079 * @param {boolean=} generatePreview
1080 * @param {?Array.<string>=} columnNames
1081 * @param {boolean=} isTable
1082 * @param {boolean=} skipEntriesPreview
1083 */
1084InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames, isTable, skipEntriesPreview)
1085{
1086    this.type = typeof object;
1087    if (this.type === "undefined" && injectedScript._isHTMLAllCollection(object))
1088        this.type = "object";
1089
1090    if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
1091        // We don't send undefined values over JSON.
1092        if (this.type !== "undefined")
1093            this.value = object;
1094
1095        // Null object is object with 'null' subtype.
1096        if (object === null)
1097            this.subtype = "null";
1098
1099        // Provide user-friendly number values.
1100        if (this.type === "number") {
1101            this.description = toStringDescription(object);
1102            // Override "value" property for values that can not be JSON-stringified.
1103            switch (this.description) {
1104            case "NaN":
1105            case "Infinity":
1106            case "-Infinity":
1107            case "-0":
1108                this.value = this.description;
1109                break;
1110            }
1111        }
1112
1113        return;
1114    }
1115
1116    object = /** @type {!Object} */ (object);
1117
1118    this.objectId = injectedScript._bind(object, objectGroupName);
1119    var subtype = injectedScript._subtype(object);
1120    if (subtype)
1121        this.subtype = subtype;
1122    var className = InjectedScriptHost.internalConstructorName(object);
1123    if (className)
1124        this.className = className;
1125    this.description = injectedScript._describe(object);
1126
1127    if (generatePreview && this.type === "object")
1128        this.preview = this._generatePreview(object, undefined, columnNames, isTable, skipEntriesPreview);
1129}
1130
1131InjectedScript.RemoteObject.prototype = {
1132    /**
1133     * @return {!RuntimeAgent.ObjectPreview} preview
1134     */
1135    _createEmptyPreview: function()
1136    {
1137        var preview = {
1138            type: /** @type {!RuntimeAgent.ObjectPreviewType.<string>} */ (this.type),
1139            description: this.description || toStringDescription(this.value),
1140            lossless: true,
1141            overflow: false,
1142            properties: [],
1143            __proto__: null
1144        };
1145        if (this.subtype)
1146            preview.subtype = /** @type {!RuntimeAgent.ObjectPreviewSubtype.<string>} */ (this.subtype);
1147        return preview;
1148    },
1149
1150    /**
1151     * @param {!Object} object
1152     * @param {?Array.<string>=} firstLevelKeys
1153     * @param {?Array.<string>=} secondLevelKeys
1154     * @param {boolean=} isTable
1155     * @param {boolean=} skipEntriesPreview
1156     * @return {!RuntimeAgent.ObjectPreview} preview
1157     */
1158    _generatePreview: function(object, firstLevelKeys, secondLevelKeys, isTable, skipEntriesPreview)
1159    {
1160        var preview = this._createEmptyPreview();
1161        var firstLevelKeysCount = firstLevelKeys ? firstLevelKeys.length : 0;
1162
1163        var propertiesThreshold = {
1164            properties: isTable ? 1000 : max(5, firstLevelKeysCount),
1165            indexes: isTable ? 1000 : max(100, firstLevelKeysCount),
1166            __proto__: null
1167        };
1168
1169        try {
1170            var descriptors = injectedScript._propertyDescriptors(object);
1171
1172            if (firstLevelKeys) {
1173                var nameToDescriptors = { __proto__: null };
1174                for (var i = 0; i < descriptors.length; ++i) {
1175                    var descriptor = descriptors[i];
1176                    nameToDescriptors["#" + descriptor.name] = descriptor;
1177                }
1178                descriptors = [];
1179                for (var i = 0; i < firstLevelKeys.length; ++i)
1180                    descriptors[i] = nameToDescriptors["#" + firstLevelKeys[i]];
1181            }
1182
1183            this._appendPropertyDescriptors(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable);
1184            if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
1185                return preview;
1186
1187            // Add internal properties to preview.
1188            var internalProperties = InjectedScriptHost.getInternalProperties(object) || [];
1189            for (var i = 0; i < internalProperties.length; ++i) {
1190                internalProperties[i] = nullifyObjectProto(internalProperties[i]);
1191                internalProperties[i].enumerable = true;
1192            }
1193            this._appendPropertyDescriptors(preview, internalProperties, propertiesThreshold, secondLevelKeys, isTable);
1194
1195            if (this.subtype === "map" || this.subtype === "set")
1196                this._appendEntriesPreview(object, preview, skipEntriesPreview);
1197
1198        } catch (e) {
1199            preview.lossless = false;
1200        }
1201
1202        return preview;
1203    },
1204
1205    /**
1206     * @param {!RuntimeAgent.ObjectPreview} preview
1207     * @param {!Array.<!Object>} descriptors
1208     * @param {!Object} propertiesThreshold
1209     * @param {?Array.<string>=} secondLevelKeys
1210     * @param {boolean=} isTable
1211     */
1212    _appendPropertyDescriptors: function(preview, descriptors, propertiesThreshold, secondLevelKeys, isTable)
1213    {
1214        for (var i = 0; i < descriptors.length; ++i) {
1215            if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
1216                break;
1217
1218            var descriptor = descriptors[i];
1219            if (!descriptor)
1220                continue;
1221            if (descriptor.wasThrown) {
1222                preview.lossless = false;
1223                continue;
1224            }
1225            if (!descriptor.enumerable && !descriptor.isOwn)
1226                continue;
1227
1228            var name = descriptor.name;
1229            if (name === "__proto__")
1230                continue;
1231            if (this.subtype === "array" && name === "length")
1232                continue;
1233
1234            if (!("value" in descriptor)) {
1235                preview.lossless = false;
1236                this._appendPropertyPreview(preview, { name: name, type: "accessor", __proto__: null }, propertiesThreshold);
1237                continue;
1238            }
1239
1240            var value = descriptor.value;
1241            if (value === null) {
1242                this._appendPropertyPreview(preview, { name: name, type: "object", subtype: "null", value: "null", __proto__: null }, propertiesThreshold);
1243                continue;
1244            }
1245
1246            var type = typeof value;
1247            if (!descriptor.enumerable && type === "function")
1248                continue;
1249            if (type === "undefined" && injectedScript._isHTMLAllCollection(value))
1250                type = "object";
1251
1252            var maxLength = 100;
1253            if (InjectedScript.primitiveTypes[type]) {
1254                if (type === "string" && value.length > maxLength) {
1255                    value = this._abbreviateString(value, maxLength, true);
1256                    preview.lossless = false;
1257                }
1258                this._appendPropertyPreview(preview, { name: name, type: type, value: toStringDescription(value), __proto__: null }, propertiesThreshold);
1259                continue;
1260            }
1261
1262            var property = { name: name, type: type, __proto__: null };
1263            var subtype = injectedScript._subtype(value);
1264            if (subtype)
1265                property.subtype = subtype;
1266
1267            if (secondLevelKeys === null || secondLevelKeys) {
1268                var subPreview = this._generatePreview(value, secondLevelKeys || undefined, undefined, isTable);
1269                property.valuePreview = subPreview;
1270                if (!subPreview.lossless)
1271                    preview.lossless = false;
1272                if (subPreview.overflow)
1273                    preview.overflow = true;
1274            } else {
1275                var description = "";
1276                if (type !== "function")
1277                    description = this._abbreviateString(/** @type {string} */ (injectedScript._describe(value)), maxLength, subtype === "regexp");
1278                property.value = description;
1279                preview.lossless = false;
1280            }
1281            this._appendPropertyPreview(preview, property, propertiesThreshold);
1282        }
1283    },
1284
1285    /**
1286     * @param {!RuntimeAgent.ObjectPreview} preview
1287     * @param {!Object} property
1288     * @param {!Object} propertiesThreshold
1289     */
1290    _appendPropertyPreview: function(preview, property, propertiesThreshold)
1291    {
1292        if (toString(property.name >>> 0) === property.name)
1293            propertiesThreshold.indexes--;
1294        else
1295            propertiesThreshold.properties--;
1296        if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0) {
1297            preview.overflow = true;
1298            preview.lossless = false;
1299        } else {
1300            push(preview.properties, property);
1301        }
1302    },
1303
1304    /**
1305     * @param {!Object} object
1306     * @param {!RuntimeAgent.ObjectPreview} preview
1307     * @param {boolean=} skipEntriesPreview
1308     */
1309    _appendEntriesPreview: function(object, preview, skipEntriesPreview)
1310    {
1311        var entries = InjectedScriptHost.collectionEntries(object);
1312        if (!entries)
1313            return;
1314        if (skipEntriesPreview) {
1315            if (entries.length) {
1316                preview.overflow = true;
1317                preview.lossless = false;
1318            }
1319            return;
1320        }
1321        preview.entries = [];
1322        var entriesThreshold = 5;
1323        for (var i = 0; i < entries.length; ++i) {
1324            if (preview.entries.length >= entriesThreshold) {
1325                preview.overflow = true;
1326                preview.lossless = false;
1327                break;
1328            }
1329            var entry = nullifyObjectProto(entries[i]);
1330            var previewEntry = {
1331                value: generateValuePreview(entry.value),
1332                __proto__: null
1333            };
1334            if ("key" in entry)
1335                previewEntry.key = generateValuePreview(entry.key);
1336            push(preview.entries, previewEntry);
1337        }
1338
1339        /**
1340         * @param {*} value
1341         * @return {!RuntimeAgent.ObjectPreview}
1342         */
1343        function generateValuePreview(value)
1344        {
1345            var remoteObject = new InjectedScript.RemoteObject(value, undefined, undefined, true, undefined, undefined, true);
1346            var valuePreview = remoteObject.preview || remoteObject._createEmptyPreview();
1347            if (remoteObject.objectId)
1348                injectedScript.releaseObject(remoteObject.objectId);
1349            if (!valuePreview.lossless)
1350                preview.lossless = false;
1351            return valuePreview;
1352        }
1353    },
1354
1355    /**
1356     * @param {string} string
1357     * @param {number} maxLength
1358     * @param {boolean=} middle
1359     * @return {string}
1360     */
1361    _abbreviateString: function(string, maxLength, middle)
1362    {
1363        if (string.length <= maxLength)
1364            return string;
1365        if (middle) {
1366            var leftHalf = maxLength >> 1;
1367            var rightHalf = maxLength - leftHalf - 1;
1368            return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
1369        }
1370        return string.substr(0, maxLength) + "\u2026";
1371    },
1372
1373    __proto__: null
1374}
1375/**
1376 * @constructor
1377 * @param {number} ordinal
1378 * @param {!JavaScriptCallFrame} callFrame
1379 * @param {number} asyncOrdinal
1380 */
1381InjectedScript.CallFrameProxy = function(ordinal, callFrame, asyncOrdinal)
1382{
1383    this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + (asyncOrdinal ? ",\"asyncOrdinal\":" + asyncOrdinal : "") + "}";
1384    this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
1385    this.location = { scriptId: toString(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column, __proto__: null };
1386    this.scopeChain = this._wrapScopeChain(callFrame);
1387    this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
1388    if (callFrame.isAtReturn)
1389        this.returnValue = injectedScript._wrapObject(callFrame.returnValue, "backtrace");
1390}
1391
1392InjectedScript.CallFrameProxy.prototype = {
1393    /**
1394     * @param {!JavaScriptCallFrame} callFrame
1395     * @return {!Array.<!DebuggerAgent.Scope>}
1396     */
1397    _wrapScopeChain: function(callFrame)
1398    {
1399        var scopeChain = callFrame.scopeChain;
1400        var scopeChainProxy = [];
1401        for (var i = 0; i < scopeChain.length; ++i)
1402            scopeChainProxy[i] = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
1403        return scopeChainProxy;
1404    },
1405
1406    __proto__: null
1407}
1408
1409/**
1410 * @param {number} scopeTypeCode
1411 * @param {*} scopeObject
1412 * @param {string} groupId
1413 * @return {!DebuggerAgent.Scope}
1414 */
1415InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId)
1416{
1417    const GLOBAL_SCOPE = 0;
1418    const LOCAL_SCOPE = 1;
1419    const WITH_SCOPE = 2;
1420    const CLOSURE_SCOPE = 3;
1421    const CATCH_SCOPE = 4;
1422
1423    /** @type {!Object.<number, string>} */
1424    var scopeTypeNames = { __proto__: null };
1425    scopeTypeNames[GLOBAL_SCOPE] = "global";
1426    scopeTypeNames[LOCAL_SCOPE] = "local";
1427    scopeTypeNames[WITH_SCOPE] = "with";
1428    scopeTypeNames[CLOSURE_SCOPE] = "closure";
1429    scopeTypeNames[CATCH_SCOPE] = "catch";
1430
1431    return {
1432        object: injectedScript._wrapObject(scopeObject, groupId),
1433        type: /** @type {!DebuggerAgent.ScopeType} */ (scopeTypeNames[scopeTypeCode]),
1434        __proto__: null
1435    };
1436}
1437
1438/**
1439 * @constructor
1440 * @param {!CommandLineAPIImpl} commandLineAPIImpl
1441 * @param {?Object} callFrame
1442 */
1443function CommandLineAPI(commandLineAPIImpl, callFrame)
1444{
1445    /**
1446     * @param {string} member
1447     * @return {boolean}
1448     */
1449    function inScopeVariables(member)
1450    {
1451        if (!callFrame)
1452            return false;
1453
1454        var scopeChain = callFrame.scopeChain;
1455        for (var i = 0; i < scopeChain.length; ++i) {
1456            if (member in scopeChain[i])
1457                return true;
1458        }
1459        return false;
1460    }
1461
1462    /**
1463     * @param {string} name The name of the method for which a toString method should be generated.
1464     * @return {function():string}
1465     */
1466    function customToStringMethod(name)
1467    {
1468        return function()
1469        {
1470            var funcArgsSyntax = "";
1471            try {
1472                var funcSyntax = "" + commandLineAPIImpl[name];
1473                funcSyntax = funcSyntax.replace(/\n/g, " ");
1474                funcSyntax = funcSyntax.replace(/^function[^\(]*\(([^\)]*)\).*$/, "$1");
1475                funcSyntax = funcSyntax.replace(/\s*,\s*/g, ", ");
1476                funcSyntax = funcSyntax.replace(/\bopt_(\w+)\b/g, "[$1]");
1477                funcArgsSyntax = funcSyntax.trim();
1478            } catch (e) {
1479            }
1480            return "function " + name + "(" + funcArgsSyntax + ") { [Command Line API] }";
1481        };
1482    }
1483
1484    for (var i = 0; i < CommandLineAPI.members_.length; ++i) {
1485        var member = CommandLineAPI.members_[i];
1486        if (member in inspectedWindow || inScopeVariables(member))
1487            continue;
1488
1489        this[member] = bind(commandLineAPIImpl[member], commandLineAPIImpl);
1490        this[member].toString = customToStringMethod(member);
1491    }
1492
1493    for (var i = 0; i < 5; ++i) {
1494        var member = "$" + i;
1495        if (member in inspectedWindow || inScopeVariables(member))
1496            continue;
1497
1498        this.__defineGetter__("$" + i, bind(commandLineAPIImpl._inspectedObject, commandLineAPIImpl, i));
1499    }
1500
1501    this.$_ = injectedScript._lastResult;
1502
1503    this.__proto__ = null;
1504}
1505
1506// NOTE: Please keep the list of API methods below snchronized to that in WebInspector.RuntimeModel!
1507// NOTE: Argument names of these methods will be printed in the console, so use pretty names!
1508/**
1509 * @type {!Array.<string>}
1510 * @const
1511 */
1512CommandLineAPI.members_ = [
1513    "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
1514    "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners",
1515    "debug", "undebug", "monitor", "unmonitor", "table"
1516];
1517
1518/**
1519 * @constructor
1520 */
1521function CommandLineAPIImpl()
1522{
1523}
1524
1525CommandLineAPIImpl.prototype = {
1526    /**
1527     * @param {string} selector
1528     * @param {!Node=} opt_startNode
1529     * @return {*}
1530     */
1531    $: function (selector, opt_startNode)
1532    {
1533        if (this._canQuerySelectorOnNode(opt_startNode))
1534            return opt_startNode.querySelector(selector);
1535
1536        return inspectedWindow.document.querySelector(selector);
1537    },
1538
1539    /**
1540     * @param {string} selector
1541     * @param {!Node=} opt_startNode
1542     * @return {*}
1543     */
1544    $$: function (selector, opt_startNode)
1545    {
1546        if (this._canQuerySelectorOnNode(opt_startNode))
1547            return opt_startNode.querySelectorAll(selector);
1548        return inspectedWindow.document.querySelectorAll(selector);
1549    },
1550
1551    /**
1552     * @param {!Node=} node
1553     * @return {boolean}
1554     */
1555    _canQuerySelectorOnNode: function(node)
1556    {
1557        return !!node && InjectedScriptHost.subtype(node) === "node" && (node.nodeType === Node.ELEMENT_NODE || node.nodeType === Node.DOCUMENT_NODE || node.nodeType === Node.DOCUMENT_FRAGMENT_NODE);
1558    },
1559
1560    /**
1561     * @param {string} xpath
1562     * @param {!Node=} opt_startNode
1563     * @return {*}
1564     */
1565    $x: function(xpath, opt_startNode)
1566    {
1567        var doc = (opt_startNode && opt_startNode.ownerDocument) || inspectedWindow.document;
1568        var result = doc.evaluate(xpath, opt_startNode || doc, null, XPathResult.ANY_TYPE, null);
1569        switch (result.resultType) {
1570        case XPathResult.NUMBER_TYPE:
1571            return result.numberValue;
1572        case XPathResult.STRING_TYPE:
1573            return result.stringValue;
1574        case XPathResult.BOOLEAN_TYPE:
1575            return result.booleanValue;
1576        default:
1577            var nodes = [];
1578            var node;
1579            while (node = result.iterateNext())
1580                push(nodes, node);
1581            return nodes;
1582        }
1583    },
1584
1585    /**
1586     * @return {*}
1587     */
1588    dir: function(var_args)
1589    {
1590        return InjectedScriptHost.callFunction(inspectedWindow.console.dir, inspectedWindow.console, slice(arguments));
1591    },
1592
1593    /**
1594     * @return {*}
1595     */
1596    dirxml: function(var_args)
1597    {
1598        return InjectedScriptHost.callFunction(inspectedWindow.console.dirxml, inspectedWindow.console, slice(arguments));
1599    },
1600
1601    /**
1602     * @return {!Array.<string>}
1603     */
1604    keys: function(object)
1605    {
1606        return Object.keys(object);
1607    },
1608
1609    /**
1610     * @return {!Array.<*>}
1611     */
1612    values: function(object)
1613    {
1614        var result = [];
1615        for (var key in object)
1616            push(result, object[key]);
1617        return result;
1618    },
1619
1620    /**
1621     * @return {*}
1622     */
1623    profile: function(opt_title)
1624    {
1625        return InjectedScriptHost.callFunction(inspectedWindow.console.profile, inspectedWindow.console, slice(arguments));
1626    },
1627
1628    /**
1629     * @return {*}
1630     */
1631    profileEnd: function(opt_title)
1632    {
1633        return InjectedScriptHost.callFunction(inspectedWindow.console.profileEnd, inspectedWindow.console, slice(arguments));
1634    },
1635
1636    /**
1637     * @param {!Object} object
1638     * @param {!Array.<string>|string=} opt_types
1639     */
1640    monitorEvents: function(object, opt_types)
1641    {
1642        if (!object || !object.addEventListener || !object.removeEventListener)
1643            return;
1644        var types = this._normalizeEventTypes(opt_types);
1645        for (var i = 0; i < types.length; ++i) {
1646            object.removeEventListener(types[i], this._logEvent, false);
1647            object.addEventListener(types[i], this._logEvent, false);
1648        }
1649    },
1650
1651    /**
1652     * @param {!Object} object
1653     * @param {!Array.<string>|string=} opt_types
1654     */
1655    unmonitorEvents: function(object, opt_types)
1656    {
1657        if (!object || !object.addEventListener || !object.removeEventListener)
1658            return;
1659        var types = this._normalizeEventTypes(opt_types);
1660        for (var i = 0; i < types.length; ++i)
1661            object.removeEventListener(types[i], this._logEvent, false);
1662    },
1663
1664    /**
1665     * @param {*} object
1666     * @return {*}
1667     */
1668    inspect: function(object)
1669    {
1670        return injectedScript._inspect(object);
1671    },
1672
1673    copy: function(object)
1674    {
1675        var string;
1676        if (injectedScript._subtype(object) === "node") {
1677            string = object.outerHTML;
1678        } else if (injectedScript.isPrimitiveValue(object)) {
1679            string = toString(object);
1680        } else {
1681            try {
1682                string = JSON.stringify(object, null, "  ");
1683            } catch (e) {
1684                string = toString(object);
1685            }
1686        }
1687
1688        var hints = { copyToClipboard: true, __proto__: null };
1689        var remoteObject = injectedScript._wrapObject(string, "")
1690        InjectedScriptHost.inspect(remoteObject, hints);
1691    },
1692
1693    clear: function()
1694    {
1695        InjectedScriptHost.clearConsoleMessages();
1696    },
1697
1698    /**
1699     * @param {!Node} node
1700     * @return {!Array.<!{type: string, listener: function(), useCapture: boolean, remove: function()}>|undefined}
1701     */
1702    getEventListeners: function(node)
1703    {
1704        var result = nullifyObjectProto(InjectedScriptHost.getEventListeners(node));
1705        if (!result)
1706            return result;
1707        /** @this {{type: string, listener: function(), useCapture: boolean}} */
1708        var removeFunc = function()
1709        {
1710            node.removeEventListener(this.type, this.listener, this.useCapture);
1711        }
1712        for (var type in result) {
1713            var listeners = result[type];
1714            for (var i = 0, listener; listener = listeners[i]; ++i) {
1715                listener["type"] = type;
1716                listener["remove"] = removeFunc;
1717            }
1718        }
1719        return result;
1720    },
1721
1722    debug: function(fn)
1723    {
1724        InjectedScriptHost.debugFunction(fn);
1725    },
1726
1727    undebug: function(fn)
1728    {
1729        InjectedScriptHost.undebugFunction(fn);
1730    },
1731
1732    monitor: function(fn)
1733    {
1734        InjectedScriptHost.monitorFunction(fn);
1735    },
1736
1737    unmonitor: function(fn)
1738    {
1739        InjectedScriptHost.unmonitorFunction(fn);
1740    },
1741
1742    table: function(data, opt_columns)
1743    {
1744        InjectedScriptHost.callFunction(inspectedWindow.console.table, inspectedWindow.console, slice(arguments));
1745    },
1746
1747    /**
1748     * @param {number} num
1749     */
1750    _inspectedObject: function(num)
1751    {
1752        return InjectedScriptHost.inspectedObject(num);
1753    },
1754
1755    /**
1756     * @param {!Array.<string>|string=} types
1757     * @return {!Array.<string>}
1758     */
1759    _normalizeEventTypes: function(types)
1760    {
1761        if (typeof types === "undefined")
1762            types = ["mouse", "key", "touch", "control", "load", "unload", "abort", "error", "select", "change", "submit", "reset", "focus", "blur", "resize", "scroll", "search", "devicemotion", "deviceorientation"];
1763        else if (typeof types === "string")
1764            types = [types];
1765
1766        var result = [];
1767        for (var i = 0; i < types.length; ++i) {
1768            if (types[i] === "mouse")
1769                push(result, "mousedown", "mouseup", "click", "dblclick", "mousemove", "mouseover", "mouseout", "mousewheel");
1770            else if (types[i] === "key")
1771                push(result, "keydown", "keyup", "keypress", "textInput");
1772            else if (types[i] === "touch")
1773                push(result, "touchstart", "touchmove", "touchend", "touchcancel");
1774            else if (types[i] === "control")
1775                push(result, "resize", "scroll", "zoom", "focus", "blur", "select", "change", "submit", "reset");
1776            else
1777                push(result, types[i]);
1778        }
1779        return result;
1780    },
1781
1782    /**
1783     * @param {!Event} event
1784     */
1785    _logEvent: function(event)
1786    {
1787        inspectedWindow.console.log(event.type, event);
1788    }
1789}
1790
1791injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
1792return injectedScript;
1793})
1794