diff --git a/runtime/vm/benchmark_test.cc b/runtime/vm/benchmark_test.cc
index 9347fca4c96..84c8c88daf7 100644
--- a/runtime/vm/benchmark_test.cc
+++ b/runtime/vm/benchmark_test.cc
@@ -406,7 +406,7 @@ BENCHMARK(CoreSnapshotSize) {
       "import 'dart:math';\n"
       "import 'dart:isolate';\n"
       "import 'dart:mirrors';\n"
-      "import 'dart:scalarlist';\n"
+      "import 'dart:typeddata';\n"
       "\n";
 
   // Start an Isolate, load a script and create a full snapshot.
@@ -432,7 +432,7 @@ BENCHMARK(StandaloneSnapshotSize) {
       "import 'dart:math';\n"
       "import 'dart:isolate';\n"
       "import 'dart:mirrors';\n"
-      "import 'dart:scalarlist';\n"
+      "import 'dart:typeddata';\n"
       "import 'dart:uri';\n"
       "import 'dart:utf';\n"
       "import 'dart:json';\n"
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 41d711b2b30..daa8761b137 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -575,7 +575,7 @@ void Object::CreateInternalMetaData() {
 
 // Make unused space in an object whose type has been transformed safe
 // for traversing during GC.
-// The unused part of the transformed object is marked as an Int8Array
+// The unused part of the transformed object is marked as an TypedDataInt8Array
 // object.
 void Object::MakeUnusedSpaceTraversable(const Object& obj,
                                         intptr_t original_size,
@@ -587,16 +587,16 @@ void Object::MakeUnusedSpaceTraversable(const Object& obj,
     intptr_t leftover_size = original_size - used_size;
 
     uword addr = RawObject::ToAddr(obj.raw()) + used_size;
-    ASSERT(Int8Array::InstanceSize(0) == Object::InstanceSize());
-    // Update the leftover space as an Int8Array object.
-    RawInt8Array* raw =
-        reinterpret_cast<RawInt8Array*>(RawObject::FromAddr(addr));
+    ASSERT(TypedData::InstanceSize(0) == Object::InstanceSize());
+    // Update the leftover space as an TypedDataInt8Array object.
+    RawTypedData* raw =
+        reinterpret_cast<RawTypedData*>(RawObject::FromAddr(addr));
     uword tags = 0;
     tags = RawObject::SizeTag::update(leftover_size, tags);
-    tags = RawObject::ClassIdTag::update(kInt8ArrayCid, tags);
+    tags = RawObject::ClassIdTag::update(kTypedDataInt8ArrayCid, tags);
     raw->ptr()->tags_ = tags;
-    intptr_t leftover_len = (leftover_size - Int8Array::InstanceSize(0));
-    ASSERT(Int8Array::InstanceSize(leftover_len) == leftover_size);
+    intptr_t leftover_len = (leftover_size - TypedData::InstanceSize(0));
+    ASSERT(TypedData::InstanceSize(leftover_len) == leftover_size);
     raw->ptr()->length_ = Smi::New(leftover_len);
   }
 }
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index e78f306e182..44d6e61d19e 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -1761,7 +1761,7 @@ TEST_CASE(GrowableObjectArray) {
   // object is properly setup.
   // 1. Should produce an array of length 2 and a left over int8 array.
   Array& new_array = Array::Handle();
-  Int8Array& left_over_array = Int8Array::Handle();
+  TypedData& left_over_array = TypedData::Handle();
   Object& obj = Object::Handle();
   uword addr = 0;
   intptr_t used_size = 0;
@@ -1782,7 +1782,7 @@ TEST_CASE(GrowableObjectArray) {
   EXPECT_EQ(2, new_array.Length());
   addr += used_size;
   obj = RawObject::FromAddr(addr);
-  EXPECT(obj.IsInt8Array());
+  EXPECT(obj.IsTypedData());
   left_over_array ^= obj.raw();
   EXPECT_EQ((2 * kWordSize), left_over_array.Length());
 
@@ -1803,7 +1803,7 @@ TEST_CASE(GrowableObjectArray) {
   EXPECT_EQ(3, new_array.Length());
   addr += used_size;
   obj = RawObject::FromAddr(addr);
-  EXPECT(obj.IsInt8Array());
+  EXPECT(obj.IsTypedData());
   left_over_array ^= obj.raw();
   EXPECT_EQ(0, left_over_array.Length());
 
@@ -1824,545 +1824,137 @@ TEST_CASE(GrowableObjectArray) {
   EXPECT_EQ(1, new_array.Length());
   addr += used_size;
   obj = RawObject::FromAddr(addr);
-  EXPECT(obj.IsInt8Array());
+  EXPECT(obj.IsTypedData());
   left_over_array ^= obj.raw();
   EXPECT_EQ((6 * kWordSize), left_over_array.Length());
 }
 
 
-TEST_CASE(InternalByteArray) {
+TEST_CASE(InternalTypedData) {
   uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  const Int8Array& int8_array =
-      Int8Array::Handle(Int8Array::New(reinterpret_cast<int8_t*>(data),
-                                       data_length));
+  const TypedData& int8_array =
+      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
+  for (intptr_t i = 0; i < data_length; ++i) {
+    int8_array.SetInt8(i, data[i]);
+  }
 
-  EXPECT_EQ(-3, int8_array.At(0));
-  uint8_t at_0;
-  ByteArray::Copy(&at_0, int8_array, 0, sizeof(at_0));
-  EXPECT_EQ(253, at_0);
+  EXPECT_EQ(-3, int8_array.GetInt8(0));
+  EXPECT_EQ(253, int8_array.GetUint8(0));
 
-  EXPECT_EQ(-2, int8_array.At(1));
-  uint8_t at_1;
-  ByteArray::Copy(&at_1, int8_array, 1, sizeof(at_1));
-  EXPECT_EQ(254, at_1);
+  EXPECT_EQ(-2, int8_array.GetInt8(1));
+  EXPECT_EQ(254, int8_array.GetUint8(1));
 
-  EXPECT_EQ(-1, int8_array.At(2));
-  uint8_t at_2;
-  ByteArray::Copy(&at_2, int8_array, 2, sizeof(at_2));
-  EXPECT_EQ(255, at_2);
+  EXPECT_EQ(-1, int8_array.GetInt8(2));
+  EXPECT_EQ(255, int8_array.GetUint8(2));
 
-  EXPECT_EQ(0, int8_array.At(3));
-  uint8_t at_3;
-  ByteArray::Copy(&at_3, int8_array, 3, sizeof(at_3));
-  EXPECT_EQ(0, at_3);
+  EXPECT_EQ(0, int8_array.GetInt8(3));
+  EXPECT_EQ(0, int8_array.GetUint8(3));
 
-  EXPECT_EQ(1, int8_array.At(4));
-  uint8_t at_4;
-  ByteArray::Copy(&at_4, int8_array, 4, sizeof(at_4));
-  EXPECT_EQ(1, at_4);
+  EXPECT_EQ(1, int8_array.GetInt8(4));
+  EXPECT_EQ(1, int8_array.GetUint8(4));
 
-  EXPECT_EQ(2, int8_array.At(5));
-  uint8_t at_5;
-  ByteArray::Copy(&at_5, int8_array, 5, sizeof(at_5));
-  EXPECT_EQ(2, at_5);
+  EXPECT_EQ(2, int8_array.GetInt8(5));
+  EXPECT_EQ(2, int8_array.GetUint8(5));
 
-  EXPECT_EQ(3, int8_array.At(6));
-  uint8_t at_6;
-  ByteArray::Copy(&at_6, int8_array, 6, sizeof(at_6));
-  EXPECT_EQ(3, at_6);
+  EXPECT_EQ(3, int8_array.GetInt8(6));
+  EXPECT_EQ(3, int8_array.GetUint8(6));
 
-  EXPECT_EQ(4, int8_array.At(7));
-  uint8_t at_7;
-  ByteArray::Copy(&at_7, int8_array, 7, sizeof(at_7));
-  EXPECT_EQ(4, at_7);
+  EXPECT_EQ(4, int8_array.GetInt8(7));
+  EXPECT_EQ(4, int8_array.GetUint8(7));
 
-  const Int8Array& int8_array2 =
-      Int8Array::Handle(Int8Array::New(reinterpret_cast<int8_t*>(data),
-                                       data_length));
+  const TypedData& int8_array2 =
+      TypedData::Handle(TypedData::New(kTypedDataInt8ArrayCid, data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
+  for (intptr_t i = 0; i < data_length; ++i) {
+    int8_array2.SetInt8(i, data[i]);
+  }
 
   for (intptr_t i = 0; i < data_length; ++i) {
-    EXPECT_EQ(int8_array.At(i), int8_array2.At(i));
+    EXPECT_EQ(int8_array.GetInt8(i), int8_array2.GetInt8(i));
   }
   for (intptr_t i = 0; i < data_length; ++i) {
-    int8_array.SetAt(i, 123 + i);
+    int8_array.SetInt8(i, 123 + i);
   }
   for (intptr_t i = 0; i < data_length; ++i) {
-    EXPECT(int8_array.At(i) != int8_array2.At(i));
+    EXPECT(int8_array.GetInt8(i) != int8_array2.GetInt8(i));
   }
 }
 
 
-TEST_CASE(ExternalByteArray) {
+TEST_CASE(ExternalTypedData) {
   uint8_t data[] = { 253, 254, 255, 0, 1, 2, 3, 4 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  const ExternalInt8Array& int8_array =
-      ExternalInt8Array::Handle(
-          ExternalInt8Array::New(reinterpret_cast<int8_t*>(data),
+  const ExternalTypedData& int8_array =
+      ExternalTypedData::Handle(
+          ExternalTypedData::New(kExternalTypedDataInt8ArrayCid,
+                                 data,
                                  data_length));
   EXPECT(!int8_array.IsNull());
   EXPECT_EQ(data_length, int8_array.Length());
 
-  const ExternalUint8Array& uint8_array =
-      ExternalUint8Array::Handle(
-          ExternalUint8Array::New(data, data_length));
+  const ExternalTypedData& uint8_array =
+      ExternalTypedData::Handle(
+          ExternalTypedData::New(kExternalTypedDataUint8ArrayCid,
+                                  data,
+                                  data_length));
   EXPECT(!uint8_array.IsNull());
   EXPECT_EQ(data_length, uint8_array.Length());
 
-  const ExternalUint8ClampedArray& uint8_clamped_array =
-      ExternalUint8ClampedArray::Handle(
-          ExternalUint8ClampedArray::New(data, data_length));
+  const ExternalTypedData& uint8_clamped_array =
+      ExternalTypedData::Handle(
+          ExternalTypedData::New(kExternalTypedDataUint8ClampedArrayCid,
+                                 data,
+                                 data_length));
   EXPECT(!uint8_clamped_array.IsNull());
   EXPECT_EQ(data_length, uint8_clamped_array.Length());
 
-  EXPECT_EQ(-3, int8_array.At(0));
-  EXPECT_EQ(253, uint8_array.At(0));
-  EXPECT_EQ(253, uint8_clamped_array.At(0));
+  EXPECT_EQ(-3, int8_array.GetInt8(0));
+  EXPECT_EQ(253, uint8_array.GetUint8(0));
+  EXPECT_EQ(253, uint8_clamped_array.GetUint8(0));
 
-  EXPECT_EQ(-2, int8_array.At(1));
-  EXPECT_EQ(254, uint8_array.At(1));
-  EXPECT_EQ(254, uint8_clamped_array.At(1));
+  EXPECT_EQ(-2, int8_array.GetInt8(1));
+  EXPECT_EQ(254, uint8_array.GetUint8(1));
+  EXPECT_EQ(254, uint8_clamped_array.GetUint8(1));
 
-  EXPECT_EQ(-1, int8_array.At(2));
-  EXPECT_EQ(255, uint8_array.At(2));
-  EXPECT_EQ(255, uint8_clamped_array.At(2));
+  EXPECT_EQ(-1, int8_array.GetInt8(2));
+  EXPECT_EQ(255, uint8_array.GetUint8(2));
+  EXPECT_EQ(255, uint8_clamped_array.GetUint8(2));
 
-  EXPECT_EQ(0, int8_array.At(3));
-  EXPECT_EQ(0, uint8_array.At(3));
-  EXPECT_EQ(0, uint8_clamped_array.At(3));
+  EXPECT_EQ(0, int8_array.GetInt8(3));
+  EXPECT_EQ(0, uint8_array.GetUint8(3));
+  EXPECT_EQ(0, uint8_clamped_array.GetUint8(3));
 
-  EXPECT_EQ(1, int8_array.At(4));
-  EXPECT_EQ(1, uint8_array.At(4));
-  EXPECT_EQ(1, uint8_clamped_array.At(4));
+  EXPECT_EQ(1, int8_array.GetInt8(4));
+  EXPECT_EQ(1, uint8_array.GetUint8(4));
+  EXPECT_EQ(1, uint8_clamped_array.GetUint8(4));
 
-  EXPECT_EQ(2, int8_array.At(5));
-  EXPECT_EQ(2, uint8_array.At(5));
-  EXPECT_EQ(2, uint8_clamped_array.At(5));
+  EXPECT_EQ(2, int8_array.GetInt8(5));
+  EXPECT_EQ(2, uint8_array.GetUint8(5));
+  EXPECT_EQ(2, uint8_clamped_array.GetUint8(5));
 
   for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
-    uint8_t value = 0;
-    ByteArray::Copy(&value, int8_array, i, sizeof(value));
-    EXPECT_EQ(value, uint8_array.At(i));
+    EXPECT_EQ(int8_array.GetUint8(i), uint8_array.GetUint8(i));
   }
 
-  int8_array.SetAt(2, -123);
-  uint8_array.SetAt(0, 123);
+  int8_array.SetInt8(2, -123);
+  uint8_array.SetUint8(0, 123);
   for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
-    int8_t value = 0;
-    ByteArray::Copy(&value, uint8_array, i, sizeof(value));
-    EXPECT_EQ(int8_array.At(i), value);
+    EXPECT_EQ(int8_array.GetInt8(i), uint8_array.GetInt8(i));
   }
 
-  uint8_clamped_array.SetAt(0, 123);
+  uint8_clamped_array.SetUint8(0, 123);
   for (intptr_t i = 0 ; i < int8_array.Length(); ++i) {
-    int8_t value = 0;
-    ByteArray::Copy(&value, uint8_clamped_array, i, sizeof(value));
-    EXPECT_EQ(int8_array.At(i), value);
+    EXPECT_EQ(int8_array.GetUint8(i), uint8_clamped_array.GetUint8(i));
   }
 }
 
 
-TEST_CASE(UInt8ByteArrayCopyInternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
-
-  const Uint8Array& internal =
-      Uint8Array::Handle(Uint8Array::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
-  EXPECT(!internal.IsNull());
-  EXPECT_EQ(4, internal.Length());
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(internal, 0, b_4_5_6_7, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // Another zero length copy.
-  ByteArray::Copy(internal, 4, b_4_5_6_7, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A one element copy.
-  ByteArray::Copy(internal, 0, b_4_5_6_7, 1);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A two element copy.
-  ByteArray::Copy(internal, 2, b_4_5_6_7, 2);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(4, internal.At(2));
-  EXPECT_EQ(5, internal.At(3));
-
-  // A three element copy.
-  ByteArray::Copy(internal, 1, b_4_5_6_7, 3);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(4, internal.At(1));
-  EXPECT_EQ(5, internal.At(2));
-  EXPECT_EQ(6, internal.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(internal, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-}
-
-TEST_CASE(ClampedUInt8ByteArrayCopyInternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
-
-  const Uint8ClampedArray& internal =
-      Uint8ClampedArray::Handle(
-          Uint8ClampedArray::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
-  EXPECT(!internal.IsNull());
-  EXPECT_EQ(4, internal.Length());
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(internal, 0, b_4_5_6_7, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // Another zero length copy.
-  ByteArray::Copy(internal, 4, b_4_5_6_7, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A one element copy.
-  ByteArray::Copy(internal, 0, b_4_5_6_7, 1);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A two element copy.
-  ByteArray::Copy(internal, 2, b_4_5_6_7, 2);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(4, internal.At(2));
-  EXPECT_EQ(5, internal.At(3));
-
-  // A three element copy.
-  ByteArray::Copy(internal, 1, b_4_5_6_7, 3);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(4, internal.At(1));
-  EXPECT_EQ(5, internal.At(2));
-  EXPECT_EQ(6, internal.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(internal, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-}
-
-
-TEST_CASE(Uint8ByteArrayCopyExternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
-
-  uint8_t data[] = { 0, 1, 2, 3 };
-
-  const ExternalUint8Array& external =
-      ExternalUint8Array::Handle(
-          ExternalUint8Array::New(data, ARRAY_SIZE(data)));
-  EXPECT(!external.IsNull());
-  EXPECT_EQ(4, external.Length());
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(external, 0, b_4_5_6_7, 0);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // Another zero length copy.
-  ByteArray::Copy(external, 4, b_4_5_6_7, 0);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A one element copy.
-  ByteArray::Copy(external, 0, b_4_5_6_7, 1);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A two element copy.
-  ByteArray::Copy(external, 2, b_4_5_6_7, 2);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(4, external.At(2));
-  EXPECT_EQ(5, external.At(3));
-
-  // A three element copy.
-  ByteArray::Copy(external, 1, b_4_5_6_7, 3);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(4, external.At(1));
-  EXPECT_EQ(5, external.At(2));
-  EXPECT_EQ(6, external.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(external, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-}
-
-
-TEST_CASE(ClampedUint8ByteArrayCopyExternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  const uint8_t b_4_5_6_7[] = { 4, 5, 6, 7 };
-
-  uint8_t data[] = { 0, 1, 2, 3 };
-
-  const ExternalUint8ClampedArray& external =
-      ExternalUint8ClampedArray::Handle(
-          ExternalUint8ClampedArray::New(data, ARRAY_SIZE(data)));
-  EXPECT(!external.IsNull());
-  EXPECT_EQ(4, external.Length());
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(external, 0, b_4_5_6_7, 0);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // Another zero length copy.
-  ByteArray::Copy(external, 4, b_4_5_6_7, 0);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A one element copy.
-  ByteArray::Copy(external, 0, b_4_5_6_7, 1);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-
-  // A two element copy.
-  ByteArray::Copy(external, 2, b_4_5_6_7, 2);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(4, external.At(2));
-  EXPECT_EQ(5, external.At(3));
-
-  // A three element copy.
-  ByteArray::Copy(external, 1, b_4_5_6_7, 3);
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(4, external.At(1));
-  EXPECT_EQ(5, external.At(2));
-  EXPECT_EQ(6, external.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(external, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-}
-
-
-TEST_CASE(Uint8ByteArrayCopyInternalExternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  uint8_t data[] = { 4, 5, 6, 7 };
-
-  const Uint8Array& internal =
-      Uint8Array::Handle(Uint8Array::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
-  EXPECT(!internal.IsNull());
-  EXPECT_EQ(4, internal.Length());
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  const ExternalUint8Array& external =
-      ExternalUint8Array::Handle(
-          ExternalUint8Array::New(data, ARRAY_SIZE(data)));
-  EXPECT(!external.IsNull());
-  EXPECT_EQ(4, external.Length());
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(internal, 0, external, 0, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 2.
-  ByteArray::Copy(internal, 4, external, 0, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 3.
-  ByteArray::Copy(internal, 0, external, 4, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 4.
-  ByteArray::Copy(internal, 4, external, 4, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(internal, 0, external, 0, 4);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(5, internal.At(1));
-  EXPECT_EQ(6, internal.At(2));
-  EXPECT_EQ(7, internal.At(3));
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-
-  // A four element copy, take 2.
-  ByteArray::Copy(external, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-  ByteArray::Copy(external, 0, internal, 0, 4);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(5, internal.At(1));
-  EXPECT_EQ(6, internal.At(2));
-  EXPECT_EQ(7, internal.At(3));
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-}
-
-
-TEST_CASE(ClampedUint8ByteArrayCopyInternalExternal) {
-  const uint8_t b_0_1_2_3[] = { 0, 1, 2, 3 };
-  uint8_t data[] = { 4, 5, 6, 7 };
-
-  const Uint8ClampedArray& internal =
-      Uint8ClampedArray::Handle(
-          Uint8ClampedArray::New(b_0_1_2_3, ARRAY_SIZE(b_0_1_2_3)));
-  EXPECT(!internal.IsNull());
-  EXPECT_EQ(4, internal.Length());
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  const ExternalUint8ClampedArray& external =
-      ExternalUint8ClampedArray::Handle(
-          ExternalUint8ClampedArray::New(data, ARRAY_SIZE(data)));
-  EXPECT(!external.IsNull());
-  EXPECT_EQ(4, external.Length());
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-
-  // A zero length copy.
-  ByteArray::Copy(internal, 0, external, 0, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 2.
-  ByteArray::Copy(internal, 4, external, 0, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 3.
-  ByteArray::Copy(internal, 0, external, 4, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A zero length copy, take 4.
-  ByteArray::Copy(internal, 4, external, 4, 0);
-  EXPECT_EQ(0, internal.At(0));
-  EXPECT_EQ(1, internal.At(1));
-  EXPECT_EQ(2, internal.At(2));
-  EXPECT_EQ(3, internal.At(3));
-
-  // A four element copy.
-  ByteArray::Copy(internal, 0, external, 0, 4);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(5, internal.At(1));
-  EXPECT_EQ(6, internal.At(2));
-  EXPECT_EQ(7, internal.At(3));
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-
-  // A four element copy, take 2.
-  ByteArray::Copy(external, 0, b_0_1_2_3, 4);
-  EXPECT_EQ(0, external.At(0));
-  EXPECT_EQ(1, external.At(1));
-  EXPECT_EQ(2, external.At(2));
-  EXPECT_EQ(3, external.At(3));
-  ByteArray::Copy(external, 0, internal, 0, 4);
-  EXPECT_EQ(4, internal.At(0));
-  EXPECT_EQ(5, internal.At(1));
-  EXPECT_EQ(6, internal.At(2));
-  EXPECT_EQ(7, internal.At(3));
-  EXPECT_EQ(4, external.At(0));
-  EXPECT_EQ(5, external.At(1));
-  EXPECT_EQ(6, external.At(2));
-  EXPECT_EQ(7, external.At(3));
-}
-
-
 TEST_CASE(Script) {
   const char* url_chars = "builtin:test-case";
   const char* source_chars = "This will not compile.";
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index f8723e35e99..6150db4536c 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -1440,6 +1440,8 @@ class RawTypedData : public RawInstance {
 
   // Variable length data follows here.
   uint8_t data_[0];
+
+  friend class Object;
 };
 
 
@@ -1471,8 +1473,6 @@ class RawInt8Array : public RawByteArray {
 
   // Variable length data follows here.
   int8_t data_[0];
-
-  friend class Object;
 };
 
 
diff --git a/runtime/vm/snapshot_test.cc b/runtime/vm/snapshot_test.cc
index 9e947951a19..1b2b171499c 100644
--- a/runtime/vm/snapshot_test.cc
+++ b/runtime/vm/snapshot_test.cc
@@ -647,18 +647,21 @@ TEST_CASE(SerializeByteArray) {
     uint8_t* buffer;                                                          \
     MessageWriter writer(&buffer, &zone_allocator);                           \
     const int kArrayLength = 127;                                             \
-    darttype& array = darttype::Handle(darttype::New(kArrayLength));          \
+    TypedData& array = TypedData::Handle(                                     \
+        TypedData::New(kTypedData##darttype##ArrayCid, kArrayLength));        \
+    intptr_t scale = array.ElementSizeInBytes();                              \
     for (int i = 0; i < kArrayLength; i++) {                                  \
-      array.SetAt(i, i);                                                      \
+      array.Set##darttype((i * scale), i);                                    \
     }                                                                         \
     writer.WriteMessage(array);                                               \
     intptr_t buffer_len = writer.BytesWritten();                              \
     SnapshotReader reader(buffer, buffer_len,                                 \
                           Snapshot::kMessage, Isolate::Current());            \
-    darttype& serialized_array = darttype::Handle();                          \
+    TypedData& serialized_array = TypedData::Handle();                        \
     serialized_array ^= reader.ReadObject();                                  \
     for (int i = 0; i < kArrayLength; i++) {                                  \
-      EXPECT_EQ(static_cast<ctype>(i), serialized_array.At(i));               \
+      EXPECT_EQ(static_cast<ctype>(i),                                        \
+                serialized_array.Get##darttype(i*scale));                     \
     }                                                                         \
   }
 
@@ -668,47 +671,50 @@ TEST_CASE(SerializeByteArray) {
     StackZone zone(Isolate::Current());                                       \
     ctype data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };                         \
     intptr_t length = ARRAY_SIZE(data);                                       \
-    External##darttype& array = External##darttype::Handle(                   \
-        External##darttype::New(data, length));                               \
+    ExternalTypedData& array = ExternalTypedData::Handle(                     \
+        ExternalTypedData::New(kExternalTypedData##darttype##ArrayCid,        \
+                               reinterpret_cast<uint8_t*>(data), length));    \
+    intptr_t scale = array.ElementSizeInBytes();                              \
     uint8_t* buffer;                                                          \
     MessageWriter writer(&buffer, &zone_allocator);                           \
     writer.WriteMessage(array);                                               \
     intptr_t buffer_len = writer.BytesWritten();                              \
     SnapshotReader reader(buffer, buffer_len,                                 \
                           Snapshot::kMessage, Isolate::Current());            \
-    darttype& serialized_array = darttype::Handle();                          \
+    TypedData& serialized_array = TypedData::Handle();                        \
     serialized_array ^= reader.ReadObject();                                  \
     for (int i = 0; i < length; i++) {                                        \
-      EXPECT_EQ(static_cast<ctype>(data[i]), serialized_array.At(i));         \
+      EXPECT_EQ(static_cast<ctype>(data[i]),                                  \
+                serialized_array.Get##darttype(i*scale));                     \
     }                                                                         \
   }
 
 
 TEST_CASE(SerializeTypedArray) {
-  TEST_TYPED_ARRAY(Int8Array, int8_t);
-  TEST_TYPED_ARRAY(Uint8Array, uint8_t);
-  TEST_TYPED_ARRAY(Int16Array, int16_t);
-  TEST_TYPED_ARRAY(Uint16Array, uint16_t);
-  TEST_TYPED_ARRAY(Int32Array, int32_t);
-  TEST_TYPED_ARRAY(Uint32Array, uint32_t);
-  TEST_TYPED_ARRAY(Int64Array, int64_t);
-  TEST_TYPED_ARRAY(Uint64Array, uint64_t);
-  TEST_TYPED_ARRAY(Float32Array, float);
-  TEST_TYPED_ARRAY(Float64Array, double);
+  TEST_TYPED_ARRAY(Int8, int8_t);
+  TEST_TYPED_ARRAY(Uint8, uint8_t);
+  TEST_TYPED_ARRAY(Int16, int16_t);
+  TEST_TYPED_ARRAY(Uint16, uint16_t);
+  TEST_TYPED_ARRAY(Int32, int32_t);
+  TEST_TYPED_ARRAY(Uint32, uint32_t);
+  TEST_TYPED_ARRAY(Int64, int64_t);
+  TEST_TYPED_ARRAY(Uint64, uint64_t);
+  TEST_TYPED_ARRAY(Float32, float);
+  TEST_TYPED_ARRAY(Float64, double);
 }
 
 
 TEST_CASE(SerializeExternalTypedArray) {
-  TEST_EXTERNAL_TYPED_ARRAY(Int8Array, int8_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Uint8Array, uint8_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Int16Array, int16_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Uint16Array, uint16_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Int32Array, int32_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Uint32Array, uint32_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Int64Array, int64_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Uint64Array, uint64_t);
-  TEST_EXTERNAL_TYPED_ARRAY(Float32Array, float);
-  TEST_EXTERNAL_TYPED_ARRAY(Float64Array, double);
+  TEST_EXTERNAL_TYPED_ARRAY(Int8, int8_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Uint8, uint8_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Int16, int16_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Uint16, uint16_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Int32, int32_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Uint32, uint32_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Int64, int64_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Uint64, uint64_t);
+  TEST_EXTERNAL_TYPED_ARRAY(Float32, float);
+  TEST_EXTERNAL_TYPED_ARRAY(Float64, double);
 }