diff -r 000000000000 -r 6474c204b198 xpcom/base/nsAutoPtr.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/base/nsAutoPtr.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1477 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* 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/. */
+
+#ifndef nsAutoPtr_h___
+#define nsAutoPtr_h___
+
+#include "nsCOMPtr.h"
+
+#include "nsCycleCollectionNoteChild.h"
+#include "mozilla/MemoryReporting.h"
+
+/*****************************************************************************/
+
+// template <class T> class nsAutoPtrGetterTransfers;
+
+template <class T>
+class nsAutoPtr
+  {
+    private:
+      void**
+      begin_assignment()
+        {
+          assign(0);
+          return reinterpret_cast<void**>(&mRawPtr);
+        }
+
+      void
+      assign( T* newPtr )
+        {
+          T* oldPtr = mRawPtr;
+
+          if (newPtr != nullptr && newPtr == oldPtr) {
+            NS_RUNTIMEABORT("Logic flaw in the caller");
+          }
+
+          mRawPtr = newPtr;
+          delete oldPtr;
+        }
+
+      // |class Ptr| helps us prevent implicit "copy construction"
+      // through |operator T*() const| from a |const nsAutoPtr<T>|
+      // because two implicit conversions in a row aren't allowed.
+      // It still allows assignment from T* through implicit conversion
+      // from |T*| to |nsAutoPtr<T>::Ptr|
+      class Ptr
+        {
+          public:
+            Ptr( T* aPtr )
+                  : mPtr(aPtr)
+              {
+              }
+
+            operator T*() const
+              {
+                return mPtr;
+              }
+
+          private:
+            T* mPtr;
+        };
+
+    private:
+      T* mRawPtr;
+
+    public:
+      typedef T element_type;
+      
+     ~nsAutoPtr()
+        {
+          delete mRawPtr;
+        }
+
+        // Constructors
+
+      nsAutoPtr()
+            : mRawPtr(0)
+          // default constructor
+        {
+        }
+
+      nsAutoPtr( Ptr aRawPtr )
+            : mRawPtr(aRawPtr)
+          // construct from a raw pointer (of the right type)
+        {
+        }
+
+      // This constructor shouldn't exist; we should just use the &&
+      // constructor.
+      nsAutoPtr( nsAutoPtr<T>& aSmartPtr )
+            : mRawPtr( aSmartPtr.forget() )
+          // Construct by transferring ownership from another smart pointer.
+        {
+        }
+
+      nsAutoPtr( nsAutoPtr<T>&& aSmartPtr )
+            : mRawPtr( aSmartPtr.forget() )
+          // Construct by transferring ownership from another smart pointer.
+        {
+        }
+
+        // Assignment operators
+
+      nsAutoPtr<T>&
+      operator=( T* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign(rhs);
+          return *this;
+        }
+
+      nsAutoPtr<T>& operator=( nsAutoPtr<T>& rhs )
+          // assign by transferring ownership from another smart pointer.
+        {
+          assign(rhs.forget());
+          return *this;
+        }
+
+        // Other pointer operators
+
+      T*
+      get() const
+          /*
+            Prefer the implicit conversion provided automatically by
+            |operator T*() const|.  Use |get()| _only_ to resolve
+            ambiguity.
+          */
+        {
+          return mRawPtr;
+        }
+
+      operator T*() const
+          /*
+            ...makes an |nsAutoPtr| act like its underlying raw pointer
+            type  whenever it is used in a context where a raw pointer
+            is expected.  It is this operator that makes an |nsAutoPtr|
+            substitutable for a raw pointer.
+
+            Prefer the implicit use of this operator to calling |get()|,
+            except where necessary to resolve ambiguity.
+          */
+        {
+          return get();
+        }
+
+      T*
+      forget()
+        {
+          T* temp = mRawPtr;
+          mRawPtr = 0;
+          return temp;
+        }
+
+      T*
+      operator->() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->().");
+          return get();
+        }
+
+      // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+      // causes internal compiler errors for some MSVC versions.  (It's not
+      // clear to me whether it should be needed.)
+#ifndef _MSC_VER
+      template <class U, class V>
+      U&
+      operator->*(U V::* aMember)
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator->*().");
+          return get()->*aMember;
+        }
+#endif
+
+      nsAutoPtr<T>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsAutoPtr<T>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+      T&
+      operator*() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoPtr with operator*().");
+          return *get();
+        }
+
+      T**
+      StartAssignment()
+        {
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+          return reinterpret_cast<T**>(begin_assignment());
+#else
+          assign(0);
+          return reinterpret_cast<T**>(&mRawPtr);
+#endif
+        }
+  };
+
+template <class T>
+inline
+nsAutoPtr<T>*
+address_of( nsAutoPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+inline
+const nsAutoPtr<T>*
+address_of( const nsAutoPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+class nsAutoPtrGetterTransfers
+    /*
+      ...
+
+      This class is designed to be used for anonymous temporary objects in the
+      argument list of calls that return COM interface pointers, e.g.,
+
+        nsAutoPtr<IFoo> fooP;
+        ...->GetTransferedPointer(getter_Transfers(fooP))
+
+      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+
+      When initialized with a |nsAutoPtr|, as in the example above, it returns
+      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+      outer call (|GetTransferedPointer| in this case) can fill in.
+
+      This type should be a nested class inside |nsAutoPtr<T>|.
+    */
+  {
+    public:
+      explicit
+      nsAutoPtrGetterTransfers( nsAutoPtr<T>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+
+      operator T**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      T*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsAutoPtr<T>& mTargetSmartPtr;
+  };
+
+template <class T>
+inline
+nsAutoPtrGetterTransfers<T>
+getter_Transfers( nsAutoPtr<T>& aSmartPtr )
+    /*
+      Used around a |nsAutoPtr| when 
+      ...makes the class |nsAutoPtrGetterTransfers<T>| invisible.
+    */
+  {
+    return nsAutoPtrGetterTransfers<T>(aSmartPtr);
+  }
+
+
+
+  // Comparing two |nsAutoPtr|s
+
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+  }
+
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, const nsAutoPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+  }
+
+
+  // Comparing an |nsAutoPtr| to a raw pointer
+
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsAutoPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsAutoPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+
+  // To avoid ambiguities caused by the presence of builtin |operator==|s
+  // creating a situation where one of the |operator==| defined above
+  // has a better conversion for one argument and the builtin has a
+  // better conversion for the other argument, define additional
+  // |operator==| without the |const| on the raw pointer.
+  // See bug 65664 for details.
+
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsAutoPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsAutoPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+#endif
+
+
+
+  // Comparing an |nsAutoPtr| to |0|
+
+template <class T>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+template <class T>
+inline
+bool
+operator!=( const nsAutoPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr != 0|
+  {
+    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsAutoPtr<T>& rhs )
+    // specifically to allow |0 != smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+  }
+
+
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+
+  // We need to explicitly define comparison operators for `int'
+  // because the compiler is lame.
+
+template <class T>
+inline
+bool
+operator==( const nsAutoPtr<T>& lhs, int rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( int lhs, const nsAutoPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+
+/*****************************************************************************/
+
+// template <class T> class nsAutoArrayPtrGetterTransfers;
+
+template <class T>
+class nsAutoArrayPtr
+  {
+    private:
+      void**
+      begin_assignment()
+        {
+          assign(0);
+          return reinterpret_cast<void**>(&mRawPtr);
+        }
+
+      void
+      assign( T* newPtr )
+        {
+          T* oldPtr = mRawPtr;
+          mRawPtr = newPtr;
+          delete [] oldPtr;
+        }
+
+    private:
+      T* mRawPtr;
+
+    public:
+      typedef T element_type;
+      
+     ~nsAutoArrayPtr()
+        {
+          delete [] mRawPtr;
+        }
+
+        // Constructors
+
+      nsAutoArrayPtr()
+            : mRawPtr(0)
+          // default constructor
+        {
+        }
+
+      nsAutoArrayPtr( T* aRawPtr )
+            : mRawPtr(aRawPtr)
+          // construct from a raw pointer (of the right type)
+        {
+        }
+
+      nsAutoArrayPtr( nsAutoArrayPtr<T>& aSmartPtr )
+            : mRawPtr( aSmartPtr.forget() )
+          // Construct by transferring ownership from another smart pointer.
+        {
+        }
+
+
+        // Assignment operators
+
+      nsAutoArrayPtr<T>&
+      operator=( T* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign(rhs);
+          return *this;
+        }
+
+      nsAutoArrayPtr<T>& operator=( nsAutoArrayPtr<T>& rhs )
+          // assign by transferring ownership from another smart pointer.
+        {
+          assign(rhs.forget());
+          return *this;
+        }
+
+        // Other pointer operators
+
+      T*
+      get() const
+          /*
+            Prefer the implicit conversion provided automatically by
+            |operator T*() const|.  Use |get()| _only_ to resolve
+            ambiguity.
+          */
+        {
+          return mRawPtr;
+        }
+
+      operator T*() const
+          /*
+            ...makes an |nsAutoArrayPtr| act like its underlying raw pointer
+            type  whenever it is used in a context where a raw pointer
+            is expected.  It is this operator that makes an |nsAutoArrayPtr|
+            substitutable for a raw pointer.
+
+            Prefer the implicit use of this operator to calling |get()|,
+            except where necessary to resolve ambiguity.
+          */
+        {
+          return get();
+        }
+
+      T*
+      forget()
+        {
+          T* temp = mRawPtr;
+          mRawPtr = 0;
+          return temp;
+        }
+
+      T*
+      operator->() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator->().");
+          return get();
+        }
+
+      nsAutoArrayPtr<T>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsAutoArrayPtr<T>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+      T&
+      operator*() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsAutoArrayPtr with operator*().");
+          return *get();
+        }
+
+      T**
+      StartAssignment()
+        {
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+          return reinterpret_cast<T**>(begin_assignment());
+#else
+          assign(0);
+          return reinterpret_cast<T**>(&mRawPtr);
+#endif
+        }
+
+      size_t
+      SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+        {
+          return aMallocSizeOf(mRawPtr);
+        }
+
+      size_t
+      SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
+        {
+          return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
+        }
+  };
+
+template <class T>
+inline
+nsAutoArrayPtr<T>*
+address_of( nsAutoArrayPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+inline
+const nsAutoArrayPtr<T>*
+address_of( const nsAutoArrayPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+class nsAutoArrayPtrGetterTransfers
+    /*
+      ...
+
+      This class is designed to be used for anonymous temporary objects in the
+      argument list of calls that return COM interface pointers, e.g.,
+
+        nsAutoArrayPtr<IFoo> fooP;
+        ...->GetTransferedPointer(getter_Transfers(fooP))
+
+      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_Transfers()| instead.
+
+      When initialized with a |nsAutoArrayPtr|, as in the example above, it returns
+      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+      outer call (|GetTransferedPointer| in this case) can fill in.
+
+      This type should be a nested class inside |nsAutoArrayPtr<T>|.
+    */
+  {
+    public:
+      explicit
+      nsAutoArrayPtrGetterTransfers( nsAutoArrayPtr<T>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+
+      operator T**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      T*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsAutoArrayPtr<T>& mTargetSmartPtr;
+  };
+
+template <class T>
+inline
+nsAutoArrayPtrGetterTransfers<T>
+getter_Transfers( nsAutoArrayPtr<T>& aSmartPtr )
+    /*
+      Used around a |nsAutoArrayPtr| when 
+      ...makes the class |nsAutoArrayPtrGetterTransfers<T>| invisible.
+    */
+  {
+    return nsAutoArrayPtrGetterTransfers<T>(aSmartPtr);
+  }
+
+
+
+  // Comparing two |nsAutoArrayPtr|s
+
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+  }
+
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, const nsAutoArrayPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+  }
+
+
+  // Comparing an |nsAutoArrayPtr| to a raw pointer
+
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsAutoArrayPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsAutoArrayPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+
+  // To avoid ambiguities caused by the presence of builtin |operator==|s
+  // creating a situation where one of the |operator==| defined above
+  // has a better conversion for one argument and the builtin has a
+  // better conversion for the other argument, define additional
+  // |operator==| without the |const| on the raw pointer.
+  // See bug 65664 for details.
+
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsAutoArrayPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsAutoArrayPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+#endif
+
+
+
+  // Comparing an |nsAutoArrayPtr| to |0|
+
+template <class T>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+template <class T>
+inline
+bool
+operator!=( const nsAutoArrayPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr != 0|
+  {
+    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsAutoArrayPtr<T>& rhs )
+    // specifically to allow |0 != smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+  }
+
+
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+
+  // We need to explicitly define comparison operators for `int'
+  // because the compiler is lame.
+
+template <class T>
+inline
+bool
+operator==( const nsAutoArrayPtr<T>& lhs, int rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( int lhs, const nsAutoArrayPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+
+
+/*****************************************************************************/
+
+// template <class T> class nsRefPtrGetterAddRefs;
+
+template <class T>
+class nsRefPtr
+  {
+    private:
+
+      void
+      assign_with_AddRef( T* rawPtr )
+        {
+          if ( rawPtr )
+            rawPtr->AddRef();
+          assign_assuming_AddRef(rawPtr);
+        }
+
+      void**
+      begin_assignment()
+        {
+          assign_assuming_AddRef(0);
+          return reinterpret_cast<void**>(&mRawPtr);
+        }
+
+      void
+      assign_assuming_AddRef( T* newPtr )
+        {
+          T* oldPtr = mRawPtr;
+          mRawPtr = newPtr;
+          if ( oldPtr )
+            oldPtr->Release();
+        }
+
+    private:
+      T* mRawPtr;
+
+    public:
+      typedef T element_type;
+      
+     ~nsRefPtr()
+        {
+          if ( mRawPtr )
+            mRawPtr->Release();
+        }
+
+        // Constructors
+
+      nsRefPtr()
+            : mRawPtr(0)
+          // default constructor
+        {
+        }
+
+      nsRefPtr(const nsRefPtr<T>& aSmartPtr)
+            : mRawPtr(aSmartPtr.mRawPtr)
+          // copy-constructor
+        {
+          if ( mRawPtr )
+            mRawPtr->AddRef();
+        }
+
+      nsRefPtr(nsRefPtr<T>&& aRefPtr)
+            : mRawPtr(aRefPtr.mRawPtr)
+        {
+          aRefPtr.mRawPtr = nullptr;
+        }
+
+      // construct from a raw pointer (of the right type)
+
+      nsRefPtr(T* aRawPtr)
+        : mRawPtr(aRawPtr)
+        {
+          if ( mRawPtr )
+            mRawPtr->AddRef();
+        }
+
+      template <typename I>
+      nsRefPtr( already_AddRefed<I>& aSmartPtr )
+            : mRawPtr(aSmartPtr.take())
+          // construct from |already_AddRefed|
+        {
+        }
+
+      template <typename I>
+      nsRefPtr( already_AddRefed<I>&& aSmartPtr )
+            : mRawPtr(aSmartPtr.take())
+          // construct from |otherRefPtr.forget()|
+        {
+        }
+
+      nsRefPtr( const nsCOMPtr_helper& helper )
+        {
+          void* newRawPtr;
+          if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+            newRawPtr = 0;
+          mRawPtr = static_cast<T*>(newRawPtr);
+        }
+
+        // Assignment operators
+
+      nsRefPtr<T>&
+      operator=(const nsRefPtr<T>& rhs)
+          // copy assignment operator
+        {
+          assign_with_AddRef(rhs.mRawPtr);
+          return *this;
+        }
+
+      nsRefPtr<T>&
+      operator=( T* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign_with_AddRef(rhs);
+          return *this;
+        }
+
+      template <typename I>
+      nsRefPtr<T>&
+      operator=( already_AddRefed<I>& rhs )
+          // assign from |already_AddRefed|
+        {
+          assign_assuming_AddRef(rhs.take());
+          return *this;
+        }
+
+      template <typename I>
+      nsRefPtr<T>&
+      operator=( already_AddRefed<I>&& rhs )
+          // assign from |otherRefPtr.forget()|
+        {
+          assign_assuming_AddRef(rhs.take());
+          return *this;
+        }
+
+      nsRefPtr<T>&
+      operator=( const nsCOMPtr_helper& helper )
+        {
+          void* newRawPtr;
+          if (NS_FAILED(helper(NS_GET_TEMPLATE_IID(T), &newRawPtr)))
+            newRawPtr = 0;
+          assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+          return *this;
+        }
+
+      nsRefPtr<T>&
+      operator=(nsRefPtr<T>&& aRefPtr)
+      {
+        assign_assuming_AddRef(aRefPtr.mRawPtr);
+        aRefPtr.mRawPtr = nullptr;
+        return *this;
+      }
+
+        // Other pointer operators
+
+      void
+      swap( nsRefPtr<T>& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          T* temp = rhs.mRawPtr;
+          rhs.mRawPtr = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      void
+      swap( T*& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          T* temp = rhs;
+          rhs = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      already_AddRefed<T>
+      forget()
+          // return the value of mRawPtr and null out mRawPtr. Useful for
+          // already_AddRefed return values.
+        {
+          T* temp = 0;
+          swap(temp);
+          return already_AddRefed<T>(temp);
+        }
+
+      template <typename I>
+      void
+      forget( I** rhs)
+          // Set the target of rhs to the value of mRawPtr and null out mRawPtr.
+          // Useful to avoid unnecessary AddRef/Release pairs with "out"
+          // parameters where rhs bay be a T** or an I** where I is a base class
+          // of T.
+        {
+          NS_ASSERTION(rhs, "Null pointer passed to forget!");
+          *rhs = mRawPtr;
+          mRawPtr = 0;
+        }
+
+      T*
+      get() const
+          /*
+            Prefer the implicit conversion provided automatically by |operator T*() const|.
+            Use |get()| to resolve ambiguity or to get a castable pointer.
+          */
+        {
+          return const_cast<T*>(mRawPtr);
+        }
+
+      operator T*() const
+          /*
+            ...makes an |nsRefPtr| act like its underlying raw pointer type whenever it
+            is used in a context where a raw pointer is expected.  It is this operator
+            that makes an |nsRefPtr| substitutable for a raw pointer.
+
+            Prefer the implicit use of this operator to calling |get()|, except where
+            necessary to resolve ambiguity.
+          */
+        {
+          return get();
+        }
+
+      T*
+      operator->() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->().");
+          return get();
+        }
+
+      // This operator is needed for gcc <= 4.0.* and for Sun Studio; it
+      // causes internal compiler errors for some MSVC versions.  (It's not
+      // clear to me whether it should be needed.)
+#ifndef _MSC_VER
+      template <class U, class V>
+      U&
+      operator->*(U V::* aMember)
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator->*().");
+          return get()->*aMember;
+        }
+#endif
+
+      nsRefPtr<T>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsRefPtr<T>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+      T&
+      operator*() const
+        {
+          NS_PRECONDITION(mRawPtr != 0, "You can't dereference a NULL nsRefPtr with operator*().");
+          return *get();
+        }
+
+      T**
+      StartAssignment()
+        {
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+          return reinterpret_cast<T**>(begin_assignment());
+#else
+          assign_assuming_AddRef(0);
+          return reinterpret_cast<T**>(&mRawPtr);
+#endif
+        }
+  };
+
+template <typename T>
+inline void
+ImplCycleCollectionUnlink(nsRefPtr<T>& aField)
+{
+  aField = nullptr;
+}
+
+template <typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsRefPtr<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+
+template <class T>
+inline
+nsRefPtr<T>*
+address_of( nsRefPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+inline
+const nsRefPtr<T>*
+address_of( const nsRefPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+class nsRefPtrGetterAddRefs
+    /*
+      ...
+
+      This class is designed to be used for anonymous temporary objects in the
+      argument list of calls that return COM interface pointers, e.g.,
+
+        nsRefPtr<IFoo> fooP;
+        ...->GetAddRefedPointer(getter_AddRefs(fooP))
+
+      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
+
+      When initialized with a |nsRefPtr|, as in the example above, it returns
+      a |void**|, a |T**|, or an |nsISupports**| as needed, that the
+      outer call (|GetAddRefedPointer| in this case) can fill in.
+
+      This type should be a nested class inside |nsRefPtr<T>|.
+    */
+  {
+    public:
+      explicit
+      nsRefPtrGetterAddRefs( nsRefPtr<T>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+
+      operator T**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      T*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsRefPtr<T>& mTargetSmartPtr;
+  };
+
+template <class T>
+inline
+nsRefPtrGetterAddRefs<T>
+getter_AddRefs( nsRefPtr<T>& aSmartPtr )
+    /*
+      Used around a |nsRefPtr| when 
+      ...makes the class |nsRefPtrGetterAddRefs<T>| invisible.
+    */
+  {
+    return nsRefPtrGetterAddRefs<T>(aSmartPtr);
+  }
+
+
+
+  // Comparing two |nsRefPtr|s
+
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+  }
+
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, const nsRefPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+  }
+
+
+  // Comparing an |nsRefPtr| to a raw pointer
+
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsRefPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsRefPtr<T>& rhs )
+  {
+    return static_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+
+  // To avoid ambiguities caused by the presence of builtin |operator==|s
+  // creating a situation where one of the |operator==| defined above
+  // has a better conversion for one argument and the builtin has a
+  // better conversion for the other argument, define additional
+  // |operator==| without the |const| on the raw pointer.
+  // See bug 65664 for details.
+
+#ifndef NSCAP_DONT_PROVIDE_NONCONST_OPEQ
+template <class T, class U>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( U* lhs, const nsRefPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != const_cast<const U*>(rhs);
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( U* lhs, const nsRefPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+#endif
+
+
+
+  // Comparing an |nsRefPtr| to |0|
+
+template <class T>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+template <class T>
+inline
+bool
+operator!=( const nsRefPtr<T>& lhs, NSCAP_Zero* rhs )
+    // specifically to allow |smartPtr != 0|
+  {
+    return static_cast<const void*>(lhs.get()) != reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator!=( NSCAP_Zero* lhs, const nsRefPtr<T>& rhs )
+    // specifically to allow |0 != smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) != static_cast<const void*>(rhs.get());
+  }
+
+
+#ifdef HAVE_CPP_TROUBLE_COMPARING_TO_ZERO
+
+  // We need to explicitly define comparison operators for `int'
+  // because the compiler is lame.
+
+template <class T>
+inline
+bool
+operator==( const nsRefPtr<T>& lhs, int rhs )
+    // specifically to allow |smartPtr == 0|
+  {
+    return static_cast<const void*>(lhs.get()) == reinterpret_cast<const void*>(rhs);
+  }
+
+template <class T>
+inline
+bool
+operator==( int lhs, const nsRefPtr<T>& rhs )
+    // specifically to allow |0 == smartPtr|
+  {
+    return reinterpret_cast<const void*>(lhs) == static_cast<const void*>(rhs.get());
+  }
+
+#endif // !defined(HAVE_CPP_TROUBLE_COMPARING_TO_ZERO)
+
+template <class SourceType, class DestinationType>
+inline
+nsresult
+CallQueryInterface( nsRefPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr )
+  {
+    return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+  }
+
+/*****************************************************************************/
+
+template<class T>
+class nsQueryObject : public nsCOMPtr_helper
+{
+public:
+  nsQueryObject(T* aRawPtr)
+    : mRawPtr(aRawPtr) {}
+
+  virtual nsresult NS_FASTCALL operator()( const nsIID& aIID, void** aResult ) const {
+    nsresult status = mRawPtr ? mRawPtr->QueryInterface(aIID, aResult)
+                              : NS_ERROR_NULL_POINTER;
+    return status;
+  }
+private:
+  T* mRawPtr;
+};
+
+template<class T>
+class nsQueryObjectWithError : public nsCOMPtr_helper
+{
+public:
+  nsQueryObjectWithError(T* aRawPtr, nsresult* aErrorPtr)
+    : mRawPtr(aRawPtr), mErrorPtr(aErrorPtr) {}
+
+  virtual nsresult NS_FASTCALL operator()( const nsIID& aIID, void** aResult ) const {
+    nsresult status = mRawPtr ? mRawPtr->QueryInterface(aIID, aResult)
+                              : NS_ERROR_NULL_POINTER;
+    if (mErrorPtr)
+      *mErrorPtr = status;
+    return status;
+  }
+private:
+  T* mRawPtr;
+  nsresult* mErrorPtr;
+};
+
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(T* aRawPtr)
+{
+  return nsQueryObject<T>(aRawPtr);
+}
+
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(nsCOMPtr<T>& aRawPtr)
+{
+  return nsQueryObject<T>(aRawPtr);
+}
+
+template<class T>
+inline
+nsQueryObject<T>
+do_QueryObject(nsRefPtr<T>& aRawPtr)
+{
+  return nsQueryObject<T>(aRawPtr);
+}
+
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(T* aRawPtr, nsresult* aErrorPtr)
+{
+  return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(nsCOMPtr<T>& aRawPtr, nsresult* aErrorPtr)
+{
+  return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+
+template<class T>
+inline
+nsQueryObjectWithError<T>
+do_QueryObject(nsRefPtr<T>& aRawPtr, nsresult* aErrorPtr)
+{
+  return nsQueryObjectWithError<T>(aRawPtr, aErrorPtr);
+}
+
+/*****************************************************************************/
+
+#endif // !defined(nsAutoPtr_h___)