a1c252d548cf3453849e093a911cb74b6c292390
[WebKit-https.git] / Source / JavaScriptCore / inspector / InjectedScriptSource.js
1 /*
2  * Copyright (C) 2007, 2014 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 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 //# sourceURL=__WebInspectorInjectedScript__
31
32 (function (InjectedScriptHost, inspectedGlobalObject, injectedScriptId) {
33
34 // Protect against Object overwritten by the user code.
35 var Object = {}.constructor;
36
37 function toString(obj)
38 {
39     return String(obj);
40 }
41
42 function toStringDescription(obj)
43 {
44     if (obj === 0 && 1 / obj < 0)
45         return "-0";
46
47     return toString(obj);
48 }
49
50 function isUInt32(obj)
51 {
52     if (typeof obj === "number")
53         return obj >>> 0 === obj && (obj > 0 || 1 / obj > 0);
54     return "" + (obj >>> 0) === obj;
55 }
56
57 function isSymbol(obj)
58 {
59     return typeof obj === "symbol";
60 }
61
62 var InjectedScript = function()
63 {
64     this._lastBoundObjectId = 1;
65     this._idToWrappedObject = {};
66     this._idToObjectGroupName = {};
67     this._objectGroups = {};
68     this._modules = {};
69     this._nextSavedResultIndex = 1;
70     this._savedResults = [];
71 }
72
73 InjectedScript.primitiveTypes = {
74     undefined: true,
75     boolean: true,
76     number: true,
77     string: true,
78 }
79
80 InjectedScript.CollectionMode = {
81     OwnProperties: 1 << 0,          // own properties.
82     NativeGetterProperties: 1 << 1, // native getter properties in the prototype chain.
83     AllProperties: 1 << 2,          // all properties in the prototype chain.
84 }
85
86 InjectedScript.prototype = {
87     isPrimitiveValue: function(object)
88     {
89         // FIXME(33716): typeof document.all is always 'undefined'.
90         return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
91     },
92
93     wrapObject: function(object, groupName, canAccessInspectedGlobalObject, generatePreview)
94     {
95         if (canAccessInspectedGlobalObject)
96             return this._wrapObject(object, groupName, false, generatePreview);
97         return this._fallbackWrapper(object);
98     },
99
100     setExceptionValue: function(value)
101     {
102         this._exceptionValue = value;
103     },
104
105     clearExceptionValue: function()
106     {
107         delete this._exceptionValue;
108     },
109
110     _fallbackWrapper: function(object)
111     {
112         var result = {};
113         result.type = typeof object;
114         if (this.isPrimitiveValue(object))
115             result.value = object;
116         else
117             result.description = toString(object);
118         return result;
119     },
120
121     wrapTable: function(canAccessInspectedGlobalObject, table, columns)
122     {
123         if (!canAccessInspectedGlobalObject)
124             return this._fallbackWrapper(table);
125
126         // FIXME: Currently columns are ignored. Instead, the frontend filters all
127         // properties based on the provided column names and in the provided order.
128         // Should we filter here too?
129
130         var columnNames = null;
131         if (typeof columns === "string")
132             columns = [columns];
133
134         if (InjectedScriptHost.subtype(columns) === "array") {
135             columnNames = [];
136             for (var i = 0; i < columns.length; ++i)
137                 columnNames.push(toString(columns[i]));
138         }
139
140         return this._wrapObject(table, "console", false, true, columnNames);
141     },
142
143     inspectObject: function(object)
144     {
145         if (this._commandLineAPIImpl)
146             this._commandLineAPIImpl.inspect(object);
147     },
148
149     _wrapObject: function(object, objectGroupName, forceValueType, generatePreview, columnNames)
150     {
151         try {
152             return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType, generatePreview, columnNames);
153         } catch (e) {
154             try {
155                 var description = injectedScript._describe(e);
156             } catch (ex) {
157                 var description = "<failed to convert exception to string>";
158             }
159             return new InjectedScript.RemoteObject(description);
160         }
161     },
162
163     _bind: function(object, objectGroupName)
164     {
165         var id = this._lastBoundObjectId++;
166         this._idToWrappedObject[id] = object;
167         var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
168         if (objectGroupName) {
169             var group = this._objectGroups[objectGroupName];
170             if (!group) {
171                 group = [];
172                 this._objectGroups[objectGroupName] = group;
173             }
174             group.push(id);
175             this._idToObjectGroupName[id] = objectGroupName;
176         }
177         return objectId;
178     },
179
180     _parseObjectId: function(objectId)
181     {
182         return InjectedScriptHost.evaluate("(" + objectId + ")");
183     },
184
185     releaseObjectGroup: function(objectGroupName)
186     {
187         if (objectGroupName === "console") {
188             delete this._lastResult;
189             this._nextSavedResultIndex = 1;
190             this._savedResults = [];
191         }
192
193         var group = this._objectGroups[objectGroupName];
194         if (!group)
195             return;
196
197         for (var i = 0; i < group.length; i++)
198             this._releaseObject(group[i]);
199
200         delete this._objectGroups[objectGroupName];
201     },
202
203     dispatch: function(methodName, args)
204     {
205         var argsArray = InjectedScriptHost.evaluate("(" + args + ")");
206         var result = this[methodName].apply(this, argsArray);
207         if (typeof result === "undefined") {
208             if (inspectedGlobalObject.console)
209                 inspectedGlobalObject.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
210             result = null;
211         }
212         return result;
213     },
214
215     _getProperties: function(objectId, collectionMode, generatePreview)
216     {
217         var parsedObjectId = this._parseObjectId(objectId);
218         var object = this._objectForId(parsedObjectId);
219         var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
220
221         if (!this._isDefined(object))
222             return false;
223
224         if (isSymbol(object))
225             return false;
226
227         var descriptors = this._propertyDescriptors(object, collectionMode);
228
229         // Go over properties, wrap object values.
230         for (var i = 0; i < descriptors.length; ++i) {
231             var descriptor = descriptors[i];
232             if ("get" in descriptor)
233                 descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
234             if ("set" in descriptor)
235                 descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
236             if ("value" in descriptor)
237                 descriptor.value = this._wrapObject(descriptor.value, objectGroupName, false, generatePreview);
238             if (!("configurable" in descriptor))
239                 descriptor.configurable = false;
240             if (!("enumerable" in descriptor))
241                 descriptor.enumerable = false;
242         }
243
244         return descriptors;
245     },
246
247     getProperties: function(objectId, ownProperties, generatePreview)
248     {
249         var collectionMode = ownProperties ? InjectedScript.CollectionMode.OwnProperties : InjectedScript.CollectionMode.AllProperties;
250         return this._getProperties(objectId, collectionMode, generatePreview);
251     },
252
253     getDisplayableProperties: function(objectId, generatePreview)
254     {
255         var collectionMode = InjectedScript.CollectionMode.OwnProperties | InjectedScript.CollectionMode.NativeGetterProperties;
256         return this._getProperties(objectId, collectionMode, generatePreview);
257     },
258
259     getInternalProperties: function(objectId, generatePreview)
260     {
261         var parsedObjectId = this._parseObjectId(objectId);
262         var object = this._objectForId(parsedObjectId);
263         var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
264
265         if (!this._isDefined(object))
266             return false;
267
268         if (isSymbol(object))
269             return false;
270
271         var descriptors = this._internalPropertyDescriptors(object);
272         if (!descriptors)
273             return [];
274
275         // Go over properties, wrap object values.
276         for (var i = 0; i < descriptors.length; ++i) {
277             var descriptor = descriptors[i];
278             if ("value" in descriptor)
279                 descriptor.value = this._wrapObject(descriptor.value, objectGroupName, false, generatePreview);
280         }
281
282         return descriptors;
283     },
284
285     getCollectionEntries: function(objectId, objectGroupName, startIndex, numberToFetch)
286     {
287         var parsedObjectId = this._parseObjectId(objectId);
288         var object = this._objectForId(parsedObjectId);
289         var objectGroupName = objectGroupName || this._idToObjectGroupName[parsedObjectId.id];
290
291         if (!this._isDefined(object))
292             return;
293
294         if (typeof object !== "object")
295             return;
296
297         var entries = this._entries(object, InjectedScriptHost.subtype(object), startIndex, numberToFetch);
298         return entries.map(function(entry) {
299             entry.value = injectedScript._wrapObject(entry.value, objectGroupName, false, true);
300             if ("key" in entry)
301                 entry.key = injectedScript._wrapObject(entry.key, objectGroupName, false, true);
302             return entry;
303         });
304     },
305
306     saveResult: function(callArgumentJSON)
307     {
308         this._savedResultIndex = 0;
309
310         try {
311             var callArgument = InjectedScriptHost.evaluate("(" + callArgumentJSON + ")");
312             var value = this._resolveCallArgument(callArgument);
313             this._saveResult(value);
314         } catch (e) {}
315
316         return this._savedResultIndex;
317     },
318
319     getFunctionDetails: function(functionId)
320     {
321         var parsedFunctionId = this._parseObjectId(functionId);
322         var func = this._objectForId(parsedFunctionId);
323         if (typeof func !== "function")
324             return "Cannot resolve function by id.";
325         var details = InjectedScriptHost.functionDetails(func);
326         if (!details)
327             return "Cannot resolve function details.";
328         if ("rawScopes" in details) {
329             var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
330             var rawScopes = details.rawScopes;
331             var scopes = [];
332             delete details.rawScopes;
333             for (var i = 0; i < rawScopes.length; i++)
334                 scopes.push(InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName));
335             details.scopeChain = scopes;
336         }
337         return details;
338     },
339
340     releaseObject: function(objectId)
341     {
342         var parsedObjectId = this._parseObjectId(objectId);
343         this._releaseObject(parsedObjectId.id);
344     },
345
346     _releaseObject: function(id)
347     {
348         delete this._idToWrappedObject[id];
349         delete this._idToObjectGroupName[id];
350     },
351
352     evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview, saveResult)
353     {
354         return this._evaluateAndWrap(InjectedScriptHost.evaluate, InjectedScriptHost, expression, objectGroup, false, injectCommandLineAPI, returnByValue, generatePreview, saveResult);
355     },
356
357     callFunctionOn: function(objectId, expression, args, returnByValue, generatePreview)
358     {
359         var parsedObjectId = this._parseObjectId(objectId);
360         var object = this._objectForId(parsedObjectId);
361         if (!this._isDefined(object))
362             return "Could not find object with given id";
363
364         if (args) {
365             var resolvedArgs = [];
366             var callArgs = InjectedScriptHost.evaluate(args);
367             for (var i = 0; i < callArgs.length; ++i) {
368                 try {
369                     resolvedArgs[i] = this._resolveCallArgument(callArgs[i]);
370                 } catch (e) {
371                     return String(e);
372                 }
373             }
374         }
375
376         try {
377             var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
378             var func = InjectedScriptHost.evaluate("(" + expression + ")");
379             if (typeof func !== "function")
380                 return "Given expression does not evaluate to a function";
381
382             return {
383                 wasThrown: false,
384                 result: this._wrapObject(func.apply(object, resolvedArgs), objectGroup, returnByValue, generatePreview)
385             };
386         } catch (e) {
387             return this._createThrownValue(e, objectGroup);
388         }
389     },
390
391     _resolveCallArgument: function(callArgumentJSON)
392     {
393         if ("value" in callArgumentJSON)
394             return callArgumentJSON.value;
395
396         var objectId = callArgumentJSON.objectId;
397         if (objectId) {
398             var parsedArgId = this._parseObjectId(objectId);
399             if (!parsedArgId || parsedArgId["injectedScriptId"] !== injectedScriptId)
400                 throw "Arguments should belong to the same JavaScript world as the target object.";
401
402             var resolvedArg = this._objectForId(parsedArgId);
403             if (!this._isDefined(resolvedArg))
404                 throw "Could not find object with given id";
405
406             return resolvedArg;
407         }
408
409         return undefined;
410     },
411
412     _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue, generatePreview, saveResult)
413     {
414         try {
415             this._savedResultIndex = 0;
416
417             var returnObject = {
418                 wasThrown: false,
419                 result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, saveResult), objectGroup, returnByValue, generatePreview)
420             };
421
422             if (saveResult && this._savedResultIndex)
423                 returnObject.savedResultIndex = this._savedResultIndex;
424
425             return returnObject;
426         } catch (e) {
427             return this._createThrownValue(e, objectGroup);
428         }
429     },
430
431     _createThrownValue: function(value, objectGroup)
432     {
433         var remoteObject = this._wrapObject(value, objectGroup);
434         try {
435             remoteObject.description = toStringDescription(value);
436         } catch (e) {}
437         return {
438             wasThrown: true,
439             result: remoteObject
440         };
441     },
442
443     _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI, saveResult)
444     {
445         var commandLineAPI = null;
446         if (injectCommandLineAPI) {
447             if (this.CommandLineAPI)
448                 commandLineAPI = new this.CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
449             else
450                 commandLineAPI = new BasicCommandLineAPI;
451         }
452
453         if (isEvalOnCallFrame) {
454             // We can only use this approach if the evaluate function is the true 'eval'. That allows us to use it with
455             // the 'eval' identifier when calling it. Using 'eval' grants access to the local scope of the closure we
456             // create that provides the command line APIs.
457
458             var parameters = [InjectedScriptHost.evaluate, expression];
459             var expressionFunctionBody = "" +
460                 "var global = Function('return this')() || (1, eval)('this');" +
461                 "var __originalEval = global.eval; global.eval = __eval;" +
462                 "try { return eval(__currentExpression); }" +
463                 "finally { global.eval = __originalEval; }";
464
465             if (commandLineAPI) {
466                 // To avoid using a 'with' statement (which fails in strict mode and requires injecting the API object)
467                 // we instead create a closure where we evaluate the expression. The command line APIs are passed as
468                 // parameters to the closure so they are in scope but not injected. This allows the code evaluated in
469                 // the console to stay in strict mode (if is was already set), or to get strict mode by prefixing
470                 // expressions with 'use strict';.
471
472                 var parameterNames = Object.getOwnPropertyNames(commandLineAPI);
473                 for (var i = 0; i < parameterNames.length; ++i)
474                     parameters.push(commandLineAPI[parameterNames[i]]);
475
476                 var expressionFunctionString = "(function(__eval, __currentExpression, " + parameterNames.join(", ") + ") { " + expressionFunctionBody + " })";
477             } else {
478                 // Use a closure in this case too to keep the same behavior of 'var' being captured by the closure instead
479                 // of leaking out into the calling scope.
480                 var expressionFunctionString = "(function(__eval, __currentExpression) { " + expressionFunctionBody + " })";
481             }
482
483             // Bind 'this' to the function expression using another closure instead of Function.prototype.bind. This ensures things will work if the page replaces bind.
484             var boundExpressionFunctionString = "(function(__function, __thisObject) { return function() { return __function.apply(__thisObject, arguments) }; })(" + expressionFunctionString + ", this)";
485             var expressionFunction = evalFunction.call(object, boundExpressionFunctionString);
486             var result = expressionFunction.apply(null, parameters);
487
488             if (objectGroup === "console" && saveResult)
489                 this._saveResult(result);
490
491             return result;
492         }
493
494         // When not evaluating on a call frame we use a 'with' statement to allow var and function statements to leak
495         // into the global scope. This allow them to stick around between evaluations.
496
497         try {
498             if (commandLineAPI) {
499                 if (inspectedGlobalObject.console)
500                     inspectedGlobalObject.console.__commandLineAPI = commandLineAPI;
501                 else
502                     inspectedGlobalObject.__commandLineAPI = commandLineAPI;
503                 expression = "with ((this && (this.console ? this.console.__commandLineAPI : this.__commandLineAPI)) || {}) { " + expression + "\n}";
504             }
505
506             var result = evalFunction.call(inspectedGlobalObject, expression);
507
508             if (objectGroup === "console" && saveResult)
509                 this._saveResult(result);
510
511             return result;
512         } finally {
513             if (commandLineAPI) {
514                 if (inspectedGlobalObject.console)
515                     delete inspectedGlobalObject.console.__commandLineAPI;
516                 else
517                     delete inspectedGlobalObject.__commandLineAPI;
518             }
519         }
520     },
521
522     wrapCallFrames: function(callFrame)
523     {
524         if (!callFrame)
525             return false;
526
527         var result = [];
528         var depth = 0;
529         do {
530             result.push(new InjectedScript.CallFrameProxy(depth++, callFrame));
531             callFrame = callFrame.caller;
532         } while (callFrame);
533         return result;
534     },
535
536     evaluateOnCallFrame: function(topCallFrame, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue, generatePreview, saveResult)
537     {
538         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
539         if (!callFrame)
540             return "Could not find call frame with given id";
541         return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue, generatePreview, saveResult);
542     },
543
544     _callFrameForId: function(topCallFrame, callFrameId)
545     {
546         var parsedCallFrameId = InjectedScriptHost.evaluate("(" + callFrameId + ")");
547         var ordinal = parsedCallFrameId["ordinal"];
548         var callFrame = topCallFrame;
549         while (--ordinal >= 0 && callFrame)
550             callFrame = callFrame.caller;
551         return callFrame;
552     },
553
554     _objectForId: function(objectId)
555     {
556         return this._idToWrappedObject[objectId.id];
557     },
558
559     findObjectById: function(objectId)
560     {
561         var parsedObjectId = this._parseObjectId(objectId);
562         return this._objectForId(parsedObjectId);
563     },
564
565     module: function(name)
566     {
567         return this._modules[name];
568     },
569
570     injectModule: function(name, source, host)
571     {
572         delete this._modules[name];
573
574         var moduleFunction = InjectedScriptHost.evaluate("(" + source + ")");
575         if (typeof moduleFunction !== "function") {
576             if (inspectedGlobalObject.console)
577                 inspectedGlobalObject.console.error("Web Inspector error: A function was expected for module %s evaluation", name);
578             return null;
579         }
580
581         var module = moduleFunction.call(inspectedGlobalObject, InjectedScriptHost, inspectedGlobalObject, injectedScriptId, this, host);
582         this._modules[name] = module;
583         return module;
584     },
585
586     _internalPropertyDescriptors: function(object, completeDescriptor)
587     {
588         var internalProperties = InjectedScriptHost.getInternalProperties(object);
589         if (!internalProperties)
590             return null;
591
592         var descriptors = [];
593         for (var i = 0; i < internalProperties.length; i++) {
594             var property = internalProperties[i];
595             var descriptor = {name: property.name, value: property.value};
596             if (completeDescriptor) {
597                 descriptor.writable = false;
598                 descriptor.configurable = false;
599                 descriptor.enumerable = false;
600                 descriptor.isOwn = true;
601             }
602             descriptors.push(descriptor);
603         }
604         return descriptors;
605     },
606
607     _propertyDescriptors: function(object, collectionMode)
608     {
609         var descriptors = [];
610         var nameProcessed = {};
611         nameProcessed["__proto__"] = null;
612
613         function createFakeValueDescriptor(name, descriptor, isOwnProperty, possibleNativeBindingGetter)
614         {
615             try {
616                 var descriptor = {name, value: object[name], writable: descriptor.writable || false, configurable: descriptor.configurable || false, enumerable: descriptor.enumerable || false};
617                 if (possibleNativeBindingGetter)
618                     descriptor.nativeGetter = true;
619                 return descriptor;
620             } catch (e) {
621                 var errorDescriptor = {name, value: e, wasThrown: true};
622                 if (isOwnProperty)
623                     errorDescriptor.isOwn = true;
624                 return errorDescriptor;
625             }
626         }
627
628         function processDescriptor(descriptor, isOwnProperty, possibleNativeBindingGetter)
629         {
630             // All properties.
631             if (collectionMode & InjectedScript.CollectionMode.AllProperties) {
632                 descriptors.push(descriptor);
633                 return;
634             }
635
636             // Own properties.
637             if (collectionMode & InjectedScript.CollectionMode.OwnProperties && isOwnProperty) {
638                 descriptors.push(descriptor);
639                 return;
640             }
641
642             // Native Getter properties.
643             if (collectionMode & InjectedScript.CollectionMode.NativeGetterProperties) {
644                 // FIXME: <https://webkit.org/b/140575> Web Inspector: Native Bindings Descriptors are Incomplete
645                 // if (descriptor.hasOwnProperty("get") && descriptor.get && isNativeFunction(descriptor.get)) { ... }
646
647                 if (possibleNativeBindingGetter) {
648                     // Possible getter property in the prototype chain.
649                     descriptors.push(descriptor);
650                     return;
651                 }
652             }
653         }
654
655         function processPropertyNames(o, names, isOwnProperty)
656         {
657             for (var i = 0; i < names.length; ++i) {
658                 var name = names[i];
659                 if (nameProcessed[name] || name === "__proto__")
660                     continue;
661
662                 nameProcessed[name] = true;
663
664                 var descriptor = Object.getOwnPropertyDescriptor(o, name);
665                 if (!descriptor) {
666                     // FIXME: Bad descriptor. Can we get here?
667                     // Fall back to very restrictive settings.
668                     var fakeDescriptor = createFakeValueDescriptor(name, {writable: false, configurable: false, enumerable: false}, isOwnProperty);
669                     processDescriptor(fakeDescriptor, isOwnProperty);
670                     continue;
671                 }
672
673                 if (descriptor.hasOwnProperty("get") && descriptor.hasOwnProperty("set") && !descriptor.get && !descriptor.set) {
674                     // FIXME: <https://webkit.org/b/140575> Web Inspector: Native Bindings Descriptors are Incomplete
675                     // Developers may create such a descriptors, so we should be resilient:
676                     // var x = {}; Object.defineProperty(x, "p", {get:undefined}); Object.getOwnPropertyDescriptor(x, "p")
677                     var fakeDescriptor = createFakeValueDescriptor(name, descriptor, isOwnProperty, true);
678                     processDescriptor(fakeDescriptor, isOwnProperty, true);
679                     continue;
680                 }
681
682                 descriptor.name = name;
683                 if (isOwnProperty)
684                     descriptor.isOwn = true;
685                 processDescriptor(descriptor, isOwnProperty);
686             }
687         }
688
689         // Iterate prototype chain.
690         for (var o = object; this._isDefined(o); o = o.__proto__) {
691             var isOwnProperty = o === object;
692             processPropertyNames(o, Object.getOwnPropertyNames(o), isOwnProperty);
693             if (collectionMode === InjectedScript.CollectionMode.OwnProperties)
694                 break;
695         }
696
697         // Always include __proto__ at the end.
698         try {
699             if (object.__proto__)
700                 descriptors.push({name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false, isOwn: true});
701         } catch (e) {}
702
703         return descriptors;
704     },
705
706     _isDefined: function(object)
707     {
708         return !!object || this._isHTMLAllCollection(object);
709     },
710
711     _isHTMLAllCollection: function(object)
712     {
713         // document.all is reported as undefined, but we still want to process it.
714         return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
715     },
716
717     _subtype: function(obj)
718     {
719         if (obj === null)
720             return "null";
721
722         if (this.isPrimitiveValue(obj) || isSymbol(obj))
723             return null;
724
725         if (this._isHTMLAllCollection(obj))
726             return "array";
727
728         var preciseType = InjectedScriptHost.subtype(obj);
729         if (preciseType)
730             return preciseType;
731
732         // FireBug's array detection.
733         try {
734             if (typeof obj.splice === "function" && isFinite(obj.length))
735                 return "array";
736             if (Object.prototype.toString.call(obj) === "[object Arguments]" && isFinite(obj.length)) // arguments.
737                 return "array";
738         } catch (e) {
739         }
740
741         return null;
742     },
743
744     _describe: function(obj)
745     {
746         if (this.isPrimitiveValue(obj))
747             return null;
748
749         if (isSymbol(obj))
750             return toString(obj);
751
752         var subtype = this._subtype(obj);
753
754         if (subtype === "regexp")
755             return toString(obj);
756
757         if (subtype === "date")
758             return toString(obj);
759
760         if (subtype === "error")
761             return toString(obj);
762
763         if (subtype === "node") {
764             var description = obj.nodeName.toLowerCase();
765             switch (obj.nodeType) {
766             case 1 /* Node.ELEMENT_NODE */:
767                 description += obj.id ? "#" + obj.id : "";
768                 var className = obj.className;
769                 description += (className && typeof className === "string") ? "." + className.trim().replace(/\s+/g, ".") : "";
770                 break;
771             case 10 /*Node.DOCUMENT_TYPE_NODE */:
772                 description = "<!DOCTYPE " + description + ">";
773                 break;
774             }
775             return description;
776         }
777
778         var className = InjectedScriptHost.internalConstructorName(obj);
779         if (subtype === "array")
780             return className;
781
782         // NodeList in JSC is a function, check for array prior to this.
783         if (typeof obj === "function")
784             return toString(obj);
785
786         // If Object, try for a better name from the constructor.
787         if (className === "Object") {
788             var constructorName = obj.constructor && obj.constructor.name;
789             if (constructorName)
790                 return constructorName;
791         }
792
793         return className;
794     },
795
796     _getSetEntries: function(object, skip, numberToFetch)
797     {
798         var entries = [];
799
800         for (var value of object) {
801             if (skip > 0) {
802                 skip--;
803                 continue;
804             }
805
806             entries.push({value});
807
808             if (numberToFetch && entries.length === numberToFetch)
809                 break;
810         }
811
812         return entries;
813     },
814
815     _getMapEntries: function(object, skip, numberToFetch)
816     {
817         var entries = [];
818
819         for (var [key, value] of object) {
820             if (skip > 0) {
821                 skip--;
822                 continue;
823             }
824
825             entries.push({key, value});
826
827             if (numberToFetch && entries.length === numberToFetch)
828                 break;
829         }
830
831         return entries;
832     },
833
834     _getWeakMapEntries: function(object, numberToFetch)
835     {
836         return InjectedScriptHost.weakMapEntries(object, numberToFetch);
837     },
838
839     _getIteratorEntries: function(object, numberToFetch)
840     {
841         return InjectedScriptHost.iteratorEntries(object, numberToFetch);
842     },
843
844     _entries: function(object, subtype, startIndex, numberToFetch)
845     {
846         if (subtype === "set")
847             return this._getSetEntries(object, startIndex, numberToFetch);
848         if (subtype === "map")
849             return this._getMapEntries(object, startIndex, numberToFetch);
850         if (subtype === "weakmap")
851             return this._getWeakMapEntries(object, numberToFetch);
852         if (subtype === "iterator")
853             return this._getIteratorEntries(object, numberToFetch);
854
855         throw "unexpected type";
856     },
857
858     _saveResult: function(result)
859     {
860         this._lastResult = result;
861
862         if (result === undefined || result === null)
863             return;
864
865         var existingIndex = this._savedResults.indexOf(result);
866         if (existingIndex !== -1) {
867             this._savedResultIndex = existingIndex;
868             return;
869         }
870
871         this._savedResultIndex = this._nextSavedResultIndex;
872         this._savedResults[this._nextSavedResultIndex++] = result;
873
874         // $n is limited from $1-$99. $0 is special.
875         if (this._nextSavedResultIndex >= 100)
876             this._nextSavedResultIndex = 1;
877     },
878
879     _savedResult: function(index)
880     {
881         return this._savedResults[index];
882     }
883 }
884
885 var injectedScript = new InjectedScript;
886
887
888 InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType, generatePreview, columnNames)
889 {
890     this.type = typeof object;
891
892     if (this.type === "undefined" && injectedScript._isHTMLAllCollection(object))
893         this.type = "object";
894
895     if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
896         // We don't send undefined values over JSON.
897         if (this.type !== "undefined")
898             this.value = object;
899
900         // Null object is object with 'null' subtype.
901         if (object === null)
902             this.subtype = "null";
903
904         // Provide user-friendly number values.
905         if (this.type === "number")
906             this.description = toStringDescription(object);
907         return;
908     }
909
910     this.objectId = injectedScript._bind(object, objectGroupName);
911
912     var subtype = injectedScript._subtype(object);
913     if (subtype)
914         this.subtype = subtype;
915
916     this.className = InjectedScriptHost.internalConstructorName(object);
917     this.description = injectedScript._describe(object);
918
919     if (subtype === "array")
920         this.size = typeof object.length === "number" ? object.length : 0;
921     else if (subtype === "set" || subtype === "map")
922         this.size = object.size;
923     else if (subtype === "weakmap")
924         this.size = InjectedScriptHost.weakMapSize(object);
925
926     if (generatePreview && this.type === "object")
927         this.preview = this._generatePreview(object, undefined, columnNames);
928 }
929
930 InjectedScript.RemoteObject.prototype = {
931     _emptyPreview: function()
932     {
933         var preview = {
934             type: this.type,
935             description: this.description || toString(this.value),
936             lossless: true,
937         };
938
939         if (this.subtype) {
940             preview.subtype = this.subtype;
941             if (this.subtype !== "null") {
942                 preview.overflow = false;
943                 preview.properties = [];
944             }
945         }
946
947         if ("size" in this)
948             preview.size = this.size;
949
950         return preview;
951     },
952
953     _createObjectPreviewForValue: function(value)
954     {
955         var remoteObject = new InjectedScript.RemoteObject(value, undefined, false, true, undefined);
956         if (remoteObject.objectId)
957             injectedScript.releaseObject(remoteObject.objectId);
958
959         return remoteObject.preview || remoteObject._emptyPreview();
960     },
961
962     _generatePreview: function(object, firstLevelKeys, secondLevelKeys)
963     {
964         var preview = this._emptyPreview();
965
966         // Primitives just have a value.
967         if (this.type !== "object")
968             return;
969
970         var isTableRowsRequest = secondLevelKeys === null || secondLevelKeys;
971         var firstLevelKeysCount = firstLevelKeys ? firstLevelKeys.length : 0;
972
973         var propertiesThreshold = {
974             properties: isTableRowsRequest ? 1000 : Math.max(5, firstLevelKeysCount),
975             indexes: isTableRowsRequest ? 1000 : Math.max(100, firstLevelKeysCount)
976         };
977
978         try {
979             // Maps, Sets, and Iterators have entries.
980             if (this.subtype === "map" || this.subtype === "set" || this.subtype === "weakmap" || this.subtype === "iterator")
981                 this._appendEntryPreviews(object, preview);
982
983             preview.properties = [];
984
985             // Internal Properties.
986             var internalPropertyDescriptors = injectedScript._internalPropertyDescriptors(object, true);
987             if (internalPropertyDescriptors) {
988                 this._appendPropertyPreviews(preview, internalPropertyDescriptors, true, propertiesThreshold, firstLevelKeys, secondLevelKeys);
989                 if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
990                     return preview;
991             }
992
993             if (preview.entries)
994                 return preview;
995
996             // Properties.
997             var descriptors = injectedScript._propertyDescriptors(object, InjectedScript.CollectionMode.AllProperties);
998             this._appendPropertyPreviews(preview, descriptors, false, propertiesThreshold, firstLevelKeys, secondLevelKeys);
999             if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
1000                 return preview;
1001         } catch (e) {
1002             preview.lossless = false;
1003         }
1004
1005         return preview;
1006     },
1007
1008     _appendPropertyPreviews: function(preview, descriptors, internal, propertiesThreshold, firstLevelKeys, secondLevelKeys)
1009     {
1010         for (var descriptor of descriptors) {
1011             // Seen enough.
1012             if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0)
1013                 break;
1014
1015             // Error in descriptor.
1016             if (descriptor.wasThrown) {
1017                 preview.lossless = false;
1018                 continue;
1019             }
1020
1021             // Do not show "__proto__" in preview.
1022             var name = descriptor.name;
1023             if (name === "__proto__")
1024                 continue;
1025
1026             // Do not show "length" on array like objects in preview.
1027             if (this.subtype === "array" && name === "length")
1028                 continue;
1029
1030             // Do not show non-enumerable non-own properties. Special case to allow array indexes that may be on the prototype.
1031             if (!descriptor.enumerable && !descriptor.isOwn && !(this.subtype === "array" && isUInt32(name)))
1032                 continue;
1033
1034             // If we have a filter, only show properties in the filter.
1035             if (firstLevelKeys && firstLevelKeys.indexOf(name) === -1)
1036                 continue;
1037
1038             // Getter/setter.
1039             if (!("value" in descriptor)) {
1040                 preview.lossless = false;
1041                 this._appendPropertyPreview(preview, internal, {name, type: "accessor"}, propertiesThreshold);
1042                 continue;
1043             }
1044
1045             // Null value.
1046             var value = descriptor.value;
1047             if (value === null) {
1048                 this._appendPropertyPreview(preview, internal, {name, type: "object", subtype: "null", value: "null"}, propertiesThreshold);
1049                 continue;
1050             }
1051
1052             // Ignore non-enumerable functions.
1053             var type = typeof value;
1054             if (!descriptor.enumerable && type === "function")
1055                 continue;
1056
1057             // Fix type of document.all.
1058             if (type === "undefined" && injectedScript._isHTMLAllCollection(value))
1059                 type = "object";
1060
1061             // Primitive.
1062             const maxLength = 100;
1063             if (InjectedScript.primitiveTypes[type]) {
1064                 if (type === "string" && value.length > maxLength) {
1065                     value = this._abbreviateString(value, maxLength, true);
1066                     preview.lossless = false;
1067                 }
1068                 this._appendPropertyPreview(preview, internal, {name, type, value: toStringDescription(value)}, propertiesThreshold);
1069                 continue;
1070             }
1071
1072             // Symbol.
1073             if (isSymbol(value)) {
1074                 var symbolString = toString(value);
1075                 if (symbolString.length > maxLength) {
1076                     symbolString = this._abbreviateString(symbolString, maxLength, true);
1077                     preview.lossless = false;
1078                 }
1079                 this._appendPropertyPreview(preview, internal, {name, type, value: symbolString}, propertiesThreshold);
1080                 return;
1081             }
1082
1083             // Object.
1084             var property = {name, type};
1085             var subtype = injectedScript._subtype(value);
1086             if (subtype)
1087                 property.subtype = subtype;
1088
1089             // Second level.
1090             if (secondLevelKeys === null || secondLevelKeys) {
1091                 var subPreview = this._generatePreview(value, secondLevelKeys || undefined, undefined);
1092                 property.valuePreview = subPreview;
1093                 if (!subPreview.lossless)
1094                     preview.lossless = false;
1095                 if (subPreview.overflow)
1096                     preview.overflow = true;
1097             } else if (this._isPreviewableObject(value)) {
1098                 var subPreview = this._createObjectPreviewForValue(value);
1099                 property.valuePreview = subPreview;
1100                 if (!subPreview.lossless)
1101                     preview.lossless = false;
1102                 if (subPreview.overflow)
1103                     preview.overflow = true;
1104             } else {
1105                 var description = "";
1106                 if (type !== "function")
1107                     description = this._abbreviateString(injectedScript._describe(value), maxLength, subtype === "regexp");
1108                 property.value = description;
1109                 preview.lossless = false;
1110             }
1111
1112             this._appendPropertyPreview(preview, internal, property, propertiesThreshold);
1113         }
1114     },
1115
1116     _appendPropertyPreview: function(preview, internal, property, propertiesThreshold)
1117     {
1118         if (toString(property.name >>> 0) === property.name)
1119             propertiesThreshold.indexes--;
1120         else
1121             propertiesThreshold.properties--;
1122
1123         if (propertiesThreshold.indexes < 0 || propertiesThreshold.properties < 0) {
1124             preview.overflow = true;
1125             preview.lossless = false;
1126             return;
1127         }
1128
1129         if (internal)
1130             property.internal = true;
1131
1132         preview.properties.push(property);
1133     },
1134
1135     _appendEntryPreviews: function(object, preview)
1136     {
1137         // Fetch 6, but only return 5, so we can tell if we overflowed.
1138         var entries = injectedScript._entries(object, this.subtype, 0, 6);
1139         if (!entries)
1140             return;
1141
1142         if (entries.length > 5) {
1143             entries.pop();
1144             preview.overflow = true;
1145             preview.lossless = false;
1146         }
1147
1148         preview.entries = entries.map(function(entry) {
1149             entry.value = this._createObjectPreviewForValue(entry.value);
1150             if ("key" in entry)
1151                 entry.key = this._createObjectPreviewForValue(entry.key);
1152             return entry;
1153         }, this);
1154     },
1155
1156     _isPreviewableObject: function(object)
1157     {
1158         return this._isPreviewableObjectInternal(object, new Set, 1);
1159     },
1160
1161     _isPreviewableObjectInternal: function(object, knownObjects, depth)
1162     {
1163         // Deep object.
1164         if (depth > 3)
1165             return false;
1166
1167         // Primitive.
1168         if (injectedScript.isPrimitiveValue(object) || isSymbol(object))
1169             return true;
1170
1171         // Cyclic objects.
1172         if (knownObjects.has(object))
1173             return false;
1174
1175         ++depth;
1176         knownObjects.add(object);
1177
1178         // Arrays are simple if they have 5 or less simple objects.
1179         var subtype = injectedScript._subtype(object);
1180         if (subtype === "array") {
1181             var length = object.length;
1182             if (length > 5)
1183                 return false;
1184             for (var i = 0; i < length; ++i) {
1185                 if (!this._isPreviewableObjectInternal(object[i], knownObjects, depth))
1186                     return false;
1187             }
1188             return true;
1189         }
1190
1191         // Not a basic object.
1192         if (object.__proto__ && object.__proto__.__proto__)
1193             return false;
1194
1195         // Objects are simple if they have 3 or less simple properties.
1196         var ownPropertyNames = Object.getOwnPropertyNames(object);
1197         if (ownPropertyNames.length > 3)
1198             return false;
1199         for (var propertyName of ownPropertyNames) {
1200             if (!this._isPreviewableObjectInternal(object[propertyName], knownObjects, depth))
1201                 return false;
1202         }
1203
1204         return true;
1205     },
1206
1207     _abbreviateString: function(string, maxLength, middle)
1208     {
1209         if (string.length <= maxLength)
1210             return string;
1211
1212         if (middle) {
1213             var leftHalf = maxLength >> 1;
1214             var rightHalf = maxLength - leftHalf - 1;
1215             return string.substr(0, leftHalf) + "\u2026" + string.substr(string.length - rightHalf, rightHalf);
1216         }
1217
1218         return string.substr(0, maxLength) + "\u2026";
1219     }
1220 }
1221
1222 InjectedScript.CallFrameProxy = function(ordinal, callFrame)
1223 {
1224     this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + "}";
1225     this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
1226     this.location = {scriptId: String(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column};
1227     this.scopeChain = this._wrapScopeChain(callFrame);
1228     this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
1229 }
1230
1231 InjectedScript.CallFrameProxy.prototype = {
1232     _wrapScopeChain: function(callFrame)
1233     {
1234         var scopeChain = callFrame.scopeChain;
1235         var scopeChainProxy = [];
1236         for (var i = 0; i < scopeChain.length; i++)
1237             scopeChainProxy[i] = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
1238         return scopeChainProxy;
1239     }
1240 }
1241
1242 InjectedScript.CallFrameProxy._scopeTypeNames = {
1243     0: "global", // GLOBAL_SCOPE
1244     1: "local", // LOCAL_SCOPE
1245     2: "with", // WITH_SCOPE
1246     3: "closure", // CLOSURE_SCOPE
1247     4: "catch", // CATCH_SCOPE
1248     5: "functionName", // FUNCTION_NAME_SCOPE
1249 }
1250
1251 InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId)
1252 {
1253     return {
1254         object: injectedScript._wrapObject(scopeObject, groupId),
1255         type: InjectedScript.CallFrameProxy._scopeTypeNames[scopeTypeCode]
1256     };
1257 }
1258
1259
1260 function slice(array, index)
1261 {
1262     var result = [];
1263     for (var i = index || 0; i < array.length; ++i)
1264         result.push(array[i]);
1265     return result;
1266 }
1267
1268 function bind(func, thisObject, var_args)
1269 {
1270     var args = slice(arguments, 2);
1271     return function(var_args) {
1272         return func.apply(thisObject, args.concat(slice(arguments)));
1273     }
1274 }
1275
1276 function BasicCommandLineAPI()
1277 {
1278     this.$_ = injectedScript._lastResult;
1279     this.$exception = injectedScript._exceptionValue;
1280
1281     // $1-$99
1282     for (var i = 1; i <= injectedScript._savedResults.length; ++i) {
1283         var member = "$" + i;
1284         if (member in inspectedGlobalObject)
1285             continue;
1286         this.__defineGetter__("$" + i, bind(injectedScript._savedResult, injectedScript, i));
1287     }
1288 }
1289
1290 return injectedScript;
1291 })