Do not collect stack trace unnecessarily

runtime/vm/debugger.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/debugger.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
@@ skipping 620 matching lines @@
   }
 }
 
 
 bool Debugger::IsActive() {
   // TODO(hausner): The code generator uses this function to prevent
   // generation of optimized code when Dart code is being debugged.
   // This is probably not conservative enough (we could set the first
   // breakpoint after optimized code has already been produced).
   // Long-term, we need to be able to de-optimize code.
-  return (src_breakpoints_ != NULL) || (code_breakpoints_ != NULL);
+  return (src_breakpoints_ != NULL) ||
+         (code_breakpoints_ != NULL) ||
+         (exc_pause_info_ != kNoPauseOnExceptions);
 }
 
 
 static RawFunction* ResolveLibraryFunction(
                         const Library& library,
                         const String& fname) {
   ASSERT(!library.IsNull());
   Function& function = Function::Handle();
   const Object& object = Object::Handle(library.LookupObject(fname));
   if (!object.IsNull() && object.IsFunction()) {
@@ skipping 95 matching lines @@
         new ActivationFrame(frame->pc(), frame->fp(), frame->sp(), ctx);
     ctx = activation->CallerContext();
     stack_trace->AddActivation(activation);
     frame = iterator.NextFrame();
   }
   return stack_trace;
 }
 
 
 void Debugger::SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info) {
+  ASSERT((pause_info == kNoPauseOnExceptions) ||
+         (pause_info == kPauseOnUnhandledExceptions) ||
+         (pause_info == kPauseOnAllExceptions));
   exc_pause_info_ = pause_info;
 }
 
 
 // TODO(hausner): Determine whether the exception is handled or not.
 bool Debugger::ShouldPauseOnException(DebuggerStackTrace* stack_trace,
                                       const Object& exc) {
   if (exc_pause_info_ == kNoPauseOnExceptions) {
     return false;
   }
   if ((exc_pause_info_ & kPauseOnAllExceptions) != 0) {
     return true;
   }
   // Assume TypeError and AssertionError exceptions are unhandled.
   const Class& exc_class = Class::Handle(exc.clazz());
   const String& class_name = String::Handle(exc_class.Name());
   // TODO(hausner): Note the poor man's type test. This code will go
   // away when we have a way to determine whether an exception is unhandled.
   if (class_name.Equals("TypeError")) {
     return true;
   }
   if (class_name.Equals("AssertionError")) {
     return true;
   }
   return false;
 }
 
 
 void Debugger::SignalExceptionThrown(const Object& exc) {
-  if (ignore_breakpoints_ || (event_handler_ == NULL)) {
+  if (ignore_breakpoints_ ||
+      (event_handler_ == NULL) ||
+      (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
   // No single-stepping possible after this pause event.
   last_bpt_line_ = -1;
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
@@ skipping 668 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart