Bug 1316432 - Replace 0's with nullptr in nsCOMPtr.* - r=froydnj
authorGerald Squelart <gsquelart@mozilla.com>
Thu, 10 Nov 2016 14:19:56 +1100
changeset 321999 09a8134e26ea7b22e6b3c316d2089f4a0ffe5456
parent 321998 2168cbd4b15410c24f6947e9218385dd8a0ab3dd
child 322000 376b38e78518ba0774db44085ec9586bd5ddbdbf
push id30939
push usercbook@mozilla.com
push dateFri, 11 Nov 2016 15:32:21 +0000
treeherdermozilla-central@d284cdb3ad6e [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersfroydnj
bugs1316432
milestone52.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1316432 - Replace 0's with nullptr in nsCOMPtr.* - r=froydnj Just a mechanical find/replace of all zero pointers, before the next patch. MozReview-Commit-ID: DSzSZunAXWu
xpcom/glue/nsCOMPtr.cpp
xpcom/glue/nsCOMPtr.h
--- a/xpcom/glue/nsCOMPtr.cpp
+++ b/xpcom/glue/nsCOMPtr.cpp
@@ -44,85 +44,85 @@ nsCOMPtr_base::assign_with_AddRef(nsISup
   assign_assuming_AddRef(aRawPtr);
 }
 
 void
 nsCOMPtr_base::assign_from_qi(const nsQueryInterface aQI, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aQI(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_qi_with_error(const nsQueryInterfaceWithError& aQI,
                                          const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aQI(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_gs_cid(const nsGetServiceByCID aGS,
                                   const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_gs_cid_with_error(
     const nsGetServiceByCIDWithError& aGS, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_gs_contractid(const nsGetServiceByContractID aGS,
                                          const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_gs_contractid_with_error(
     const nsGetServiceByContractIDWithError& aGS, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void
 nsCOMPtr_base::assign_from_helper(const nsCOMPtr_helper& aHelper,
                                   const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aHelper(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<nsISupports*>(newRawPtr));
 }
 
 void**
 nsCOMPtr_base::begin_assignment()
 {
-  assign_assuming_AddRef(0);
+  assign_assuming_AddRef(nullptr);
   return reinterpret_cast<void**>(&mRawPtr);
 }
--- a/xpcom/glue/nsCOMPtr.h
+++ b/xpcom/glue/nsCOMPtr.h
@@ -280,17 +280,17 @@ private:
  *
  *   template<class T> class Foo { ... };
  *   template<> class Foo<void*> { ... };
  *   template<class T> class Foo<T*> : private Foo<void*> { ... };
  */
 class nsCOMPtr_base
 {
 public:
-  explicit nsCOMPtr_base(nsISupports* aRawPtr = 0) : mRawPtr(aRawPtr) {}
+  explicit nsCOMPtr_base(nsISupports* aRawPtr = nullptr) : mRawPtr(aRawPtr) {}
 
   NS_CONSTRUCTOR_FASTCALL ~nsCOMPtr_base()
   {
     NSCAP_LOG_RELEASE(this, mRawPtr);
     if (mRawPtr) {
       NSCAP_RELEASE(this, mRawPtr);
     }
   }
@@ -419,20 +419,20 @@ public:
 #else
   #define NSCAP_ASSERT_NO_QUERY_NEEDED()
 #endif
 
 
   // Constructors
 
   nsCOMPtr()
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
   }
 
   nsCOMPtr(const nsCOMPtr<T>& aSmartPtr)
     : NSCAP_CTOR_BASE(aSmartPtr.mRawPtr)
   {
     assert_validity();
     if (mRawPtr) {
       NSCAP_ADDREF(this, mRawPtr);
@@ -500,75 +500,75 @@ public:
     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();
   }
 
   // Construct from |do_QueryInterface(expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsQueryInterface aQI)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_qi(aQI, NS_GET_TEMPLATE_IID(T));
   }
 
   // Construct from |do_QueryInterface(expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsQueryInterfaceWithError& aQI)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_qi_with_error(aQI, NS_GET_TEMPLATE_IID(T));
   }
 
   // Construct from |do_GetService(cid_expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCID aGS)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_cid(aGS, NS_GET_TEMPLATE_IID(T));
   }
 
   // Construct from |do_GetService(cid_expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_cid_with_error(aGS, NS_GET_TEMPLATE_IID(T));
   }
 
   // Construct from |do_GetService(contractid_expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractID aGS)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_contractid(aGS, NS_GET_TEMPLATE_IID(T));
   }
 
   // Construct from |do_GetService(contractid_expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_contractid_with_error(aGS, NS_GET_TEMPLATE_IID(T));
   }
 
   // And finally, anything else we might need to construct from can exploit the
   // nsCOMPtr_helper facility.
   MOZ_IMPLICIT nsCOMPtr(const nsCOMPtr_helper& aHelper)
-    : NSCAP_CTOR_BASE(0)
+    : NSCAP_CTOR_BASE(nullptr)
   {
     assert_validity();
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_helper(aHelper, NS_GET_TEMPLATE_IID(T));
     NSCAP_ASSERT_NO_QUERY_NEEDED();
   }
 
   // Defined in OwningNonNull.h
   template<class U>
   MOZ_IMPLICIT nsCOMPtr(const mozilla::OwningNonNull<U>& aOther);
 
@@ -701,31 +701,31 @@ public:
 
 
   // Other pointer operators
 
   // Return the value of mRawPtr and null out mRawPtr. Useful for
   // already_AddRefed return values.
   already_AddRefed<T> forget()
   {
-    T* temp = 0;
+    T* temp = nullptr;
     swap(temp);
     return already_AddRefed<T>(temp);
   }
 
   // Set the target of aRhs to the value of mRawPtr and null out mRawPtr.
   // Useful to avoid unnecessary AddRef/Release pairs with "out" parameters
   // where aRhs bay be a T** or an I** where I is a base class of T.
   template<typename I>
   void forget(I** aRhs)
   {
     NS_ASSERTION(aRhs, "Null pointer passed to forget!");
     NSCAP_LOG_RELEASE(this, mRawPtr);
     *aRhs = get();
-    mRawPtr = 0;
+    mRawPtr = nullptr;
   }
 
   // Prefer the implicit conversion provided automatically by
   // |operator T*() const|. Use |get()| to resolve ambiguity or to get a
   // castable pointer.
   T* get() const { return reinterpret_cast<T*>(mRawPtr); }
 
   // Makes an nsCOMPtr act like its underlying raw pointer type whenever it is
@@ -747,39 +747,39 @@ public:
   operator T*() const && = delete;
 
   // Needed to avoid the deleted operator above
   explicit operator bool() const { return !!mRawPtr; }
 #endif
 
   T* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
   {
-    MOZ_ASSERT(mRawPtr != 0,
+    MOZ_ASSERT(mRawPtr != nullptr,
                "You can't dereference a NULL nsCOMPtr with operator->().");
     return get();
   }
 
   // These are not intended to be used by clients. See |address_of| below.
   nsCOMPtr<T>* get_address() { return this; }
   const nsCOMPtr<T>* get_address() const { return this; }
 
 public:
   T& operator*() const
   {
-    MOZ_ASSERT(mRawPtr != 0,
+    MOZ_ASSERT(mRawPtr != nullptr,
                "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);
+    assign_assuming_AddRef(nullptr);
     return reinterpret_cast<T**>(&mRawPtr);
 #endif
   }
 };
 
 
 /*
  * Specializing nsCOMPtr for nsISupports allows us to use nsCOMPtr<nsISupports>
@@ -795,19 +795,19 @@ class nsCOMPtr<nsISupports>
   : private nsCOMPtr_base
 {
 public:
   typedef nsISupports element_type;
 
   // Constructors
 
   nsCOMPtr()
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
   }
 
   nsCOMPtr(const nsCOMPtr<nsISupports>& aSmartPtr)
     : nsCOMPtr_base(aSmartPtr.mRawPtr)
   {
     if (mRawPtr) {
       NSCAP_ADDREF(this, mRawPtr);
     }
@@ -834,68 +834,68 @@ public:
   MOZ_IMPLICIT nsCOMPtr(already_AddRefed<nsISupports>&& aSmartPtr)
     : nsCOMPtr_base(aSmartPtr.take())
   {
     NSCAP_LOG_ASSIGNMENT(this, mRawPtr);
   }
 
   // Construct from |do_QueryInterface(expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsQueryInterface aQI)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_qi(aQI, NS_GET_IID(nsISupports));
   }
 
   // Construct from |do_QueryInterface(expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsQueryInterfaceWithError& aQI)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_qi_with_error(aQI, NS_GET_IID(nsISupports));
   }
 
   // Construct from |do_GetService(cid_expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCID aGS)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_cid(aGS, NS_GET_IID(nsISupports));
   }
 
   // Construct from |do_GetService(cid_expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByCIDWithError& aGS)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_cid_with_error(aGS, NS_GET_IID(nsISupports));
   }
 
   // Construct from |do_GetService(contractid_expr)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractID aGS)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_contractid(aGS, NS_GET_IID(nsISupports));
   }
 
   // Construct from |do_GetService(contractid_expr, &rv)|.
   MOZ_IMPLICIT nsCOMPtr(const nsGetServiceByContractIDWithError& aGS)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_gs_contractid_with_error(aGS, NS_GET_IID(nsISupports));
   }
 
   // And finally, anything else we might need to construct from can exploit
   // the |nsCOMPtr_helper| facility
   MOZ_IMPLICIT nsCOMPtr(const nsCOMPtr_helper& aHelper)
-    : nsCOMPtr_base(0)
+    : nsCOMPtr_base(nullptr)
   {
-    NSCAP_LOG_ASSIGNMENT(this, 0);
+    NSCAP_LOG_ASSIGNMENT(this, nullptr);
     assign_from_helper(aHelper, NS_GET_IID(nsISupports));
   }
 
 
   // Assignment operators
 
   nsCOMPtr<nsISupports>& operator=(const nsCOMPtr<nsISupports>& aRhs)
   {
@@ -994,28 +994,28 @@ public:
     aRhs = mRawPtr;
     mRawPtr = temp;
   }
 
   // Return the value of mRawPtr and null out mRawPtr. Useful for
   // already_AddRefed return values.
   already_AddRefed<nsISupports> forget()
   {
-    nsISupports* temp = 0;
+    nsISupports* temp = nullptr;
     swap(temp);
     return already_AddRefed<nsISupports>(temp);
   }
 
   // Set the target of aRhs to the value of mRawPtr and null out mRawPtr.
   // Useful to avoid unnecessary AddRef/Release pairs with "out"
   // parameters.
   void forget(nsISupports** aRhs)
   {
     NS_ASSERTION(aRhs, "Null pointer passed to forget!");
-    *aRhs = 0;
+    *aRhs = nullptr;
     swap(*aRhs);
   }
 
   // Other pointer operators
 
   // Prefer the implicit conversion provided automatically by
   // |operator nsISupports*() const|. Use |get()| to resolve ambiguity or to
   // get a castable pointer.
@@ -1026,40 +1026,40 @@ public:
   // 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/
   operator nsISupports* () const { return get(); }
 
   nsISupports* operator->() const MOZ_NO_ADDREF_RELEASE_ON_RETURN
   {
-    MOZ_ASSERT(mRawPtr != 0,
+    MOZ_ASSERT(mRawPtr != nullptr,
                "You can't dereference a NULL nsCOMPtr with operator->().");
     return get();
   }
 
   // These are not intended to be used by clients. See |address_of| below.
   nsCOMPtr<nsISupports>* get_address() { return this; }
   const nsCOMPtr<nsISupports>* get_address() const { return this; }
 
 public:
 
   nsISupports& operator*() const
   {
-    MOZ_ASSERT(mRawPtr != 0,
+    MOZ_ASSERT(mRawPtr != nullptr,
                "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);
+    assign_assuming_AddRef(nullptr);
     return reinterpret_cast<nsISupports**>(&mRawPtr);
 #endif
   }
 };
 
 template<typename T>
 inline void
 ImplCycleCollectionUnlink(nsCOMPtr<T>& aField)
@@ -1089,96 +1089,96 @@ nsCOMPtr<T>::assign_with_AddRef(nsISuppo
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_qi(const nsQueryInterface aQI, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aQI(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_qi_with_error(const nsQueryInterfaceWithError& aQI,
                                        const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aQI(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_gs_cid(const nsGetServiceByCID aGS, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_gs_cid_with_error(const nsGetServiceByCIDWithError& aGS,
                                            const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_gs_contractid(const nsGetServiceByContractID aGS,
                                        const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void
 nsCOMPtr<T>::assign_from_gs_contractid_with_error(
     const nsGetServiceByContractIDWithError& aGS, const nsIID& aIID)
 {
   void* newRawPtr;
   if (NS_FAILED(aGS(aIID, &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   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;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
 }
 
 template<class T>
 void**
 nsCOMPtr<T>::begin_assignment()
 {
-  assign_assuming_AddRef(0);
+  assign_assuming_AddRef(nullptr);
   union
   {
     T** mT;
     void** mVoid;
   } result;
   result.mT = &mRawPtr;
   return result.mVoid;
 }
@@ -1421,27 +1421,27 @@ CallQueryInterface(nsCOMPtr<SourceType>&
   return CallQueryInterface(aSourcePtr.get(), aDestPtr);
 }
 
 template <class T>
 RefPtr<T>::RefPtr(const nsCOMPtr_helper& aHelper)
 {
   void* newRawPtr;
   if (NS_FAILED(aHelper(NS_GET_TEMPLATE_IID(T), &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   mRawPtr = static_cast<T*>(newRawPtr);
 }
 
 template <class T>
 RefPtr<T>&
 RefPtr<T>::operator=(const nsCOMPtr_helper& aHelper)
 {
   void* newRawPtr;
   if (NS_FAILED(aHelper(NS_GET_TEMPLATE_IID(T), &newRawPtr))) {
-    newRawPtr = 0;
+    newRawPtr = nullptr;
   }
   assign_assuming_AddRef(static_cast<T*>(newRawPtr));
   return *this;
 }
 
 
 #endif // !defined(nsCOMPtr_h___)