DevTools: Show detailed information for exceptions during snippet execution.

Source/devtools/front_end/sdk/ScriptSnippetModel.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 203 matching lines @@
         var evaluationUrl = this._evaluationSourceURL(uiSourceCode);
         var expression = uiSourceCode.workingCopy();
 
         WebInspector.console.show();
         var target = executionContext.target();
         target.debuggerAgent().compileScript(expression, evaluationUrl, executionContext.id, compileCallback.bind(this, target));
 
         /**
          * @param {!WebInspector.Target} target
          * @param {?string} error
-         * @param {string=} scriptId
-         * @param {string=} syntaxErrorMessage
+         * @param {!DebuggerAgent.ScriptId=} scriptId
+         * @param {?DebuggerAgent.ExceptionMessage=} exceptionMessage
          * @this {WebInspector.ScriptSnippetModel}
          */
-        function compileCallback(target, error, scriptId, syntaxErrorMessage)
+        function compileCallback(target, error, scriptId, exceptionMessage)
         {
             if (!uiSourceCode || uiSourceCode._evaluationIndex !== evaluationIndex)
                 return;
 
             if (error) {
                 console.error(error);
                 return;
             }
 
             if (!scriptId) {
                 var consoleMessage = new WebInspector.ConsoleMessage(
                         target,
-                        WebInspector.ConsoleMessage.MessageSource.JS,
+                        exceptionMessage.source,
                         WebInspector.ConsoleMessage.MessageLevel.Error,
-                        syntaxErrorMessage || "");
+                        exceptionMessage.text || "",
+                        undefined,
+                        evaluationUrl,
+                        exceptionMessage.line,
+                        exceptionMessage.column,
+                        undefined,
+                        undefined,
+                        exceptionMessage.stackTrace);
                 target.consoleModel.addMessage(consoleMessage);
                 return;
             }
 
             var breakpointLocations = this._removeBreakpoints(uiSourceCode);
             this._restoreBreakpoints(uiSourceCode, breakpointLocations);
 
-            this._runScript(scriptId, executionContext);
+            this._runScript(scriptId, executionContext, evaluationUrl);
         }
     },
 
     /**
      * @param {!DebuggerAgent.ScriptId} scriptId
      * @param {!WebInspector.ExecutionContext} executionContext
      */
-    _runScript: function(scriptId, executionContext)
+    _runScript: function(scriptId, executionContext, sourceURL)
     {
         var target = executionContext.target();
         target.debuggerAgent().runScript(scriptId, executionContext.id, "console", false, runCallback.bind(this, target));
 
         /**
          * @param {!WebInspector.Target} target
          * @param {?string} error
          * @param {?RuntimeAgent.RemoteObject} result
-         * @param {boolean=} wasThrown
+         * @param {?DebuggerAgent.ExceptionMessage=} exceptionMessage
          * @this {WebInspector.ScriptSnippetModel}
          */
-        function runCallback(target, error, result, wasThrown)
+        function runCallback(target, error, result, exceptionMessage)
         {
             if (error) {
                 console.error(error);
                 return;
             }
 
-            this._printRunScriptResult(target, result, wasThrown);
+            this._printRunScriptResult(target, result, sourceURL, exceptionMessage);
         }
     },
 
     /**
      * @param {!WebInspector.Target} target
      * @param {?RuntimeAgent.RemoteObject} result
-     * @param {boolean=} wasThrown
+     * @param {?string=} sourceURL
+     * @param {?DebuggerAgent.ExceptionMessage=} exceptionMessage
      */
-    _printRunScriptResult: function(target, result, wasThrown)
+    _printRunScriptResult: function(target, result, sourceURL, exceptionMessage)
     {
+        var wasThrown = !!exceptionMessage;
         var level = (wasThrown ? WebInspector.ConsoleMessage.MessageLevel.Error : WebInspector.ConsoleMessage.MessageLevel.Log);
-        var message = new WebInspector.ConsoleMessage(target,
+        var consoleMessage = new WebInspector.ConsoleMessage(

[vsevik, 2014/05/19 12:40:23]

This is hard to read.
Let's split this into two if-branches:
if (wasThrown)
   ...

Also we could probably reuse the same ConsoleMessage constructor call for both
compile and run failures.

+            target,
             WebInspector.ConsoleMessage.MessageSource.JS,
             level,
-            "",
+            (wasThrown ? exceptionMessage.text : ""),
             undefined,
+            sourceURL,
+            (wasThrown ? exceptionMessage.line : undefined),
+            (wasThrown ? exceptionMessage.column : undefined),
             undefined,
-            undefined,
-            undefined,
-            undefined,
-            [result]);
-        target.consoleModel.addMessage(message);
+            (wasThrown ? undefined : [result]),
+            (wasThrown ? exceptionMessage.stackTrace : undefined));
+        target.consoleModel.addMessage(consoleMessage);
     },
 
     /**
      * @param {!WebInspector.DebuggerModel.Location} rawLocation
      * @return {?WebInspector.UILocation}
      */
     _rawLocationToUILocation: function(rawLocation)
     {
         var uiSourceCode = this._uiSourceCodeForScriptId[rawLocation.scriptId];
         if (!uiSourceCode)
@@ skipping 317 matching lines @@
         this._model.deleteScriptSnippet(path);
     },
 
     __proto__: WebInspector.ContentProviderBasedProjectDelegate.prototype
 }
 
 /**
  * @type {!WebInspector.ScriptSnippetModel}
  */
 WebInspector.scriptSnippetModel;