From 538dcc1d3927f954e9f6c020a5baa43bd9f93074 Mon Sep 17 00:00:00 2001
From: Birunthan Mohanathas <birunthan@mohanathas.com>
Date: Mon, 18 May 2015 13:50:35 -0700
Subject: [PATCH] Bug 968520 - Add fallible variants of
 nsTArray::AppendElements. r=froydnj

---
 xpcom/glue/nsTArray.h | 37 ++++++++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/xpcom/glue/nsTArray.h b/xpcom/glue/nsTArray.h
index 296f33dad575..817dd27753ae 100644
--- a/xpcom/glue/nsTArray.h
+++ b/xpcom/glue/nsTArray.h
@@ -1411,10 +1411,10 @@ public:
   // @param aArrayLen The number of elements to append to this array.
   // @return          A pointer to the new elements in the array, or null if
   //                  the operation failed due to insufficient memory.
-  template<class Item>
+  template<class Item, typename ActualAlloc = Alloc>
   elem_type* AppendElements(const Item* aArray, size_type aArrayLen)
   {
-    if (!Alloc::Successful(this->template EnsureCapacity<Alloc>(
+    if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
           Length() + aArrayLen, sizeof(elem_type)))) {
       return nullptr;
     }
@@ -1424,11 +1424,27 @@ public:
     return Elements() + len;
   }
 
+  template<class Item>
+  /* MOZ_WARN_UNUSED_RESULT */
+  elem_type* AppendElements(const Item* aArray, size_type aArrayLen,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, FallibleAlloc>(aArray, aArrayLen);
+  }
+
   // A variation on the AppendElements method defined above.
-  template<class Item, class Allocator>
+  template<class Item, class Allocator, typename ActualAlloc = Alloc>
   elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray)
   {
-    return AppendElements(aArray.Elements(), aArray.Length());
+    return AppendElements<Item, ActualAlloc>(aArray.Elements(), aArray.Length());
+  }
+
+  template<class Item, class Allocator>
+  /* MOZ_WARN_UNUSED_RESULT */
+  elem_type* AppendElements(const nsTArray_Impl<Item, Allocator>& aArray,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<Item, Allocator, FallibleAlloc>(aArray);
   }
 
   // Append a new element, move constructing if possible.
@@ -1448,9 +1464,9 @@ public:
   // Append new elements without copy-constructing. This is useful to avoid
   // temporaries.
   // @return A pointer to the newly appended elements, or null on OOM.
-  elem_type* AppendElements(size_type aCount)
-  {
-    if (!Alloc::Successful(this->template EnsureCapacity<Alloc>(
+  template<typename ActualAlloc = Alloc>
+  elem_type* AppendElements(size_type aCount) {
+    if (!ActualAlloc::Successful(this->template EnsureCapacity<ActualAlloc>(
           Length() + aCount, sizeof(elem_type)))) {
       return nullptr;
     }
@@ -1463,6 +1479,13 @@ public:
     return elems;
   }
 
+  /* MOZ_WARN_UNUSED_RESULT */
+  elem_type* AppendElements(size_type aCount,
+                            const mozilla::fallible_t&)
+  {
+    return AppendElements<FallibleAlloc>(aCount);
+  }
+
   // Append a new element without copy-constructing. This is useful to avoid
   // temporaries.
   // @return A pointer to the newly appended element, or null on OOM.