diff -r 000000000000 -r 6474c204b198 xpcom/glue/nsCOMPtr.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xpcom/glue/nsCOMPtr.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,1661 @@
+/* -*- 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 nsCOMPtr_h___
+#define nsCOMPtr_h___
+
+/*
+  Having problems?
+  
+  See the User Manual at:
+    http://www.mozilla.org/projects/xpcom/nsCOMPtr.html
+
+
+  nsCOMPtr
+    better than a raw pointer
+  for owning objects
+                       -- scc
+*/
+
+#include "mozilla/Attributes.h"
+#include "mozilla/TypeTraits.h"
+#include "mozilla/Assertions.h"
+#include "mozilla/NullPtr.h"
+#include "mozilla/Move.h"
+
+#include "nsDebug.h" // for |NS_ABORT_IF_FALSE|, |NS_ASSERTION|
+#include "nsISupportsUtils.h" // for |nsresult|, |NS_ADDREF|, |NS_GET_TEMPLATE_IID| et al
+#include "nscore.h" // for |NS_COM_GLUE|
+
+#include "nsCycleCollectionNoteChild.h"
+
+
+/*
+  WARNING:
+    This file defines several macros for internal use only.  These macros begin with the
+    prefix |NSCAP_|.  Do not use these macros in your own code.  They are for internal use
+    only for cross-platform compatibility, and are subject to change without notice.
+*/
+
+
+#ifdef _MSC_VER
+  #define NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+    // under VC++, we win by inlining StartAssignment
+
+    // Also under VC++, at the highest warning level, we are overwhelmed  with warnings
+    //  about (unused) inline functions being removed.  This is to be expected with
+    //  templates, so we disable the warning.
+  #pragma warning( disable: 4514 )
+#endif
+
+#define NSCAP_FEATURE_USE_BASE
+
+#ifdef DEBUG
+  #define NSCAP_FEATURE_TEST_DONTQUERY_CASES
+  #undef NSCAP_FEATURE_USE_BASE
+//#define NSCAP_FEATURE_TEST_NONNULL_QUERY_SUCCEEDS
+#endif
+
+#ifdef __GNUC__
+  // Our use of nsCOMPtr_base::mRawPtr violates the C++ standard's aliasing
+  // rules. Mark it with the may_alias attribute so that gcc 3.3 and higher
+  // don't reorder instructions based on aliasing assumptions for
+  // this variable.  Fortunately, gcc versions < 3.3 do not do any
+  // optimizations that break nsCOMPtr.
+
+  #define NS_MAY_ALIAS_PTR(t)    t*  __attribute__((__may_alias__))
+#else
+  #define NS_MAY_ALIAS_PTR(t)    t*
+#endif
+
+#if defined(NSCAP_DISABLE_DEBUG_PTR_TYPES)
+  #define NSCAP_FEATURE_USE_BASE
+#endif
+
+  /*
+    The following three macros (|NSCAP_ADDREF|, |NSCAP_RELEASE|, and |NSCAP_LOG_ASSIGNMENT|)
+      allow external clients the ability to add logging or other interesting debug facilities.
+      In fact, if you want |nsCOMPtr| to participate in the standard logging facility, you
+      provide (e.g., in "nsISupportsImpl.h") suitable definitions
+
+        #define NSCAP_ADDREF(this, ptr)         NS_ADDREF(ptr)
+        #define NSCAP_RELEASE(this, ptr)        NS_RELEASE(ptr)
+  */
+
+#ifndef NSCAP_ADDREF
+  #define NSCAP_ADDREF(this, ptr)     (ptr)->AddRef()
+#endif
+
+#ifndef NSCAP_RELEASE
+  #define NSCAP_RELEASE(this, ptr)    (ptr)->Release()
+#endif
+
+  // Clients can define |NSCAP_LOG_ASSIGNMENT| to perform logging.
+#ifdef NSCAP_LOG_ASSIGNMENT
+    // Remember that |NSCAP_LOG_ASSIGNMENT| was defined by some client so that we know
+    //  to instantiate |~nsGetterAddRefs| in turn to note the external assignment into
+    //  the |nsCOMPtr|.
+  #define NSCAP_LOG_EXTERNAL_ASSIGNMENT
+#else
+    // ...otherwise, just strip it out of the code
+  #define NSCAP_LOG_ASSIGNMENT(this, ptr)
+#endif
+
+#ifndef NSCAP_LOG_RELEASE
+  #define NSCAP_LOG_RELEASE(this, ptr)
+#endif
+
+namespace mozilla {
+
+struct unused_t;
+
+} // namespace mozilla
+
+template <class T>
+struct already_AddRefed
+    /*
+      ...cooperates with |nsCOMPtr| to allow you to assign in a pointer _without_
+      |AddRef|ing it.  You might want to use this as a return type from a function
+      that produces an already |AddRef|ed pointer as a result.
+
+      See also |getter_AddRefs()|, |dont_AddRef()|, and |class nsGetterAddRefs|.
+
+      This type should be a nested class inside |nsCOMPtr<T>|.
+
+      Yes, |already_AddRefed| could have been implemented as an |nsCOMPtr_helper| to
+      avoid adding specialized machinery to |nsCOMPtr| ... but this is the simplest
+      case, and perhaps worth the savings in time and space that its specific
+      implementation affords over the more general solution offered by
+      |nsCOMPtr_helper|.
+    */
+  {
+    /*
+     * Prohibit all one-argument overloads but already_AddRefed(T*) and
+     * already_AddRefed(decltype(nullptr)), and funnel the nullptr case through
+     * the T* constructor.
+     */
+    template<typename N>
+    already_AddRefed(N,
+                     typename mozilla::EnableIf<mozilla::IsNullPointer<N>::value,
+                                                int>::Type dummy = 0)
+      : mRawPtr(nullptr)
+    {
+      // nothing else to do here
+    }
+
+    already_AddRefed( T* aRawPtr )
+      : mRawPtr(aRawPtr)
+    {
+      // nothing else to do here
+    }
+
+    // Disallowed.  Use move semantics instead.
+    already_AddRefed(const already_AddRefed<T>& aOther) MOZ_DELETE;
+
+    already_AddRefed(already_AddRefed<T>&& aOther)
+      : mRawPtr(aOther.take())
+    {
+      // nothing else to do here
+    }
+
+    ~already_AddRefed()
+    {
+      MOZ_ASSERT(!mRawPtr);
+    }
+
+    // Specialize the unused operator<< for already_AddRefed, to allow
+    // nsCOMPtr<nsIFoo> foo;
+    // unused << foo.forget();
+    friend void operator<<(const mozilla::unused_t& unused,
+                           const already_AddRefed<T>& rhs)
+    {
+      auto mutableAlreadyAddRefed = const_cast<already_AddRefed<T>*>(&rhs);
+      unused << mutableAlreadyAddRefed->take();
+    }
+
+    MOZ_WARN_UNUSED_RESULT T* take()
+    {
+      T* rawPtr = mRawPtr;
+      mRawPtr = nullptr;
+      return rawPtr;
+    }
+
+    /**
+     * This helper is useful in cases like
+     *
+     *  already_AddRefed<BaseClass>
+     *  Foo()
+     *  {
+     *    nsRefPtr<SubClass> x = ...;
+     *    return x.forget();
+     *  }
+     *
+     * The autoconversion allows one to omit the idiom
+     *
+     *    nsRefPtr<BaseClass> y = x.forget();
+     *    return y.forget();
+     */
+    template<class U>
+    operator already_AddRefed<U>()
+    {
+      U* tmp = mRawPtr;
+      mRawPtr = nullptr;
+      return already_AddRefed<U>(tmp);
+    }
+
+    /**
+     * This helper provides a static_cast replacement for already_AddRefed, so
+     * if you have
+     *
+     *   already_AddRefed<Parent> F();
+     *
+     * you can write
+     *
+     *   already_AddRefed<Child>
+     *   G()
+     *   {
+     *     return F().downcast<Child>();
+     *   }
+     *
+     * instead of
+     *
+     *     return dont_AddRef(static_cast<Child*>(F().get()));
+     */
+    template<class U>
+    already_AddRefed<U> downcast()
+    {
+      U* tmp = static_cast<U*>(mRawPtr);
+      mRawPtr = nullptr;
+      return already_AddRefed<U>(tmp);
+    }
+
+  private:
+    T* mRawPtr;
+  };
+
+template <class T>
+inline
+already_AddRefed<T>
+dont_AddRef( T* aRawPtr )
+  {
+    return already_AddRefed<T>(aRawPtr);
+  }
+
+template <class T>
+inline
+already_AddRefed<T>&&
+dont_AddRef( already_AddRefed<T>&& aAlreadyAddRefedPtr )
+  {
+    return mozilla::Move(aAlreadyAddRefedPtr);
+  }
+
+
+
+class nsCOMPtr_helper
+    /*
+      An |nsCOMPtr_helper| transforms commonly called getters into typesafe forms
+      that are more convenient to call, and more efficient to use with |nsCOMPtr|s.
+      Good candidates for helpers are |QueryInterface()|, |CreateInstance()|, etc.
+
+      Here are the rules for a helper:
+        - it implements |operator()| to produce an interface pointer
+        - (except for its name) |operator()| is a valid [XP]COM `getter'
+        - the interface pointer that it returns is already |AddRef()|ed (as from any good getter)
+        - it matches the type requested with the supplied |nsIID| argument
+        - its constructor provides an optional |nsresult*| that |operator()| can fill
+          in with an error when it is executed
+          
+      See |class nsGetInterface| for an example.
+    */
+  {
+    public:
+      virtual nsresult NS_FASTCALL operator()( const nsIID&, void** ) const = 0;
+  };
+
+/*
+  |nsQueryInterface| could have been implemented as an |nsCOMPtr_helper| to
+  avoid adding specialized machinery in |nsCOMPtr|, But |do_QueryInterface|
+  is called often enough that the codesize savings are big enough to
+  warrant the specialcasing.
+*/
+
+class
+  NS_COM_GLUE
+  MOZ_STACK_CLASS
+nsQueryInterface MOZ_FINAL
+  {
+    public:
+      explicit
+      nsQueryInterface( nsISupports* aRawPtr )
+          : mRawPtr(aRawPtr)
+        {
+          // nothing else to do here
+        }
+
+      nsresult NS_FASTCALL operator()( const nsIID& aIID, void** ) const;
+
+    private:
+      nsISupports*  mRawPtr;
+  };
+
+class NS_COM_GLUE nsQueryInterfaceWithError
+  {
+    public:
+      nsQueryInterfaceWithError( nsISupports* aRawPtr, nsresult* error )
+          : mRawPtr(aRawPtr),
+            mErrorPtr(error)
+        {
+          // nothing else to do here
+        }
+
+      nsresult NS_FASTCALL operator()( const nsIID& aIID, void** ) const;
+
+    private:
+      nsISupports*  mRawPtr;
+      nsresult*     mErrorPtr;
+  };
+
+inline
+nsQueryInterface
+do_QueryInterface( nsISupports* aRawPtr )
+  {
+    return nsQueryInterface(aRawPtr);
+  }
+
+inline
+nsQueryInterfaceWithError
+do_QueryInterface( nsISupports* aRawPtr, nsresult* error )
+  {
+    return nsQueryInterfaceWithError(aRawPtr, error);
+  }
+
+template <class T>
+inline
+void
+do_QueryInterface( already_AddRefed<T>& )
+  {
+    // This signature exists solely to _stop_ you from doing the bad thing.
+    //  Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
+    //  someone else is an automatic leak.  See <http://bugzilla.mozilla.org/show_bug.cgi?id=8221>.
+  }
+
+template <class T>
+inline
+void
+do_QueryInterface( already_AddRefed<T>&, nsresult* )
+  {
+    // This signature exists solely to _stop_ you from doing the bad thing.
+    //  Saying |do_QueryInterface()| on a pointer that is not otherwise owned by
+    //  someone else is an automatic leak.  See <http://bugzilla.mozilla.org/show_bug.cgi?id=8221>.
+  }
+
+
+////////////////////////////////////////////////////////////////////////////
+// Using servicemanager with COMPtrs
+class NS_COM_GLUE nsGetServiceByCID
+{
+ public:
+    explicit nsGetServiceByCID(const nsCID& aCID)
+        : mCID(aCID)
+        {
+            // nothing else to do
+        }
+    
+    nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
+    
+ private:
+    const nsCID&                mCID;
+};
+
+class NS_COM_GLUE nsGetServiceByCIDWithError
+{
+ public:
+    nsGetServiceByCIDWithError( const nsCID& aCID, nsresult* aErrorPtr )
+        : mCID(aCID),
+          mErrorPtr(aErrorPtr)
+        {
+            // nothing else to do
+        }
+    
+    nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
+    
+ private:
+    const nsCID&                mCID;
+    nsresult*                   mErrorPtr;
+};
+
+class NS_COM_GLUE nsGetServiceByContractID
+{
+ public:
+    explicit nsGetServiceByContractID(const char* aContractID)
+        : mContractID(aContractID)
+        {
+            // nothing else to do
+        }
+    
+    nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
+    
+ private:
+    const char*                 mContractID;
+};
+
+class NS_COM_GLUE nsGetServiceByContractIDWithError
+{
+ public:
+    nsGetServiceByContractIDWithError(const char* aContractID, nsresult* aErrorPtr)
+        : mContractID(aContractID),
+          mErrorPtr(aErrorPtr)
+        {
+            // nothing else to do
+        }
+    
+    nsresult NS_FASTCALL operator()( const nsIID&, void** ) const;
+    
+ private:
+    const char*                 mContractID;
+    nsresult*                   mErrorPtr;
+};
+
+class
+nsCOMPtr_base
+    /*
+      ...factors implementation for all template versions of |nsCOMPtr|.
+
+      This should really be an |nsCOMPtr<nsISupports>|, but this wouldn't work
+      because unlike the
+
+      Here's the way people normally do things like this
+      
+        template <class T> class Foo { ... };
+        template <> class Foo<void*> { ... };
+        template <class T> class Foo<T*> : private Foo<void*> { ... };
+    */
+  {
+    public:
+
+      nsCOMPtr_base( nsISupports* rawPtr = 0 )
+          : mRawPtr(rawPtr)
+        {
+          // nothing else to do here
+        }
+
+      NS_COM_GLUE NS_CONSTRUCTOR_FASTCALL ~nsCOMPtr_base()
+        {
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+            if ( mRawPtr )
+              NSCAP_RELEASE(this, mRawPtr);
+        }
+
+      NS_COM_GLUE void NS_FASTCALL   assign_with_AddRef( nsISupports* );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_qi( const nsQueryInterface, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_qi_with_error( const nsQueryInterfaceWithError&, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_gs_cid( const nsGetServiceByCID, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError&, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_gs_contractid( const nsGetServiceByContractID, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError&, const nsIID& );
+      NS_COM_GLUE void NS_FASTCALL   assign_from_helper( const nsCOMPtr_helper&, const nsIID& );
+      NS_COM_GLUE void** NS_FASTCALL begin_assignment();
+
+    protected:
+      NS_MAY_ALIAS_PTR(nsISupports) mRawPtr;
+
+      void
+      assign_assuming_AddRef( nsISupports* newPtr )
+        {
+            /*
+              |AddRef()|ing the new value (before entering this function) before
+              |Release()|ing the old lets us safely ignore the self-assignment case.
+              We must, however, be careful only to |Release()| _after_ doing the
+              assignment, in case the |Release()| leads to our _own_ destruction,
+              which would, in turn, cause an incorrect second |Release()| of our old
+              pointer.  Thank <waterson@netscape.com> for discovering this.
+            */
+          nsISupports* oldPtr = mRawPtr;
+          mRawPtr = newPtr;
+          NSCAP_LOG_ASSIGNMENT(this, newPtr);
+          NSCAP_LOG_RELEASE(this, oldPtr);
+          if ( oldPtr )
+            NSCAP_RELEASE(this, oldPtr);
+        }
+  };
+
+// template <class T> class nsGetterAddRefs;
+
+template <class T>
+class nsCOMPtr MOZ_FINAL
+#ifdef NSCAP_FEATURE_USE_BASE
+    : private nsCOMPtr_base
+#endif
+  {
+
+#ifdef NSCAP_FEATURE_USE_BASE
+  #define NSCAP_CTOR_BASE(x) nsCOMPtr_base(x)
+#else
+  #define NSCAP_CTOR_BASE(x) mRawPtr(x)
+
+    private:
+      void    assign_with_AddRef( nsISupports* );
+      void    assign_from_qi( const nsQueryInterface, const nsIID& );
+      void    assign_from_qi_with_error( const nsQueryInterfaceWithError&, const nsIID& );
+      void    assign_from_gs_cid( const nsGetServiceByCID, const nsIID& );
+      void    assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError&, const nsIID& );
+      void    assign_from_gs_contractid( const nsGetServiceByContractID, const nsIID& );
+      void    assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError&, const nsIID& );
+      void    assign_from_helper( const nsCOMPtr_helper&, const nsIID& );
+      void**  begin_assignment();
+
+      void
+      assign_assuming_AddRef( T* newPtr )
+        {
+          T* oldPtr = mRawPtr;
+          mRawPtr = newPtr;
+          NSCAP_LOG_ASSIGNMENT(this, newPtr);
+          NSCAP_LOG_RELEASE(this, oldPtr);
+          if ( oldPtr )
+            NSCAP_RELEASE(this, oldPtr);
+        }
+
+    private:
+      T* mRawPtr;
+#endif
+
+    public:
+      typedef T element_type;
+      
+#ifndef NSCAP_FEATURE_USE_BASE
+     ~nsCOMPtr()
+        {
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          if ( mRawPtr )
+            NSCAP_RELEASE(this, mRawPtr);
+        }
+#endif
+
+#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
+      void
+      Assert_NoQueryNeeded()
+        {
+          if ( mRawPtr )
+            {
+              nsCOMPtr<T> query_result( do_QueryInterface(mRawPtr) );
+              NS_ASSERTION(query_result.get() == mRawPtr, "QueryInterface needed");
+            }
+        }
+
+  #define NSCAP_ASSERT_NO_QUERY_NEEDED() Assert_NoQueryNeeded();
+#else
+  #define NSCAP_ASSERT_NO_QUERY_NEEDED()
+#endif
+
+
+        // Constructors
+
+      nsCOMPtr()
+            : NSCAP_CTOR_BASE(0)
+          // default constructor
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+        }
+
+      nsCOMPtr( const nsCOMPtr<T>& aSmartPtr )
+            : NSCAP_CTOR_BASE(aSmartPtr.mRawPtr)
+          // copy-constructor
+        {
+          if ( mRawPtr )
+            NSCAP_ADDREF(this, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
+        }
+
+      nsCOMPtr( T* aRawPtr )
+            : NSCAP_CTOR_BASE(aRawPtr)
+          // construct from a raw pointer (of the right type)
+        {
+          if ( mRawPtr )
+            NSCAP_ADDREF(this, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+      nsCOMPtr( already_AddRefed<T>& aSmartPtr )
+            : NSCAP_CTOR_BASE(aSmartPtr.take())
+          // construct from |already_AddRefed|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+      nsCOMPtr( already_AddRefed<T>&& aSmartPtr )
+            : NSCAP_CTOR_BASE(aSmartPtr.take())
+          // construct from |otherComPtr.forget()|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+      template<typename U>
+      nsCOMPtr( already_AddRefed<U>& aSmartPtr )
+            : NSCAP_CTOR_BASE(static_cast<T*>(aSmartPtr.take()))
+          // construct from |already_AddRefed|
+        {
+          // But make sure that U actually inherits from T
+          static_assert(mozilla::IsBaseOf<T, U>::value,
+                        "U is not a subclass of T");
+          NSCAP_LOG_ASSIGNMENT(this, static_cast<T*>(mRawPtr));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+      template<typename U>
+      nsCOMPtr( already_AddRefed<U>&& aSmartPtr )
+            : NSCAP_CTOR_BASE(static_cast<T*>(aSmartPtr.take()))
+          // construct from |otherComPtr.forget()|
+        {
+          // But make sure that U actually inherits from T
+          static_assert(mozilla::IsBaseOf<T, U>::value,
+                        "U is not a subclass of T");
+          NSCAP_LOG_ASSIGNMENT(this, static_cast<T*>(mRawPtr));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+      nsCOMPtr( const nsQueryInterface qi )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_QueryInterface(expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_qi(qi, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsQueryInterfaceWithError& qi )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_QueryInterface(expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_qi_with_error(qi, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsGetServiceByCID gs )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_GetService(cid_expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_cid(gs, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsGetServiceByCIDWithError& gs )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_GetService(cid_expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_cid_with_error(gs, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsGetServiceByContractID gs )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_GetService(contractid_expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_contractid(gs, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsGetServiceByContractIDWithError& gs )
+            : NSCAP_CTOR_BASE(0)
+          // construct from |do_GetService(contractid_expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_contractid_with_error(gs, NS_GET_TEMPLATE_IID(T));
+        }
+
+      nsCOMPtr( const nsCOMPtr_helper& helper )
+            : NSCAP_CTOR_BASE(0)
+          // ...and finally, anything else we might need to construct from
+          //  can exploit the |nsCOMPtr_helper| facility
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_helper(helper, NS_GET_TEMPLATE_IID(T));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+
+        // Assignment operators
+
+      nsCOMPtr<T>&
+      operator=( const nsCOMPtr<T>& rhs )
+          // copy assignment operator
+        {
+          assign_with_AddRef(rhs.mRawPtr);
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( T* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign_with_AddRef(rhs);
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+          return *this;
+        }
+
+      template<typename U>
+      nsCOMPtr<T>&
+      operator=( already_AddRefed<U>& rhs )
+          // assign from |already_AddRefed|
+        {
+          // Make sure that U actually inherits from T
+          static_assert(mozilla::IsBaseOf<T, U>::value,
+                        "U is not a subclass of T");
+          assign_assuming_AddRef(static_cast<T*>(rhs.take()));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+          return *this;
+        }
+
+      template<typename U>
+      nsCOMPtr<T>&
+      operator=( already_AddRefed<U>&& rhs )
+          // assign from |otherComPtr.forget()|
+        {
+          // Make sure that U actually inherits from T
+          static_assert(mozilla::IsBaseOf<T, U>::value,
+                        "U is not a subclass of T");
+          assign_assuming_AddRef(static_cast<T*>(rhs.take()));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsQueryInterface rhs )
+          // assign from |do_QueryInterface(expr)|
+        {
+          assign_from_qi(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsQueryInterfaceWithError& rhs )
+          // assign from |do_QueryInterface(expr, &rv)|
+        {
+          assign_from_qi_with_error(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsGetServiceByCID rhs )
+          // assign from |do_GetService(cid_expr)|
+        {
+          assign_from_gs_cid(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsGetServiceByCIDWithError& rhs )
+          // assign from |do_GetService(cid_expr, &rv)|
+        {
+          assign_from_gs_cid_with_error(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsGetServiceByContractID rhs )
+          // assign from |do_GetService(contractid_expr)|
+        {
+          assign_from_gs_contractid(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsGetServiceByContractIDWithError& rhs )
+          // assign from |do_GetService(contractid_expr, &rv)|
+        {
+          assign_from_gs_contractid_with_error(rhs, NS_GET_TEMPLATE_IID(T));
+          return *this;
+        }
+
+      nsCOMPtr<T>&
+      operator=( const nsCOMPtr_helper& rhs )
+          // ...and finally, anything else we might need to assign from
+          //  can exploit the |nsCOMPtr_helper| facility.
+        {
+          assign_from_helper(rhs, NS_GET_TEMPLATE_IID(T));
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+          return *this;
+        }
+
+      void
+      swap( nsCOMPtr<T>& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+#ifdef NSCAP_FEATURE_USE_BASE
+          nsISupports* temp = rhs.mRawPtr;
+#else
+          T* temp = rhs.mRawPtr;
+#endif
+          NSCAP_LOG_ASSIGNMENT(&rhs, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, temp);
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          NSCAP_LOG_RELEASE(&rhs, temp);
+          rhs.mRawPtr = mRawPtr;
+          mRawPtr = temp;
+          // |rhs| maintains the same invariants, so we don't need to |NSCAP_ASSERT_NO_QUERY_NEEDED|
+        }
+
+      void
+      swap( T*& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+#ifdef NSCAP_FEATURE_USE_BASE
+          nsISupports* temp = rhs;
+#else
+          T* temp = rhs;
+#endif
+          NSCAP_LOG_ASSIGNMENT(this, temp);
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          rhs = reinterpret_cast<T*>(mRawPtr);
+          mRawPtr = temp;
+          NSCAP_ASSERT_NO_QUERY_NEEDED();
+        }
+
+
+        // Other pointer operators
+
+      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!");
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          *rhs = get();
+          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 reinterpret_cast<T*>(mRawPtr);
+        }
+
+      operator T*() const
+          /*
+            ...makes an |nsCOMPtr| 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 |nsCOMPtr| 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_ABORT_IF_FALSE(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator->().");
+          return get();
+        }
+
+      nsCOMPtr<T>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsCOMPtr<T>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+      T&
+      operator*() const
+        {
+          NS_ABORT_IF_FALSE(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr 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
+        }
+  };
+
+
+
+  /*
+    Specializing |nsCOMPtr| for |nsISupports| allows us to use |nsCOMPtr<nsISupports>| the
+    same way people use |nsISupports*| and |void*|, i.e., as a `catch-all' pointer pointing
+    to any valid [XP]COM interface.  Otherwise, an |nsCOMPtr<nsISupports>| would only be able
+    to point to the single [XP]COM-correct |nsISupports| instance within an object; extra
+    querying ensues.  Clients need to be able to pass around arbitrary interface pointers,
+    without hassles, through intermediary code that doesn't know the exact type.
+  */
+
+template <>
+class nsCOMPtr<nsISupports>
+    : private nsCOMPtr_base
+  {
+    public:
+      typedef nsISupports element_type;
+
+        // Constructors
+
+      nsCOMPtr()
+            : nsCOMPtr_base(0)
+          // default constructor
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+        }
+
+      nsCOMPtr( const nsCOMPtr<nsISupports>& aSmartPtr )
+            : nsCOMPtr_base(aSmartPtr.mRawPtr)
+          // copy constructor
+        {
+          if ( mRawPtr )
+            NSCAP_ADDREF(this, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, aSmartPtr.mRawPtr);
+        }
+
+      nsCOMPtr( nsISupports* aRawPtr )
+            : nsCOMPtr_base(aRawPtr)
+          // construct from a raw pointer (of the right type)
+        {
+          if ( mRawPtr )
+            NSCAP_ADDREF(this, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, aRawPtr);
+        }
+
+      nsCOMPtr( already_AddRefed<nsISupports>& aSmartPtr )
+            : nsCOMPtr_base(aSmartPtr.take())
+          // construct from |already_AddRefed|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
+        }
+
+      nsCOMPtr( already_AddRefed<nsISupports>&& aSmartPtr )
+            : nsCOMPtr_base(aSmartPtr.take())
+          // construct from |otherComPtr.forget()|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
+        }
+
+      nsCOMPtr( const nsQueryInterface qi )
+            : nsCOMPtr_base(0)
+          // assign from |do_QueryInterface(expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_qi(qi, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsQueryInterfaceWithError& qi )
+            : nsCOMPtr_base(0)
+          // assign from |do_QueryInterface(expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_qi_with_error(qi, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsGetServiceByCID gs )
+            : nsCOMPtr_base(0)
+          // assign from |do_GetService(cid_expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_cid(gs, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsGetServiceByCIDWithError& gs )
+            : nsCOMPtr_base(0)
+          // assign from |do_GetService(cid_expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_cid_with_error(gs, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsGetServiceByContractID gs )
+            : nsCOMPtr_base(0)
+          // assign from |do_GetService(contractid_expr)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_contractid(gs, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsGetServiceByContractIDWithError& gs )
+            : nsCOMPtr_base(0)
+          // assign from |do_GetService(contractid_expr, &rv)|
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_gs_contractid_with_error(gs, NS_GET_IID(nsISupports));
+        }
+
+      nsCOMPtr( const nsCOMPtr_helper& helper )
+            : nsCOMPtr_base(0)
+          // ...and finally, anything else we might need to construct from
+          //  can exploit the |nsCOMPtr_helper| facility
+        {
+          NSCAP_LOG_ASSIGNMENT(this, 0);
+          assign_from_helper(helper, NS_GET_IID(nsISupports));
+        }
+
+
+        // Assignment operators
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsCOMPtr<nsISupports>& rhs )
+          // copy assignment operator
+        {
+          assign_with_AddRef(rhs.mRawPtr);
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( nsISupports* rhs )
+          // assign from a raw pointer (of the right type)
+        {
+          assign_with_AddRef(rhs);
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( already_AddRefed<nsISupports>& rhs )
+          // assign from |already_AddRefed|
+        {
+          assign_assuming_AddRef(rhs.take());
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( already_AddRefed<nsISupports>&& rhs )
+          // assign from |otherComPtr.forget()|
+        {
+          assign_assuming_AddRef(rhs.take());
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsQueryInterface rhs )
+          // assign from |do_QueryInterface(expr)|
+        {
+          assign_from_qi(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsQueryInterfaceWithError& rhs )
+          // assign from |do_QueryInterface(expr, &rv)|
+        {
+          assign_from_qi_with_error(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsGetServiceByCID rhs )
+          // assign from |do_GetService(cid_expr)|
+        {
+          assign_from_gs_cid(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsGetServiceByCIDWithError& rhs )
+          // assign from |do_GetService(cid_expr, &rv)|
+        {
+          assign_from_gs_cid_with_error(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsGetServiceByContractID rhs )
+          // assign from |do_GetService(contractid_expr)|
+        {
+          assign_from_gs_contractid(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsGetServiceByContractIDWithError& rhs )
+          // assign from |do_GetService(contractid_expr, &rv)|
+        {
+          assign_from_gs_contractid_with_error(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      nsCOMPtr<nsISupports>&
+      operator=( const nsCOMPtr_helper& rhs )
+          // ...and finally, anything else we might need to assign from
+          //  can exploit the |nsCOMPtr_helper| facility.
+        {
+          assign_from_helper(rhs, NS_GET_IID(nsISupports));
+          return *this;
+        }
+
+      void
+      swap( nsCOMPtr<nsISupports>& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          nsISupports* temp = rhs.mRawPtr;
+          NSCAP_LOG_ASSIGNMENT(&rhs, mRawPtr);
+          NSCAP_LOG_ASSIGNMENT(this, temp);
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          NSCAP_LOG_RELEASE(&rhs, temp);
+          rhs.mRawPtr = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      void
+      swap( nsISupports*& rhs )
+          // ...exchange ownership with |rhs|; can save a pair of refcount operations
+        {
+          nsISupports* temp = rhs;
+          NSCAP_LOG_ASSIGNMENT(this, temp);
+          NSCAP_LOG_RELEASE(this, mRawPtr);
+          rhs = mRawPtr;
+          mRawPtr = temp;
+        }
+
+      already_AddRefed<nsISupports>
+      forget()
+          // return the value of mRawPtr and null out mRawPtr. Useful for
+          // already_AddRefed return values.
+        {
+          nsISupports* temp = 0;
+          swap(temp);
+          return already_AddRefed<nsISupports>(temp);
+        }
+
+      void
+      forget( nsISupports** 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.
+        {
+          NS_ASSERTION(rhs, "Null pointer passed to forget!");
+          *rhs = 0;
+          swap(*rhs);
+        }
+
+        // Other pointer operators
+
+      nsISupports*
+      get() const
+          /*
+            Prefer the implicit conversion provided automatically by
+            |operator nsISupports*() const|.
+            Use |get()| to resolve ambiguity or to get a castable pointer.
+          */
+        {
+          return reinterpret_cast<nsISupports*>(mRawPtr);
+        }
+
+      operator nsISupports*() const
+          /*
+            ...makes an |nsCOMPtr| 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 |nsCOMPtr| substitutable for a raw pointer.
+
+            Prefer the implicit use of this operator to calling |get()|, except where
+            necessary to resolve ambiguity.
+          */
+        {
+          return get();
+        }
+
+      nsISupports*
+      operator->() const
+        {
+          NS_ABORT_IF_FALSE(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator->().");
+          return get();
+        }
+
+      nsCOMPtr<nsISupports>*
+      get_address()
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+      const nsCOMPtr<nsISupports>*
+      get_address() const
+          // This is not intended to be used by clients.  See |address_of|
+          // below.
+        {
+          return this;
+        }
+
+    public:
+
+      nsISupports&
+      operator*() const
+        {
+          NS_ABORT_IF_FALSE(mRawPtr != 0, "You can't dereference a NULL nsCOMPtr with operator*().");
+          return *get();
+        }
+
+      nsISupports**
+      StartAssignment()
+        {
+#ifndef NSCAP_FEATURE_INLINE_STARTASSIGNMENT
+          return reinterpret_cast<nsISupports**>(begin_assignment());
+#else
+          assign_assuming_AddRef(0);
+          return reinterpret_cast<nsISupports**>(&mRawPtr);
+#endif
+        }
+  };
+
+template <typename T>
+inline void
+ImplCycleCollectionUnlink(nsCOMPtr<T>& aField)
+{
+  aField = nullptr;
+}
+
+template <typename T>
+inline void
+ImplCycleCollectionTraverse(nsCycleCollectionTraversalCallback& aCallback,
+                            nsCOMPtr<T>& aField,
+                            const char* aName,
+                            uint32_t aFlags = 0)
+{
+  CycleCollectionNoteChild(aCallback, aField.get(), aName, aFlags);
+}
+
+#ifndef NSCAP_FEATURE_USE_BASE
+template <class T>
+void
+nsCOMPtr<T>::assign_with_AddRef( nsISupports* rawPtr )
+  {
+    if ( rawPtr )
+      NSCAP_ADDREF(this, rawPtr);
+    assign_assuming_AddRef(reinterpret_cast<T*>(rawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_qi( const nsQueryInterface qi, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( qi(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_qi_with_error( const nsQueryInterfaceWithError& qi, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( qi(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_gs_cid( const nsGetServiceByCID gs, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( gs(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_gs_cid_with_error( const nsGetServiceByCIDWithError& gs, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( gs(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_gs_contractid( const nsGetServiceByContractID gs, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( gs(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_gs_contractid_with_error( const nsGetServiceByContractIDWithError& gs, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( gs(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void
+nsCOMPtr<T>::assign_from_helper( const nsCOMPtr_helper& helper, const nsIID& aIID )
+  {
+    void* newRawPtr;
+    if ( NS_FAILED( helper(aIID, &newRawPtr) ) )
+      newRawPtr = 0;
+    assign_assuming_AddRef(static_cast<T*>(newRawPtr));
+  }
+
+template <class T>
+void**
+nsCOMPtr<T>::begin_assignment()
+  {
+    assign_assuming_AddRef(0);
+    union { T** mT; void** mVoid; } result;
+    result.mT = &mRawPtr;
+    return result.mVoid;
+  }
+#endif
+
+template <class T>
+inline
+nsCOMPtr<T>*
+address_of( nsCOMPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+inline
+const nsCOMPtr<T>*
+address_of( const nsCOMPtr<T>& aPtr )
+  {
+    return aPtr.get_address();
+  }
+
+template <class T>
+class nsGetterAddRefs
+    /*
+      ...
+
+      This class is designed to be used for anonymous temporary objects in the
+      argument list of calls that return COM interface pointers, e.g.,
+
+        nsCOMPtr<IFoo> fooP;
+        ...->QueryInterface(iid, getter_AddRefs(fooP))
+
+      DO NOT USE THIS TYPE DIRECTLY IN YOUR CODE.  Use |getter_AddRefs()| instead.
+
+      When initialized with a |nsCOMPtr|, as in the example above, it returns
+      a |void**|, a |T**|, or an |nsISupports**| as needed, that the outer call (|QueryInterface| in this
+      case) can fill in.
+
+      This type should be a nested class inside |nsCOMPtr<T>|.
+    */
+  {
+    public:
+      explicit
+      nsGetterAddRefs( nsCOMPtr<T>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+#if defined(NSCAP_FEATURE_TEST_DONTQUERY_CASES) || defined(NSCAP_LOG_EXTERNAL_ASSIGNMENT)
+     ~nsGetterAddRefs()
+        {
+#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
+          NSCAP_LOG_ASSIGNMENT(reinterpret_cast<void *>(address_of(mTargetSmartPtr)), mTargetSmartPtr.get());
+#endif
+
+#ifdef NSCAP_FEATURE_TEST_DONTQUERY_CASES
+          mTargetSmartPtr.Assert_NoQueryNeeded();
+#endif
+        }
+#endif
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+      operator T**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      T*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsCOMPtr<T>& mTargetSmartPtr;
+  };
+
+
+template <>
+class nsGetterAddRefs<nsISupports>
+  {
+    public:
+      explicit
+      nsGetterAddRefs( nsCOMPtr<nsISupports>& aSmartPtr )
+          : mTargetSmartPtr(aSmartPtr)
+        {
+          // nothing else to do
+        }
+
+#ifdef NSCAP_LOG_EXTERNAL_ASSIGNMENT
+     ~nsGetterAddRefs()
+        {
+          NSCAP_LOG_ASSIGNMENT(reinterpret_cast<void *>(address_of(mTargetSmartPtr)), mTargetSmartPtr.get());
+        }
+#endif
+
+      operator void**()
+        {
+          return reinterpret_cast<void**>(mTargetSmartPtr.StartAssignment());
+        }
+
+      operator nsISupports**()
+        {
+          return mTargetSmartPtr.StartAssignment();
+        }
+
+      nsISupports*&
+      operator*()
+        {
+          return *(mTargetSmartPtr.StartAssignment());
+        }
+
+    private:
+      nsCOMPtr<nsISupports>& mTargetSmartPtr;
+  };
+
+
+template <class T>
+inline
+nsGetterAddRefs<T>
+getter_AddRefs( nsCOMPtr<T>& aSmartPtr )
+    /*
+      Used around a |nsCOMPtr| when 
+      ...makes the class |nsGetterAddRefs<T>| invisible.
+    */
+  {
+    return nsGetterAddRefs<T>(aSmartPtr);
+  }
+
+template <class T, class DestinationType>
+inline
+nsresult
+CallQueryInterface( T* aSource, nsGetterAddRefs<DestinationType> aDestination )
+{
+    return CallQueryInterface(aSource,
+                              static_cast<DestinationType**>(aDestination));
+}
+
+
+  // Comparing two |nsCOMPtr|s
+
+template <class T, class U>
+inline
+bool
+operator==( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == static_cast<const U*>(rhs.get());
+  }
+
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsCOMPtr<T>& lhs, const nsCOMPtr<U>& rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != static_cast<const U*>(rhs.get());
+  }
+
+
+  // Comparing an |nsCOMPtr| to a raw pointer
+
+template <class T, class U>
+inline
+bool
+operator==( const nsCOMPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) == rhs;
+  }
+
+template <class T, class U>
+inline
+bool
+operator==( const U* lhs, const nsCOMPtr<T>& rhs )
+  {
+    return lhs == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsCOMPtr<T>& lhs, const U* rhs )
+  {
+    return static_cast<const T*>(lhs.get()) != rhs;
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const U* lhs, const nsCOMPtr<T>& rhs )
+  {
+    return 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 nsCOMPtr<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 nsCOMPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) == static_cast<const T*>(rhs.get());
+  }
+
+template <class T, class U>
+inline
+bool
+operator!=( const nsCOMPtr<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 nsCOMPtr<T>& rhs )
+  {
+    return const_cast<const U*>(lhs) != static_cast<const T*>(rhs.get());
+  }
+#endif
+
+
+
+  // Comparing an |nsCOMPtr| to |0|
+
+class NSCAP_Zero;
+
+template <class T>
+inline
+bool
+operator==( const nsCOMPtr<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 nsCOMPtr<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 nsCOMPtr<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 nsCOMPtr<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 nsCOMPtr<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 nsCOMPtr<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)
+
+  // Comparing any two [XP]COM objects for identity
+
+inline
+bool
+SameCOMIdentity( nsISupports* lhs, nsISupports* rhs )
+  {
+    return nsCOMPtr<nsISupports>( do_QueryInterface(lhs) ) == nsCOMPtr<nsISupports>( do_QueryInterface(rhs) );
+  }
+
+
+
+template <class SourceType, class DestinationType>
+inline
+nsresult
+CallQueryInterface( nsCOMPtr<SourceType>& aSourcePtr, DestinationType** aDestPtr )
+  {
+    return CallQueryInterface(aSourcePtr.get(), aDestPtr);
+  }
+
+#endif // !defined(nsCOMPtr_h___)