Add the streamListen and streamCancel rpcs to the vm service.

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 209 matching lines @@
       deopt_frame_(Array::ZoneHandle(deopt_frame.raw())),
       deopt_frame_offset_(deopt_frame_offset),
       vars_initialized_(false),
       var_descriptors_(LocalVarDescriptors::ZoneHandle()),
       desc_indices_(8),
       pc_desc_(PcDescriptors::ZoneHandle()) {
 }
 
 
 bool Debugger::HasEventHandler() {
-  return (event_handler_ != NULL) || Service::NeedsEvents();
+  return ((event_handler_ != NULL) ||
+          Service::NeedsIsolateEvents() ||
+          Service::NeedsDebugEvents());
 }
 
 
+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::NeedsDebugEvents();
+
+    case DebuggerEvent::kIsolateCreated:
+    case DebuggerEvent::kIsolateShutdown:
+      return Service::NeedsIsolateEvents();
+
+    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 (Service::NeedsEvents() &&
-      (event->type() != DebuggerEvent::kBreakpointResolved)) {
+  if (ServiceNeedsDebuggerEvent(event->type())) {
     ServiceEvent service_event(event);
     Service::HandleEvent(&service_event);
   }
 
   if (FLAG_steal_breakpoints && event->IsPauseEvent()) {
     // We allow the embedder's default breakpoint handler to be overridden.
     isolate_->PauseEventHandler();
   } else if (event_handler_ != NULL) {
     (*event_handler_)(event);
   }
 
-  if (Service::NeedsEvents() && event->IsPauseEvent()) {
+  if (ServiceNeedsDebuggerEvent(event->type()) && event->IsPauseEvent()) {
     // If we were paused, notify the service that we have resumed.
     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()) {
@@ skipping 22 matching lines @@
     ASSERT(debugger != NULL);
     debugger->SignalIsolateEvent(DebuggerEvent::kIsolateInterrupted);
   }
 }
 
 
 // The vm service handles breakpoint notifications in a different way
 // than the regular debugger breakpoint notifications.
 static void SendServiceBreakpointEvent(ServiceEvent::EventType type,
                                        SourceBreakpoint* bpt) {
-  if (Service::NeedsEvents()) {
+  if (Service::NeedsDebugEvents()) {
     ServiceEvent service_event(Isolate::Current(), type);
     service_event.set_breakpoint(bpt);
     Service::HandleEvent(&service_event);
   }
 }
 
 
 const char* Debugger::QualifiedFunctionName(const Function& func) {
   const String& func_name = String::Handle(func.name());
   Class& func_class = Class::Handle(func.Owner());
@@ skipping 2391 matching lines @@
 }
 
 
 void Debugger::RegisterCodeBreakpoint(CodeBreakpoint* bpt) {
   ASSERT(bpt->next() == NULL);
   bpt->set_next(code_breakpoints_);
   code_breakpoints_ = bpt;
 }
 
 }  // namespace dart