Pause and show call stack on exceptions

webkit/glue/devtools/js/debugger_agent.js

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Provides communication interface to remote v8 debugger. See
  * protocol decription at http://code.google.com/p/v8/wiki/DebuggerProtocol
  */
 goog.provide('devtools.DebuggerAgent');
 
@@ skipping 21 matching lines @@
   this.requestNumberToBreakpointInfo_ = null;
   
   /**
    * Information on current stack top frame.
    * See JavaScriptCallFrame.idl.
    * @type {?Object}
    */
   this.currentCallFrame_ = null;
   
   /**
+   * Whether to stop in the debugger on the exceptions.
+   * @type {boolean}
+   */
+  this.pauseOnExceptions_ = true;
+  
+  /**
    * Mapping: request sequence number->callback.
    * @type {Object}
    */
   this.requestSeqToCallback_ = null;  
 };
 
 
 /**
  * Resets debugger agent to its initial state.
  */
@@ skipping 114 matching lines @@
  * Tells the v8 debugger to continue execution after it has been stopped on a
  * breakpoint or an exception.
  */
 devtools.DebuggerAgent.prototype.resumeExecution = function() {
   var cmd = new devtools.DebugCommand('continue');
   devtools.DebuggerAgent.sendCommand_(cmd);
 };
 
 
 /**
+ * @return {boolean} True iff the debugger will pause execution on the
+ * exceptions.
+ */
+devtools.DebuggerAgent.prototype.pauseOnExceptions = function() { 
+  return this.pauseOnExceptions_;
+};
+
+
+/**
+ * Tells whether to pause in the debugger on the exceptions or not.
+ * @param {boolean} value True iff execution should be stopped in the debugger
+ * on the exceptions.
+ */
+devtools.DebuggerAgent.prototype.setPauseOnExceptions = function(value) {
+  this.pauseOnExceptions_ = value;
+};
+
+
+/**
  * Current stack top frame.
  * @return {Object}
  */
 devtools.DebuggerAgent.prototype.getCurrentCallFrame = function() {
   return this.currentCallFrame_;
 };
 
 
 /**
  * Sends 'evaluate' request to the debugger.
@@ skipping 164 matching lines @@
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleExceptionEvent_ = function(msg) {
   var body = msg.getBody();
   debugPrint('Uncaught exception in ' + body.script.name + ':' +
              body.sourceLine + '\n' + body.sourceLineText);
-  this.resumeExecution();
+  if (this.pauseOnExceptions_) {
+    var body = msg.getBody();
+
+    var sourceId = -1;
+    // The exception may happen in native code in which case there is no script.
+    if (body.script) {
+      sourceId = body.script.id;
+    }
+    
+    var line = devtools.DebuggerAgent.v8ToWwebkitLineNumber_(body.sourceLine);
+    
+    this.currentCallFrame_ = {
+      'sourceID': sourceId,
+      'line': line,
+      'script': body.script,
+      'scopeChain': [],
+      'thisObject': {}
+    };
+    this.requestBacktrace_();
+  } else {             
+    this.resumeExecution();
+  }
 };
 
 
 /**
  * @param {devtools.DebuggerMessage} msg
  */
 devtools.DebuggerAgent.prototype.handleScriptsResponse_ = function(msg) {
   var scripts = msg.getBody();
   for (var i = 0; i < scripts.length; i++) {
     var script = scripts[i];
@@ skipping 148 matching lines @@
 
 
 /**
  * Returns user-friendly representation of the function call from the stack
  * frame.
  * @param {Object} stackFrame Frame json object from 'backtrace' response.
  * @return {!string} Function name with argument values.
  */
 devtools.DebuggerAgent.formatFunctionCall_ = function(stackFrame, msg) {
   var func = msg.lookup(stackFrame.func.ref);
-  var argv = [];
-  for (var j = 0; j < stackFrame.arguments.length; j++) {
-    var arg = stackFrame.arguments[j];
-    var val = devtools.DebuggerAgent.formatObjectReference_(arg.value, msg);
-    argv.push(arg.name + ' = ' + val);
+  if (func.name) {
+    return func.name;
+  } else {
+    // TODO(yurys): support method name inference(F.m = function() {} should be
+    // a function with name 'm')
+    return '(anonymous function)';
   }
-  return func.name + '(' + argv.join(', ') + ')';
 };
 
 
 /**
  * Converts an object from the debugger response to the format understandable
  * by ScriptsPanel.
  * @param {Object} object An object from the debugger protocol response.
  * @param {devtools.DebuggerMessage} msg Parsed debugger response.
  * @return {!Object} Object describing 'object' in the format expected by
  *     ScriptsPanel and its panes.
@@ skipping 431 matching lines @@
 
 
 /**
  * @param {number} handle Object handle.
  * @return {?Object} Returns the object with the handle if it was sent in this
  *    message(some objects referenced by handles may be missing in the message).
  */
 devtools.DebuggerMessage.prototype.lookup = function(handle) {
   return this.refs_[handle];
 };