Add a mid-sized integration test for the Dart Embedding Api which

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 583 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_HandleMessage(Dart_Port dest_port,
                                            Dart_Port reply_port,
                                            Dart_Message dart_message) {
   DARTSCOPE(Isolate::Current());
 
   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_"));
+      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);
@@ skipping 22 matching lines @@
     isolate->StandardRunLoop();
     result = Api::Success();
   } else {
     SetupErrorResult(&result);
   }
   isolate->set_long_jump_base(base);
   return result;
 }
 
 
+DART_EXPORT bool Dart_IsolateHasActivePorts() {
+  // TODO(turnidge): before submitting turn this into a straight field access
+  // instead of a static method call?
+  Dart_EnterScope();
+  Dart_Handle lib = Dart_LookupLibrary(Dart_NewString("dart:coreimpl"));
+  if (Dart_IsError(lib)) {
+    return lib;
+  }
+  Dart_Handle count = Dart_InvokeStatic(lib,
+                                        Dart_NewString("ReceivePortImpl"),
+                                        Dart_NewString("_getNumLivePorts"),
+                                        0,
+                                        NULL);
+  DART_CHECK_VALID(count);
+  int64_t count_value = 0;
+  Dart_Handle result = Dart_IntegerValue(count, &count_value);
+  DART_CHECK_VALID(result);
+  Dart_ExitScope();
+
+  return count_value > 0;
+}
+
+
 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);
 }
 
 
 DART_EXPORT bool Dart_PostIntArray(Dart_Port port,
                                    intptr_t len,
                                    intptr_t* data) {
   uint8_t* buffer = NULL;
@@ skipping 10 matching lines @@
   DARTSCOPE(Isolate::Current());
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   SnapshotWriter writer(false, &data, &allocator);
   writer.WriteObject(object.raw());
   writer.FinalizeBuffer();
   return PortMap::PostMessage(port, kNoReplyPort, data);
 }
 
 
+DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port) {
+  // TODO(turnidge): before submitting consider grabbing the impl of this from
+  // lib/isolate.cc instead and sharing the code.
+  Dart_Handle lib = Dart_LookupLibrary(Dart_NewString("dart:coreimpl"));
+  if (Dart_IsError(lib)) {
+    return lib;
+  }
+  Dart_Handle arg = Dart_NewInteger(port);
+  if (Dart_IsError(arg)) {
+    return arg;
+  }
+  Dart_Handle sp_args[1];
+  sp_args[0] = arg;
+  Dart_Handle send_port = Dart_InvokeStatic(lib,
+                                            Dart_NewString("SendPortImpl"),
+                                            Dart_NewString("_create"),
+                                            1,
+                                            sp_args);
+  return send_port;
+}
+
+
+DART_EXPORT Dart_Handle Dart_NewReceivePort(Dart_Port port) {
+  // TODO(turnidge): before submitting consider grabbing the impl of this from
+  // lib/isolate.cc instead and sharing the code.
+  Dart_Handle lib = Dart_LookupLibrary(Dart_NewString("dart:coreimpl"));
+  if (Dart_IsError(lib)) {
+    return lib;
+  }
+  Dart_Handle arg = Dart_NewInteger(port);
+  if (Dart_IsError(arg)) {
+    return arg;
+  }
+  Dart_Handle rp_args[1];
+  rp_args[0] = arg;
+  Dart_Handle recv_port = Dart_InvokeStatic(lib,
+                                            Dart_NewString("ReceivePortImpl"),
+                                            Dart_NewString("_create"),
+                                            1,
+                                            rp_args);
+  return recv_port;
+}
+
+
+DART_EXPORT Dart_Port Dart_GetMainPort() {
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate);
+  return isolate->main_port();
+}
+
 // --- Scopes ----
 
 
 DART_EXPORT void Dart_EnterScope() {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* new_scope = new ApiLocalScope(state->top_scope(),
                                                reinterpret_cast<uword>(&state));
@@ skipping 143 matching lines @@
   if (obj.IsBigint()) {
     Bigint& bigint = Bigint::Handle();
     bigint ^= obj.raw();
     if (BigintOperations::FitsIntoInt64(bigint)) {
       *value = BigintOperations::ToInt64(bigint);
       return Api::Success();
     } else {
       return Api::Error("Integer too big to fit in int64_t");
     }
   }
+  OS::Print("%s\n", obj.ToCString());

[Anton Muhin, 2011/11/23 19:28:14]

nit: debugging stuff

[turnidge, 2011/11/23 21:45:37]

Oops, thanks.

   return Api::Error("Object is not a Integer");
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerValueHexCString(Dart_Handle integer,
                                                     const char** value) {
   DARTSCOPE(Isolate::Current());
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   Bigint& bigint = Bigint::Handle();
   if (obj.IsSmi() || obj.IsMint()) {
@@ skipping 1445 matching lines @@
     }
     delete debug_region;
   } else {
     *buffer = NULL;
     *buffer_size = 0;
   }
 }
 
 
 }  // namespace dart