Bug 1289211 - Rename InfallibleTArray to nsTArray in ipc/ r=nika
authorBarret Rennie <barret@brennie.ca>
Wed, 10 Jul 2019 03:31:24 +0000
changeset 542718 257168f9ac940eaffef6a65fc77bf4e0b0e8859b
parent 542717 1d35ca0edcf9eb4900f22217b098950009927aed
child 542719 147678848f254d84c08eb4026483b1b11db59215
push id11848
push userffxbld-merge
push dateMon, 26 Aug 2019 19:26:25 +0000
treeherdermozilla-beta@9b31bfdfac10 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnika
bugs1289211
milestone70.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1289211 - Rename InfallibleTArray to nsTArray in ipc/ r=nika Differential Revision: https://phabricator.services.mozilla.com/D36961
ipc/ipdl/test/cxx/TestDataStructures.cpp
ipc/ipdl/test/cxx/TestDataStructures.h
ipc/ipdl/test/cxx/TestJSON.cpp
--- 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);