Home | History | Annotate | Download | only in sdk 
      1 /*
      2  * Copyright (C) 2011 Google 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 are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 /**
     32  * @constructor
     33  * @extends {WebInspector.SDKModel}
     34  * @param {!WebInspector.Target} target
     35  */
     36 WebInspector.ConsoleModel = function(target)
     37 {
     38     WebInspector.SDKModel.call(this, WebInspector.ConsoleModel, target);
     39 
     40     /** @type {!Array.<!WebInspector.ConsoleMessage>} */
     41     this._messages = [];
     42     this.warnings = 0;
     43     this.errors = 0;
     44     this._consoleAgent = target.consoleAgent();
     45     target.registerConsoleDispatcher(new WebInspector.ConsoleDispatcher(this));
     46     this._enableAgent();
     47 }
     48 
     49 WebInspector.ConsoleModel.Events = {
     50     ConsoleCleared: "ConsoleCleared",
     51     MessageAdded: "MessageAdded",
     52     CommandEvaluated: "CommandEvaluated",
     53 }
     54 
     55 WebInspector.ConsoleModel.prototype = {
     56     _enableAgent: function()
     57     {
     58         if (WebInspector.settings.monitoringXHREnabled.get())
     59             this._consoleAgent.setMonitoringXHREnabled(true);
     60 
     61         this._enablingConsole = true;
     62 
     63         /**
     64          * @this {WebInspector.ConsoleModel}
     65          */
     66         function callback()
     67         {
     68             delete this._enablingConsole;
     69         }
     70         this._consoleAgent.enable(callback.bind(this));
     71     },
     72 
     73     /**
     74      * @return {boolean}
     75      */
     76     enablingConsole: function()
     77     {
     78         return !!this._enablingConsole;
     79     },
     80 
     81     /**
     82      * @param {!WebInspector.ConsoleMessage} msg
     83      */
     84     addMessage: function(msg)
     85     {
     86         if (WebInspector.NetworkManager.hasDevToolsRequestHeader(msg.request))
     87             return;
     88 
     89         msg.index = this._messages.length;
     90         this._messages.push(msg);
     91         this._incrementErrorWarningCount(msg);
     92 
     93         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, msg);
     94     },
     95 
     96     /**
     97      * @param {!WebInspector.ConsoleMessage} msg
     98      */
     99     _incrementErrorWarningCount: function(msg)
    100     {
    101         switch (msg.level) {
    102             case WebInspector.ConsoleMessage.MessageLevel.Warning:
    103                 this.warnings++;
    104                 break;
    105             case WebInspector.ConsoleMessage.MessageLevel.Error:
    106                 this.errors++;
    107                 break;
    108         }
    109     },
    110 
    111     /**
    112      * @return {!Array.<!WebInspector.ConsoleMessage>}
    113      */
    114     messages: function()
    115     {
    116         return this._messages;
    117     },
    118 
    119     requestClearMessages: function()
    120     {
    121         this._consoleAgent.clearMessages();
    122         this._messagesCleared();
    123     },
    124 
    125     _messagesCleared: function()
    126     {
    127         this._messages = [];
    128         this.errors = 0;
    129         this.warnings = 0;
    130         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
    131     },
    132 
    133     __proto__: WebInspector.SDKModel.prototype
    134 }
    135 
    136 /**
    137  * @param {!WebInspector.ExecutionContext} executionContext
    138  * @param {string} text
    139  * @param {boolean=} useCommandLineAPI
    140  */
    141 WebInspector.ConsoleModel.evaluateCommandInConsole = function(executionContext, text, useCommandLineAPI)
    142 {
    143     useCommandLineAPI = !!useCommandLineAPI;
    144     var target = executionContext.target();
    145 
    146     var commandMessage = new WebInspector.ConsoleMessage(target, WebInspector.ConsoleMessage.MessageSource.JS, null, text, WebInspector.ConsoleMessage.MessageType.Command);
    147     commandMessage.setExecutionContextId(executionContext.id);
    148     target.consoleModel.addMessage(commandMessage);
    149 
    150     /**
    151      * @param {?WebInspector.RemoteObject} result
    152      * @param {boolean} wasThrown
    153      * @param {?RuntimeAgent.RemoteObject=} valueResult
    154      * @param {?DebuggerAgent.ExceptionDetails=} exceptionDetails
    155      * @this {WebInspector.ConsoleModel}
    156      */
    157     function printResult(result, wasThrown, valueResult, exceptionDetails)
    158     {
    159         if (!result)
    160             return;
    161 
    162         WebInspector.console.show();
    163         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.CommandEvaluated, {result: result, wasThrown: wasThrown, text: text, commandMessage: commandMessage, exceptionDetails: exceptionDetails});
    164     }
    165 
    166     executionContext.evaluate(text, "console", useCommandLineAPI, false, false, true, printResult.bind(target.consoleModel));
    167 
    168     WebInspector.userMetrics.ConsoleEvaluated.record();
    169 }
    170 
    171 
    172 /**
    173  * @constructor
    174  * @param {?WebInspector.Target} target
    175  * @param {string} source
    176  * @param {?string} level
    177  * @param {string} messageText
    178  * @param {string=} type
    179  * @param {?string=} url
    180  * @param {number=} line
    181  * @param {number=} column
    182  * @param {!NetworkAgent.RequestId=} requestId
    183  * @param {!Array.<!RuntimeAgent.RemoteObject>=} parameters
    184  * @param {!Array.<!ConsoleAgent.CallFrame>=} stackTrace
    185  * @param {number=} timestamp
    186  * @param {boolean=} isOutdated
    187  * @param {!RuntimeAgent.ExecutionContextId=} executionContextId
    188  * @param {!ConsoleAgent.AsyncStackTrace=} asyncStackTrace
    189  * @param {?string=} scriptId
    190  */
    191 WebInspector.ConsoleMessage = function(target, source, level, messageText, type, url, line, column, requestId, parameters, stackTrace, timestamp, isOutdated, executionContextId, asyncStackTrace, scriptId)
    192 {
    193     this._target = target;
    194     this.source = source;
    195     this.level = level;
    196     this.messageText = messageText;
    197     this.type = type || WebInspector.ConsoleMessage.MessageType.Log;
    198     /** @type {string|undefined} */
    199     this.url = url || undefined;
    200     /** @type {number} */
    201     this.line = line || 0;
    202     /** @type {number} */
    203     this.column = column || 0;
    204     this.parameters = parameters;
    205     /** @type {!Array.<!ConsoleAgent.CallFrame>|undefined} */
    206     this.stackTrace = stackTrace;
    207     this.timestamp = timestamp || Date.now();
    208     this.isOutdated = isOutdated;
    209     this.executionContextId = executionContextId || 0;
    210     this.asyncStackTrace = asyncStackTrace;
    211     this.scriptId = scriptId || null;
    212 
    213     this.request = requestId ? target.networkLog.requestForId(requestId) : null;
    214 
    215     if (this.request) {
    216         var initiator = this.request.initiator();
    217         if (initiator) {
    218             this.stackTrace = initiator.stackTrace || undefined;
    219             this.asyncStackTrace = initiator.asyncStackTrace;
    220             if (initiator.url) {
    221                 this.url = initiator.url;
    222                 this.line = initiator.lineNumber || 0;
    223             }
    224         }
    225     }
    226 }
    227 
    228 WebInspector.ConsoleMessage.prototype = {
    229     /**
    230      * @return {?WebInspector.Target}
    231      */
    232     target: function()
    233     {
    234         return this._target;
    235     },
    236 
    237     /**
    238      * @param {!WebInspector.ConsoleMessage} originatingMessage
    239      */
    240     setOriginatingMessage: function(originatingMessage)
    241     {
    242         this._originatingConsoleMessage = originatingMessage;
    243         this.executionContextId = originatingMessage.executionContextId;
    244     },
    245 
    246     /**
    247      * @param {!RuntimeAgent.ExecutionContextId} executionContextId
    248      */
    249     setExecutionContextId: function(executionContextId)
    250     {
    251         this.executionContextId = executionContextId;
    252     },
    253 
    254     /**
    255      * @return {?WebInspector.ConsoleMessage}
    256      */
    257     originatingMessage: function()
    258     {
    259         return this._originatingConsoleMessage;
    260     },
    261 
    262     /**
    263      * @return {boolean}
    264      */
    265     isGroupMessage: function()
    266     {
    267         return this.type === WebInspector.ConsoleMessage.MessageType.StartGroup ||
    268             this.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed ||
    269             this.type === WebInspector.ConsoleMessage.MessageType.EndGroup;
    270     },
    271 
    272     /**
    273      * @return {boolean}
    274      */
    275     isGroupStartMessage: function()
    276     {
    277         return this.type === WebInspector.ConsoleMessage.MessageType.StartGroup ||
    278             this.type === WebInspector.ConsoleMessage.MessageType.StartGroupCollapsed;
    279     },
    280 
    281     /**
    282      * @return {boolean}
    283      */
    284     isErrorOrWarning: function()
    285     {
    286         return (this.level === WebInspector.ConsoleMessage.MessageLevel.Warning || this.level === WebInspector.ConsoleMessage.MessageLevel.Error);
    287     },
    288 
    289     /**
    290      * @return {!WebInspector.ConsoleMessage}
    291      */
    292     clone: function()
    293     {
    294         return new WebInspector.ConsoleMessage(
    295             this.target(),
    296             this.source,
    297             this.level,
    298             this.messageText,
    299             this.type,
    300             this.url,
    301             this.line,
    302             this.column,
    303             this.request ? this.request.requestId : undefined,
    304             this.parameters,
    305             this.stackTrace,
    306             this.timestamp,
    307             this.isOutdated,
    308             this.executionContextId,
    309             this.asyncStackTrace,
    310             this.scriptId);
    311     },
    312 
    313     /**
    314      * @param {?WebInspector.ConsoleMessage} msg
    315      * @return {boolean}
    316      */
    317     isEqual: function(msg)
    318     {
    319         if (!msg)
    320             return false;
    321 
    322         if (!this._isEqualStackTraces(this.stackTrace, msg.stackTrace))
    323             return false;
    324 
    325         var asyncTrace1 = this.asyncStackTrace;
    326         var asyncTrace2 = msg.asyncStackTrace;
    327         while (asyncTrace1 || asyncTrace2) {
    328             if (!asyncTrace1 || !asyncTrace2)
    329                 return false;
    330             if (asyncTrace1.description !== asyncTrace2.description)
    331                 return false;
    332             if (!this._isEqualStackTraces(asyncTrace1.callFrames, asyncTrace2.callFrames))
    333                 return false;
    334             asyncTrace1 = asyncTrace1.asyncStackTrace;
    335             asyncTrace2 = asyncTrace2.asyncStackTrace;
    336         }
    337 
    338         if (this.parameters) {
    339             if (!msg.parameters || this.parameters.length !== msg.parameters.length)
    340                 return false;
    341 
    342             for (var i = 0; i < msg.parameters.length; ++i) {
    343                 // Never treat objects as equal - their properties might change over time.
    344                 if (this.parameters[i].type !== msg.parameters[i].type || msg.parameters[i].type === "object" || this.parameters[i].value !== msg.parameters[i].value)
    345                     return false;
    346             }
    347         }
    348 
    349         return (this.target() === msg.target())
    350             && (this.source === msg.source)
    351             && (this.type === msg.type)
    352             && (this.level === msg.level)
    353             && (this.line === msg.line)
    354             && (this.url === msg.url)
    355             && (this.messageText === msg.messageText)
    356             && (this.request === msg.request)
    357             && (this.executionContextId === msg.executionContextId)
    358             && (this.scriptId === msg.scriptId);
    359     },
    360 
    361     /**
    362      * @param {!Array.<!ConsoleAgent.CallFrame>|undefined} stackTrace1
    363      * @param {!Array.<!ConsoleAgent.CallFrame>|undefined} stackTrace2
    364      * @return {boolean}
    365      */
    366     _isEqualStackTraces: function(stackTrace1, stackTrace2)
    367     {
    368         stackTrace1 = stackTrace1 || [];
    369         stackTrace2 = stackTrace2 || [];
    370         if (stackTrace1.length !== stackTrace2.length)
    371             return false;
    372         for (var i = 0, n = stackTrace1.length; i < n; ++i) {
    373             if (stackTrace1[i].url !== stackTrace2[i].url ||
    374                 stackTrace1[i].functionName !== stackTrace2[i].functionName ||
    375                 stackTrace1[i].lineNumber !== stackTrace2[i].lineNumber ||
    376                 stackTrace1[i].columnNumber !== stackTrace2[i].columnNumber)
    377                 return false;
    378         }
    379         return true;
    380     }
    381 }
    382 
    383 // Note: Keep these constants in sync with the ones in Console.h
    384 /**
    385  * @enum {string}
    386  */
    387 WebInspector.ConsoleMessage.MessageSource = {
    388     XML: "xml",
    389     JS: "javascript",
    390     Network: "network",
    391     ConsoleAPI: "console-api",
    392     Storage: "storage",
    393     AppCache: "appcache",
    394     Rendering: "rendering",
    395     CSS: "css",
    396     Security: "security",
    397     Other: "other",
    398     Deprecation: "deprecation"
    399 }
    400 
    401 /**
    402  * @enum {string}
    403  */
    404 WebInspector.ConsoleMessage.MessageType = {
    405     Log: "log",
    406     Dir: "dir",
    407     DirXML: "dirxml",
    408     Table: "table",
    409     Trace: "trace",
    410     Clear: "clear",
    411     StartGroup: "startGroup",
    412     StartGroupCollapsed: "startGroupCollapsed",
    413     EndGroup: "endGroup",
    414     Assert: "assert",
    415     Result: "result",
    416     Profile: "profile",
    417     ProfileEnd: "profileEnd",
    418     Command: "command"
    419 }
    420 
    421 /**
    422  * @enum {string}
    423  */
    424 WebInspector.ConsoleMessage.MessageLevel = {
    425     Log: "log",
    426     Info: "info",
    427     Warning: "warning",
    428     Error: "error",
    429     Debug: "debug"
    430 };
    431 
    432 WebInspector.ConsoleMessage._messageLevelPriority = {
    433     "debug": 0,
    434     "log": 1,
    435     "info": 2,
    436     "warning": 3,
    437     "error": 4
    438 };
    439 
    440 /**
    441  * @param {!WebInspector.ConsoleMessage} a
    442  * @param {!WebInspector.ConsoleMessage} b
    443  * @return {number}
    444  */
    445 WebInspector.ConsoleMessage.messageLevelComparator = function(a, b)
    446 {
    447     return WebInspector.ConsoleMessage._messageLevelPriority[a.level] - WebInspector.ConsoleMessage._messageLevelPriority[b.level];
    448 }
    449 
    450 /**
    451  * @param {!WebInspector.ConsoleMessage} a
    452  * @param {!WebInspector.ConsoleMessage} b
    453  * @return {number}
    454  */
    455 WebInspector.ConsoleMessage.timestampComparator = function (a, b)
    456 {
    457     return a.timestamp - b.timestamp;
    458 }
    459 
    460 /**
    461  * @constructor
    462  * @implements {ConsoleAgent.Dispatcher}
    463  * @param {!WebInspector.ConsoleModel} console
    464  */
    465 WebInspector.ConsoleDispatcher = function(console)
    466 {
    467     this._console = console;
    468 }
    469 
    470 WebInspector.ConsoleDispatcher.prototype = {
    471     /**
    472      * @param {!ConsoleAgent.ConsoleMessage} payload
    473      */
    474     messageAdded: function(payload)
    475     {
    476         var consoleMessage = new WebInspector.ConsoleMessage(
    477             this._console.target(),
    478             payload.source,
    479             payload.level,
    480             payload.text,
    481             payload.type,
    482             payload.url,
    483             payload.line,
    484             payload.column,
    485             payload.networkRequestId,
    486             payload.parameters,
    487             payload.stackTrace,
    488             payload.timestamp * 1000, // Convert to ms.
    489             this._console._enablingConsole,
    490             payload.executionContextId,
    491             payload.asyncStackTrace,
    492             payload.scriptId);
    493         this._console.addMessage(consoleMessage);
    494     },
    495 
    496     /**
    497      * @param {number} count
    498      */
    499     messageRepeatCountUpdated: function(count)
    500     {
    501     },
    502 
    503     messagesCleared: function()
    504     {
    505         if (!WebInspector.settings.preserveConsoleLog.get())
    506             this._console._messagesCleared();
    507     }
    508 }
    509 
    510 /**
    511  * @constructor
    512  * @extends {WebInspector.Object}
    513  * @implements {WebInspector.TargetManager.Observer}
    514  */
    515 WebInspector.MultitargetConsoleModel = function()
    516 {
    517     WebInspector.targetManager.observeTargets(this);
    518     WebInspector.targetManager.addModelListener(WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.MessageAdded, this._consoleMessageAdded, this);
    519     WebInspector.targetManager.addModelListener(WebInspector.ConsoleModel, WebInspector.ConsoleModel.Events.CommandEvaluated, this._commandEvaluated, this);
    520 }
    521 
    522 WebInspector.MultitargetConsoleModel.prototype = {
    523     /**
    524      * @param {!WebInspector.Target} target
    525      */
    526     targetAdded: function(target)
    527     {
    528         if (!this._mainTarget) {
    529             this._mainTarget = target;
    530             target.consoleModel.addEventListener(WebInspector.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
    531         }
    532     },
    533 
    534     /**
    535      * @param {!WebInspector.Target} target
    536      */
    537     targetRemoved: function(target)
    538     {
    539         if (this._mainTarget === target) {
    540             delete this._mainTarget;
    541             target.consoleModel.removeEventListener(WebInspector.ConsoleModel.Events.ConsoleCleared, this._consoleCleared, this);
    542         }
    543     },
    544 
    545     /**
    546      * @return {!Array.<!WebInspector.ConsoleMessage>}
    547      */
    548     messages: function()
    549     {
    550         var targets = WebInspector.targetManager.targets();
    551         var result = [];
    552         for (var i = 0; i < targets.length; ++i)
    553             result = result.concat(targets[i].consoleModel.messages());
    554         return result;
    555     },
    556 
    557     _consoleCleared: function()
    558     {
    559         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.ConsoleCleared);
    560     },
    561 
    562     /**
    563      * @param {!WebInspector.Event} event
    564      */
    565     _consoleMessageAdded: function(event)
    566     {
    567         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.MessageAdded, event.data);
    568     },
    569 
    570     /**
    571      * @param {!WebInspector.Event} event
    572      */
    573     _commandEvaluated: function(event)
    574     {
    575         this.dispatchEventToListeners(WebInspector.ConsoleModel.Events.CommandEvaluated, event.data);
    576     },
    577 
    578     __proto__: WebInspector.Object.prototype
    579 }
    580 
    581 /**
    582  * @type {!WebInspector.MultitargetConsoleModel}
    583  */
    584 WebInspector.multitargetConsoleModel;
    585