--- a/ipc/ipdl/test/cxx/TestDataStructures.cpp
+++ b/ipc/ipdl/test/cxx/TestDataStructures.cpp
@@ -1,27 +1,26 @@
 #include "TestDataStructures.h"
 
 #include "mozilla/Unused.h"
 
 #include "IPDLUnitTests.h"  // fail etc.
 
-typedef InfallibleTArray<nsIntRegion> RegionArray;
+typedef nsTArray<nsIntRegion> RegionArray;
 
 namespace mozilla {
 namespace _ipdltest {
 
 static const uint32_t nactors = 10;
 
 #define test_assert(_cond, _msg) \
   if (!(_cond)) fail(_msg)
 
 template <typename T>
-static void assert_arrays_equal(const InfallibleTArray<T>& a,
-                                const InfallibleTArray<T>& b) {
+static void assert_arrays_equal(const nsTArray<T>& a, const nsTArray<T>& b) {
   test_assert(a == b, "arrays equal");
 }
 
 inline static TestDataStructuresSub& Cast(PTestDataStructuresSubParent* a) {
   return *static_cast<TestDataStructuresSub*>(a);
 }
 
 //-----------------------------------------------------------------------------
@@ -47,29 +46,29 @@ bool TestDataStructuresParent::DeallocPT
   test_assert(Cast(actor).mI == Cast(mKids[0]).mI, "dtor sent to wrong actor");
   mKids.RemoveElementAt(0);
   delete actor;
   if (mKids.Length() > 0) return true;
 
   return true;
 }
 
-mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest1(
-    InfallibleTArray<int>&& ia, InfallibleTArray<int>* oa) {
+mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest1(nsTArray<int>&& ia,
+                                                            nsTArray<int>* oa) {
   test_assert(5 == ia.Length(), "wrong length");
   for (int i = 0; i < 5; ++i) test_assert(i == ia[i], "wrong value");
 
   *oa = ia;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest2(
-    InfallibleTArray<PTestDataStructuresSubParent*>&& i1,
-    InfallibleTArray<PTestDataStructuresSubParent*>* o1) {
+    nsTArray<PTestDataStructuresSubParent*>&& i1,
+    nsTArray<PTestDataStructuresSubParent*>* o1) {
   test_assert(nactors == i1.Length(), "wrong #actors");
   for (uint32_t i = 0; i < i1.Length(); ++i)
     test_assert(i == Cast(i1[i]).mI, "wrong mI value");
   *o1 = i1;
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest3(const IntDouble& i1,
@@ -81,17 +80,17 @@ mozilla::ipc::IPCResult TestDataStructur
 
   *o1 = i1;
   *o2 = i2;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest4(
-    InfallibleTArray<IntDouble>&& i1, InfallibleTArray<IntDouble>* o1) {
+    nsTArray<IntDouble>&& i1, nsTArray<IntDouble>* o1) {
   test_assert(4 == i1.Length(), "wrong length");
   test_assert(1 == i1[0].get_int(), "wrong value");
   test_assert(2.0 == i1[1].get_double(), "wrong value");
   test_assert(3 == i1[2].get_int(), "wrong value");
   test_assert(4.0 == i1[3].get_double(), "wrong value");
 
   *o1 = i1;
 
@@ -99,23 +98,23 @@ mozilla::ipc::IPCResult TestDataStructur
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest5(
     const IntDoubleArrays& i1, const IntDoubleArrays& i2,
     const IntDoubleArrays& i3, IntDoubleArrays* o1, IntDoubleArrays* o2,
     IntDoubleArrays* o3) {
   test_assert(42 == i1.get_int(), "wrong value");
 
-  const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
+  const nsTArray<int>& i2a = i2.get_ArrayOfint();
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
-  const InfallibleTArray<double>& i3a = i3.get_ArrayOfdouble();
+  const nsTArray<double>& i3a = i3.get_ArrayOfdouble();
   test_assert(3 == i3a.Length(), "wrong length");
   test_assert(1.0 == i3a[0], "wrong value");
   test_assert(2.0 == i3a[1], "wrong value");
   test_assert(3.0 == i3a[2], "wrong value");
 
   *o1 = i1;
   *o2 = i2a;
   *o3 = i3a;
@@ -134,30 +133,29 @@ mozilla::ipc::IPCResult TestDataStructur
   o1->actorParent() = mKids[0];
   // malicious behavior
   o1->actorChild() =
       reinterpret_cast<PTestDataStructuresSubChild*>(uintptr_t(0xdeadbeef));
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest6(
-    InfallibleTArray<IntDoubleArrays>&& i1,
-    InfallibleTArray<IntDoubleArrays>* o1) {
+    nsTArray<IntDoubleArrays>&& i1, nsTArray<IntDoubleArrays>* o1) {
   test_assert(3 == i1.Length(), "wrong length");
 
   IntDoubleArrays id1(i1[0]);
   test_assert(42 == id1.get_int(), "wrong value");
 
-  InfallibleTArray<int> i2a(i1[1].get_ArrayOfint());
+  nsTArray<int> i2a(i1[1].get_ArrayOfint());
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
-  InfallibleTArray<double> i3a(i1[2].get_ArrayOfdouble());
+  nsTArray<double> i3a(i1[2].get_ArrayOfdouble());
   test_assert(3 == i3a.Length(), "wrong length");
   test_assert(1.0 == i3a[0], "wrong value");
   test_assert(2.0 == i3a[1], "wrong value");
   test_assert(3.0 == i3a[2], "wrong value");
 
   o1->AppendElement(id1);
   o1->AppendElement(IntDoubleArrays(i2a));
   o1->AppendElement(IntDoubleArrays(i3a));
@@ -165,37 +163,37 @@ mozilla::ipc::IPCResult TestDataStructur
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest7(
     const Actors& i1, const Actors& i2, const Actors& i3, Actors* o1,
     Actors* o2, Actors* o3) {
   test_assert(42 == i1.get_int(), "wrong value");
 
-  InfallibleTArray<int> i2a(i2.get_ArrayOfint());
+  nsTArray<int> i2a(i2.get_ArrayOfint());
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
   assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
 
   *o1 = 42;
   *o2 = i2a;
   *o3 = mKids;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest8(
-    InfallibleTArray<Actors>&& i1, InfallibleTArray<Actors>* o1) {
+    nsTArray<Actors>&& i1, nsTArray<Actors>* o1) {
   test_assert(3 == i1.Length(), "wrong length");
   test_assert(42 == i1[0].get_int(), "wrong value");
 
-  const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
+  const nsTArray<int>& i2a = i1[1].get_ArrayOfint();
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
   assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
 
   *o1 = i1;
@@ -203,49 +201,49 @@ mozilla::ipc::IPCResult TestDataStructur
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest9(
     const Unions& i1, const Unions& i2, const Unions& i3, const Unions& i4,
     Unions* o1, Unions* o2, Unions* o3, Unions* o4) {
   test_assert(42 == i1.get_int(), "wrong value");
 
-  const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
+  const nsTArray<int>& i2a = i2.get_ArrayOfint();
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
   assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
 
-  const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
+  const nsTArray<PTestDataStructuresSubParent*>& i4a =
       i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
   assert_arrays_equal(mKids, i4a);
 
   *o1 = i1;
   *o2 = i2;
   *o3 = i3;
   *o4 = i4;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest10(
-    InfallibleTArray<Unions>&& i1, InfallibleTArray<Unions>* o1) {
+    nsTArray<Unions>&& i1, nsTArray<Unions>* o1) {
   test_assert(42 == i1[0].get_int(), "wrong value");
 
-  const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
+  const nsTArray<int>& i2a = i1[1].get_ArrayOfint();
   test_assert(3 == i2a.Length(), "wrong length");
   test_assert(1 == i2a[0], "wrong value");
   test_assert(2 == i2a[1], "wrong value");
   test_assert(3 == i2a[2], "wrong value");
 
   assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
 
-  const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
+  const nsTArray<PTestDataStructuresSubParent*>& i4a =
       i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
   assert_arrays_equal(mKids, i4a);
 
   *o1 = i1;
 
   return IPC_OK();
 }
 
@@ -254,54 +252,54 @@ mozilla::ipc::IPCResult TestDataStructur
   test_assert(1 == i.i(), "wrong value");
   test_assert(2.0 == i.d(), "wrong value");
   *o = i;
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest12(
     const SIntDoubleArrays& i, SIntDoubleArrays* o) {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
-  InfallibleTArray<double> ad;
+  nsTArray<double> ad;
   ad.AppendElement(.5);
   ad.AppendElement(1.0);
   ad.AppendElement(2.0);
 
   test_assert(42 == i.i(), "wrong value");
   assert_arrays_equal(ai, i.ai());
   assert_arrays_equal(ad, i.ad());
 
   *o = i;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest13(const SActors& i,
                                                              SActors* o) {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   test_assert(42 == i.i(), "wrong value");
   assert_arrays_equal(ai, i.ai());
   assert_arrays_equal(mKids, i.apParent());
 
   *o = i;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest14(const Structs& i,
                                                              Structs* o) {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   test_assert(42 == i.i(), "wrong value");
   assert_arrays_equal(ai, i.ai());
   assert_arrays_equal(mKids, i.apParent());
 
@@ -314,17 +312,17 @@ mozilla::ipc::IPCResult TestDataStructur
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest15(
     const WithStructs& i1, const WithStructs& i2, const WithStructs& i3,
     const WithStructs& i4, const WithStructs& i5, WithStructs* o1,
     WithStructs* o2, WithStructs* o3, WithStructs* o4, WithStructs* o5) {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   test_assert(i1 == int(42), "wrong value");
   assert_arrays_equal(i2.get_ArrayOfint(), ai);
   assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);
 
@@ -351,42 +349,42 @@ mozilla::ipc::IPCResult TestDataStructur
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest16(
     const WithUnions& i, WithUnions* o) {
   test_assert(i.i() == 42, "wrong value");
 
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
   assert_arrays_equal(ai, i.ai());
 
   assert_arrays_equal(i.apParent(), mKids);
 
   assert_arrays_equal(mKids,
                       i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());
 
-  const InfallibleTArray<Unions>& iau = i.au();
+  const nsTArray<Unions>& iau = i.au();
   test_assert(iau[0] == 42, "wrong value");
   assert_arrays_equal(ai, iau[1].get_ArrayOfint());
   assert_arrays_equal(mKids, iau[2].get_ArrayOfPTestDataStructuresSubParent());
   assert_arrays_equal(
       mKids,
       iau[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent());
 
   *o = i;
 
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest17(
-    InfallibleTArray<Op>&& sa) {
+    nsTArray<Op>&& sa) {
   test_assert(sa.Length() == 1 && Op::TSetAttrs == sa[0].type(), "wrong value");
   return IPC_OK();
 }
 
 mozilla::ipc::IPCResult TestDataStructuresParent::RecvTest18(RegionArray&& ra) {
   for (RegionArray::index_type i = 0; i < ra.Length(); ++i) {
     // if |ra| has been realloc()d and given a different allocator
     // chunk, this loop will nondeterministically crash or iloop.
@@ -440,30 +438,30 @@ mozilla::ipc::IPCResult TestDataStructur
       fail("can't send dtor");
 
   Close();
 
   return IPC_OK();
 }
 
 void TestDataStructuresChild::Test1() {
-  InfallibleTArray<int> ia;
+  nsTArray<int> ia;
 
   for (int i = 0; i < 5; ++i) ia.AppendElement(i);
 
-  InfallibleTArray<int> oa;
+  nsTArray<int> oa;
   if (!SendTest1(ia, &oa)) fail("can't send Test1");
 
   assert_arrays_equal(ia, oa);
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test2() {
-  InfallibleTArray<PTestDataStructuresSubChild*> oa;
+  nsTArray<PTestDataStructuresSubChild*> oa;
   if (!SendTest2(mKids, &oa)) fail("can't send Test2");
   assert_arrays_equal(mKids, oa);
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test3() {
   int i1i = 42;
@@ -476,42 +474,42 @@ void TestDataStructuresChild::Test3() {
 
   test_assert(i1i == o1.get_int(), "wrong value");
   test_assert(i2d == o2.get_double(), "wrong value");
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test4() {
-  InfallibleTArray<IntDouble> i1;
+  nsTArray<IntDouble> i1;
   i1.AppendElement(IntDouble(int(1)));
   i1.AppendElement(IntDouble(2.0));
   i1.AppendElement(IntDouble(int(3)));
   i1.AppendElement(IntDouble(4.0));
 
-  InfallibleTArray<IntDouble> o1;
+  nsTArray<IntDouble> o1;
   if (!SendTest4(i1, &o1)) fail("can't send Test4");
 
   // TODO Union::operator==()
   test_assert(i1.Length() == o1.Length(), "wrong length");
   test_assert(1 == o1[0].get_int(), "wrong value");
   test_assert(2.0 == o1[1].get_double(), "wrong value");
   test_assert(3 == o1[2].get_int(), "wrong value");
   test_assert(4.0 == o1[3].get_double(), "wrong value");
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test5() {
   IntDoubleArrays i1(int(42));
-  InfallibleTArray<int> i2;
+  nsTArray<int> i2;
   i2.AppendElement(1);
   i2.AppendElement(2);
   i2.AppendElement(3);
-  InfallibleTArray<double> i3;
+  nsTArray<double> i3;
   i3.AppendElement(1.0);
   i3.AppendElement(2.0);
   i3.AppendElement(3.0);
 
   IntDoubleArrays o1, o2, o3;
   if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3), &o1, &o2, &o3))
     fail("can't send Test5");
 
@@ -519,37 +517,37 @@ void TestDataStructuresChild::Test5() {
   assert_arrays_equal(i2, o2.get_ArrayOfint());
   assert_arrays_equal(i3, o3.get_ArrayOfdouble());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test6() {
   IntDoubleArrays id1(int(42));
-  InfallibleTArray<int> id2;
+  nsTArray<int> id2;
   id2.AppendElement(1);
   id2.AppendElement(2);
   id2.AppendElement(3);
-  InfallibleTArray<double> id3;
+  nsTArray<double> id3;
   id3.AppendElement(1.0);
   id3.AppendElement(2.0);
   id3.AppendElement(3.0);
 
-  InfallibleTArray<IntDoubleArrays> i1;
+  nsTArray<IntDoubleArrays> i1;
   i1.AppendElement(id1);
   i1.AppendElement(IntDoubleArrays(id2));
   i1.AppendElement(IntDoubleArrays(id3));
 
-  InfallibleTArray<IntDoubleArrays> o1;
+  nsTArray<IntDoubleArrays> o1;
   if (!SendTest6(i1, &o1)) fail("can't send Test6");
 
   test_assert(3 == o1.Length(), "wrong length");
   IntDoubleArrays od1(o1[0]);
-  InfallibleTArray<int> od2(o1[1].get_ArrayOfint());
-  InfallibleTArray<double> od3(o1[2].get_ArrayOfdouble());
+  nsTArray<int> od2(o1[1].get_ArrayOfint());
+  nsTArray<double> od3(o1[2].get_ArrayOfdouble());
 
   test_assert(42 == od1.get_int(), "wrong value");
   assert_arrays_equal(id2, od2);
   assert_arrays_equal(id3, od3);
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
@@ -571,17 +569,17 @@ void TestDataStructuresChild::Test7_0() 
         "child");
 
   if (oaw.actorChild() != mKids[0])
     fail("should have got back same child-side actor");
 }
 
 void TestDataStructuresChild::Test7() {
   Actors i1(42);
-  InfallibleTArray<int> i2a;
+  nsTArray<int> i2a;
   i2a.AppendElement(1);
   i2a.AppendElement(2);
   i2a.AppendElement(3);
 
   Actors o1, o2, o3;
   if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))
     fail("can't send Test7");
 
@@ -589,46 +587,46 @@ void TestDataStructuresChild::Test7() {
   assert_arrays_equal(i2a, o2.get_ArrayOfint());
   assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test8() {
   Actors i1e(42);
-  InfallibleTArray<int> i2a;
+  nsTArray<int> i2a;
   i2a.AppendElement(1);
   i2a.AppendElement(2);
   i2a.AppendElement(3);
 
-  InfallibleTArray<Actors> i1;
+  nsTArray<Actors> i1;
   i1.AppendElement(i1e);
   i1.AppendElement(i2a);
   i1.AppendElement(mKids);
 
-  InfallibleTArray<Actors> o1;
+  nsTArray<Actors> o1;
   if (!SendTest8(i1, &o1)) fail("can't send Test8");
 
   test_assert(3 == o1.Length(), "wrong length");
   test_assert(42 == o1[0].get_int(), "wrong value");
   assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
   assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test9() {
   Unions i1(int(42));
 
-  InfallibleTArray<int> i2a;
+  nsTArray<int> i2a;
   i2a.AppendElement(1);
   i2a.AppendElement(2);
   i2a.AppendElement(3);
 
-  InfallibleTArray<Actors> i4a;
+  nsTArray<Actors> i4a;
   i4a.AppendElement(mKids);
 
   Unions o1, o2, o3, o4;
   if (!SendTest9(i1, Unions(i2a), Unions(mKids), Unions(i4a), &o1, &o2, &o3,
                  &o4))
     fail("can't send Test9");
 
   test_assert(42 == o1.get_int(), "wrong value");
@@ -639,31 +637,31 @@ void TestDataStructuresChild::Test9() {
       o4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test10() {
   Unions i1a(int(42));
 
-  InfallibleTArray<int> i2a;
+  nsTArray<int> i2a;
   i2a.AppendElement(1);
   i2a.AppendElement(2);
   i2a.AppendElement(3);
 
-  InfallibleTArray<Actors> i4a;
+  nsTArray<Actors> i4a;
   i4a.AppendElement(mKids);
 
-  InfallibleTArray<Unions> i1;
+  nsTArray<Unions> i1;
   i1.AppendElement(i1a);
   i1.AppendElement(Unions(i2a));
   i1.AppendElement(Unions(mKids));
   i1.AppendElement(Unions(i4a));
 
-  InfallibleTArray<Unions> o1;
+  nsTArray<Unions> o1;
   if (!SendTest10(i1, &o1)) fail("can't send Test10");
 
   test_assert(4 == o1.Length(), "wrong length");
   test_assert(42 == o1[0].get_int(), "wrong value");
   assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
   assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
   assert_arrays_equal(
       mKids,
@@ -679,22 +677,22 @@ void TestDataStructuresChild::Test11() {
   if (!SendTest11(i, &o)) fail("sending Test11");
 
   test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test12() {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
-  InfallibleTArray<double> ad;
+  nsTArray<double> ad;
   ad.AppendElement(.5);
   ad.AppendElement(1.0);
   ad.AppendElement(2.0);
 
   SIntDoubleArrays i(42, ai, ad);
   SIntDoubleArrays o;
 
   if (!SendTest12(i, &o)) fail("sending Test12");
@@ -702,17 +700,17 @@ void TestDataStructuresChild::Test12() {
   test_assert(42 == o.i(), "wrong value");
   assert_arrays_equal(ai, o.ai());
   assert_arrays_equal(ad, o.ad());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test13() {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   SActors i;
   i.i() = 42;
   i.ai() = ai;
   i.apChild() = mKids;
@@ -723,26 +721,26 @@ void TestDataStructuresChild::Test13() {
   test_assert(42 == o.i(), "wrong value");
   assert_arrays_equal(ai, o.ai());
   assert_arrays_equal(mKids, o.apChild());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test14() {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   SActors ia;
   ia.i() = 42;
   ia.ai() = ai;
   ia.apChild() = mKids;
-  InfallibleTArray<SActors> aa;
+  nsTArray<SActors> aa;
   aa.AppendElement(ia);
 
   Structs i;
   i.i() = 42;
   i.ai() = ai;
   i.apChild() = mKids;
   i.aa() = aa;
 
@@ -757,34 +755,34 @@ void TestDataStructuresChild::Test14() {
   test_assert(42 == os.i(), "wrong value");
   assert_arrays_equal(ai, os.ai());
   assert_arrays_equal(mKids, os.apChild());
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test15() {
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
 
   SActors ia;
   ia.i() = 42;
   ia.ai() = ai;
   ia.apChild() = mKids;
-  InfallibleTArray<SActors> iaa;
+  nsTArray<SActors> iaa;
   iaa.AppendElement(ia);
 
   Structs is;
   is.i() = 42;
   is.ai() = ai;
   is.apChild() = mKids;
   is.aa() = iaa;
-  InfallibleTArray<Structs> isa;
+  nsTArray<Structs> isa;
   isa.AppendElement(is);
 
   WithStructs o1, o2, o3, o4, o5;
   if (!SendTest15(WithStructs(42), WithStructs(ai), WithStructs(mKids),
                   WithStructs(iaa), WithStructs(isa), &o1, &o2, &o3, &o4, &o5))
     fail("sending Test15");
 
   test_assert(o1 == int(42), "wrong value");
@@ -809,62 +807,62 @@ void TestDataStructuresChild::Test15() {
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test16() {
   WithUnions i;
 
   i.i() = 42;
 
-  InfallibleTArray<int> ai;
+  nsTArray<int> ai;
   ai.AppendElement(1);
   ai.AppendElement(2);
   ai.AppendElement(3);
   i.ai() = ai;
 
   i.apChild() = mKids;
 
-  InfallibleTArray<Actors> iaa;
+  nsTArray<Actors> iaa;
   iaa.AppendElement(mKids);
   i.aa() = iaa;
 
-  InfallibleTArray<Unions> iau;
+  nsTArray<Unions> iau;
   iau.AppendElement(int(42));
   iau.AppendElement(ai);
   iau.AppendElement(mKids);
   iau.AppendElement(iaa);
   i.au() = iau;
 
   WithUnions o;
   if (!SendTest16(i, &o)) fail("sending Test16");
 
   test_assert(42 == o.i(), "wrong value");
   assert_arrays_equal(o.ai(), ai);
   assert_arrays_equal(o.apChild(), mKids);
 
   const Actors& oaa = o.aa()[0];
   assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);
 
-  const InfallibleTArray<Unions>& oau = o.au();
+  const nsTArray<Unions>& oau = o.au();
   test_assert(oau[0] == 42, "wrong value");
   assert_arrays_equal(oau[1].get_ArrayOfint(), ai);
   assert_arrays_equal(oau[2].get_ArrayOfPTestDataStructuresSubChild(), mKids);
   assert_arrays_equal(
       oau[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild(),
       mKids);
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test17() {
   Attrs attrs;
   attrs.common() = CommonAttrs(true);
   attrs.specific() = BarAttrs(1.0f);
 
-  InfallibleTArray<Op> ops;
+  nsTArray<Op> ops;
   ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));
 
   if (!SendTest17(ops)) fail("sending Test17");
 
   printf("  passed %s\n", __FUNCTION__);
 }
 
 void TestDataStructuresChild::Test18() {

--- a/ipc/ipdl/test/cxx/TestDataStructures.h
+++ b/ipc/ipdl/test/cxx/TestDataStructures.h
@@ -46,54 +46,53 @@ class TestDataStructuresParent : public 
       const int& i) {
     PTestDataStructuresSubParent* actor = new TestDataStructuresSub(i);
     mKids.AppendElement(actor);
     return actor;
   }
 
   bool DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor);
 
-  mozilla::ipc::IPCResult RecvTest1(InfallibleTArray<int>&& i1,
-                                    InfallibleTArray<int>* o1);
+  mozilla::ipc::IPCResult RecvTest1(nsTArray<int>&& i1, nsTArray<int>* o1);
 
   mozilla::ipc::IPCResult RecvTest2(
-      InfallibleTArray<PTestDataStructuresSubParent*>&& i1,
-      InfallibleTArray<PTestDataStructuresSubParent*>* o1);
+      nsTArray<PTestDataStructuresSubParent*>&& i1,
+      nsTArray<PTestDataStructuresSubParent*>* o1);
 
   mozilla::ipc::IPCResult RecvTest3(const IntDouble& i1, const IntDouble& i2,
                                     IntDouble* o1, IntDouble* o2);
 
-  mozilla::ipc::IPCResult RecvTest4(InfallibleTArray<IntDouble>&& i1,
-                                    InfallibleTArray<IntDouble>* o1);
+  mozilla::ipc::IPCResult RecvTest4(nsTArray<IntDouble>&& i1,
+                                    nsTArray<IntDouble>* o1);
 
   mozilla::ipc::IPCResult RecvTest5(const IntDoubleArrays& i1,
                                     const IntDoubleArrays& i2,
                                     const IntDoubleArrays& i3,
                                     IntDoubleArrays* o1, IntDoubleArrays* o2,
                                     IntDoubleArrays* o3);
 
-  mozilla::ipc::IPCResult RecvTest6(InfallibleTArray<IntDoubleArrays>&& i1,
-                                    InfallibleTArray<IntDoubleArrays>* o1);
+  mozilla::ipc::IPCResult RecvTest6(nsTArray<IntDoubleArrays>&& i1,
+                                    nsTArray<IntDoubleArrays>* o1);
 
   mozilla::ipc::IPCResult RecvTest7_0(const ActorWrapper& i1, ActorWrapper* o1);
 
   mozilla::ipc::IPCResult RecvTest7(const Actors& i1, const Actors& i2,
                                     const Actors& i3, Actors* o1, Actors* o2,
                                     Actors* o3);
 
-  mozilla::ipc::IPCResult RecvTest8(InfallibleTArray<Actors>&& i1,
-                                    InfallibleTArray<Actors>* o1);
+  mozilla::ipc::IPCResult RecvTest8(nsTArray<Actors>&& i1,
+                                    nsTArray<Actors>* o1);
 
   mozilla::ipc::IPCResult RecvTest9(const Unions& i1, const Unions& i2,
                                     const Unions& i3, const Unions& i4,
                                     Unions* o1, Unions* o2, Unions* o3,
                                     Unions* o4);
 
-  mozilla::ipc::IPCResult RecvTest10(InfallibleTArray<Unions>&& i1,
-                                     InfallibleTArray<Unions>* o1);
+  mozilla::ipc::IPCResult RecvTest10(nsTArray<Unions>&& i1,
+                                     nsTArray<Unions>* o1);
 
   mozilla::ipc::IPCResult RecvTest11(const SIntDouble& i, SIntDouble* o);
 
   mozilla::ipc::IPCResult RecvTest12(const SIntDoubleArrays& i,
                                      SIntDoubleArrays* o);
 
   mozilla::ipc::IPCResult RecvTest13(const SActors& i, SActors* o);
 
@@ -101,33 +100,33 @@ class TestDataStructuresParent : public 
 
   mozilla::ipc::IPCResult RecvTest15(
       const WithStructs& i1, const WithStructs& i2, const WithStructs& i3,
       const WithStructs& i4, const WithStructs& i5, WithStructs* o1,
       WithStructs* o2, WithStructs* o3, WithStructs* o4, WithStructs* o5);
 
   mozilla::ipc::IPCResult RecvTest16(const WithUnions& i, WithUnions* o);
 
-  mozilla::ipc::IPCResult RecvTest17(InfallibleTArray<Op>&& sa);
+  mozilla::ipc::IPCResult RecvTest17(nsTArray<Op>&& sa);
 
-  mozilla::ipc::IPCResult RecvTest18(InfallibleTArray<nsIntRegion>&& ra);
+  mozilla::ipc::IPCResult RecvTest18(nsTArray<nsIntRegion>&& ra);
 
   mozilla::ipc::IPCResult RecvDummy(const ShmemUnion& su, ShmemUnion* rsu) {
     *rsu = su;
     return IPC_OK();
   }
 
   virtual void ActorDestroy(ActorDestroyReason why) override {
     if (NormalShutdown != why) fail("unexpected destruction!");
     passed("ok");
     QuitParent();
   }
 
  private:
-  InfallibleTArray<PTestDataStructuresSubParent*> mKids;
+  nsTArray<PTestDataStructuresSubParent*> mKids;
 };
 
 class TestDataStructuresChild : public PTestDataStructuresChild {
   friend class PTestDataStructuresChild;
 
  public:
   TestDataStructuresChild();
   virtual ~TestDataStructuresChild();
@@ -167,15 +166,15 @@ class TestDataStructuresChild : public P
   void Test12();
   void Test13();
   void Test14();
   void Test15();
   void Test16();
   void Test17();
   void Test18();
 
-  InfallibleTArray<PTestDataStructuresSubChild*> mKids;
+  nsTArray<PTestDataStructuresSubChild*> mKids;
 };
 
 }  // namespace _ipdltest
 }  // namespace mozilla
 
 #endif  // ifndef mozilla__ipdltest_TestDataStructures_h

--- a/ipc/ipdl/test/cxx/TestJSON.cpp
+++ b/ipc/ipdl/test/cxx/TestJSON.cpp
@@ -7,17 +7,17 @@
 
 namespace mozilla {
 namespace _ipdltest {
 
 static nsString String(const char* const str) {
   return NS_ConvertUTF8toUTF16(str);
 }
 
-static void Array123(InfallibleTArray<JSONVariant>& a123) {
+static void Array123(nsTArray<JSONVariant>& a123) {
   a123.AppendElement(1);
   a123.AppendElement(2);
   a123.AppendElement(3);
 
   test_assert(a123 == a123, "operator== is broken");
 }
 
 template <class HandleT>
@@ -33,38 +33,38 @@ JSONVariant MakeTestVariant(HandleT* han
   //       "true"      : true,
   //       "1.25"      : 1.25,
   //       "string"    : "string"
   //       "handle"    : handle,
   //       "array"     : [ 1, 2, 3 ]
   //     }
   //   ]
   //
-  InfallibleTArray<JSONVariant> outer;
+  nsTArray<JSONVariant> outer;
 
   outer.AppendElement(void_t());
   outer.AppendElement(null_t());
   outer.AppendElement(true);
   outer.AppendElement(1.25);
   outer.AppendElement(String("test string"));
 
   outer.AppendElement(handle);
 
-  InfallibleTArray<JSONVariant> tmp;
+  nsTArray<JSONVariant> tmp;
   Array123(tmp);
   outer.AppendElement(tmp);
 
-  InfallibleTArray<KeyValue> obj;
+  nsTArray<KeyValue> obj;
   obj.AppendElement(KeyValue(String("undefined"), void_t()));
   obj.AppendElement(KeyValue(String("null"), null_t()));
   obj.AppendElement(KeyValue(String("true"), true));
   obj.AppendElement(KeyValue(String("1.25"), 1.25));
   obj.AppendElement(KeyValue(String("string"), String("value")));
   obj.AppendElement(KeyValue(String("handle"), handle));
-  InfallibleTArray<JSONVariant> tmp2;
+  nsTArray<JSONVariant> tmp2;
   Array123(tmp2);
   obj.AppendElement(KeyValue(String("array"), tmp2));
 
   outer.AppendElement(obj);
 
   test_assert(outer == outer, "operator== is broken");
 
   return JSONVariant(outer);