Changes per discussion with Anton

vm/dart_api_impl.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 "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 1658 matching lines @@
     return Api::NewError("Unable to allocate memory");
   }
   const char* string_value = str_obj.ToCString();
   memmove(res, string_value, string_length + 1);
   ASSERT(res[string_length] == '\0');
   *cstr = res;
   return Api::Success(isolate);
 }
 
 
+DART_EXPORT Dart_Handle Dart_StringToLatin1(Dart_Handle str,
+                                            uint8_t** latin1_array,
+                                            intptr_t* length) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  if (latin1_array == NULL) {
+    RETURN_NULL_ERROR(latin1_array);
+  }
+  if (length == NULL) {
+    RETURN_NULL_ERROR(length);
+  }
+  const String& str_obj = Api::UnwrapStringHandle(isolate, str);
+  if (str_obj.IsNull() || !Dart_IsStringLatin1(str)) {
+    RETURN_TYPE_ERROR(isolate, str, String);
+  }
+  intptr_t str_len = str_obj.Length();
+  uint8_t* res = Api::TopScope(isolate)->zone()->Alloc<uint8_t>(str_len);
+  if (res == NULL) {
+    return Api::NewError("Unable to allocate memory");
+  }
+  // We have already asserted that the string object is a Latin-1 string
+  // so we can copy the characters over using a simple loop.
+  for (intptr_t i = 0; i < str_len; i++) {
+    res[i] = str_obj.CharAt(i);
+  }
+  *latin1_array = res;
+  *length = str_len;
+  return Api::Success(isolate);
+}
+
+
 DART_EXPORT Dart_Handle Dart_StringToUTF8(Dart_Handle str,
                                           uint8_t** utf8_array,
                                           intptr_t* length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf8_array == NULL) {
     RETURN_NULL_ERROR(utf8_array);
   }
   if (length == NULL) {
     RETURN_NULL_ERROR(length);
@@ skipping 58 matching lines @@
   const String& str_obj = Api::UnwrapStringHandle(isolate, str);
   if (str_obj.IsExternal()) {
     return str;  // String is already an external string.
   }
   if (str_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, str, String);
   }
   if (array == NULL) {
     RETURN_NULL_ERROR(array);
   }
-  if (str_obj.IsCanonical()) {
-    return Api::NewError("Dart_MakeExternalString "
-                         "cannot externalize a read-only string.");
-  }
   intptr_t str_size = (str_obj.Length() * str_obj.CharSize());
   if ((length < str_size) || (length > String::kMaxElements)) {
     return Api::NewError("Dart_MakeExternalString "
                          "expects argument length to be in the range"
                          "[%"Pd"..%"Pd"].",
                          str_size, String::kMaxElements);
   }
+  if (str_obj.IsCanonical()) {
+    // Since the string object is read only we do not externalize
+    // the string but instead copy the contents of the string into the
+    // specified buffer and return a Null object.
+    // This ensures that the embedder does not have to call again
+    // to get at the contents.
+    intptr_t copy_len = str_obj.Length();
+    if (str_obj.IsOneByteString()) {
+      ASSERT(length >= copy_len);
+      uint8_t* latin1_array = reinterpret_cast<uint8_t*>(array);
+      for (intptr_t i = 0; i < copy_len; i++) {
+        latin1_array[i] = static_cast<uint8_t>(str_obj.CharAt(i));
+      }
+    } else {
+      ASSERT(str_obj.IsTwoByteString());
+      ASSERT(length >= (copy_len * sizeof(uint16_t)));
+      uint16_t* utf16_array = reinterpret_cast<uint16_t*>(array);
+      for (intptr_t i = 0; i < copy_len; i++) {
+        utf16_array[i] = static_cast<uint16_t>(str_obj.CharAt(i));
+      }
+    }
+    return Api::Null(isolate);
+  }
   return Api::NewHandle(isolate,
                         str_obj.MakeExternal(array, length, peer, cback));
 }
 
 
 // --- Lists ---
 
 
 static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
   if (obj.IsInstance()) {
@@ skipping 2681 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart