Add support for non ASCII strings when communicating with native ports

runtime/vm/dart_api_message.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/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
+#include "vm/unicode.h"
 
 namespace dart {
 
 static const int kNumInitialReferences = 4;
 
 ApiMessageReader::ApiMessageReader(const uint8_t* buffer,
                                    intptr_t length,
                                    ReAlloc alloc)
     : BaseReader(buffer, length),
       alloc_(alloc),
@@ skipping 329 matching lines @@
       USE(hash);
       Dart_CObject* object = AllocateDartCObjectString(len);
       AddBackRef(object_id, object, kIsDeserialized);
       char* p = object->value.as_string;
       for (intptr_t i = 0; i < len; i++) {
         p[i] = Read<uint8_t>();
       }
       p[len] = '\0';
       return object;
     }
-    case kTwoByteStringCid:
-      // Two byte strings not supported.
-      return AllocateDartCObjectUnsupported();
+    case kTwoByteStringCid: {
+      intptr_t len = ReadSmiValue();
+      intptr_t hash = ReadSmiValue();
+      USE(hash);
+      uint16_t *utf16 =
+          reinterpret_cast<uint16_t*>(::malloc(len * sizeof(uint16_t)));
+      intptr_t utf8_len = 0;
+      for (intptr_t i = 0; i < len; i++) {
+        utf16[i] = Read<uint16_t>();
+        // TODO(sgjesse): Check for surrogate pairs.
+        utf8_len += Utf8::Length(utf16[i]);
+      }
+      Dart_CObject* object = AllocateDartCObjectString(utf8_len);
+      AddBackRef(object_id, object, kIsDeserialized);
+      char* p = object->value.as_string;
+      for (intptr_t i = 0; i < len; i++) {
+        // TODO(sgjesse): Check for surrogate pairs.
+        p += Utf8::Encode(utf16[i], p);
+      }
+      *p = '\0';
+      ASSERT(p == object->value.as_string + utf8_len);
+      ::free(utf16);
+      return object;
+    }
     case kUint8ArrayCid: {
       intptr_t len = ReadSmiValue();
       Dart_CObject* object = AllocateDartCObjectUint8Array(len);
       AddBackRef(object_id, object, kIsDeserialized);
       if (len > 0) {
         uint8_t* p = object->value.as_byte_array.values;
         for (intptr_t i = 0; i < len; i++) {
           p[i] = Read<uint8_t>();
         }
       }
@@ skipping 238 matching lines @@
 void ApiMessageWriter::WriteInlinedHeader(Dart_CObject* object) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id_);
   // Mark object with its object id.
   MarkCObject(object, object_id_);
   // Advance object id.
   object_id_++;
 }
 
 
-void ApiMessageWriter::WriteCObject(Dart_CObject* object) {
+bool ApiMessageWriter::WriteCObject(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
-    return;
+    return true;
   }
 
   Dart_CObject::Type type = object->type;
   if (type == Dart_CObject::kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class and tags information.
     WriteIndexedObject(kArrayCid);
     WriteIntptrValue(0);
 
     WriteSmi(object->value.as_array.length);
     // Write out the type arguments.
     WriteNullObject();
     // Write out array elements.
     for (int i = 0; i < object->value.as_array.length; i++) {
-      WriteCObjectRef(object->value.as_array.values[i]);
+      bool success = WriteCObjectRef(object->value.as_array.values[i]);
+      if (!success) return false;
     }
-    return;
+    return true;
   }
-  WriteCObjectInlined(object, type);
+  return WriteCObjectInlined(object, type);
 }
 
 
-void ApiMessageWriter::WriteCObjectRef(Dart_CObject* object) {
+bool ApiMessageWriter::WriteCObjectRef(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
-    return;
+    return true;
   }
 
   Dart_CObject::Type type = object->type;
   if (type == Dart_CObject::kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class information.
     WriteIndexedObject(kArrayCid);
     // Write out the length information.
     WriteSmi(object->value.as_array.length);
     // Add object to forward list so that this object is serialized later.
     AddToForwardList(object);
-    return;
+    return true;
   }
-  WriteCObjectInlined(object, type);
+  return WriteCObjectInlined(object, type);
 }
 
 
