Web Inspector: store last evaluation result in $_
[WebKit-https.git] / Source / WebCore / inspector / InjectedScriptSource.js
1 /*
2  * Copyright (C) 2007 Apple Inc.  All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 /**
30  * @param {InjectedScriptHost} InjectedScriptHost
31  * @param {Window} inspectedWindow
32  * @param {number} injectedScriptId
33  */
34 (function (InjectedScriptHost, inspectedWindow, injectedScriptId) {
35
36 /**
37  * @constructor
38  */
39 var InjectedScript = function()
40 {
41     this._lastBoundObjectId = 1;
42     this._idToWrappedObject = {};
43     this._idToObjectGroupName = {};
44     this._objectGroups = {};
45     this._modules = {};
46 }
47
48 /**
49  * @type {Object.<string, boolean>}
50  * @const
51  */
52 InjectedScript.primitiveTypes = {
53     undefined: true,
54     boolean: true,
55     number: true,
56     string: true
57 }
58
59 InjectedScript.prototype = {
60     /**
61      * @param {*} object
62      * @return {boolean}
63      */
64     isPrimitiveValue: function(object)
65     {
66         // FIXME(33716): typeof document.all is always 'undefined'.
67         return InjectedScript.primitiveTypes[typeof object] && !this._isHTMLAllCollection(object);
68     },
69
70     /**
71      * @param {*} object
72      * @param {string} groupName
73      * @param {boolean} canAccessInspectedWindow
74      * @return {Object}
75      */
76     wrapObject: function(object, groupName, canAccessInspectedWindow)
77     {
78         if (canAccessInspectedWindow)
79             return this._wrapObject(object, groupName);
80
81         var result = {};
82         result.type = typeof object;
83         if (this.isPrimitiveValue(object))
84             result.value = object;
85         else
86             result.description = this._toString(object);
87         return result;
88     },
89
90     /**
91      * @param {*} object
92      */
93     inspectNode: function(object)
94     {
95         this._inspect(object);
96     },
97
98     /**
99      * @param {*} object
100      * @return {*}
101      */
102     _inspect: function(object)
103     {
104         if (arguments.length === 0)
105             return;
106
107         var objectId = this._wrapObject(object, "");
108         var hints = {};
109
110         switch (injectedScript._describe(object)) {
111             case "Database":
112                 var databaseId = InjectedScriptHost.databaseId(object)
113                 if (databaseId)
114                     hints.databaseId = databaseId;
115                 break;
116             case "Storage":
117                 var storageId = InjectedScriptHost.storageId(object)
118                 if (storageId)
119                     hints.domStorageId = storageId;
120                 break;
121         }
122         InjectedScriptHost.inspect(objectId, hints);
123         return object;
124     },
125
126     /**
127      * This method cannot throw.
128      * @param {*} object
129      * @param {string=} objectGroupName
130      * @param {boolean=} forceValueType
131      * @return {InjectedScript.RemoteObject}
132      */
133     _wrapObject: function(object, objectGroupName, forceValueType)
134     {
135         try {
136             return new InjectedScript.RemoteObject(object, objectGroupName, forceValueType);
137         } catch (e) {
138             try {
139                 var description = injectedScript._describe(e);
140             } catch (ex) {
141                 var description = "<failed to convert exception to string>";
142             }
143             return new InjectedScript.RemoteObject(description);
144         }
145     },
146
147     /**
148      * @param {*} object
149      * @param {string=} objectGroupName
150      * @return {string}
151      */
152     _bind: function(object, objectGroupName)
153     {
154         var id = this._lastBoundObjectId++;
155         this._idToWrappedObject[id] = object;
156         var objectId = "{\"injectedScriptId\":" + injectedScriptId + ",\"id\":" + id + "}";
157         if (objectGroupName) {
158             var group = this._objectGroups[objectGroupName];
159             if (!group) {
160                 group = [];
161                 this._objectGroups[objectGroupName] = group;
162             }
163             group.push(id);
164             this._idToObjectGroupName[id] = objectGroupName;
165         }
166         return objectId;
167     },
168
169     /**
170      * @param {string} objectId
171      * @return {*}
172      */
173     _parseObjectId: function(objectId)
174     {
175         return eval("(" + objectId + ")");
176     },
177
178     /**
179      * @param {string} objectGroupName
180      */
181     releaseObjectGroup: function(objectGroupName)
182     {
183         var group = this._objectGroups[objectGroupName];
184         if (!group)
185             return;
186         for (var i = 0; i < group.length; i++)
187             this._releaseObject(group[i]);
188         delete this._objectGroups[objectGroupName];
189     },
190
191     /**
192      * @param {string} methodName
193      * @param {string} args
194      * @return {*}
195      */
196     dispatch: function(methodName, args)
197     {
198         var argsArray = eval("(" + args + ")");
199         var result = this[methodName].apply(this, argsArray);
200         if (typeof result === "undefined") {
201             inspectedWindow.console.error("Web Inspector error: InjectedScript.%s returns undefined", methodName);
202             result = null;
203         }
204         return result;
205     },
206
207     /**
208      * @param {string} objectId
209      * @param {boolean} ownProperties
210      * @return {Array.<Object>|boolean}
211      */
212     getProperties: function(objectId, ownProperties)
213     {
214         var parsedObjectId = this._parseObjectId(objectId);
215         var object = this._objectForId(parsedObjectId);
216         var objectGroupName = this._idToObjectGroupName[parsedObjectId.id];
217
218         if (!this._isDefined(object))
219             return false;
220         var descriptors = this._propertyDescriptors(object, ownProperties);
221
222         // Go over properties, wrap object values.
223         if (descriptors.length === 0 && "arguments" in object) {
224             // Fill in JSC scope object.
225             for (var key in object)
226                 descriptors.push({ name: key, value: object[key], writable: false, configurable: false, enumerable: true});
227         }
228
229         for (var i = 0; i < descriptors.length; ++i) {
230             var descriptor = descriptors[i];
231             if ("get" in descriptor)
232                 descriptor.get = this._wrapObject(descriptor.get, objectGroupName);
233             if ("set" in descriptor)
234                 descriptor.set = this._wrapObject(descriptor.set, objectGroupName);
235             if ("value" in descriptor)
236                 descriptor.value = this._wrapObject(descriptor.value, objectGroupName);
237             if (!("configurable" in descriptor))
238                 descriptor.configurable = false;
239             if (!("enumerable" in descriptor))
240                 descriptor.enumerable = false;
241             
242         }
243         return descriptors;
244     },
245
246     /**
247      * @param {string} functionId
248      * @return {Object|string}
249      */
250     getFunctionDetails: function(functionId)
251     {
252         var parsedFunctionId = this._parseObjectId(functionId);
253         var func = this._objectForId(parsedFunctionId);
254         if (typeof func !== "function")
255             return "Cannot resolve function by id.";
256         var details = InjectedScriptHost.functionDetails(func);
257         if ("rawScopes" in details) {
258             var objectGroupName = this._idToObjectGroupName[parsedFunctionId.id];
259             var rawScopes = details.rawScopes;
260             var scopes = [];
261             delete details.rawScopes;
262             for (var i = 0; i < rawScopes.length; i++)
263                 scopes.push(InjectedScript.CallFrameProxy._createScopeJson(rawScopes[i].type, rawScopes[i].object, objectGroupName));
264             details.scopeChain = scopes;
265         }
266         return details;
267     },
268
269     /**
270      * @param {string} objectId
271      */
272     releaseObject: function(objectId)
273     {
274         var parsedObjectId = this._parseObjectId(objectId);
275         this._releaseObject(parsedObjectId.id);
276     },
277
278     /**
279      * @param {string} id
280      */
281     _releaseObject: function(id)
282     {
283         delete this._idToWrappedObject[id];
284         delete this._idToObjectGroupName[id];
285     },
286
287     /**
288      * @param {Object} object
289      * @param {boolean} ownProperties
290      * @return {Array.<Object>}
291      */
292     _propertyDescriptors: function(object, ownProperties)
293     {
294         var descriptors = [];
295         var nameProcessed = {};
296         nameProcessed["__proto__"] = null;
297         for (var o = object; this._isDefined(o); o = o.__proto__) {
298             var names = Object.getOwnPropertyNames(/** @type {!Object} */ (o));
299             for (var i = 0; i < names.length; ++i) {
300                 var name = names[i];
301                 if (nameProcessed[name])
302                     continue;
303
304                 try {
305                     nameProcessed[name] = true;
306                     var descriptor = Object.getOwnPropertyDescriptor(/** @type {!Object} */ (object), name);
307                     if (!descriptor) {
308                         // Not all bindings provide proper descriptors. Fall back to the writable, configurable property.
309                         try {
310                             descriptors.push({ name: name, value: object[name], writable: false, configurable: false, enumerable: false});
311                         } catch (e) {
312                             // Silent catch.
313                         }
314                         continue;
315                     }
316                 } catch (e) {
317                     var descriptor = {};
318                     descriptor.value = e;
319                     descriptor.wasThrown = true;
320                 }
321
322                 descriptor.name = name;
323                 descriptors.push(descriptor); 
324             }
325             if (ownProperties) {
326                 if (object.__proto__)
327                     descriptors.push({ name: "__proto__", value: object.__proto__, writable: true, configurable: true, enumerable: false});
328                 break;
329             }
330         }
331         return descriptors;
332     },
333
334     /**
335      * @param {string} expression
336      * @param {string} objectGroup
337      * @param {boolean} injectCommandLineAPI
338      * @param {boolean} returnByValue
339      * @return {*}
340      */
341     evaluate: function(expression, objectGroup, injectCommandLineAPI, returnByValue)
342     {
343         return this._evaluateAndWrap(inspectedWindow.eval, inspectedWindow, expression, objectGroup, false, injectCommandLineAPI, returnByValue);
344     },
345
346     /**
347      * @param {string} objectId
348      * @param {string} expression
349      * @param {boolean} returnByValue
350      * @return {Object|string}
351      */
352     callFunctionOn: function(objectId, expression, args, returnByValue)
353     {
354         var parsedObjectId = this._parseObjectId(objectId);
355         var object = this._objectForId(parsedObjectId);
356         if (!this._isDefined(object))
357             return "Could not find object with given id";
358
359         if (args) {
360             var resolvedArgs = [];
361             args = eval(args);
362             for (var i = 0; i < args.length; ++i) {
363                 objectId = args[i].objectId;
364                 if (objectId) {
365                     var parsedArgId = this._parseObjectId(objectId);
366                     if (!parsedArgId || parsedArgId.injectedScriptId !== injectedScriptId)
367                         return "Arguments should belong to the same JavaScript world as the target object.";
368
369                     var resolvedArg = this._objectForId(parsedArgId);
370                     if (!this._isDefined(resolvedArg))
371                         return "Could not find object with given id";
372
373                     resolvedArgs.push(resolvedArg);
374                 } else if ("value" in args[i])
375                     resolvedArgs.push(args[i].value);
376                 else
377                     resolvedArgs.push(undefined);
378             }
379         }
380
381         try {
382             var objectGroup = this._idToObjectGroupName[parsedObjectId.id];
383             var func = eval("(" + expression + ")");
384             if (typeof func !== "function")
385                 return "Given expression does not evaluate to a function";
386
387             return { wasThrown: false,
388                      result: this._wrapObject(func.apply(object, resolvedArgs), objectGroup, returnByValue) };
389         } catch (e) {
390             return this._createThrownValue(e, objectGroup);
391         }
392     },
393
394     /**
395      * @param {Function} evalFunction
396      * @param {Object} object
397      * @param {string} objectGroup
398      * @param {boolean} isEvalOnCallFrame
399      * @param {boolean} injectCommandLineAPI
400      * @param {boolean} returnByValue
401      * @return {*}
402      */
403     _evaluateAndWrap: function(evalFunction, object, expression, objectGroup, isEvalOnCallFrame, injectCommandLineAPI, returnByValue)
404     {
405         try {
406             return { wasThrown: false,
407                      result: this._wrapObject(this._evaluateOn(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI), objectGroup, returnByValue) };
408         } catch (e) {
409             return this._createThrownValue(e, objectGroup);
410         }
411     },
412
413     /**
414      * @param {*} value
415      * @param {string} objectGroup
416      * @return {Object}
417      */
418     _createThrownValue: function(value, objectGroup)
419     {
420         var remoteObject = this._wrapObject(value, objectGroup);
421         try {
422             remoteObject.description = this._toString(value);
423         } catch (e) {}
424         return { wasThrown: true,
425                  result: remoteObject };
426     },
427
428     /**
429      * @param {Function} evalFunction
430      * @param {Object} object
431      * @param {string} objectGroup
432      * @param {string} expression
433      * @param {boolean} isEvalOnCallFrame
434      * @param {boolean} injectCommandLineAPI
435      * @return {*}
436      */
437     _evaluateOn: function(evalFunction, object, objectGroup, expression, isEvalOnCallFrame, injectCommandLineAPI)
438     {
439         // Only install command line api object for the time of evaluation.
440         // Surround the expression in with statements to inject our command line API so that
441         // the window object properties still take more precedent than our API functions.
442
443         try {
444             if (injectCommandLineAPI && inspectedWindow.console) {
445                 inspectedWindow.console._commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
446                 expression = "with ((window && window.console && window.console._commandLineAPI) || {}) {\n" + expression + "\n}";
447             }
448             var result = evalFunction.call(object, expression);
449             if (objectGroup === "console")
450                 this._lastResult = result;
451             return result;
452         } finally {
453             if (injectCommandLineAPI && inspectedWindow.console)
454                 delete inspectedWindow.console._commandLineAPI;
455         }
456     },
457
458     /**
459      * @param {Object} callFrame
460      * @return {Array.<InjectedScript.CallFrameProxy>|boolean}
461      */
462     wrapCallFrames: function(callFrame)
463     {
464         if (!callFrame)
465             return false;
466
467         var result = [];
468         var depth = 0;
469         do {
470             result.push(new InjectedScript.CallFrameProxy(depth++, callFrame));
471             callFrame = callFrame.caller;
472         } while (callFrame);
473         return result;
474     },
475
476     /**
477      * @param {Object} topCallFrame
478      * @param {string} callFrameId
479      * @param {string} expression
480      * @param {string} objectGroup
481      * @param {boolean} injectCommandLineAPI
482      * @param {boolean} returnByValue
483      * @return {*}
484      */
485     evaluateOnCallFrame: function(topCallFrame, callFrameId, expression, objectGroup, injectCommandLineAPI, returnByValue)
486     {
487         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
488         if (!callFrame)
489             return "Could not find call frame with given id";
490         return this._evaluateAndWrap(callFrame.evaluate, callFrame, expression, objectGroup, true, injectCommandLineAPI, returnByValue);
491     },
492
493     /**
494      * @param {Object} topCallFrame
495      * @param {string} callFrameId
496      * @return {*}
497      */
498     restartFrame: function(topCallFrame, callFrameId)
499     {
500         var callFrame = this._callFrameForId(topCallFrame, callFrameId);
501         if (!callFrame)
502             return "Could not find call frame with given id";
503         var result = callFrame.restart();
504         if (result === false)
505             result = "Restart frame is not supported"; 
506         return result;
507     },
508
509     /**
510      * @param {Object} topCallFrame
511      * @param {string} callFrameId
512      * @return {Object}
513      */
514     _callFrameForId: function(topCallFrame, callFrameId)
515     {
516         var parsedCallFrameId = eval("(" + callFrameId + ")");
517         var ordinal = parsedCallFrameId["ordinal"];
518         var callFrame = topCallFrame;
519         while (--ordinal >= 0 && callFrame)
520             callFrame = callFrame.caller;
521         return callFrame;
522     },
523
524     /**
525      * @param {Object} objectId
526      * @return {Object}
527      */
528     _objectForId: function(objectId)
529     {
530         return this._idToWrappedObject[objectId.id];
531     },
532
533     /**
534      * @param {string} objectId
535      * @return {Object}
536      */
537     findObjectById: function(objectId)
538     {
539         var parsedObjectId = this._parseObjectId(objectId);
540         return this._objectForId(parsedObjectId);
541     },
542
543     /**
544      * @param {string} objectId
545      * @return {Node}
546      */
547     nodeForObjectId: function(objectId)
548     {
549         var object = this.findObjectById(objectId);
550         if (!object || this._subtype(object) !== "node")
551             return null;
552         return object;
553     },
554
555     module: function(name)
556     {
557         return this._modules[name];
558     },
559  
560     injectModule: function(name, source)
561     {
562         delete this._modules[name];
563         var module = eval("(" + source + ")");
564         this._modules[name] = module;
565         return module;
566     },
567
568     /**
569      * @param {*} object
570      * @return {boolean}
571      */
572     _isDefined: function(object)
573     {
574         return object || this._isHTMLAllCollection(object);
575     },
576
577     /**
578      * @param {*} object
579      * @return {boolean}
580      */
581     _isHTMLAllCollection: function(object)
582     {
583         // document.all is reported as undefined, but we still want to process it.
584         return (typeof object === "undefined") && InjectedScriptHost.isHTMLAllCollection(object);
585     },
586
587     /**
588      * @param {Object=} obj
589      * @return {string?}
590      */
591     _subtype: function(obj)
592     {
593         if (obj === null)
594             return "null";
595
596         var type = typeof obj;
597         if (this.isPrimitiveValue(obj))
598             return null;
599
600         if (this._isHTMLAllCollection(obj))
601             return "array";
602
603         var preciseType = InjectedScriptHost.type(obj);
604         if (preciseType)
605             return preciseType;
606
607         // FireBug's array detection.
608         try {
609             if (typeof obj.splice === "function" && isFinite(obj.length))
610                 return "array";
611             if (Object.prototype.toString.call(obj) === "[object Arguments]" && isFinite(obj.length)) // arguments.
612                 return "array";
613         } catch (e) {
614         }
615
616         // If owning frame has navigated to somewhere else window properties will be undefined.
617         return null;
618     },
619
620     /**
621      * @param {*} obj
622      * @return {string?}
623      */
624     _describe: function(obj)
625     {
626         if (this.isPrimitiveValue(obj))
627             return null;
628
629         // Type is object, get subtype.
630         var subtype = this._subtype(obj);
631
632         if (subtype === "regexp")
633             return this._toString(obj);
634
635         if (subtype === "date")
636             return this._toString(obj);
637
638         var className = InjectedScriptHost.internalConstructorName(obj);
639         if (subtype === "array") {
640             if (typeof obj.length === "number")
641                 className += "[" + obj.length + "]";
642             return className;
643         }
644
645         // NodeList in JSC is a function, check for array prior to this.
646         if (typeof obj === "function")
647             return this._toString(obj);
648
649         if (className === "Object") {
650             // In Chromium DOM wrapper prototypes will have Object as their constructor name,
651             // get the real DOM wrapper name from the constructor property.
652             var constructorName = obj.constructor && obj.constructor.name;
653             if (constructorName)
654                 return constructorName;
655         }
656         return className;
657     },
658
659     /**
660      * @param {*} obj
661      * @return {string}
662      */
663     _toString: function(obj)
664     {
665         // We don't use String(obj) because inspectedWindow.String is undefined if owning frame navigated to another page.
666         return "" + obj;
667     }
668 }
669
670 /**
671  * @type {InjectedScript}
672  * @const
673  */
674 var injectedScript = new InjectedScript();
675
676 /**
677  * @constructor
678  * @param {*} object
679  * @param {string=} objectGroupName
680  * @param {boolean=} forceValueType
681  */
682 InjectedScript.RemoteObject = function(object, objectGroupName, forceValueType)
683 {
684     this.type = typeof object;
685     if (injectedScript.isPrimitiveValue(object) || object === null || forceValueType) {
686         // We don't send undefined values over JSON.
687         if (typeof object !== "undefined")
688             this.value = object;
689
690         // Null object is object with 'null' subtype'
691         if (object === null)
692             this.subtype = "null";
693
694         // Provide user-friendly number values.
695         if (typeof object === "number")
696             this.description = object + "";
697         return;
698     }
699
700     this.objectId = injectedScript._bind(object, objectGroupName);
701     var subtype = injectedScript._subtype(object)
702     if (subtype)
703         this.subtype = subtype;
704     this.className = InjectedScriptHost.internalConstructorName(object);
705     this.description = injectedScript._describe(object);
706 }
707
708 /**
709  * @constructor
710  * @param {number} ordinal
711  * @param {Object} callFrame
712  */
713 InjectedScript.CallFrameProxy = function(ordinal, callFrame)
714 {
715     this.callFrameId = "{\"ordinal\":" + ordinal + ",\"injectedScriptId\":" + injectedScriptId + "}";
716     this.functionName = (callFrame.type === "function" ? callFrame.functionName : "");
717     this.location = { scriptId: String(callFrame.sourceID), lineNumber: callFrame.line, columnNumber: callFrame.column };
718     this.scopeChain = this._wrapScopeChain(callFrame);
719     this.this = injectedScript._wrapObject(callFrame.thisObject, "backtrace");
720 }
721
722 InjectedScript.CallFrameProxy.prototype = {
723     /**
724      * @param {Object} callFrame
725      * @return {Array.<Object>}
726      */
727     _wrapScopeChain: function(callFrame)
728     {
729         var scopeChain = callFrame.scopeChain;
730         var scopeChainProxy = [];
731         for (var i = 0; i < scopeChain.length; i++) {
732             var scope = InjectedScript.CallFrameProxy._createScopeJson(callFrame.scopeType(i), scopeChain[i], "backtrace");
733             scopeChainProxy.push(scope);
734         }
735         return scopeChainProxy;
736     }
737 }
738
739 /**
740  * @param {number} scopeTypeCode
741  * @param {*} scopeObject
742  * @param {string} groupId
743  * @return {Object}
744  */
745 InjectedScript.CallFrameProxy._createScopeJson = function(scopeTypeCode, scopeObject, groupId) {
746     const GLOBAL_SCOPE = 0;
747     const LOCAL_SCOPE = 1;
748     const WITH_SCOPE = 2;
749     const CLOSURE_SCOPE = 3;
750     const CATCH_SCOPE = 4;
751
752     var scopeTypeNames = {};
753     scopeTypeNames[GLOBAL_SCOPE] = "global";
754     scopeTypeNames[LOCAL_SCOPE] = "local";
755     scopeTypeNames[WITH_SCOPE] = "with";
756     scopeTypeNames[CLOSURE_SCOPE] = "closure";
757     scopeTypeNames[CATCH_SCOPE] = "catch";
758
759     return {
760         object: injectedScript._wrapObject(scopeObject, groupId),
761         type: scopeTypeNames[scopeTypeCode]
762     };
763 }
764
765 /**
766  * @constructor
767  * @param {CommandLineAPIImpl} commandLineAPIImpl
768  * @param {Object} callFrame
769  */
770 function CommandLineAPI(commandLineAPIImpl, callFrame)
771 {
772     /**
773      * @param {string} member
774      * @return {boolean}
775      */
776     function inScopeVariables(member)
777     {
778         if (!callFrame)
779             return false;
780
781         var scopeChain = callFrame.scopeChain;
782         for (var i = 0; i < scopeChain.length; ++i) {
783             if (member in scopeChain[i])
784                 return true;
785         }
786         return false;
787     }
788
789     for (var i = 0; i < CommandLineAPI.members_.length; ++i) {
790         var member = CommandLineAPI.members_[i];
791         if (member in inspectedWindow || inScopeVariables(member))
792             continue;
793
794         this[member] = commandLineAPIImpl[member].bind(commandLineAPIImpl);
795     }
796
797     for (var i = 0; i < 5; ++i) {
798         var member = "$" + i;
799         if (member in inspectedWindow || inScopeVariables(member))
800             continue;
801
802         this.__defineGetter__("$" + i, commandLineAPIImpl._inspectedObject.bind(commandLineAPIImpl, i));
803     }
804
805     this.$_ = injectedScript._lastResult;
806 }
807
808 /**
809  * @type {Array.<string>}
810  * @const
811  */
812 CommandLineAPI.members_ = [
813     "$", "$$", "$x", "dir", "dirxml", "keys", "values", "profile", "profileEnd",
814     "monitorEvents", "unmonitorEvents", "inspect", "copy", "clear", "getEventListeners"
815 ];
816
817 /**
818  * @constructor
819  */
820 function CommandLineAPIImpl()
821 {
822 }
823
824 CommandLineAPIImpl.prototype = {
825     $: function()
826     {
827         return document.getElementById.apply(document, arguments)
828     },
829
830     $$: function()
831     {
832         return document.querySelectorAll.apply(document, arguments)
833     },
834
835     $x: function(xpath, context)
836     {
837         var doc = (context && context.ownerDocument) || inspectedWindow.document;
838         var result = doc.evaluate(xpath, context || doc, null, XPathResult.ANY_TYPE, null);
839         switch (result.resultType) {
840         case XPathResult.NUMBER_TYPE:
841             return result.numberValue;
842         case XPathResult.STRING_TYPE:
843             return result.stringValue;
844         case XPathResult.BOOLEAN_TYPE:
845             return result.booleanValue;
846         default:
847             var nodes = [];
848             var node;
849             while (node = result.iterateNext())
850                 nodes.push(node);
851             return nodes;
852         }
853     },
854
855     dir: function()
856     {
857         return console.dir.apply(console, arguments)
858     },
859
860     dirxml: function()
861     {
862         return console.dirxml.apply(console, arguments)
863     },
864
865     keys: function(object)
866     {
867         return Object.keys(object);
868     },
869
870     values: function(object)
871     {
872         var result = [];
873         for (var key in object)
874             result.push(object[key]);
875         return result;
876     },
877
878     profile: function()
879     {
880         return console.profile.apply(console, arguments)
881     },
882
883     profileEnd: function()
884     {
885         return console.profileEnd.apply(console, arguments)
886     },
887
888     /**
889      * @param {Object} object
890      * @param {Array.<string>|string=} types
891      */
892     monitorEvents: function(object, types)
893     {
894         if (!object || !object.addEventListener || !object.removeEventListener)
895             return;
896         types = this._normalizeEventTypes(types);
897         for (var i = 0; i < types.length; ++i) {
898             object.removeEventListener(types[i], this._logEvent, false);
899             object.addEventListener(types[i], this._logEvent, false);
900         }
901     },
902
903     /**
904      * @param {Object} object
905      * @param {Array.<string>|string=} types
906      */
907     unmonitorEvents: function(object, types)
908     {
909         if (!object || !object.addEventListener || !object.removeEventListener)
910             return;
911         types = this._normalizeEventTypes(types);
912         for (var i = 0; i < types.length; ++i)
913             object.removeEventListener(types[i], this._logEvent, false);
914     },
915
916     /**
917      * @param {*} object
918      * @return {*}
919      */
920     inspect: function(object)
921     {
922         return injectedScript._inspect(object);
923     },
924
925     copy: function(object)
926     {
927         if (injectedScript._subtype(object) === "node")
928             object = object.outerHTML;
929         InjectedScriptHost.copyText(object);
930     },
931
932     clear: function()
933     {
934         InjectedScriptHost.clearConsoleMessages();
935     },
936
937     /**
938      * @param {Node} node
939      */
940     getEventListeners: function(node)
941     {
942         return InjectedScriptHost.getEventListeners(node);
943     },
944
945     /**
946      * @param {number} num
947      */
948     _inspectedObject: function(num)
949     {
950         return InjectedScriptHost.inspectedObject(num);
951     },
952
953     /**
954      * @param {Array.<string>|string=} types
955      * @return {Array.<string>}
956      */
957     _normalizeEventTypes: function(types)
958     {
959         if (typeof types === "undefined")
960             types = [ "mouse", "key", "touch", "control", "load", "unload", "abort", "error", "select", "change", "submit", "reset", "focus", "blur", "resize", "scroll", "search", "devicemotion", "deviceorientation" ];
961         else if (typeof types === "string")
962             types = [ types ];
963
964         var result = [];
965         for (var i = 0; i < types.length; i++) {
966             if (types[i] === "mouse")
967                 result.splice(0, 0, "mousedown", "mouseup", "click", "dblclick", "mousemove", "mouseover", "mouseout", "mousewheel");
968             else if (types[i] === "key")
969                 result.splice(0, 0, "keydown", "keyup", "keypress", "textInput");
970             else if (types[i] === "touch")
971                 result.splice(0, 0, "touchstart", "touchmove", "touchend", "touchcancel");
972             else if (types[i] === "control")
973                 result.splice(0, 0, "resize", "scroll", "zoom", "focus", "blur", "select", "change", "submit", "reset");
974             else
975                 result.push(types[i]);
976         }
977         return result;
978     },
979
980     /**
981      * @param {Event} event
982      */
983     _logEvent: function(event)
984     {
985         console.log(event.type, event);
986     }
987 }
988
989 injectedScript._commandLineAPIImpl = new CommandLineAPIImpl();
990 return injectedScript;
991 })