Allow embedders to provide custom message delivery for an isolate.

runtime/lib/isolate.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 "vm/bootstrap_natives.h"
 
 #include "vm/assert.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_entry.h"
@@ skipping 19 matching lines @@
         class_name_(class_name),
         port_id_(port_id) {}
 
   Isolate* isolate_;
   char* library_url_;
   char* class_name_;
   intptr_t port_id_;
 };
 
 
-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 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* SerializeObject(const Instance& obj) {
   uint8_t* result = NULL;
   SnapshotWriter writer(false, &result, &allocator);
   writer.WriteObject(obj.raw());
@@ skipping 73 matching lines @@
                               kNoArgumentNames,
                               Resolver::kIsQualified));
   GrowableArray<const Object*> arguments(kNumArguments);
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
   const Instance& result = Instance::Handle(
       DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
   return result.raw();
 }
 
 
-void PortMessage::Handle() {
-  const Instance& msg = Instance::Handle(DeserializeMessage(data()));
-  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_id())));
-  arguments.Add(&Integer::Handle(Integer::New(reply_id())));
-  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);
-  }
-  ASSERT(result.IsNull());
-}
-
-
 static void RunIsolate(uword parameter) {
   IsolateStartData* data = reinterpret_cast<IsolateStartData*>(parameter);
   Isolate* isolate = data->isolate_;
   char* library_url = data->library_url_;
   char* class_name = data->class_name_;
   intptr_t port_id = data->port_id_;
   delete data;
 
   Isolate::SetCurrent(isolate);
   // Intialize stack limit in case we are running isolate in a
@@ skipping 53 matching lines @@
                                       arguments,
                                       kNoArgumentNames);
     if (result.IsUnhandledException()) {
       UnhandledException& uhe = UnhandledException::Handle();
       uhe ^= result.raw();
       ProcessUnhandledException(uhe);
     }
     ASSERT(result.IsNull());
     free(class_name);
 
     // Keep listening until there are no active receive ports.

[Anton Muhin, 2011/10/18 17:19:58]

nit: this comment can probably go away now.

[turnidge, 2011/10/18 17:33:40]

Done.

-    while (isolate->active_ports() > 0) {
-      Zone zone;
-      HandleScope handle_scope;
+    isolate->StandardRunLoop();
 
-      PortMessage* message = PortMap::ReceiveMessage(0);
-      message->Handle();
-      delete message;
-    }
   } else {
     Zone zone;
     HandleScope handle_scope;
     const String& error = String::Handle(
         Isolate::Current()->object_store()->sticky_error());
     const char* errmsg = error.ToCString();
     fprintf(stderr, "%s\n", errmsg);
     exit(255);
   }
   isolate->set_long_jump_base(base);
@@ skipping 113 matching lines @@
   PortMap::ClosePort(id);
 }
 
 
 DEFINE_NATIVE_ENTRY(SendPortImpl_sendInternal_, 3) {
   intptr_t send_id = Smi::CheckedHandle(arguments->At(0)).Value();
   intptr_t reply_id = Smi::CheckedHandle(arguments->At(1)).Value();
   // TODO(iposva): Allow for arbitrary messages to be sent.
   void* data = SerializeObject(Instance::CheckedHandle(arguments->At(2)));
 
-  PortMessage* message = new PortMessage(send_id, reply_id, data);
-  PortMap::PostMessage(message);
+  // TODO(turnidge): Throw an exception when the return value is false?
+  PortMap::PostMessage(send_id, reply_id, data);
 }
 
 }  // namespace dart