Provide stdout and stderr output in the Observatory debugger.

runtime/vm/service.cc

 // Copyright (c) 2013, 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/service.h"
 
 #include "include/dart_api.h"
+#include "include/dart_native_api.h"
 #include "platform/globals.h"
 
 #include "vm/compiler.h"
 #include "vm/coverage.h"
 #include "vm/cpu.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/isolate.h"
 #include "vm/lockers.h"
@@ skipping 49 matching lines @@
   return zone->PrintToString("objects/%" Pd "", id);
 }
 
 
 // TODO(johnmccutchan): Unify embedder service handler lists and their APIs.
 EmbedderServiceHandler* Service::isolate_service_handler_head_ = NULL;
 EmbedderServiceHandler* Service::root_service_handler_head_ = NULL;
 struct ServiceMethodDescriptor;
 ServiceMethodDescriptor* FindMethod(const char* method_name);
 
-// TODO(turnidge): Build a general framework later.  For now, we have
-// a small set of well-known streams.
+
+// These are the set of streams known to the core VM.
+const char* const Service::kIsolateStreamId = "Isolate";
+const char* const Service::kDebugStreamId = "Debug";
+const char* const Service::kGCStreamId = "GC";
+const char* const Service::kEchoStreamId = "_Echo";
+const char* const Service::kGraphStreamId = "_Graph";

[Cutch, 2015/07/13 14:10:29]

