Change VM's string-buffer patch to use a Uin16Array as backing buffer.

runtime/lib/string.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/exceptions.h"
 #include "vm/native_entry.h"
 #include "vm/object.h"
 #include "vm/symbols.h"
@@ skipping 31 matching lines @@
       }
     }
     utf32_array[i] = value;
   }
   if (is_one_byte_string) {
     return OneByteString::New(utf32_array, array_len, Heap::kNew);
   }
   return TwoByteString::New(utf16_len, utf32_array, array_len, Heap::kNew);
 }
 
-
 DEFINE_NATIVE_ENTRY(StringBase_substringUnchecked, 3) {
   const String& receiver = String::CheckedHandle(arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, start_obj, arguments->NativeArgAt(1));
   GET_NON_NULL_NATIVE_ARGUMENT(Smi, end_obj, arguments->NativeArgAt(2));
 
   intptr_t start = start_obj.Value();
   intptr_t end = end_obj.Value();
   return String::SubString(receiver, start, (end - start));
 }
 
@@ skipping 127 matching lines @@
     elem ^= strings.At(i);
     if (!elem.IsString()) {
       const Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, elem);
       Exceptions::ThrowByType(Exceptions::kArgument, args);
     }
   }
   return String::ConcatAll(strings);
 }
 
+DEFINE_NATIVE_ENTRY(StringBuffer_createStringFromUint16Array, 2) {
+  GET_NON_NULL_NATIVE_ARGUMENT(Uint16Array, a, arguments->NativeArgAt(0));
+  GET_NON_NULL_NATIVE_ARGUMENT(Smi, smiLength, arguments->NativeArgAt(1));
+  intptr_t array_len = a.Length();
+  int32_t length = smiLength.Value();
+  if (length < 0 || length > array_len) {
+    const Array& args = Array::Handle(Array::New(1));
+    args.SetAt(0, smiLength);
+    Exceptions::ThrowByType(Exceptions::kRange, args);
+  }
+  // TODO(lrn): Pass parameter saying whether the data is Latin1, and
+  // use RawOneByteString::New/RawTwoByteString::New directly.
+  uint16_t* data_position = reinterpret_cast<uint16_t*>(
+      reinterpret_cast<char*>(a.raw()) +
+      Uint16Array::data_offset() - kHeapObjectTag);
+  return String::FromUTF16(data_position, length, Heap::kNew);

[Vyacheslav Egorov (Google), 2013/03/05 14:44:32]

This is not GC safe and is against VM guidelines. 

String::FromUTF16 first allocates new string and then copies content into it. 

Which means your data might get moved to some other place under your feet, if GC
happens when new string is allocated and you will end up copying garbage.

In VM we only pass handles into functions (with a few exceptions), raw pointers
into the middle are not allowed.

+}
+
 }  // namespace dart