--- a/xpcom/reflect/xptcall/src/md/os2/xptcstubs_gcc_x86_os2.cpp
+++ b/xpcom/reflect/xptcall/src/md/os2/xptcstubs_gcc_x86_os2.cpp
@@ -12,17 +12,17 @@
 extern "C" {
 static nsresult ATTRIBUTE_USED
 __attribute__ ((regparm (3)))
 PrepareAndDispatch(uint32_t methodIndex, nsXPTCStubBase* self, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_alpha_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_alpha_openbsd.cpp
@@ -15,17 +15,17 @@ PrepareAndDispatch(nsXPTCStubBase* self,
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint64_t* args)
 {
     const uint8_t PARAM_BUFFER_COUNT = 16;
     const uint8_t NUM_ARG_REGS = 6-1;        // -1 for "this" pointer
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_amd64_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_amd64_openbsd.cpp
@@ -28,17 +28,17 @@ const uint32_t FPR_COUNT            = 8;
 // The parameters are mapped into an array of type 'nsXPTCMiniVariant'
 // and then the method gets called.
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase * self, uint32_t methodIndex,
                    uint64_t * args, uint64_t * gpregs, double *fpregs)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm.cpp
@@ -42,17 +42,17 @@ DONT_DROP_OR_WARN;
 #endif
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm_netbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm_netbsd.cpp
@@ -8,18 +8,18 @@
 #include "xptcprivate.h"
 
 nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_arm_openbsd.cpp
@@ -25,17 +25,17 @@ static nsresult PrepareAndDispatch(nsXPT
 DONT_DROP_OR_WARN;
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_gcc_x86_unix.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_gcc_x86_unix.cpp
@@ -12,17 +12,17 @@
 extern "C" {
 static nsresult ATTRIBUTE_USED
 __attribute__ ((regparm (3)))
 PrepareAndDispatch(uint32_t methodIndex, nsXPTCStubBase* self, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ipf32.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ipf32.cpp
@@ -19,17 +19,17 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex,
   uint64_t* intargs, uint64_t* floatargs, uint64_t* restargs)
 {
 
 #define PARAM_BUFFER_COUNT     16
 
   nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-  nsXPTCMiniVariant* dispatchParams = NULL;
+  nsXPTCMiniVariant* dispatchParams = nullptr;
   const nsXPTMethodInfo* info;
   nsresult result = NS_ERROR_FAILURE;
   uint64_t* iargs = intargs;
   uint64_t* fargs = floatargs;
   uint8_t paramCount;
   uint8_t i;
 
   NS_ASSERTION(self,"no self");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ipf64.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ipf64.cpp
@@ -20,17 +20,17 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex,
   uint64_t* intargs, uint64_t* floatargs, uint64_t* restargs)
 {
 
 #define PARAM_BUFFER_COUNT     16
 
   nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-  nsXPTCMiniVariant* dispatchParams = NULL;
+  nsXPTCMiniVariant* dispatchParams = nullptr;
   const nsXPTMethodInfo* info;
   nsresult result = NS_ERROR_FAILURE;
   uint64_t* iargs = intargs;
   uint64_t* fargs = floatargs;
   uint8_t paramCount;
   uint8_t i;
 
   NS_ASSERTION(self,"no self");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_alpha.cpp
@@ -15,17 +15,17 @@ PrepareAndDispatch(nsXPTCStubBase* self,
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint64_t* args)
 {
     const uint8_t PARAM_BUFFER_COUNT = 16;
     const uint8_t NUM_ARG_REGS = 6-1;        // -1 for "this" pointer
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_m68k.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_m68k.cpp
@@ -10,17 +10,17 @@
 
 extern "C" {
     nsresult
     PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
     {
 #define PARAM_BUFFER_COUNT     16
 
         nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-        nsXPTCMiniVariant* dispatchParams = NULL;
+        nsXPTCMiniVariant* dispatchParams = nullptr;
         const nsXPTMethodInfo* info;
         uint8_t paramCount;
         uint8_t i;
         nsresult result = NS_ERROR_FAILURE;
 
         NS_ASSERTION(self,"no self");
 
         self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_s390.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_s390.cpp
@@ -11,17 +11,17 @@
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, 
                    uint32_t* a_gpr, uint64_t *a_fpr, uint32_t *a_ov)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_s390x.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_linux_s390x.cpp
@@ -11,17 +11,17 @@
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, 
                    uint64_t* a_gpr, uint64_t *a_fpr, uint64_t *a_ov)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_mips.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_mips.cpp
@@ -18,17 +18,17 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
     args++; // always skip over a0
 
 #define PARAM_BUFFER_COUNT		16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_mips64.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_mips64.cpp
@@ -24,17 +24,17 @@ extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint64_t* args,
                    uint64_t *gprData, double *fprData)
 {
 #define PARAM_BUFFER_COUNT        16
 #define PARAM_GPR_COUNT            7
 #define PARAM_FPR_COUNT            7
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_netbsd_m68k.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_netbsd_m68k.cpp
@@ -13,18 +13,18 @@
 
 extern "C" {
     static nsresult
     PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
     {
 #define PARAM_BUFFER_COUNT     16
 
         nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-        nsXPTCMiniVariant* dispatchParams = NULL;
-        nsIInterfaceInfo* iface_info = NULL;
+        nsXPTCMiniVariant* dispatchParams = nullptr;
+        nsIInterfaceInfo* iface_info = nullptr;
         const nsXPTMethodInfo* info;
         uint8_t paramCount;
         uint8_t i;
         nsresult result = NS_ERROR_FAILURE;
 
         NS_ASSERTION(self,"no self");
 
         self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_nto_arm.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_nto_arm.cpp
@@ -15,18 +15,18 @@
 static nsresult PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args) asm("_PrepareAndDispatch");
 
 static nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_nto_shle.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_nto_shle.cpp
@@ -22,18 +22,18 @@ PrepareAndDispatch(nsXPTCStubBase* self,
 				   uint32_t *intRegParams, float *floatRegParams)
 {
 #define PARAM_BUFFER_COUNT     16
 
 	nsresult result = NS_ERROR_FAILURE;
 	int intCount = 0;
 	int floatCount = 0;
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
 	uint8_t i;
 
 	NS_ASSERTION(self,"no self");
 
 	self->GetInterfaceInfo(&iface_info);
 	NS_ASSERTION(iface_info,"no interface info");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_pa32.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_pa32.cpp
@@ -22,17 +22,17 @@ PrepareAndDispatch(nsXPTCStubBase* self,
   typedef struct {
     uint32_t hi;
     uint32_t lo;
   } DU;
 
 #define PARAM_BUFFER_COUNT     16
 
   nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-  nsXPTCMiniVariant* dispatchParams = NULL;
+  nsXPTCMiniVariant* dispatchParams = nullptr;
   const nsXPTMethodInfo* info;
   int32_t regwords = 1; /* self pointer is not in the variant records */
   nsresult result = NS_ERROR_FAILURE;
   uint8_t paramCount;
   uint8_t i;
 
   NS_ASSERTION(self,"no self");
 

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc64_linux.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc64_linux.cpp
@@ -35,17 +35,17 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self,
                    uint64_t methodIndex,
                    uint64_t* args,
                    uint64_t *gprData,
                    double *fprData)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_aix.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_aix.cpp
@@ -23,18 +23,18 @@ PrepareAndDispatch(nsXPTCStubBase* self,
         uint32_t hi;
         uint32_t lo;      // have to move 64 bit entities as 32 bit halves since
     } DU;               // stack slots are not guaranteed 16 byte aligned
 
 #define PARAM_BUFFER_COUNT     16
 #define PARAM_GPR_COUNT         7  
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info,"no method info");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_aix64.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_aix64.cpp
@@ -18,18 +18,18 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint64_t methodIndex, uint64_t* args, uint64_t *gprData, double *fprData)
 {
 
 #define PARAM_BUFFER_COUNT     16
 #define PARAM_GPR_COUNT         7  
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info,"no method info");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_linux.cpp
@@ -34,18 +34,18 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self,
                    uint32_t methodIndex,
                    uint32_t* args,
                    uint32_t *gprData,
                    double *fprData)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info,"no method info");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_netbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_netbsd.cpp
@@ -30,18 +30,18 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self,
                    uint32_t methodIndex,
                    uint32_t* args,
                    uint32_t *gprData,
                    double *fprData)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_openbsd.cpp
@@ -31,18 +31,18 @@
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self,
                    uint32_t methodIndex,
                    uint32_t* args,
                    uint32_t *gprData,
                    double *fprData)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info,"no method info");

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_rhapsody.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_ppc_rhapsody.cpp
@@ -42,17 +42,17 @@ PrepareAndDispatch(
   uint32_t       *argsStack,
   uint32_t       *argsGPR,
   double         *argsFPR) {
 #define PARAM_BUFFER_COUNT 16
 #define PARAM_FPR_COUNT    13
 #define PARAM_GPR_COUNT     7
 
   nsXPTCMiniVariant      paramBuffer[PARAM_BUFFER_COUNT];
-  nsXPTCMiniVariant     *dispatchParams = NULL;
+  nsXPTCMiniVariant     *dispatchParams = nullptr;
   const nsXPTMethodInfo *methodInfo;
   uint8_t                paramCount;
   uint8_t                i;
   nsresult               result         = NS_ERROR_FAILURE;
   uint32_t               argIndex       = 0;
   uint32_t               fprIndex       = 0;
 
   typedef struct {

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc64_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc64_openbsd.cpp
@@ -13,17 +13,17 @@
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint64_t methodIndex, uint64_t* args)
 {
 
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_netbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_netbsd.cpp
@@ -17,18 +17,18 @@ PrepareAndDispatch(nsXPTCStubBase* self,
         uint32_t hi;
         uint32_t lo;
     } DU;               // have to move 64 bit entities as 32 bit halves since
                         // stack slots are not guaranteed 16 byte aligned
 
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_openbsd.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_openbsd.cpp
@@ -17,18 +17,18 @@ PrepareAndDispatch(nsXPTCStubBase* self,
         uint32_t hi;
         uint32_t lo;
     } DU;               // have to move 64 bit entities as 32 bit halves since
                         // stack slots are not guaranteed 16 byte aligned
 
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    nsIInterfaceInfo* iface_info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    nsIInterfaceInfo* iface_info = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->GetInterfaceInfo(&iface_info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_solaris.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparc_solaris.cpp
@@ -18,17 +18,17 @@ PrepareAndDispatch(nsXPTCStubBase* self,
         uint32_t hi;
         uint32_t lo;
     } DU;               // have to move 64 bit entities as 32 bit halves since
                         // stack slots are not guaranteed 16 byte aligned
 
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparcv9_solaris.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_sparcv9_solaris.cpp
@@ -13,17 +13,17 @@
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint64_t methodIndex, uint64_t* args)
 {
 
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_darwin.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_darwin.cpp
@@ -30,17 +30,17 @@ const uint32_t FPR_COUNT            = 8;
 // The parameters are mapped into an array of type 'nsXPTCMiniVariant'
 // and then the method gets called.
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase * self, uint32_t methodIndex,
                    uint64_t * args, uint64_t * gpregs, double *fpregs)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_linux.cpp
@@ -30,17 +30,17 @@ const uint32_t FPR_COUNT            = 8;
 // The parameters are mapped into an array of type 'nsXPTCMiniVariant'
 // and then the method gets called.
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase * self, uint32_t methodIndex,
                    uint64_t * args, uint64_t * gpregs, double *fpregs)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_solaris.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_64_solaris.cpp
@@ -30,17 +30,17 @@ const uint32_t FPR_COUNT            = 8;
 // The parameters are mapped into an array of type 'nsXPTCMiniVariant'
 // and then the method gets called.
 
 extern "C" nsresult
 PrepareAndDispatch(nsXPTCStubBase * self, uint32_t methodIndex,
                    uint64_t * args, uint64_t * gpregs, double *fpregs)
 {
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint32_t paramCount;
     uint32_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_solaris.cpp
+++ b/xpcom/reflect/xptcall/src/md/unix/xptcstubs_x86_solaris.cpp
@@ -10,17 +10,17 @@
 #include "xptiprivate.h"
 
 nsresult
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex, uint32_t* args)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
     const nsXPTMethodInfo* info;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);

--- a/xpcom/reflect/xptcall/src/md/win32/xptcstubs.cpp
+++ b/xpcom/reflect/xptcall/src/md/win32/xptcstubs.cpp
@@ -19,18 +19,18 @@ static
 #endif
 nsresult __stdcall
 PrepareAndDispatch(nsXPTCStubBase* self, uint32_t methodIndex,
                    uint32_t* args, uint32_t* stackBytesToPop)
 {
 #define PARAM_BUFFER_COUNT     16
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     // If anything fails before stackBytesToPop can be set then
     // the failure is completely catastrophic!
 
     NS_ASSERTION(self,"no self");

--- a/xpcom/reflect/xptcall/src/md/win32/xptcstubs_x86_64.cpp
+++ b/xpcom/reflect/xptcall/src/md/win32/xptcstubs_x86_64.cpp
@@ -19,18 +19,18 @@ PrepareAndDispatch(nsXPTCStubBase* self,
 #define PARAM_BUFFER_COUNT  16
 //
 // "this" pointer is first parameter, so parameter count is 3.
 //
 #define PARAM_GPR_COUNT   3
 #define PARAM_FPR_COUNT   3
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self,"no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info,"no method info");

--- a/xpcom/reflect/xptcall/src/md/win32/xptcstubs_x86_64_gnu.cpp
+++ b/xpcom/reflect/xptcall/src/md/win32/xptcstubs_x86_64_gnu.cpp
@@ -23,18 +23,18 @@ PrepareAndDispatch(nsXPTCStubBase * self
 #define PARAM_BUFFER_COUNT  16
 //
 // "this" pointer is first parameter, so parameter count is 3.
 //
 #define PARAM_GPR_COUNT   3
 #define PARAM_FPR_COUNT   3
 
     nsXPTCMiniVariant paramBuffer[PARAM_BUFFER_COUNT];
-    nsXPTCMiniVariant* dispatchParams = NULL;
-    const nsXPTMethodInfo* info = NULL;
+    nsXPTCMiniVariant* dispatchParams = nullptr;
+    const nsXPTMethodInfo* info = nullptr;
     uint8_t paramCount;
     uint8_t i;
     nsresult result = NS_ERROR_FAILURE;
 
     NS_ASSERTION(self, "no self");
 
     self->mEntry->GetMethodInfo(uint16_t(methodIndex), &info);
     NS_ASSERTION(info, "no method info");

--- a/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp
+++ b/xpcom/reflect/xptcall/tests/TestXPTCInvoke.cpp
@@ -1127,21 +1127,21 @@ FooBarImpl::FooBarImpl() : MyName("FooBa
 const char* FooBarImpl::ImplName()
 {
     return MyName;
 }
 
 NS_IMETHODIMP
 FooBarImpl::QueryInterface(REFNSIID aIID, void** aInstancePtr)
 {
-  if (NULL == aInstancePtr) {
+  if (nullptr == aInstancePtr) {
     return NS_ERROR_NULL_POINTER;
   }
 
-  *aInstancePtr = NULL;
+  *aInstancePtr = nullptr;
 
 
   if (aIID.Equals(NS_GET_IID(nsIFoo))) {
     *aInstancePtr = (void*) static_cast<nsIFoo*>(this);
     NS_ADDREF_THIS();
     return NS_OK;
   }
   if (aIID.Equals(NS_GET_IID(nsIBar))) {
@@ -1298,21 +1298,21 @@ NS_IMETHODIMP FooBarImpl2::BarMethod2(in
     printf("\tFooBarImpl2::BarMethod2 called with i == %d, local value = %x\n", 
            i, value);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 FooBarImpl2::QueryInterface(REFNSIID aIID, void** aInstancePtr)
 {
-  if (NULL == aInstancePtr) {
+  if (nullptr == aInstancePtr) {
     return NS_ERROR_NULL_POINTER;
   }
 
-  *aInstancePtr = NULL;
+  *aInstancePtr = nullptr;
 
 
   if (aIID.Equals(NS_GET_IID(nsIFoo))) {
     *aInstancePtr = (void*) static_cast<nsIFoo2*>(this);
     NS_ADDREF_THIS();
     return NS_OK;
   }
   if (aIID.Equals(NS_GET_IID(nsIBar))) {

--- a/xpcom/reflect/xptinfo/src/xptiInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/src/xptiInterfaceInfo.cpp
@@ -54,18 +54,18 @@ xptiInterfaceEntry::xptiInterfaceEntry(c
                                        const nsID& iid,
                                        XPTInterfaceDescriptor* aDescriptor,
                                        xptiTypelibGuts* aTypelib)
     : mIID(iid)
     , mDescriptor(aDescriptor)
     , mMethodBaseIndex(0)
     , mConstantBaseIndex(0)
     , mTypelib(aTypelib)
-    , mParent(NULL)
-    , mInfo(NULL)
+    , mParent(nullptr)
+    , mInfo(nullptr)
     , mFlags(0)
 {
     memcpy(mName, name, nameLength);
     SetResolvedState(PARTIALLY_RESOLVED);
 }
 
 bool 
 xptiInterfaceEntry::Resolve()
@@ -186,17 +186,17 @@ xptiInterfaceEntry::GetMethodInfo(uint16
 
     if(index < mMethodBaseIndex)
         return mParent->GetMethodInfo(index, info);
 
     if(index >= mMethodBaseIndex + 
                 mDescriptor->num_methods)
     {
         NS_ERROR("bad param");
-        *info = NULL;
+        *info = nullptr;
         return NS_ERROR_INVALID_ARG;
     }
 
     // else...
     *info = reinterpret_cast<nsXPTMethodInfo*>
        (&mDescriptor->method_descriptors[index - mMethodBaseIndex]);
     return NS_OK;
 }
@@ -240,17 +240,17 @@ xptiInterfaceEntry::GetConstant(uint16_t
 
     if(index < mConstantBaseIndex)
         return mParent->GetConstant(index, constant);
 
     if(index >= mConstantBaseIndex + 
                 mDescriptor->num_constants)
     {
         NS_PRECONDITION(0, "bad param");
-        *constant = NULL;
+        *constant = nullptr;
         return NS_ERROR_INVALID_ARG;
     }
 
     // else...
     *constant =
         reinterpret_cast<nsXPTConstant*>
                         (&mDescriptor->
                                 const_descriptors[index -

--- a/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
+++ b/xpcom/reflect/xptinfo/src/xptiInterfaceInfoManager.cpp
@@ -30,18 +30,18 @@ static int gCallCount = 0;
 
 size_t
 XPTInterfaceInfoManager::SizeOfIncludingThis(MallocSizeOf aMallocSizeOf)
 {
     size_t n = aMallocSizeOf(this);
     ReentrantMonitorAutoEnter monitor(mWorkingSet.mTableReentrantMonitor);
     // The entries themselves are allocated out of an arena accounted
     // for elsewhere, so don't measure them
-    n += mWorkingSet.mIIDTable.SizeOfExcludingThis(NULL, aMallocSizeOf);
-    n += mWorkingSet.mNameTable.SizeOfExcludingThis(NULL, aMallocSizeOf);
+    n += mWorkingSet.mIIDTable.SizeOfExcludingThis(nullptr, aMallocSizeOf);
+    n += mWorkingSet.mNameTable.SizeOfExcludingThis(nullptr, aMallocSizeOf);
     return n;
 }
 
 class XPTIWorkingSetReporter MOZ_FINAL : public MemoryUniReporter
 {
 public:
     XPTIWorkingSetReporter()
       : MemoryUniReporter("explicit/xpti-working-set", KIND_HEAP, UNITS_BYTES,

--- a/xpcom/reflect/xptinfo/src/xptiWorkingSet.cpp
+++ b/xpcom/reflect/xptinfo/src/xptiWorkingSet.cpp
@@ -32,17 +32,17 @@ xpti_Invalidator(const char* keyname, xp
     entry->LockedInvalidateInterfaceInfo();
     return PL_DHASH_NEXT;
 }
 
 void 
 XPTInterfaceInfoManager::xptiWorkingSet::InvalidateInterfaceInfos()
 {
     ReentrantMonitorAutoEnter monitor(mTableReentrantMonitor);
-    mNameTable.EnumerateRead(xpti_Invalidator, NULL);
+    mNameTable.EnumerateRead(xpti_Invalidator, nullptr);
 }        
 
 XPTInterfaceInfoManager::xptiWorkingSet::~xptiWorkingSet()
 {
     MOZ_COUNT_DTOR(xptiWorkingSet);
 
     // Only destroy the arena if we're doing leak stats. Why waste shutdown
     // time touching pages if we don't have to?

--- a/xpcom/reflect/xptinfo/tests/TestInterfaceInfo.cpp
+++ b/xpcom/reflect/xptinfo/tests/TestInterfaceInfo.cpp
@@ -66,17 +66,17 @@ int main (int argc, char **argv) {
     fprintf(stderr, "\nparams work?\n");
     fprintf(stderr, "\ngetting info for name 'nsIServiceManager'\n");
     iim->GetInfoForName("nsIComponentManager", &info5);
 #ifdef DEBUG
 //    ((nsInterfaceInfo *)info5)->print(stderr);
 #endif
 
     // XXX: nsIServiceManager is no more; what do we test with?
-    if (info5 == NULL) {
+    if (info5 == nullptr) {
         fprintf(stderr, "\nNo nsIComponentManager; cannot continue.\n");
         return 1;
     }
 
     uint16_t methodcount;
     info5->GetMethodCount(&methodcount);
     const nsXPTMethodInfo *mi;
     for (i = 0; i < methodcount; i++) {

--- a/xpcom/sample/nsSample.cpp
+++ b/xpcom/sample/nsSample.cpp
@@ -39,17 +39,17 @@ nsSampleImpl::~nsSampleImpl()
  * simple stuff, but you would have to create QueryInterface on your own.
  * nsSampleFactory.cpp is an example of this approach.
  * Notice that the second parameter to the macro is name of the interface, and
  * NOT the #defined IID.
  *
  * The _CI variant adds support for nsIClassInfo, which permits introspection
  * and interface flattening.
  */
-NS_IMPL_CLASSINFO(nsSampleImpl, NULL, 0, NS_SAMPLE_CID)
+NS_IMPL_CLASSINFO(nsSampleImpl, nullptr, 0, NS_SAMPLE_CID)
 NS_IMPL_ISUPPORTS1_CI(nsSampleImpl, nsISample)
 /**
  * Notice that in the protoype for this function, the NS_IMETHOD macro was
  * used to declare the return type.  For the implementation, the return
  * type is declared by NS_IMETHODIMP
  */
 NS_IMETHODIMP
 nsSampleImpl::GetValue(char** aValue)

--- a/xpcom/sample/nsSampleModule.cpp
+++ b/xpcom/sample/nsSampleModule.cpp
@@ -28,39 +28,39 @@
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsSampleImpl)
 
 // The following line defines a kNS_SAMPLE_CID CID variable.
 NS_DEFINE_NAMED_CID(NS_SAMPLE_CID);
 
 // Build a table of ClassIDs (CIDs) which are implemented by this module. CIDs
 // should be completely unique UUIDs.
 // each entry has the form { CID, service, factoryproc, constructorproc }
-// where factoryproc is usually NULL.
+// where factoryproc is usually nullptr.
 static const mozilla::Module::CIDEntry kSampleCIDs[] = {
-    { &kNS_SAMPLE_CID, false, NULL, nsSampleImplConstructor },
-    { NULL }
+    { &kNS_SAMPLE_CID, false, nullptr, nsSampleImplConstructor },
+    { nullptr }
 };
 
 // Build a table which maps contract IDs to CIDs.
 // A contract is a string which identifies a particular set of functionality. In some
 // cases an extension component may override the contract ID of a builtin gecko component
 // to modify or extend functionality.
 static const mozilla::Module::ContractIDEntry kSampleContracts[] = {
     { NS_SAMPLE_CONTRACTID, &kNS_SAMPLE_CID },
-    { NULL }
+    { nullptr }
 };
 
 // Category entries are category/key/value triples which can be used
 // to register contract ID as content handlers or to observe certain
 // notifications. Most modules do not need to register any category
 // entries: this is just a sample of how you'd do it.
 // @see nsICategoryManager for information on retrieving category data.
 static const mozilla::Module::CategoryEntry kSampleCategories[] = {
     { "my-category", "my-key", NS_SAMPLE_CONTRACTID },
-    { NULL }
+    { nullptr }
 };
 
 static const mozilla::Module kSampleModule = {
     mozilla::Module::kVersion,
     kSampleCIDs,
     kSampleContracts,
     kSampleCategories
 };

--- a/xpcom/string/src/nsTStringObsolete.cpp
+++ b/xpcom/string/src/nsTStringObsolete.cpp
@@ -564,17 +564,17 @@ nsTString_CharT::CompressWhitespace( boo
   /**
    * nsTString::AssignWithConversion
    */
 
 void
 nsTString_CharT::AssignWithConversion( const incompatible_char_type* aData, int32_t aLength )
   {
       // for compatibility with the old string implementation, we need to allow
-      // for a NULL input buffer :-(
+      // for a nullptr input buffer :-(
     if (!aData)
       {
         Truncate();
       }
     else
       {
         if (aLength < 0)
           aLength = nsCharTraits<incompatible_char_type>::length(aData);

--- a/xpcom/tests/RegFactory.cpp
+++ b/xpcom/tests/RegFactory.cpp
@@ -119,12 +119,12 @@ int main(int argc, char *argv[])
     {
       rv = registrar->AutoRegister(nullptr);
       ret = (NS_FAILED(rv)) ? -1 : 0;
     }
     else
       ret = ProcessArgs(registrar, argc, argv);
   } // this scopes the nsCOMPtrs
   // no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
-  rv = NS_ShutdownXPCOM( NULL );
+  rv = NS_ShutdownXPCOM(nullptr);
   NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
   return ret;
 }

--- a/xpcom/tests/SizeTest01.cpp
+++ b/xpcom/tests/SizeTest01.cpp
@@ -41,17 +41,17 @@ NS_DEF_PTR(nsIDOMNode);
 
 void
 Test01_raw( nsIDOMNode* aDOMNode, nsString* aResult )
 		// m140, w34
 	{
 			/*
 				This test is designed to be more like a typical large function where,
 				because you are working with several resources, you don't just return when
-				one of them is |NULL|.  Similarly: |Test01_nsCOMPtr00|, and |Test01_nsIPtr00|.
+				one of them is |nullptr|.  Similarly: |Test01_nsCOMPtr00|, and |Test01_nsIPtr00|.
 			*/
 
 		nsIDOMNode* node = aDOMNode;
 		NS_IF_ADDREF(node);
 
 		if ( node )
 			node->GetNodeName(*aResult);
 
@@ -59,17 +59,17 @@ Test01_raw( nsIDOMNode* aDOMNode, nsStri
 	}
 
 void
 Test01_raw_optimized( nsIDOMNode* aDOMNode, nsString* aResult )
 		// m112, w31
 	{
 			/*
 				This test simulates smaller functions where you _do_ just return
-				|NULL| at the first sign of trouble.  Similarly: |Test01_nsCOMPtr01|,
+				|nullptr| at the first sign of trouble.  Similarly: |Test01_nsCOMPtr01|,
 				and |Test01_nsIPtr01|.
 			*/
 
 			/*
 				This test produces smaller code that |Test01_raw| because it avoids
 				the three tests: |NS_IF_...|, and |if ( node )|.
 			*/
 

--- a/xpcom/tests/TestHarness.h
+++ b/xpcom/tests/TestHarness.h
@@ -96,27 +96,27 @@ public:
 };
 
 class ScopedXPCOM : public nsIDirectoryServiceProvider2
 {
   public:
     NS_DECL_ISUPPORTS
 
     ScopedXPCOM(const char* testName,
-                nsIDirectoryServiceProvider *dirSvcProvider = NULL)
+                nsIDirectoryServiceProvider *dirSvcProvider = nullptr)
     : mDirSvcProvider(dirSvcProvider)
     {
       mTestName = testName;
       printf("Running %s tests...\n", mTestName);
 
-      nsresult rv = NS_InitXPCOM2(&mServMgr, NULL, this);
+      nsresult rv = NS_InitXPCOM2(&mServMgr, nullptr, this);
       if (NS_FAILED(rv))
       {
         fail("NS_InitXPCOM2 returned failure code 0x%x", rv);
-        mServMgr = NULL;
+        mServMgr = nullptr;
         return;
       }
     }
 
     ~ScopedXPCOM()
     {
       // If we created a profile directory, we need to remove it.
       if (mProfD) {
@@ -135,30 +135,30 @@ class ScopedXPCOM : public nsIDirectoryS
         }
 
         mProfD = nullptr;
       }
 
       if (mServMgr)
       {
         NS_RELEASE(mServMgr);
-        nsresult rv = NS_ShutdownXPCOM(NULL);
+        nsresult rv = NS_ShutdownXPCOM(nullptr);
         if (NS_FAILED(rv))
         {
           fail("XPCOM shutdown failed with code 0x%x", rv);
           exit(1);
         }
       }
 
       printf("Finished running %s tests.\n", mTestName);
     }
 
     bool failed()
     {
-      return mServMgr == NULL;
+      return mServMgr == nullptr;
     }
 
     already_AddRefed<nsIFile> GetProfileDirectory()
     {
       if (mProfD) {
         nsCOMPtr<nsIFile> copy = mProfD;
         return copy.forget();
       }

--- a/xpcom/tests/TestID.cpp
+++ b/xpcom/tests/TestID.cpp
@@ -24,17 +24,17 @@ int main(int argc, char** argv)
   nsID id;
   for (int i = 0; i < NUM_IDS; i++) {
     const char* idstr = ids[i];
     if (!id.Parse(idstr)) {
       fprintf(stderr, "TestID: Parse failed on test #%d\n", i);
       return -1;
     }
     char* cp = id.ToString();
-    if (NULL == cp) {
+    if (nullptr == cp) {
       fprintf(stderr, "TestID: ToString failed on test #%d\n", i);
       return -1;
     }
     if (0 != PL_strcmp(cp, ids[4*(i/4) + 3])) {
       fprintf(stderr, "TestID: compare of ToString failed on test #%d\n", i);
       return -1;
     }
   }

--- a/xpcom/tests/TestObserverService.cpp
+++ b/xpcom/tests/TestObserverService.cpp
@@ -10,17 +10,17 @@
 #include "nsISimpleEnumerator.h"
 #include "nsStringGlue.h"
 #include "nsWeakReference.h"
 #include "nsComponentManagerUtils.h"
 #include "mozilla/Attributes.h"
 
 #include <stdio.h>
 
-static nsIObserverService *anObserverService = NULL;
+static nsIObserverService *anObserverService = nullptr;
 
 static void testResult( nsresult rv ) {
     if ( NS_SUCCEEDED( rv ) ) {
         printf("...ok\n");
     } else {
         printf("...failed, rv=0x%x\n", (int)rv);
     }
     return;

--- a/xpcom/tests/TestPipe.cpp
+++ b/xpcom/tests/TestPipe.cpp
@@ -103,38 +103,38 @@ nsresult BackwardsAllocator::Init(uint32
   return NS_OK;
 }
 
 NS_IMETHODIMP_(void*) BackwardsAllocator::Alloc(size_t size)
 {
   if (size != mSize)
   {
     NS_ERROR("umm, why would this be reached for this test?");
-    return NULL;
+    return nullptr;
   }
 
   uint32_t index = mIndex;
 
   while ((index = previous(index)) != mIndex)
   {
     if (mMemory[mSize * mCount + index] == 1)
       continue;
     mMemory[mSize * mCount + index] = 1;
     mIndex = index;
     return &mMemory[mSize * index];
   }
 
   NS_ERROR("shouldn't reach here in this test");
-  return NULL;
+  return nullptr;
 }
 
 NS_IMETHODIMP_(void*) BackwardsAllocator::Realloc(void* ptr, size_t newSize)
 {
   NS_ERROR("shouldn't reach here in this test");
-  return NULL;
+  return nullptr;
 }
 
 NS_IMETHODIMP_(void) BackwardsAllocator::Free(void* ptr)
 {
   uint8_t* p = static_cast<uint8_t*>(ptr);
   if (p)
     mMemory[mCount * mSize + (p - mMemory) / mSize] = 0;
 }

--- a/xpcom/tests/TestPipes.cpp
+++ b/xpcom/tests/TestPipes.cpp
@@ -443,27 +443,27 @@ TestSegmentedBuffer();
 #endif
 
 int
 main(int argc, char* argv[])
 {
     nsresult rv;
 
     nsCOMPtr<nsIServiceManager> servMgr;
-    rv = NS_InitXPCOM2(getter_AddRefs(servMgr), NULL, NULL);
+    rv = NS_InitXPCOM2(getter_AddRefs(servMgr), nullptr, nullptr);
     if (NS_FAILED(rv)) return rv;
 
     if (argc > 1 && nsCRT::strcmp(argv[1], "-trace") == 0)
         gTrace = true;
 
     rv = TestChainedPipes();
     NS_ASSERTION(NS_SUCCEEDED(rv), "TestChainedPipes failed");
     RunTests(16, 1);
     RunTests(4096, 16);
 
     servMgr = 0;
-    rv = NS_ShutdownXPCOM( NULL );
+    rv = NS_ShutdownXPCOM(nullptr);
     NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
 
     return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

--- a/xpcom/tests/TestRacingServiceManager.cpp
+++ b/xpcom/tests/TestRacingServiceManager.cpp
@@ -226,24 +226,24 @@ CreateFactory(const mozilla::Module& mod
         gFactory = new Factory();
         NS_ADDREF(gFactory);
     }
     nsCOMPtr<nsIFactory> ret = gFactory;
     return ret.forget();
 }
 
 static const mozilla::Module::CIDEntry kLocalCIDs[] = {
-    { &kFactoryCID1, false, CreateFactory, NULL },
-    { &kFactoryCID2, false, CreateFactory, NULL },
-    { NULL }
+    { &kFactoryCID1, false, CreateFactory, nullptr },
+    { &kFactoryCID2, false, CreateFactory, nullptr },
+    { nullptr }
 };
 
 static const mozilla::Module::ContractIDEntry kLocalContracts[] = {
     { FACTORY_CONTRACTID, &kFactoryCID2 },
-    { NULL }
+    { nullptr }
 };
 
 static const mozilla::Module kLocalModule = {
     mozilla::Module::kVersion,
     kLocalCIDs,
     kLocalContracts
 };
 

--- a/xpcom/tests/TestRegistrationOrder.cpp
+++ b/xpcom/tests/TestRegistrationOrder.cpp
@@ -106,17 +106,17 @@ nsresult TestJar()
                           kCoreServiceB_CID, kExtServiceB_CID);
 }
 
 bool TestContractFirst()
 {
   nsCOMPtr<nsIComponentRegistrar> r;
   NS_GetComponentRegistrar(getter_AddRefs(r));
 
-  nsCID* cid = NULL;
+  nsCID* cid = nullptr;
   nsresult rv = r->ContractIDToCID("@mozilla.org/RegTestOrderC;1", &cid);
   if (NS_FAILED(rv)) {
     fail("RegTestOrderC: contract not registered");
     return false;
   }
 
   nsCID goodcid;
   goodcid.Parse("{ada15884-bb89-473c-8b50-dcfbb8447ff4}");
@@ -170,17 +170,17 @@ int main(int argc, char** argv)
   const char *regPath = argv[1];
 #endif
 
   XRE_AddManifestLocation(NS_COMPONENT_LOCATION,
                           nsCOMPtr<nsIFile>(GetRegDirectory(regPath, "core", "component.manifest")));
   XRE_AddManifestLocation(NS_COMPONENT_LOCATION,
                           nsCOMPtr<nsIFile>(GetRegDirectory(regPath, "extension", "extComponent.manifest")));
   XRE_AddJarManifestLocation(NS_COMPONENT_LOCATION,
-                          nsCOMPtr<nsIFile>(GetRegDirectory(regPath, "extension2.jar", NULL)));
+                          nsCOMPtr<nsIFile>(GetRegDirectory(regPath, "extension2.jar", nullptr)));
   ScopedXPCOM xpcom("RegistrationOrder");
   if (xpcom.failed())
     return 1;
 
   int rv = 0;
   if (NS_FAILED(TestRegular()))
     rv = 1;
 

--- a/xpcom/tests/TestShutdown.cpp
+++ b/xpcom/tests/TestShutdown.cpp
@@ -6,17 +6,17 @@
 #include "nsIServiceManager.h"
 
 // Gee this seems simple! It's for testing for memory leaks with Purify.
 
 void main(int argc, char* argv[])
 {
     nsresult rv;
     nsIServiceManager* servMgr;
-    rv = NS_InitXPCOM2(&servMgr, NULL, NULL);
+    rv = NS_InitXPCOM2(&servMgr, nullptr, nullptr);
     NS_ASSERTION(NS_SUCCEEDED(rv), "NS_InitXPCOM failed");
 
     // try loading a component and releasing it to see if it leaks
     if (argc > 1 && argv[1] != nullptr) {
         char* cidStr = argv[1];
         nsISupports* obj = nullptr;
         if (cidStr[0] == '{') {
             nsCID cid;

--- a/xpcom/tests/bug656331_component/TestComponent.cpp
+++ b/xpcom/tests/bug656331_component/TestComponent.cpp
@@ -14,18 +14,18 @@ NS_DEFINE_NAMED_CID(NS_TESTING_CID);
 
 static nsresult
 DummyConstructorFunc(nsISupports* aOuter, const nsIID& aIID, void** aResult)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 static const mozilla::Module::CIDEntry kTestCIDs[] = {
-  { &kNS_TESTING_CID, false, NULL, DummyConstructorFunc },
-  { NULL }
+  { &kNS_TESTING_CID, false, nullptr, DummyConstructorFunc },
+  { nullptr }
 };
 
 static const mozilla::Module kTestModule = {
   3, /* faking mozilla::Module::kVersion with a value that will never be used */
   kTestCIDs
 };
 
 NSMODULE_DEFN(dummy) = &kTestModule;

--- a/xpcom/tests/component/TestComponent.cpp
+++ b/xpcom/tests/component/TestComponent.cpp
@@ -13,19 +13,19 @@ NS_DEFINE_NAMED_CID(NS_TESTING_CID);
 
 static nsresult
 DummyConstructorFunc(nsISupports* aOuter, const nsIID& aIID, void** aResult)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 static const mozilla::Module::CIDEntry kTestCIDs[] = {
-  { &kNS_TESTING_CID, false, NULL, DummyConstructorFunc },
-  { &kNS_TESTING_CID, false, NULL, DummyConstructorFunc },
-  { NULL }
+  { &kNS_TESTING_CID, false, nullptr, DummyConstructorFunc },
+  { &kNS_TESTING_CID, false, nullptr, DummyConstructorFunc },
+  { nullptr }
 };
 
 static const mozilla::Module kTestModule = {
   mozilla::Module::kVersion,
   kTestCIDs
 };
 
 NSMODULE_DEFN(dummy) = &kTestModule;

--- a/xpcom/tests/component_no_aslr/TestComponent.cpp
+++ b/xpcom/tests/component_no_aslr/TestComponent.cpp
@@ -13,18 +13,18 @@ NS_DEFINE_NAMED_CID(NS_TESTING_CID);
 
 static nsresult
 DummyConstructorFunc(nsISupports* aOuter, const nsIID& aIID, void** aResult)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 static const mozilla::Module::CIDEntry kTestCIDs[] = {
-  { &kNS_TESTING_CID, false, NULL, DummyConstructorFunc },
-  { NULL }
+  { &kNS_TESTING_CID, false, nullptr, DummyConstructorFunc },
+  { nullptr }
 };
 
 static const mozilla::Module kTestModule = {
   mozilla::Module::kVersion,
   kTestCIDs
 };
 
 NSMODULE_DEFN(dummy) = &kTestModule;

--- a/xpcom/tests/windows/TestCOM.cpp
+++ b/xpcom/tests/windows/TestCOM.cpp
@@ -88,23 +88,23 @@ public:
 };
 
 NS_IMPL_ISUPPORTS1(nsTestComFactory, nsIFactory)
 
 nsresult nsTestComFactory::CreateInstance(nsISupports *aOuter,
 					  const nsIID &aIID,
 					  void **aResult)
 {
-  if (aOuter != NULL) {
+  if (aOuter != nullptr) {
     return NS_ERROR_NO_AGGREGATION;
   }
 
   nsTestCom *t = new nsTestCom();
   
-  if (t == NULL) {
+  if (t == nullptr) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
   
   NS_ADDREF(t);
   nsresult res = t->QueryInterface(aIID, aResult);
   NS_RELEASE(t);
 
   if (NS_SUCCEEDED(res)) {
@@ -123,17 +123,17 @@ int main(int argc, char *argv[])
   nsTestComFactory *inst = new nsTestComFactory();
   IClassFactory *iFactory;
   inst->QueryInterface(NS_GET_IID(nsIFactory), (void **) &iFactory);
 
   IUnknown *iUnknown;  
   nsITestCom *iTestCom;
 
   iFactory->LockServer(TRUE);
-  iFactory->CreateInstance(NULL, IID_IUnknown, (void **) &iUnknown);
+  iFactory->CreateInstance(nullptr, IID_IUnknown, (void **) &iUnknown);
   iFactory->LockServer(FALSE);
 
   GUID testGUID = NS_ITEST_COM_IID;
   HRESULT hres;
   hres= iUnknown->QueryInterface(testGUID, 
 				 (void **) &iTestCom);
 
   iTestCom->Test();

--- a/xpcom/tests/windows/TestHelloXPLoop.cpp
+++ b/xpcom/tests/windows/TestHelloXPLoop.cpp
@@ -11,22 +11,22 @@
 #include <windows.h>
 
 static NS_DEFINE_CID(kNativeAppCID, NS_NATIVE_APP_CID);
 
 LRESULT CALLBACK WndProc(HWND wnd, UINT msg, WPARAM wParam, LPARAM lParam);
 
 void ErrorBox(LPSTR text)
 {
-	MessageBox(NULL, text, "XP Event Loop", MB_OK | MB_ICONSTOP);
+	MessageBox(nullptr, text, "XP Event Loop", MB_OK | MB_ICONSTOP);
 }
 
 void InfoBox(LPSTR text)
 {
-	MessageBox(NULL, text, "XP Event Loop", MB_OK | MB_ICONINFORMATION);
+	MessageBox(nullptr, text, "XP Event Loop", MB_OK | MB_ICONINFORMATION);
 }
 
 int WINAPI WinMain(HINSTANCE inst, 
                    HINSTANCE prevInstance, 
                    LPSTR lpszCmdLine,
                    int nShowCmd)
 {
 	char* lpszAppName = "HelloWorld";
@@ -56,30 +56,30 @@ int WINAPI WinMain(HINSTANCE inst,
         return -1;
       }
       wndclass.cbSize        = sizeof(wndclass);
       wndclass.style         = CS_HREDRAW | CS_VREDRAW;
       wndclass.lpfnWndProc   = WndProc;
       wndclass.cbClsExtra    = 0;
       wndclass.cbWndExtra    = 0;
       wndclass.hInstance     = inst;
-      wndclass.hIcon         = LoadIcon(NULL, IDI_APPLICATION);
-      wndclass.hCursor       = LoadCursor(NULL, IDC_ARROW);
+      wndclass.hIcon         = LoadIcon(nullptr, IDI_APPLICATION);
+      wndclass.hCursor       = LoadCursor(nullptr, IDC_ARROW);
       wndclass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
-      wndclass.lpszMenuName  = NULL;
+      wndclass.lpszMenuName  = nullptr;
       wndclass.lpszClassName = lpszAppName;
-      wndclass.hIconSm       = LoadIcon(NULL, IDI_APPLICATION);
+      wndclass.hIconSm       = LoadIcon(nullptr, IDI_APPLICATION);
 
       RegisterClassEx(&wndclass) ;
       
       wnd = CreateWindow(lpszAppName, "The Hello World",
                          WS_OVERLAPPEDWINDOW,
                          CW_USEDEFAULT, CW_USEDEFAULT,
                          CW_USEDEFAULT, CW_USEDEFAULT,
-                         NULL, NULL, inst, NULL);		     
+                         nullptr, nullptr, inst, nullptr);		     
       
       ShowWindow(wnd, nShowCmd);
       UpdateWindow(wnd);
       
       nsCOMPtr<nsIEventLoop> eventLoop;
       
       if(NS_FAILED(nativeAppService->CreateEventLoop(L"_MainLoop", 
                                                      nsEventLoopTypes::MainAppLoop, getter_AddRefs(eventLoop))))

--- a/xpcom/tests/windows/TestNTFSPermissions.cpp
+++ b/xpcom/tests/windows/TestNTFSPermissions.cpp
@@ -29,19 +29,19 @@ nsresult TestPermissions()
     nsCOMPtr<nsIFile> tempDirectory1;
     nsCOMPtr<nsIFile> tempDirectory2;
     WCHAR filePath[MAX_PATH];
     WCHAR dir1Path[MAX_PATH];
     WCHAR dir2Path[MAX_PATH];
 
     // Security variables
     DWORD result;
-    PSID everyoneSID = NULL, adminSID = NULL;
-    PACL dirACL = NULL, fileACL = NULL;
-    PSECURITY_DESCRIPTOR dirSD = NULL, fileSD = NULL;
+    PSID everyoneSID = nullptr, adminSID = nullptr;
+    PACL dirACL = nullptr, fileACL = nullptr;
+    PSECURITY_DESCRIPTOR dirSD = nullptr, fileSD = nullptr;
     EXPLICIT_ACCESS ea[2];
     SID_IDENTIFIER_AUTHORITY SIDAuthWorld =
             SECURITY_WORLD_SID_AUTHORITY;
     SID_IDENTIFIER_AUTHORITY SIDAuthNT = SECURITY_NT_AUTHORITY;
     SECURITY_ATTRIBUTES sa;
     TRUSTEE everyoneTrustee;
     ACCESS_MASK everyoneRights;
 
@@ -81,27 +81,27 @@ nsresult TestPermissions()
     ea[1].grfAccessPermissions = GENERIC_ALL | STANDARD_RIGHTS_ALL;
     ea[1].grfAccessMode = SET_ACCESS;
     ea[1].grfInheritance= SUB_CONTAINERS_AND_OBJECTS_INHERIT;
     ea[1].Trustee.TrusteeForm = TRUSTEE_IS_SID;
     ea[1].Trustee.TrusteeType = TRUSTEE_IS_GROUP;
     ea[1].Trustee.ptstrName  = (LPTSTR) adminSID;
 
     // Create a new ACL that contains the new ACEs.
-    result = SetEntriesInAcl(2, ea, NULL, &dirACL);
+    result = SetEntriesInAcl(2, ea, nullptr, &dirACL);
     if (ERROR_SUCCESS != result) 
     {
         fail("NTFS Permissions: SetEntriesInAcl Error");
         return NS_ERROR_FAILURE; 
     }
 
     // Initialize a security descriptor.  
     dirSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, 
                              SECURITY_DESCRIPTOR_MIN_LENGTH); 
-    if (NULL == dirSD) 
+    if (nullptr == dirSD) 
     { 
         fail("NTFS Permissions: LocalAlloc Error");
         return NS_ERROR_FAILURE; 
     }
 
     if (!InitializeSecurityDescriptor(dirSD,
             SECURITY_DESCRIPTOR_REVISION)) 
     {  
@@ -123,61 +123,61 @@ nsresult TestPermissions()
 
     // Create and open first temporary directory
     if(!CreateDirectoryW(L".\\NTFSPERMTEMP1", &sa))
     {
         fail("NTFS Permissions: Creating Temporary Directory");
         return NS_ERROR_FAILURE;
     }
 
-    GetFullPathNameW((LPCWSTR)L".\\NTFSPERMTEMP1", MAX_PATH, dir1Path, NULL);
-
+    GetFullPathNameW((LPCWSTR)L".\\NTFSPERMTEMP1", MAX_PATH, dir1Path,
+                     nullptr);
 
     rv = NS_NewLocalFile(nsEmbedString(dir1Path), false,
                          getter_AddRefs(tempDirectory1));
     if (NS_FAILED(rv))
     {
         fail("NTFS Permissions: Opening Temporary Directory 1");
         return rv;
     }
 
 
     // Create and open temporary file
     tempFileHandle = CreateFileW(L".\\NTFSPERMTEMP1\\NTFSPerm.tmp", 
                             GENERIC_READ | GENERIC_WRITE,
                             0, 
-                            NULL, //default security
+                            nullptr, //default security
                             CREATE_ALWAYS,        
                             FILE_ATTRIBUTE_NORMAL,
-                            NULL);  
+                            nullptr);  
 
     if(tempFileHandle == INVALID_HANDLE_VALUE)
     {
         fail("NTFS Permissions: Creating Temporary File");
         return NS_ERROR_FAILURE;
     }
 
     CloseHandle(tempFileHandle);
 
     GetFullPathNameW((LPCWSTR)L".\\NTFSPERMTEMP1\\NTFSPerm.tmp", 
-                        MAX_PATH, filePath, NULL);
+                        MAX_PATH, filePath, nullptr);
 
     rv = NS_NewLocalFile(nsEmbedString(filePath), false,
                          getter_AddRefs(tempFile));
     if (NS_FAILED(rv))
     {
         fail("NTFS Permissions: Opening Temporary File");
                 return rv;
     }
 
     // Update Everyone Explict_Acess to full access.
     ea[0].grfAccessPermissions = GENERIC_ALL | STANDARD_RIGHTS_ALL;
 
     // Update the ACL to contain the new ACEs.
-    result = SetEntriesInAcl(2, ea, NULL, &dirACL);
+    result = SetEntriesInAcl(2, ea, nullptr, &dirACL);
     if (ERROR_SUCCESS != result) 
     {
         fail("NTFS Permissions: SetEntriesInAcl 2 Error");
         return NS_ERROR_FAILURE; 
     }
 
     // Add the new ACL to the security descriptor. 
     if (!SetSecurityDescriptorDacl(dirSD, true, dirACL, false)) 
@@ -188,18 +188,18 @@ nsresult TestPermissions()
 
     // Create and open second temporary directory
     if(!CreateDirectoryW(L".\\NTFSPERMTEMP2", &sa))
     {
         fail("NTFS Permissions: Creating Temporary Directory 2");
         return NS_ERROR_FAILURE;
     }
 
-    GetFullPathNameW((LPCWSTR)L".\\NTFSPERMTEMP2", MAX_PATH, dir2Path, NULL);
-
+    GetFullPathNameW((LPCWSTR)L".\\NTFSPERMTEMP2", MAX_PATH, dir2Path,
+                     nullptr);
 
     rv = NS_NewLocalFile(nsEmbedString(dir2Path), false,
                          getter_AddRefs(tempDirectory2));
     if (NS_FAILED(rv))
     {
         fail("NTFS Permissions: Opening Temporary Directory 2");
         return rv;
     }
@@ -213,17 +213,18 @@ nsresult TestPermissions()
         return rv;
     }
 
     // Access the ACL of the file
     result = GetNamedSecurityInfoW(L".\\NTFSPERMTEMP2\\NTFSPerm.tmp", 
                                         SE_FILE_OBJECT,
                                         DACL_SECURITY_INFORMATION | 
                                         UNPROTECTED_DACL_SECURITY_INFORMATION,
-                                        NULL, NULL, &fileACL, NULL, &fileSD);
+                                        nullptr, nullptr, &fileACL, nullptr,
+                                        &fileSD);
     if (ERROR_SUCCESS != result) 
     {
         fail("NTFS Permissions: GetNamedSecurityDescriptor Error");
         return NS_ERROR_FAILURE; 
     }
 
     // Build a trustee representing "Everyone"
     BuildTrusteeWithSid(&everyoneTrustee, everyoneSID);

--- a/xpcom/tests/windows/TestWinFileAttribs.cpp
+++ b/xpcom/tests/windows/TestWinFileAttribs.cpp
@@ -40,31 +40,31 @@ nsresult TestWinAttribs()
     HANDLE hIndexed;
     nsCOMPtr<nsIFile> localFile;
     WCHAR filePath[MAX_PATH];
 
     // Create and open temporary file
     hIndexed = CreateFileW(L".\\indexbit.txt", 
                             GENERIC_READ | GENERIC_WRITE,
                             0, 
-                            NULL,
+                            nullptr,
                             CREATE_ALWAYS,        
                             FILE_ATTRIBUTE_NORMAL, //FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, not supported by cf
-                            NULL);  
+                            nullptr);  
 
     if(hIndexed == INVALID_HANDLE_VALUE)
     {
         fail("Test Win Attribs: Creating Test File");
         return NS_ERROR_FAILURE;
     }
 
     CloseHandle(hIndexed);
 
     GetFullPathNameW((LPCWSTR)L".\\indexbit.txt", 
-                        MAX_PATH, filePath, NULL);
+                        MAX_PATH, filePath, nullptr);
 
     //wprintf(filePath);
     //wprintf(L"\n");
 
     rv = NS_NewLocalFile(nsEmbedString(filePath), false,
                          getter_AddRefs(localFile));
     if (NS_FAILED(rv))
     {

--- a/xpcom/threads/HangMonitor.cpp
+++ b/xpcom/threads/HangMonitor.cpp
@@ -54,17 +54,17 @@ PRThread* gThread;
 bool gShutdown;
 
 // The timestamp of the last event notification, or PR_INTERVAL_NO_WAIT if
 // we're currently not processing events.
 volatile PRIntervalTime gTimestamp = PR_INTERVAL_NO_WAIT;
 
 #ifdef REPORT_CHROME_HANGS
 // Main thread ID used in reporting chrome hangs under Windows
-static HANDLE winMainThreadHandle = NULL;
+static HANDLE winMainThreadHandle = nullptr;
 
 // Default timeout for reporting chrome hangs to Telemetry (5 seconds)
 static const int32_t DEFAULT_CHROME_HANG_INTERVAL = 5;
 
 // Maximum number of PCs to gather from the stack
 static const int32_t MAX_CALL_STACK_PCS = 400;
 #endif
 
@@ -227,36 +227,36 @@ Startup()
   // you must also deal with the threadsafety of AnnotateCrashReport in
   // non-chrome processes!
   if (GeckoProcessType_Default != XRE_GetProcessType())
     return;
 
   MOZ_ASSERT(!gMonitor, "Hang monitor already initialized");
   gMonitor = new Monitor("HangMonitor");
 
-  Preferences::RegisterCallback(PrefChanged, kHangMonitorPrefName, NULL);
-  PrefChanged(NULL, NULL);
+  Preferences::RegisterCallback(PrefChanged, kHangMonitorPrefName, nullptr);
+  PrefChanged(nullptr, nullptr);
 
 #ifdef REPORT_CHROME_HANGS
-  Preferences::RegisterCallback(PrefChanged, kTelemetryPrefName, NULL);
+  Preferences::RegisterCallback(PrefChanged, kTelemetryPrefName, nullptr);
   winMainThreadHandle =
     OpenThread(THREAD_ALL_ACCESS, FALSE, GetCurrentThreadId());
   if (!winMainThreadHandle)
     return;
 #endif
 
   // Don't actually start measuring hangs until we hit the main event loop.
   // This potentially misses a small class of really early startup hangs,
   // but avoids dealing with some xpcshell tests and other situations which
   // start XPCOM but don't ever start the event loop.
   Suspend();
 
   gThread = PR_CreateThread(PR_USER_THREAD,
                             ThreadMain,
-                            NULL, PR_PRIORITY_LOW, PR_GLOBAL_THREAD,
+                            nullptr, PR_PRIORITY_LOW, PR_GLOBAL_THREAD,
                             PR_JOINABLE_THREAD, 0);
 }
 
 void
 Shutdown()
 {
   if (GeckoProcessType_Default != XRE_GetProcessType())
     return;
@@ -267,38 +267,38 @@ Shutdown()
     MonitorAutoLock lock(*gMonitor);
     gShutdown = true;
     lock.Notify();
   }
 
   // thread creation could theoretically fail
   if (gThread) {
     PR_JoinThread(gThread);
-    gThread = NULL;
+    gThread = nullptr;
   }
 
   delete gMonitor;
-  gMonitor = NULL;
+  gMonitor = nullptr;
 }
 
 static bool
 IsUIMessageWaiting()
 {
 #ifndef XP_WIN
   return false;
 #else
   #define NS_WM_IMEFIRST WM_IME_SETCONTEXT
   #define NS_WM_IMELAST  WM_IME_KEYUP
   BOOL haveUIMessageWaiting = FALSE;
   MSG msg;
-  haveUIMessageWaiting |= ::PeekMessageW(&msg, NULL, WM_KEYFIRST, 
+  haveUIMessageWaiting |= ::PeekMessageW(&msg, nullptr, WM_KEYFIRST, 
                                          WM_IME_KEYLAST, PM_NOREMOVE);
-  haveUIMessageWaiting |= ::PeekMessageW(&msg, NULL, NS_WM_IMEFIRST,
+  haveUIMessageWaiting |= ::PeekMessageW(&msg, nullptr, NS_WM_IMEFIRST,
                                          NS_WM_IMELAST, PM_NOREMOVE);
-  haveUIMessageWaiting |= ::PeekMessageW(&msg, NULL, WM_MOUSEFIRST,
+  haveUIMessageWaiting |= ::PeekMessageW(&msg, nullptr, WM_MOUSEFIRST,
                                          WM_MOUSELAST, PM_NOREMOVE);
   return haveUIMessageWaiting;
 #endif
 }
 
 void
 NotifyActivity(ActivityType activityType)
 {

--- a/xpcom/threads/nsEnvironment.cpp
+++ b/xpcom/threads/nsEnvironment.cpp
@@ -48,18 +48,19 @@ nsEnvironment::Exists(const nsAString& a
 {
     nsAutoCString nativeName;
     nsresult rv = NS_CopyUnicodeToNative(aName, nativeName);
     NS_ENSURE_SUCCESS(rv, rv);
 
     nsAutoCString nativeVal;
 #if defined(XP_UNIX)
     /* For Unix/Linux platforms we follow the Unix definition:
-     * An environment variable exists when |getenv()| returns a non-NULL value.
-     * An environment variable does not exist when |getenv()| returns NULL.
+     * An environment variable exists when |getenv()| returns a non-nullptr
+     * value. An environment variable does not exist when |getenv()| returns
+     * nullptr.
      */
     const char *value = PR_GetEnv(nativeName.get());
     *aOutValue = value && *value;
 #else
     /* For non-Unix/Linux platforms we have to fall back to a 
      * "portable" definition (which is incorrect for Unix/Linux!!!!)
      * which simply checks whether the string returned by |Get()| is empty
      * or not.

--- a/xpcom/threads/nsProcessCommon.cpp
+++ b/xpcom/threads/nsProcessCommon.cpp
@@ -135,17 +135,17 @@ static int assembleCmdLine(char *const *
          * Finally, we need a space between arguments, and
          * a null byte at the end of command line.
          */
         cmdLineSize += 2 * strlen(*arg)  /* \ and " need to be escaped */
                 + 2                      /* we quote every argument */
                 + 1;                     /* space in between, or final null */
     }
     p = cmdLine = (char *) PR_MALLOC(cmdLineSize*sizeof(char));
-    if (p == NULL) {
+    if (p == nullptr) {
         return -1;
     }
 
     for (arg = argv; *arg; arg++) {
         /* Add a space to separates the arguments */
         if (arg != argv) {
             *p++ = ' '; 
         }
@@ -208,17 +208,17 @@ static int assembleCmdLine(char *const *
             }
         }
         if (argNeedQuotes) {
             *p++ = '"';
         }
     } 
 
     *p = '\0';
-    int32_t numChars = MultiByteToWideChar(codePage, 0, cmdLine, -1, NULL, 0); 
+    int32_t numChars = MultiByteToWideChar(codePage, 0, cmdLine, -1, nullptr, 0);
     *wideCmdLine = (PRUnichar *) PR_MALLOC(numChars*sizeof(PRUnichar));
     MultiByteToWideChar(codePage, 0, cmdLine, -1, *wideCmdLine, numChars); 
     PR_Free(cmdLine);
     return 0;
 }
 #endif
 
 void nsProcess::Monitor(void *arg)
@@ -237,17 +237,17 @@ void nsProcess::Monitor(void *arg)
         if (GetExitCodeProcess(process->mProcess, &exitCode) == FALSE)
             exitCode = -1;
     }
 
     // Lock in case Kill or GetExitCode are called during this
     {
         MutexAutoLock lock(process->mLock);
         CloseHandle(process->mProcess);
-        process->mProcess = NULL;
+        process->mProcess = nullptr;
         process->mExitValue = exitCode;
         if (process->mShutdown)
             return;
     }
 #else
 #ifdef XP_MACOSX
     int exitCode = -1;
     int status = 0;
@@ -334,30 +334,30 @@ nsProcess::RunAsync(const char **args, u
     return CopyArgsAndRunProcess(false, args, count, observer, holdWeak);
 }
 
 nsresult
 nsProcess::CopyArgsAndRunProcess(bool blocking, const char** args,
                                  uint32_t count, nsIObserver* observer,
                                  bool holdWeak)
 {
-    // Add one to the count for the program name and one for NULL termination.
-    char **my_argv = NULL;
+    // Add one to the count for the program name and one for null termination.
+    char **my_argv = nullptr;
     my_argv = (char**)NS_Alloc(sizeof(char*) * (count + 2));
     if (!my_argv) {
         return NS_ERROR_OUT_OF_MEMORY;
     }
 
     my_argv[0] = ToNewUTF8String(mTargetPath);
 
     for (uint32_t i = 0; i < count; i++) {
         my_argv[i + 1] = const_cast<char*>(args[i]);
     }
 
-    my_argv[count + 1] = NULL;
+    my_argv[count + 1] = nullptr;
 
     nsresult rv = RunProcess(blocking, my_argv, observer, holdWeak, false);
 
     NS_Free(my_argv[0]);
     NS_Free(my_argv);
     return rv;
 }
 
@@ -376,30 +376,30 @@ nsProcess::RunwAsync(const PRUnichar **a
     return CopyArgsAndRunProcessw(false, args, count, observer, holdWeak);
 }
 
 nsresult
 nsProcess::CopyArgsAndRunProcessw(bool blocking, const PRUnichar** args,
                                   uint32_t count, nsIObserver* observer,
                                   bool holdWeak)
 {
-    // Add one to the count for the program name and one for NULL termination.
-    char **my_argv = NULL;
+    // Add one to the count for the program name and one for null termination.
+    char **my_argv = nullptr;
     my_argv = (char**)NS_Alloc(sizeof(char*) * (count + 2));
     if (!my_argv) {
         return NS_ERROR_OUT_OF_MEMORY;
     }
 
     my_argv[0] = ToNewUTF8String(mTargetPath);
 
     for (uint32_t i = 0; i < count; i++) {
         my_argv[i + 1] = ToNewUTF8String(nsDependentString(args[i]));
     }
 
-    my_argv[count + 1] = NULL;
+    my_argv[count + 1] = nullptr;
 
     nsresult rv = RunProcess(blocking, my_argv, observer, holdWeak, true);
 
     for (uint32_t i = 0; i <= count; i++) {
         NS_Free(my_argv[i]);
     }
     NS_Free(my_argv);
     return rv;
@@ -423,37 +423,37 @@ nsProcess::RunProcess(bool blocking, cha
         }
     }
 
     mExitValue = -1;
     mPid = -1;
 
 #if defined(PROCESSMODEL_WINAPI)
     BOOL retVal;
-    PRUnichar *cmdLine = NULL;
+    PRUnichar *cmdLine = nullptr;
 
     // The 'argv' array is null-terminated and always starts with the program path.
     // If the second slot is non-null then arguments are being passed.
-    if (my_argv[1] != NULL &&
+    if (my_argv[1] != nullptr &&
         assembleCmdLine(my_argv + 1, &cmdLine, argsUTF8 ? CP_UTF8 : CP_ACP) == -1) {
         return NS_ERROR_FILE_EXECUTION_FAILED;    
     }
 
     /* The SEE_MASK_NO_CONSOLE flag is important to prevent console windows
      * from appearing. This makes behavior the same on all platforms. The flag
      * will not have any effect on non-console applications.
      */
 
     // The program name in my_argv[0] is always UTF-8
     NS_ConvertUTF8toUTF16 wideFile(my_argv[0]);
 
     SHELLEXECUTEINFOW sinfo;
     memset(&sinfo, 0, sizeof(SHELLEXECUTEINFOW));
     sinfo.cbSize = sizeof(SHELLEXECUTEINFOW);
-    sinfo.hwnd   = NULL;
+    sinfo.hwnd   = nullptr;
     sinfo.lpFile = wideFile.get();
     sinfo.nShow  = SW_SHOWNORMAL;
     sinfo.fMask  = SEE_MASK_FLAG_DDEWAIT |
                    SEE_MASK_NO_CONSOLE |
                    SEE_MASK_NOCLOSEPROCESS;
 
     if (cmdLine)
         sinfo.lpParameters = cmdLine;
@@ -482,26 +482,26 @@ nsProcess::RunProcess(bool blocking, cha
     if (posix_spawnattr_setbinpref_np(&spawnattr, attr_count, pref_cpu_types, &attr_ocount) != 0 ||
         attr_ocount != attr_count) {
         posix_spawnattr_destroy(&spawnattr);
         return NS_ERROR_FAILURE;
     }
 
     // Note that the 'argv' array is already null-terminated, which 'posix_spawnp' requires.
     pid_t newPid = 0;
-    int result = posix_spawnp(&newPid, my_argv[0], NULL, &spawnattr, my_argv, *_NSGetEnviron());
+    int result = posix_spawnp(&newPid, my_argv[0], nullptr, &spawnattr, my_argv, *_NSGetEnviron());
     mPid = static_cast<int32_t>(newPid);
 
     posix_spawnattr_destroy(&spawnattr);
 
     if (result != 0) {
         return NS_ERROR_FAILURE;
     }
 #else
-    mProcess = PR_CreateProcess(my_argv[0], my_argv, NULL, NULL);
+    mProcess = PR_CreateProcess(my_argv[0], my_argv, nullptr, nullptr);
     if (!mProcess)
         return NS_ERROR_FAILURE;
     struct MYProcess {
         uint32_t pid;
     };
     MYProcess* ptrProc = (MYProcess *) mProcess;
     mPid = ptrProc->pid;
 #endif

--- a/xpcom/threads/nsThreadManager.cpp
+++ b/xpcom/threads/nsThreadManager.cpp
@@ -36,17 +36,17 @@ AppendAndRemoveThread(PRThread *key, nsR
   nsThreadArray *threads = static_cast<nsThreadArray *>(arg);
   threads->AppendElement(thread);
   return PL_DHASH_REMOVE;
 }
 
 // statically allocated instance
 NS_IMETHODIMP_(nsrefcnt) nsThreadManager::AddRef() { return 2; }
 NS_IMETHODIMP_(nsrefcnt) nsThreadManager::Release() { return 1; }
-NS_IMPL_CLASSINFO(nsThreadManager, NULL,
+NS_IMPL_CLASSINFO(nsThreadManager, nullptr,
                   nsIClassInfo::THREADSAFE | nsIClassInfo::SINGLETON,
                   NS_THREADMANAGER_CID)
 NS_IMPL_QUERY_INTERFACE1_CI(nsThreadManager, nsIThreadManager)
 NS_IMPL_CI_INTERFACE_GETTER1(nsThreadManager, nsIThreadManager)
 
 //-----------------------------------------------------------------------------
 
 nsresult

--- a/xpcom/threads/nsThreadPool.cpp
+++ b/xpcom/threads/nsThreadPool.cpp
@@ -52,17 +52,17 @@ public:
 
 private:
   nsCOMArray<nsIThread> mThreads;
   nsCOMPtr<nsIThreadPoolListener> mListener;
 };
 
 NS_IMPL_ADDREF(nsThreadPool)
 NS_IMPL_RELEASE(nsThreadPool)
-NS_IMPL_CLASSINFO(nsThreadPool, NULL, nsIClassInfo::THREADSAFE,
+NS_IMPL_CLASSINFO(nsThreadPool, nullptr, nsIClassInfo::THREADSAFE,
                   NS_THREADPOOL_CID)
 NS_IMPL_QUERY_INTERFACE3_CI(nsThreadPool, nsIThreadPool, nsIEventTarget,
                             nsIRunnable)
 NS_IMPL_CI_INTERFACE_GETTER2(nsThreadPool, nsIThreadPool, nsIEventTarget)
 
 nsThreadPool::nsThreadPool()
   : mThreadLimit(DEFAULT_THREAD_LIMIT)
   , mIdleThreadLimit(DEFAULT_IDLE_THREAD_LIMIT)

--- a/xpcom/windbgdlg/windbgdlg.cpp
+++ b/xpcom/windbgdlg/windbgdlg.cpp
@@ -110,12 +110,12 @@ wWinMain(HINSTANCE  hInstance, HINSTANCE
     snwprintf(msg,
 #endif
               size,
               L"%s\n\nClick Abort to exit the Application.\n"
               L"Click Retry to Debug the Application.\n"
               L"Click Ignore to continue running the Application.",
               lpszCmdLine);
     msg[size - 1] = L'\0';
-    return MessageBoxW(NULL, msg, L"NSGlue_Assertion",
+    return MessageBoxW(nullptr, msg, L"NSGlue_Assertion",
                        MB_ICONSTOP | MB_SYSTEMMODAL |
                        MB_ABORTRETRYIGNORE | MB_DEFBUTTON3);
 }