Would be nice if we had an array of streams (with the name and the "needs
events" flag being in a  structure together. Then, ListenStream and CancelStream
could be refactored to just loop over data.

[turnidge, 2015/07/13 22:50:36]

Done.

+
+
 bool Service::needs_isolate_events_ = false;
 bool Service::needs_debug_events_ = false;
 bool Service::needs_gc_events_ = false;
 bool Service::needs_echo_events_ = false;
 bool Service::needs_graph_events_ = false;
 
-void Service::ListenStream(const char* stream_id) {
+// Support for streams defined in embedders.
+Dart_ServiceStreamListenCallback Service::stream_listen_callback_ = NULL;
+Dart_ServiceStreamCancelCallback Service::stream_cancel_callback_ = NULL;
+
+
+bool Service::ListenStream(const char* stream_id) {
   if (FLAG_trace_service) {
     OS::Print("vm-service: starting stream '%s'\n",
               stream_id);
   }
-  if (strcmp(stream_id, "Isolate") == 0) {
+  if (strcmp(stream_id, kIsolateStreamId) == 0) {
     needs_isolate_events_ = true;
-  } else if (strcmp(stream_id, "Debug") == 0) {
+    return true;
+  } else if (strcmp(stream_id, kDebugStreamId) == 0) {
     needs_debug_events_ = true;
-  } else if (strcmp(stream_id, "GC") == 0) {
+    return true;
+  } else if (strcmp(stream_id, kGCStreamId) == 0) {
     needs_gc_events_ = true;
-  } else if (strcmp(stream_id, "_Echo") == 0) {
+    return true;
+  } else if (strcmp(stream_id, kEchoStreamId) == 0) {
     needs_echo_events_ = true;
-  } else if (strcmp(stream_id, "_Graph") == 0) {
+    return true;
+  } else if (strcmp(stream_id, kGraphStreamId) == 0) {
     needs_graph_events_ = true;
-  } else {
-    UNREACHABLE();
+    return true;
+  } else if (stream_listen_callback_) {
+    return (*stream_listen_callback_)(stream_id);
   }
+  return false;
 }
 
 void Service::CancelStream(const char* stream_id) {
   if (FLAG_trace_service) {
     OS::Print("vm-service: stopping stream '%s'\n",
               stream_id);
   }
-  if (strcmp(stream_id, "Isolate") == 0) {
+  if (strcmp(stream_id, kIsolateStreamId) == 0) {
     needs_isolate_events_ = false;
-  } else if (strcmp(stream_id, "Debug") == 0) {
+  } else if (strcmp(stream_id, kDebugStreamId) == 0) {
     needs_debug_events_ = false;
-  } else if (strcmp(stream_id, "GC") == 0) {
+  } else if (strcmp(stream_id, kGCStreamId) == 0) {
     needs_gc_events_ = false;
-  } else if (strcmp(stream_id, "_Echo") == 0) {
+  } else if (strcmp(stream_id, kEchoStreamId) == 0) {
     needs_echo_events_ = false;
-  } else if (strcmp(stream_id, "_Graph") == 0) {
+  } else if (strcmp(stream_id, kGraphStreamId) == 0) {
     needs_graph_events_ = false;
-  } else {
-    UNREACHABLE();
+  } else if (stream_cancel_callback_) {
+    return (*stream_cancel_callback_)(stream_id);
   }
 }
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 static void PrintMissingParamError(JSONStream* js,
                                    const char* param) {
@@ skipping 439 matching lines @@
     OS::Print(
         "vm-service: Pushing event of type %s to stream %s, len %" Pd "\n",
         event_type, stream_id, len);
   }
   // TODO(turnidge): For now we ignore failure to send an event.  Revisit?
   PortMap::PostMessage(
       new Message(ServiceIsolate::Port(), data, len, Message::kNormalPriority));
 }
 
 
+// TODO(turnidge): Rewrite this method to use Post_CObject instead.
 void Service::SendEventWithData(const char* stream_id,
                                 const char* event_type,
                                 const String& meta,
                                 const uint8_t* data,
                                 intptr_t size) {
   // Bitstream: [meta data size (big-endian 64 bit)] [meta data (UTF-8)] [data]
   const intptr_t meta_bytes = Utf8::Length(meta);
   const intptr_t total_bytes = sizeof(uint64_t) + meta_bytes + size;
   const TypedData& message = TypedData::Handle(
       TypedData::New(kTypedDataUint8ArrayCid, total_bytes));
@@ skipping 15 matching lines @@
   }
   ASSERT(offset == total_bytes);
   SendEvent(stream_id, event_type, message);
 }
 
 
 void Service::HandleEvent(ServiceEvent* event) {
   if (ServiceIsolate::IsServiceIsolateDescendant(event->isolate())) {
     return;
   }
+  if (!ServiceIsolate::IsRunning()) {
+    return;
+  }
   JSONStream js;
   const char* stream_id = event->stream_id();
   ASSERT(stream_id != NULL);
   {
     JSONObject jsobj(&js);
     jsobj.AddProperty("event", event);
     jsobj.AddProperty("streamId", stream_id);
   }
-  const String& message = String::Handle(String::New(js.ToCString()));
-  SendEvent(stream_id, ServiceEvent::EventTypeToCString(event->type()),
-            message);
+
+  // Message is of the format [<stream id>, <json string>].
+  //
+  // Build the event message in the C heap to avoid dart heap
+  // allocation.  This method can be called while we have acquired a
+  // direct pointer to typed data, so we can't allocate here.
+  Dart_CObject list_cobj;
+  Dart_CObject* list_values[2];
+  list_cobj.type = Dart_CObject_kArray;
+  list_cobj.value.as_array.length = 2;
+  list_cobj.value.as_array.values = list_values;
+
+  Dart_CObject stream_id_cobj;
+  stream_id_cobj.type = Dart_CObject_kString;
+  stream_id_cobj.value.as_string = const_cast<char*>(stream_id);
+  list_values[0] = &stream_id_cobj;
+
+  Dart_CObject json_cobj;
+  json_cobj.type = Dart_CObject_kString;
+  json_cobj.value.as_string = const_cast<char*>(js.ToCString());
+  list_values[1] = &json_cobj;
+
+  if (FLAG_trace_service) {
+    OS::Print(
+        "vm-service: Pushing event of type %s to stream %s\n",
+        event->KindAsCString(), stream_id);
+  }
+
+  Dart_PostCObject(ServiceIsolate::Port(), &list_cobj);
 }
 
 
 class EmbedderServiceHandler {
  public:
   explicit EmbedderServiceHandler(const char* name) : name_(NULL),
                                                       callback_(NULL),
                                                       user_data_(NULL),
                                                       next_(NULL) {
     ASSERT(name != NULL);
@@ skipping 103 matching lines @@
   handler = new EmbedderServiceHandler(name);
   handler->set_callback(callback);
   handler->set_user_data(user_data);
 
   // Insert into root_service_handler_head_ list.
   handler->set_next(root_service_handler_head_);
   root_service_handler_head_ = handler;
 }
 
 
+void Service::SetEmbedderStreamCallbacks(
+    Dart_ServiceStreamListenCallback listen_callback,
+    Dart_ServiceStreamCancelCallback cancel_callback) {
+  stream_listen_callback_ = listen_callback;
+  stream_cancel_callback_ = cancel_callback;
+}
+
+
 EmbedderServiceHandler* Service::FindRootEmbedderHandler(
     const char* name) {
   EmbedderServiceHandler* current = root_service_handler_head_;
   while (current != NULL) {
     if (strcmp(name, current->name()) == 0) {
       return current;
     }
     current = current->next();
   }
   return NULL;
@@ skipping 63 matching lines @@
     JSONObject jsobj(&js);
     {
       JSONObject event(&jsobj, "event");
       event.AddProperty("type", "Event");
       event.AddProperty("kind", "_Echo");
       event.AddProperty("isolate", isolate);
       if (text != NULL) {
         event.AddProperty("text", text);
       }
     }
-    jsobj.AddProperty("streamId", "_Echo");
+    jsobj.AddProperty("streamId", kEchoStreamId);
   }
   const String& message = String::Handle(String::New(js.ToCString()));
   uint8_t data[] = {0, 128, 255};
-  SendEventWithData("_Echo", "_Echo", message, data, sizeof(data));
+  SendEventWithData(kEchoStreamId, "_Echo", message, data, sizeof(data));
 }
 
 
 static bool TriggerEchoEvent(Isolate* isolate, JSONStream* js) {
   if (Service::NeedsEchoEvents()) {
     Service::SendEchoEvent(isolate, js->LookupParam("text"));
   }
   JSONObject jsobj(js);
   return HandleCommonEcho(&jsobj, js);
 }
@@ skipping 1494 matching lines @@
       {
         JSONObject event(&jsobj, "event");
         event.AddProperty("type", "Event");
         event.AddProperty("kind", "_Graph");
         event.AddProperty("isolate", isolate);
 
         event.AddProperty("chunkIndex", i);
         event.AddProperty("chunkCount", num_chunks);
         event.AddProperty("nodeCount", node_count);
       }
-      jsobj.AddProperty("streamId", "_Graph");
+      jsobj.AddProperty("streamId", kGraphStreamId);
     }
 
     const String& message = String::Handle(String::New(js.ToCString()));
 
     uint8_t* chunk_start = buffer + (i * kChunkSize);
     intptr_t chunk_size = (i + 1 == num_chunks)
         ? stream.bytes_written() - (i * kChunkSize)
         : kChunkSize;
 
-    SendEventWithData("_Graph", "_Graph", message, chunk_start, chunk_size);
+    SendEventWithData(kGraphStreamId, "_Graph", message,
+                      chunk_start, chunk_size);
   }
 }
 
 
 void Service::SendInspectEvent(Isolate* isolate, const Object& inspectee) {
   if (!Service::NeedsDebugEvents()) {
     return;
   }
   ServiceEvent event(isolate, ServiceEvent::kInspect);
   event.set_inspectee(&inspectee);
   Service::HandleEvent(&event);
 }
 
 
+void Service::SendEmbedderEvent(Isolate* isolate,
+                                const char* stream_id,
+                                const char* event_kind,
+                                const uint8_t* bytes,
+                                intptr_t bytes_len) {
+  if (!Service::NeedsDebugEvents()) {
+    return;
+  }
+  ServiceEvent event(isolate, ServiceEvent::kEmbedder);
+  event.set_embedder_kind(event_kind);
+  event.set_embedder_stream_id(stream_id);
+  event.set_bytes(bytes, bytes_len);
+  Service::HandleEvent(&event);
+}
+
+
 class ContainsAddressVisitor : public FindObjectVisitor {
  public:
   ContainsAddressVisitor(Isolate* isolate, uword addr)
       : FindObjectVisitor(isolate), addr_(addr) { }
   virtual ~ContainsAddressVisitor() { }
 
   virtual uword filter_addr() const { return addr_; }
 
   virtual bool FindObject(RawObject* obj) const {
     // Free list elements are not real objects, so skip them.
@@ skipping 460 matching lines @@
     ServiceMethodDescriptor& method = service_methods_[i];
     if (strcmp(method_name, method.name) == 0) {
       return &method;
     }
   }
   return NULL;
 }
 
 
 }  // namespace dart