diff -r 000000000000 -r 6474c204b198 xpcom/glue/nsCOMArray.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/glue/nsCOMArray.cpp	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,307 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsCOMArray.h"
+
+#include "mozilla/MemoryReporting.h"
+
+#include "nsCOMPtr.h"
+
+// This specialization is private to nsCOMArray.
+// It exists solely to automatically zero-out newly created array elements.
+template<>
+class nsTArrayElementTraits<nsISupports*>
+{
+    typedef nsISupports* E;
+public:
+    // Zero out the value
+    static inline void Construct(E *e) {
+        new (static_cast<void *>(e)) E();
+    }
+    // Invoke the copy-constructor in place.
+    template<class A>
+    static inline void Construct(E *e, const A &arg) {
+        new (static_cast<void *>(e)) E(arg);
+    }
+    // Invoke the destructor in place.
+    static inline void Destruct(E *e) {
+        e->~E();
+    }
+};
+
+static void ReleaseObjects(nsTArray<nsISupports*> &aArray);
+
+// implementations of non-trivial methods in nsCOMArray_base
+
+nsCOMArray_base::nsCOMArray_base(const nsCOMArray_base& aOther)
+{
+    // make sure we do only one allocation
+    mArray.SetCapacity(aOther.Count());
+    AppendObjects(aOther);
+}
+
+nsCOMArray_base::~nsCOMArray_base()
+{
+    Clear();
+}
+
+int32_t
+nsCOMArray_base::IndexOf(nsISupports* aObject, uint32_t aStartIndex) const
+{
+  return mArray.IndexOf(aObject, aStartIndex);
+}
+
+int32_t
+nsCOMArray_base::IndexOfObject(nsISupports* aObject) const
+{
+    nsCOMPtr<nsISupports> supports = do_QueryInterface(aObject);
+    if (NS_WARN_IF(!supports))
+        return -1;
+
+    uint32_t i, count;
+    int32_t retval = -1;
+    count = mArray.Length();
+    for (i = 0; i < count; ++i) {
+        nsCOMPtr<nsISupports> arrayItem = do_QueryInterface(mArray[i]);
+        if (arrayItem == supports) {
+            retval = i;
+            break;
+        }
+    }
+    return retval;
+}
+
+bool
+nsCOMArray_base::EnumerateForwards(nsBaseArrayEnumFunc aFunc, void* aData) const
+{
+    for (uint32_t index = 0; index < mArray.Length(); index++)
+        if (!(*aFunc)(mArray[index], aData))
+            return false;
+
+    return true;
+}
+
+bool
+nsCOMArray_base::EnumerateBackwards(nsBaseArrayEnumFunc aFunc, void* aData) const
+{
+    for (uint32_t index = mArray.Length(); index--; )
+        if (!(*aFunc)(mArray[index], aData))
+            return false;
+
+    return true;
+}
+
+int
+nsCOMArray_base::nsCOMArrayComparator(const void* aElement1, const void* aElement2, void* aData)
+{
+    nsCOMArrayComparatorContext* ctx = static_cast<nsCOMArrayComparatorContext*>(aData);
+    return (*ctx->mComparatorFunc)(*static_cast<nsISupports* const*>(aElement1),
+                                   *static_cast<nsISupports* const*>(aElement2),
+                                   ctx->mData);
+}
+
+void
+nsCOMArray_base::Sort(nsBaseArrayComparatorFunc aFunc, void* aData)
+{
+    if (mArray.Length() > 1) {
+        nsCOMArrayComparatorContext ctx = {aFunc, aData};
+        NS_QuickSort(mArray.Elements(), mArray.Length(), sizeof(nsISupports*),
+                     nsCOMArrayComparator, &ctx);
+    }
+}
+
+bool
+nsCOMArray_base::InsertObjectAt(nsISupports* aObject, int32_t aIndex)
+{
+    if ((uint32_t)aIndex > mArray.Length())
+        return false;
+
+    if (!mArray.InsertElementAt(aIndex, aObject))
+        return false;
+
+    NS_IF_ADDREF(aObject);
+    return true;
+}
+
+void
+nsCOMArray_base::InsertElementAt(uint32_t aIndex, nsISupports* aElement)
+{
+    mArray.InsertElementAt(aIndex, aElement);
+    NS_IF_ADDREF(aElement);
+}
+
+bool
+nsCOMArray_base::InsertObjectsAt(const nsCOMArray_base& aObjects, int32_t aIndex)
+{
+    if ((uint32_t)aIndex > mArray.Length())
+        return false;
+
+    if (!mArray.InsertElementsAt(aIndex, aObjects.mArray))
+        return false;
+
+    // need to addref all these
+    uint32_t count = aObjects.Length();
+    for (uint32_t i = 0; i < count; ++i)
+        NS_IF_ADDREF(aObjects[i]);
+
+    return true;
+}
+
+void
+nsCOMArray_base::InsertElementsAt(uint32_t aIndex, const nsCOMArray_base& aElements)
+{
+    mArray.InsertElementsAt(aIndex, aElements.mArray);
+
+    // need to addref all these
+    uint32_t count = aElements.Length();
+    for (uint32_t i = 0; i < count; ++i)
+        NS_IF_ADDREF(aElements[i]);
+}
+
+void
+nsCOMArray_base::InsertElementsAt(uint32_t aIndex, nsISupports* const* aElements, uint32_t aCount)
+{
+    mArray.InsertElementsAt(aIndex, aElements, aCount);
+
+    // need to addref all these
+    for (uint32_t i = 0; i < aCount; ++i)
+        NS_IF_ADDREF(aElements[i]);
+}
+
+bool
+nsCOMArray_base::ReplaceObjectAt(nsISupports* aObject, int32_t aIndex)
+{
+  mArray.EnsureLengthAtLeast(aIndex + 1);
+  nsISupports *oldObject = mArray[aIndex];
+  // Make sure to addref first, in case aObject == oldObject
+  NS_IF_ADDREF(mArray[aIndex] = aObject);
+  NS_IF_RELEASE(oldObject);
+  // XXX make this return void
+  return true;
+}
+
+bool
+nsCOMArray_base::RemoveObject(nsISupports *aObject)
+{
+    bool result = mArray.RemoveElement(aObject);
+    if (result)
+        NS_IF_RELEASE(aObject);
+    return result;
+}
+
+bool
+nsCOMArray_base::RemoveObjectAt(int32_t aIndex)
+{
+    if (uint32_t(aIndex) < mArray.Length()) {
+        nsISupports* element = mArray[aIndex];
+
+        mArray.RemoveElementAt(aIndex);
+        NS_IF_RELEASE(element);
+        return true;
+    }
+
+    return false;
+}
+
+void
+nsCOMArray_base::RemoveElementAt(uint32_t aIndex)
+{
+    nsISupports* element = mArray[aIndex];
+    mArray.RemoveElementAt(aIndex);
+    NS_IF_RELEASE(element);
+}
+
+bool
+nsCOMArray_base::RemoveObjectsAt(int32_t aIndex, int32_t aCount)
+{
+    if (uint32_t(aIndex) + uint32_t(aCount) <= mArray.Length()) {
+        nsTArray<nsISupports*> elementsToDestroy(aCount);
+        elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
+        mArray.RemoveElementsAt(aIndex, aCount);
+        ReleaseObjects(elementsToDestroy);
+        return true;
+    }
+
+    return false;
+}
+
+void
+nsCOMArray_base::RemoveElementsAt(uint32_t aIndex, uint32_t aCount)
+{
+    nsTArray<nsISupports*> elementsToDestroy(aCount);
+    elementsToDestroy.AppendElements(mArray.Elements() + aIndex, aCount);
+    mArray.RemoveElementsAt(aIndex, aCount);
+    ReleaseObjects(elementsToDestroy);
+}
+
+// useful for destructors
+void
+ReleaseObjects(nsTArray<nsISupports*> &aArray)
+{
+    for (uint32_t i = 0; i < aArray.Length(); i++)
+        NS_IF_RELEASE(aArray[i]);
+}
+
+void
+nsCOMArray_base::Clear()
+{
+    nsTArray<nsISupports*> objects;
+    objects.SwapElements(mArray);
+    ReleaseObjects(objects);
+}
+
+bool
+nsCOMArray_base::SetCount(int32_t aNewCount)
+{
+    NS_ASSERTION(aNewCount >= 0,"SetCount(negative index)");
+    if (aNewCount < 0)
+        return false;
+
+    int32_t count = mArray.Length();
+    if (count > aNewCount)
+        RemoveObjectsAt(aNewCount, mArray.Length() - aNewCount);
+    mArray.SetLength(aNewCount);
+    return true;
+}
+
+size_t
+nsCOMArray_base::SizeOfExcludingThis(
+                   nsBaseArraySizeOfElementIncludingThisFunc aSizeOfElementIncludingThis,
+                   mozilla::MallocSizeOf aMallocSizeOf, void* aData) const
+{
+    size_t n = mArray.SizeOfExcludingThis(aMallocSizeOf);
+
+    if (aSizeOfElementIncludingThis)
+        for (uint32_t index = 0; index < mArray.Length(); index++)
+            n += aSizeOfElementIncludingThis(mArray[index], aMallocSizeOf, aData);
+
+    return n;
+}
+
+
+void
+nsCOMArray_base::Adopt(nsISupports** aElements, uint32_t aSize)
+{
+    Clear();
+    mArray.AppendElements(aElements, aSize);
+
+    // Free the allocated array as well.
+    NS_Free(aElements);
+}
+
+uint32_t
+nsCOMArray_base::Forget(nsISupports*** elements)
+{
+    uint32_t length = Length();
+    size_t array_size = sizeof(nsISupports*) * length;
+    nsISupports** array = static_cast<nsISupports**>(NS_Alloc(array_size));
+    memmove(array, Elements(), array_size);
+    *elements = array;
+    // Don't Release the contained pointers; the caller of the method will
+    // do this eventually.
+    mArray.Clear();
+
+    return length;
+}