-void ApiMessageWriter::WriteForwardedCObject(Dart_CObject* object) {
+bool ApiMessageWriter::WriteForwardedCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   Dart_CObject::Type type =
       static_cast<Dart_CObject::Type>(object->type & kDartCObjectTypeMask);
   ASSERT(type == Dart_CObject::kArray);
 
   // Write out the serialization header value for this object.
   intptr_t object_id = GetMarkedCObjectMark(object);
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
   WriteIndexedObject(kArrayCid);
   WriteIntptrValue(0);
 
   WriteSmi(object->value.as_array.length);
   // Write out the type arguments.
   WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < object->value.as_array.length; i++) {
-    WriteCObjectRef(object->value.as_array.values[i]);
+    bool success = WriteCObjectRef(object->value.as_array.values[i]);
+    if (!success) return false;
   }
+  return true;
 }
 
 
-void ApiMessageWriter::WriteCObjectInlined(Dart_CObject* object,
+bool ApiMessageWriter::WriteCObjectInlined(Dart_CObject* object,
                                            Dart_CObject::Type type) {
   switch (type) {
     case Dart_CObject::kNull:
       WriteNullObject();
       break;
     case Dart_CObject::kBool:
       if (object->value.as_bool) {
         WriteIndexedObject(kTrueValue);
       } else {
         WriteIndexedObject(kFalseValue);
@@ skipping 23 matching lines @@
     case Dart_CObject::kDouble:
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kDoubleCid);
       WriteIntptrValue(0);
       // Write double value.
       Write<double>(object->value.as_double);
       break;
     case Dart_CObject::kString: {
+      const uint8_t* utf8_str =
+          reinterpret_cast<const uint8_t*>(object->value.as_string);
+      intptr_t utf8_len = strlen(object->value.as_string);
+      if (!Utf8::IsValid(utf8_str, utf8_len)) {
+        return false;
+      }
+
+      Utf8::Type type;
+      intptr_t len = Utf8::CodePointCount(utf8_str, utf8_len, &type);
+
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteIndexedObject(kOneByteStringCid);
+      WriteIndexedObject(type == Utf8::kAscii ? kOneByteStringCid
+                                              : kTwoByteStringCid);
       WriteIntptrValue(0);
       // Write string length, hash and content
-      char* str = object->value.as_string;
-      intptr_t len = strlen(str);
       WriteSmi(len);
       WriteSmi(0);  // TODO(sgjesse): Hash - not written.
-      for (intptr_t i = 0; i < len; i++) {
-        Write<uint8_t>(str[i]);
+      if (type == Utf8::kAscii) {
+        for (intptr_t i = 0; i < len; i++) {
+          Write<uint8_t>(utf8_str[i]);
+        }
+      } else {
+        // TODO(sgjesse): Make sure surrogate pairs are handled.
+        uint16_t* utf16_str =
+            reinterpret_cast<uint16_t*>(::malloc(len * sizeof(uint16_t)));
+        Utf8::DecodeToUTF16(utf8_str, utf8_len, utf16_str, len);
+        for (intptr_t i = 0; i < len; i++) {
+          Write<uint16_t>(utf16_str[i]);
+        }
+        ::free(utf16_str);
       }
       break;
     }
     case Dart_CObject::kUint8Array: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kUint8ArrayCid);
       WriteIntptrValue(0);
       uint8_t* bytes = object->value.as_byte_array.values;
@@ skipping 22 matching lines @@
           object->value.as_external_byte_array.callback;
       WriteSmi(length);
       WriteIntptrValue(reinterpret_cast<intptr_t>(data));
       WriteIntptrValue(reinterpret_cast<intptr_t>(peer));
       WriteIntptrValue(reinterpret_cast<intptr_t>(callback));
       break;
     }
     default:
       UNREACHABLE();
   }
+
+  return true;
 }
 
 
-void ApiMessageWriter::WriteCMessage(Dart_CObject* object) {
-  WriteCObject(object);
+bool ApiMessageWriter::WriteCMessage(Dart_CObject* object) {
+  bool success = WriteCObject(object);
+  if (!success) {
+    UnmarkAllCObjects(object);
+    return false;
+  }
   // Write out all objects that were added to the forward list and have
   // not been serialized yet. These would typically be fields of arrays.
   // NOTE: The forward list might grow as we process the list.
   for (intptr_t i = 0; i < forward_id_; i++) {
-    WriteForwardedCObject(forward_list_[i]);
+    success = WriteForwardedCObject(forward_list_[i]);
+    if (!success) {
+      UnmarkAllCObjects(object);
+      return false;
+    }
   }
   UnmarkAllCObjects(object);
+  return true;
 }
 
 }  // namespace dart