- Remove the legacy debug protocol.

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 "include/dart_api.h"
 
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 240 matching lines @@
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 void DebuggerEvent::UpdateTimestamp() {
   timestamp_ = OS::GetCurrentTimeMillis();
 }
 
 
-bool Debugger::HasEventHandler() {
+bool Debugger::HasAnyEventHandler() {
   return ((event_handler_ != NULL) ||
           Service::isolate_stream.enabled() ||
           Service::debug_stream.enabled());
 }
 
 
+bool Debugger::HasDebugEventHandler() {
+  return ((event_handler_ != NULL) ||
+          Service::debug_stream.enabled());
+}
+
+
 static bool ServiceNeedsDebuggerEvent(DebuggerEvent::EventType type) {
   switch (type) {
     case DebuggerEvent::kBreakpointResolved:
       // kBreakpointResolved events are handled differently in the vm
       // service, so suppress them here.
       return false;
 
     case DebuggerEvent::kBreakpointReached:
     case DebuggerEvent::kExceptionThrown:
     case DebuggerEvent::kIsolateInterrupted:
       return Service::debug_stream.enabled();
 
     case DebuggerEvent::kIsolateCreated:
     case DebuggerEvent::kIsolateShutdown:
       return Service::isolate_stream.enabled();
 
     default:
       UNREACHABLE();
       return false;
   }
 }
 
 
 void Debugger::InvokeEventHandler(DebuggerEvent* event) {
-  ASSERT(HasEventHandler());
-
   // Give the event to the Service first, as the debugger event handler
   // may go into a message loop and the Service will not.
   //
   // kBreakpointResolved events are handled differently in the vm
   // service, so suppress them here.
   if (ServiceNeedsDebuggerEvent(event->type())) {
     ServiceEvent service_event(event);
     Service::HandleEvent(&service_event);
   }
 
-  if (FLAG_steal_breakpoints && event->IsPauseEvent()) {
+  if ((FLAG_steal_breakpoints || (event_handler_ == NULL)) &&
+      event->IsPauseEvent()) {
     // We allow the embedder's default breakpoint handler to be overridden.
     isolate_->PauseEventHandler();
   } else if (event_handler_ != NULL) {
     (*event_handler_)(event);
   }
 
   if (ServiceNeedsDebuggerEvent(event->type()) && event->IsPauseEvent()) {
     // If we were paused, notify the service that we have resumed.
     const Error& error =
         Error::Handle(isolate_->object_store()->sticky_error());
     ASSERT(error.IsNull() || error.IsUnwindError());
 
     // Only send a resume event when the isolate is not unwinding.
     if (!error.IsUnwindError()) {
       ServiceEvent service_event(event->isolate(), ServiceEvent::kResume);
       service_event.set_top_frame(event->top_frame());
       Service::HandleEvent(&service_event);
     }
   }
 }
 
 
 void Debugger::SignalIsolateEvent(DebuggerEvent::EventType type) {
-  if (HasEventHandler()) {
+  if (HasAnyEventHandler()) {
     DebuggerEvent event(isolate_, type);
     ASSERT(event.isolate_id() != ILLEGAL_ISOLATE_ID);
     if (type == DebuggerEvent::kIsolateInterrupted) {
       DebuggerStackTrace* trace = CollectStackTrace();
       if (trace->Length() > 0) {
         event.set_top_frame(trace->FrameAt(0));
       }
       ASSERT(stack_trace_ == NULL);
       stack_trace_ = trace;
       resume_action_ = kContinue;
       Pause(&event);
       HandleSteppingRequest(trace);
       stack_trace_ = NULL;
     } else {
       InvokeEventHandler(&event);
     }
   }
 }
 
 
 RawError* Debugger::SignalIsolateInterrupted() {
-  if (HasEventHandler()) {
+  if (HasDebugEventHandler()) {
     SignalIsolateEvent(DebuggerEvent::kIsolateInterrupted);
   }
-  Dart_IsolateInterruptCallback callback = isolate_->InterruptCallback();
-  if (callback != NULL) {
-    if (!(*callback)()) {
-      if (FLAG_trace_isolates) {
-        OS::Print("[!] Embedder api: terminating isolate:\n"
-                  "\tisolate:    %s\n", isolate_->name());
-      }
-      const String& msg =
-          String::Handle(String::New("isolate terminated by embedder"));
-      return UnwindError::New(msg);
-    }
-  }
 
   // If any error occurred while in the debug message loop, return it here.
   const Error& error =
       Error::Handle(isolate_->object_store()->sticky_error());
   ASSERT(error.IsNull() || error.IsUnwindError());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
@@ skipping 1029 matching lines @@
     function ^= closures.At(pos);
     ASSERT(!function.IsNull());
     if (function.HasOptimizedCode()) {
       function.SwitchToUnoptimizedCode();
     }
   }
 }
 
 
 void Debugger::SignalBpResolved(Breakpoint* bpt) {
-  if (HasEventHandler() && !bpt->IsSingleShot()) {
+  if (HasDebugEventHandler() && !bpt->IsSingleShot()) {
     DebuggerEvent event(isolate_, DebuggerEvent::kBreakpointResolved);
     event.set_breakpoint(bpt);
     InvokeEventHandler(&event);
   }
 }
 
 
 ActivationFrame* Debugger::CollectDartFrame(Isolate* isolate,
                                             uword pc,
                                             StackFrame* frame,
@@ skipping 200 matching lines @@
 }
 
 
 void Debugger::SignalExceptionThrown(const Instance& exc) {
   // We ignore this exception event when the VM is executing code invoked
   // by the debugger to evaluate variables values, when we see a nested
   // breakpoint or exception event, or if the debugger is not
   // interested in exception events.
   if (ignore_breakpoints_ ||
       IsPaused() ||
-      (!HasEventHandler()) ||
+      (!HasDebugEventHandler()) ||
       (exc_pause_info_ == kNoPauseOnExceptions)) {
     return;
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   if (!ShouldPauseOnException(stack_trace, exc)) {
     return;
   }
   DebuggerEvent event(isolate_, DebuggerEvent::kExceptionThrown);
   event.set_exception(&exc);
   ASSERT(stack_trace->Length() > 0);
@@ skipping 963 matching lines @@
          (iter.CurrentLiteral() == Symbols::YieldKw().raw()))) {
       event.set_at_async_jump(true);
     }
   }
   Pause(&event);
 }
 
 
 RawError* Debugger::DebuggerStepCallback() {
   ASSERT(isolate_->single_step());
-  // We can't get here unless the debugger event handler enabled
-  // single stepping.
-  ASSERT(HasEventHandler());
   // Don't pause recursively.
   if (IsPaused()) {
     return Error::null();
   }
 
   // Check whether we are in a Dart function that the user is
   // interested in. If we saved the frame pointer of a stack frame
   // the user is interested in, we ignore the single step if we are
   // in a callee of that frame. Note that we assume that the stack
   // grows towards lower addresses.
@@ skipping 47 matching lines @@
       Error::Handle(isolate_->object_store()->sticky_error());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
 RawError* Debugger::SignalBpReached() {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
-  if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
+  if (ignore_breakpoints_ || IsPaused()) {
     return Error::null();
   }
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ActivationFrame* top_frame = stack_trace->FrameAt(0);
   ASSERT(top_frame != NULL);
   CodeBreakpoint* cbpt = GetCodeBreakpoint(top_frame->pc());
   ASSERT(cbpt != NULL);
 
   BreakpointLocation* bpt_location = cbpt->bpt_location_;
@@ skipping 68 matching lines @@
       Error::Handle(isolate_->object_store()->sticky_error());
   isolate_->object_store()->clear_sticky_error();
   return error.raw();
 }
 
 
 void Debugger::BreakHere(const String& msg) {
   // We ignore this breakpoint when the VM is executing code invoked
   // by the debugger to evaluate variables values, or when we see a nested
   // breakpoint or exception event.
-  if (ignore_breakpoints_ || IsPaused() || !HasEventHandler()) {
+  if (ignore_breakpoints_ || IsPaused()) {
     return;
   }
 
+  if (!HasDebugEventHandler()) {
+    OS::Print("Hit debugger!");
+  }
+
   DebuggerStackTrace* stack_trace = CollectStackTrace();
   ASSERT(stack_trace->Length() > 0);
   ASSERT(stack_trace_ == NULL);
   stack_trace_ = stack_trace;
 
   // TODO(johnmccutchan): Send |msg| to Observatory.
 
   // We are in the native call to Debugger_breakHere or Debugger_breakHereIf,
   // the developer gets a better experience by not seeing this call. To
   // accomplish this, we continue execution until the call exits (step out).
@@ skipping 456 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart