Reapply change to hide VM-only List implementation classes.

runtime/bin/common.dart

Index: runtime/bin/common.dart
diff --git a/runtime/bin/common.dart b/runtime/bin/common.dart
index 614171c440ca40d1d0f69543879b6ba15b57ef28..fafd02ac7176a737be8968235e65c15a770bbc8b 100644
--- a/runtime/bin/common.dart
+++ b/runtime/bin/common.dart
@@ -7,10 +7,13 @@
   * operating system.
   */
 class OSError {
+  /** Constant used to indicate that no OS error code is available. */
   static const int noErrorCode = -1;
 
+  /** Creates an OSError object from a message and an errorCode. */
   const OSError([String this.message = "", int this.errorCode = noErrorCode]);
 
+  /** Converts an OSError object to a string representation. */
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.add("OS Error");
@@ -40,3 +43,40 @@ class OSError {
     */
   final int errorCode;
 }
+
+
+// Check if a List is a builtin VM List type. Returns true
+// if the List is a builtin VM List type and false if it is
+// a user defined List type.
+//
+// TODO(5474): At this point it actually return false for
+// _GrowableObjectArrays because of serialization issues.
+bool _isBuiltinList(List buffer) native "Common_IsBuiltinList";

[Ivan Posva, 2012/09/28 04:56:10]

You can do this now without reaching into native! You can check if
buffer.runtimeType is equal to (const [1]).runtimeType or to (new
List(1)).runtimeType. Ideally you would cache the two values in statics.

[Ivan Posva, 2012/09/28 04:57:46]

Scratch this. List is parameterized and thus "List<int> != List". Oh well...

[Mads Ager (google), 2012/09/28 10:14:20]

Yeah, unfortunately. Luckily there was plenty of room for improvement in the
implementation of isBuiltinList. I now cache the class pointers in persistent
handles in the isolate data in the standalone binary. That should make the check
a lot cheaper.

+
+
+// Ensure that the input List can be serialized through a native port.
+// Only builtin Lists can be serialized through. If user-defined Lists
+// get here, the contents is copied to a Uint8List. This has the added
+// benefit that it is faster to access from the C code as well.
+List _ensureFastAndSerializableBuffer(
+    List buffer, int offset, int bytes) {
+  List outBuffer;
+  int outOffset = offset;
+  if (buffer is Uint8List || _isBuiltinList(buffer)) {
+    outBuffer = buffer;
+  } else {
+    outBuffer = new Uint8List(bytes);
+    outOffset = 0;
+    int j = offset;
+    for (int i = 0; i < bytes; i++) {
+      int value = buffer[j];
+      if (value is! int) {
+        throw new FileIOException(
+            "List element is not an integer at index $j");
+      }
+      outBuffer[i] = value;
+      j++;
+    }
+  }
+  return [outBuffer, outOffset];
+}