Allow embedders to provide custom message delivery for an isolate.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2011, 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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 65 matching lines @@
       Isolate::Current()->object_store()->sticky_error());
   const char* errmsg = error.ToCString();
   intptr_t errlen = strlen(errmsg) + 1;
   char* msg = reinterpret_cast<char*>(Api::Allocate(errlen));
   OS::SNPrint(msg, errlen, "%s", errmsg);
   result->type_ = kRetError;
   result->retval_.errmsg = msg;
 }
 
 
+DART_EXPORT void Dart_SetPostMessageCallback(
+    Dart_PostMessageCallback callback) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  ASSERT(callback != NULL);
+  isolate->set_post_message_callback(callback);
+}
+
+
+DART_EXPORT void Dart_SetClosePortCallback(Dart_ClosePortCallback callback) {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  ASSERT(callback != NULL);
+  isolate->set_close_port_callback(callback);
+}
+
+
+static RawInstance* DeserializeMessage(void* data) {
+  // Create a snapshot object using the buffer.
+  const Snapshot* snapshot = Snapshot::SetupFromBuffer(data);
+  ASSERT(snapshot->IsPartialSnapshot());
+
+  // Read object back from the snapshot.
+  Isolate* isolate= Isolate::Current();
+  SnapshotReader reader(snapshot, isolate->heap(), isolate->object_store());
+  Instance& instance = Instance::Handle();
+  instance ^= reader.ReadObject();
+  return instance.raw();
+}
+
+
+static void ProcessUnhandledException(const UnhandledException& uhe) {
+  const Instance& exception = Instance::Handle(uhe.exception());
+  Instance& strtmp = Instance::Handle(DartLibraryCalls::ToString(exception));
+  const char* str = strtmp.ToCString();
+  fprintf(stderr, "%s\n", str);
+  const Instance& stack = Instance::Handle(uhe.stacktrace());
+  strtmp = DartLibraryCalls::ToString(stack);
+  str = strtmp.ToCString();
+  fprintf(stderr, "%s\n", str);
+  exit(255);
+}
+
+
+DART_EXPORT void Dart_HandleMessage(Dart_Port dest_port,
+                                    Dart_Port reply_port,
+                                    Dart_Message dart_message) {
+  const Instance& msg = Instance::Handle(DeserializeMessage(dart_message));
+  const String& class_name =
+      String::Handle(String::NewSymbol("ReceivePortImpl"));
+  const String& function_name =
+      String::Handle(String::NewSymbol("handleMessage_"));
+  const int kNumArguments = 3;
+  const Array& kNoArgumentNames = Array::Handle();
+  const Function& function = Function::Handle(
+      Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
+                              class_name,
+                              function_name,
+                              kNumArguments,
+                              kNoArgumentNames,
+                              Resolver::kIsQualified));
+  GrowableArray<const Object*> arguments(kNumArguments);
+  arguments.Add(&Integer::Handle(Integer::New(dest_port)));
+  arguments.Add(&Integer::Handle(Integer::New(reply_port)));
+  arguments.Add(&msg);
+  const Object& result = Object::Handle(
+      DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
+  if (result.IsUnhandledException()) {
+    UnhandledException& uhe = UnhandledException::Handle();
+    uhe ^= result.raw();
+    ProcessUnhandledException(uhe);

[siva, 2011/10/14 23:50:32]

Not for this changelist but in a future changelist we should consider just
returning the exception from this method so that the embedder can choose to
handle the error anyway it wants instead of exiting.
In Isolate::StandardRunLoop we could check the return value from
Dart_HandleMessage and call ProcessUnhandledException.

[turnidge, 2011/10/17 18:38:48]

Added TODO

+  }
+  ASSERT(result.IsNull());
+}
+
+
 DART_EXPORT Dart_Result Dart_RunLoop() {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   Dart_Result result;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     // Keep listening until there are no active receive ports.
-    while (isolate->active_ports() > 0) {
-      Zone zone;
-      HandleScope handle_scope;
+    isolate->StandardRunLoop();
 
-      PortMessage* message = PortMap::ReceiveMessage(0);
-      message->Handle();
-      delete message;
-    }
     result.type_ = kRetCBool;
     result.retval_.bool_value = true;
   } else {
     Zone zone;
     HandleScope handle_scope;
     SetupErrorResult(&result);
   }
   isolate->set_long_jump_base(base);
   return result;
 }
@@ skipping 1371 matching lines @@
 
 
 DART_EXPORT Dart_Result Dart_PostIntArray(Dart_Port port,
                                           int field_count,
                                           intptr_t* data) {
   uint8_t* buffer = NULL;
   MessageWriter writer(&buffer, &allocator);
 
   writer.WriteMessage(field_count, data);
 
-  // Post the message at the given port. The allocated message and
-  // buffer are deallocated after the message is processed.
-  PortMessage* portMessage = new PortMessage(port, 0, buffer);
-  bool result = PortMap::PostMessage(portMessage);
+  // Post the message at the given port.
+  bool result = PortMap::PostMessage(port, 0, buffer);

[Anton Muhin, 2011/10/17 15:20:29]

0 -> kCloseAll?

[turnidge, 2011/10/17 18:38:48]

I have added a kNoReplyPort constant which means there is no reply port. 
Confusingly, it is the same value as kCloseAllPorts.  I was hunting for a name
that would work for both, but "kAllOrNothingPort" is pretty confusing :-).

Maybe kNoSuchPort... let me know what you think...

   RETURN_CBOOLEAN(result);
 }
 
 
 DART_EXPORT Dart_Result Dart_Post(Dart_Port port, Dart_Handle handle) {
   Zone zone;  // Setup a VM zone as we are creating some handles.
   HandleScope scope;  // Setup a VM handle scope.
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   SnapshotWriter writer(false, &data, &allocator);
   writer.WriteObject(object.raw());
   writer.FinalizeBuffer();
-  PortMessage* message = new PortMessage(port, 0, data);
-  bool result = PortMap::PostMessage(message);
+  bool result = PortMap::PostMessage(port, 0, data);
   RETURN_CBOOLEAN(result);
 }
 
 
 DART_EXPORT void Dart_InitPprofSupport() {
   DebugInfo* pprof_symbol_generator = DebugInfo::NewGenerator();
   ASSERT(pprof_symbol_generator != NULL);
   Dart::set_pprof_symbol_generator(pprof_symbol_generator);
 }
 
@@ skipping 87 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart