--- a/accessible/src/windows/msaa/IUnknownImpl.cpp
+++ b/accessible/src/windows/msaa/IUnknownImpl.cpp
@@ -18,17 +18,17 @@ namespace a11y {
 
 HRESULT
 GetHRESULT(nsresult aResult)
 {
   switch (aResult) {
     case NS_OK:
       return S_OK;
 
-    case NS_ERROR_INVALID_ARG:
+    case NS_ERROR_INVALID_ARG: case NS_ERROR_INVALID_POINTER:
       return E_INVALIDARG;
 
     case NS_ERROR_OUT_OF_MEMORY:
       return E_OUTOFMEMORY;
 
     case NS_ERROR_NOT_IMPLEMENTED:
       return E_NOTIMPL;
 

--- a/xpcom/base/ErrorList.h
+++ b/xpcom/base/ErrorList.h
@@ -11,29 +11,29 @@
   ERROR(NS_ERROR_NOT_INITIALIZED,               NS_ERROR_BASE + 1),
   /* Returned when an instance is already initialized */
   ERROR(NS_ERROR_ALREADY_INITIALIZED,           NS_ERROR_BASE + 2),
   /* Returned by a not implemented function */
   ERROR(NS_ERROR_NOT_IMPLEMENTED,               0x80004001),
   /* Returned when a given interface is not supported. */
   ERROR(NS_NOINTERFACE,                         0x80004002),
   ERROR(NS_ERROR_NO_INTERFACE,                  NS_NOINTERFACE),
+  ERROR(NS_ERROR_INVALID_POINTER,               0x80004003),
+  ERROR(NS_ERROR_NULL_POINTER,                  NS_ERROR_INVALID_POINTER),
   /* Returned when a function aborts */
   ERROR(NS_ERROR_ABORT,                         0x80004004),
   /* Returned when a function fails */
   ERROR(NS_ERROR_FAILURE,                       0x80004005),
   /* Returned when an unexpected error occurs */
   ERROR(NS_ERROR_UNEXPECTED,                    0x8000ffff),
   /* Returned when a memory allocation fails */
   ERROR(NS_ERROR_OUT_OF_MEMORY,                 0x8007000e),
   /* Returned when an illegal value is passed */
   ERROR(NS_ERROR_ILLEGAL_VALUE,                 0x80070057),
   ERROR(NS_ERROR_INVALID_ARG,                   NS_ERROR_ILLEGAL_VALUE),
-  ERROR(NS_ERROR_INVALID_POINTER,               NS_ERROR_INVALID_ARG),
-  ERROR(NS_ERROR_NULL_POINTER,                  NS_ERROR_INVALID_ARG),
   /* Returned when a class doesn't allow aggregation */
   ERROR(NS_ERROR_NO_AGGREGATION,                0x80040110),
   /* Returned when an operation can't complete due to an unavailable resource */
   ERROR(NS_ERROR_NOT_AVAILABLE,                 0x80040111),
   /* Returned when a class is not registered */
   ERROR(NS_ERROR_FACTORY_NOT_REGISTERED,        0x80040154),
   /* Returned when a class cannot be registered, but may be tried again later */
   ERROR(NS_ERROR_FACTORY_REGISTER_AGAIN,        0x80040155),

--- a/xpcom/base/nsAgg.h
+++ b/xpcom/base/nsAgg.h
@@ -280,19 +280,19 @@ nsresult                                
     if (!tmp->IsPartOfAggregated())                                         \
         NS_IMPL_CYCLE_COLLECTION_DESCRIBE(_class, tmp->mRefCnt.get())
 
 #define NS_GENERIC_AGGREGATED_CONSTRUCTOR(_InstanceClass)                   \
 static nsresult                                                             \
 _InstanceClass##Constructor(nsISupports *aOuter, REFNSIID aIID,             \
                             void **aResult)                                 \
 {                                                                           \
-    *aResult = nullptr;                                                     \
-    if (NS_WARN_IF(aOuter && !aIID.Equals(NS_GET_IID(nsISupports))))        \
-        return NS_ERROR_INVALID_ARG;                                        \
+    *aResult = nullptr;                                                      \
+                                                                            \
+    NS_ENSURE_PROPER_AGGREGATION(aOuter, aIID);                             \
                                                                             \
     _InstanceClass* inst = new _InstanceClass(aOuter);                      \
     if (!inst) {                                                            \
         return NS_ERROR_OUT_OF_MEMORY;                                      \
     }                                                                       \
                                                                             \
     nsISupports* inner = inst->InnerObject();                               \
     nsresult rv = inner->QueryInterface(aIID, aResult);                     \
@@ -303,19 +303,19 @@ static nsresult                         
     return rv;                                                              \
 }                                                                           \
 
 #define NS_GENERIC_AGGREGATED_CONSTRUCTOR_INIT(_InstanceClass, _InitMethod) \
 static nsresult                                                             \
 _InstanceClass##Constructor(nsISupports *aOuter, REFNSIID aIID,             \
                             void **aResult)                                 \
 {                                                                           \
-    *aResult = nullptr;                                                     \
-    if (NS_WARN_IF(aOuter && !aIID.Equals(NS_GET_IID(nsISupports))))        \
-        return NS_ERROR_INVALID_ARG;                                        \
+    *aResult = nullptr;                                                      \
+                                                                            \
+    NS_ENSURE_PROPER_AGGREGATION(aOuter, aIID);                             \
                                                                             \
     _InstanceClass* inst = new _InstanceClass(aOuter);                      \
     if (!inst) {                                                            \
         return NS_ERROR_OUT_OF_MEMORY;                                      \
     }                                                                       \
                                                                             \
     nsISupports* inner = inst->InnerObject();                               \
     NS_ADDREF(inner);                                                       \

--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -1216,41 +1216,37 @@ public:
         }
 
         // Initially create the log in a file starting with
         // "incomplete-gc-edges".  We'll move the file and strip off the
         // "incomplete-" once the dump completes.  (We do this because we don't
         // want scripts which poll the filesystem looking for gc/cc dumps to
         // grab a file before we're finished writing to it.)
         nsCOMPtr<nsIFile> gcLogFile = CreateTempFile("incomplete-gc-edges");
-        if (NS_WARN_IF(!gcLogFile))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(gcLogFile);
 
         // Dump the JS heap.
         FILE* gcLogANSIFile = nullptr;
         gcLogFile->OpenANSIFileDesc("w", &gcLogANSIFile);
-        if (NS_WARN_IF(!gcLogANSIFile))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(gcLogANSIFile);
         MozillaRegisterDebugFILE(gcLogANSIFile);
         CollectorData *data = sCollectorData.get();
         if (data && data->mRuntime)
             data->mRuntime->DumpJSHeap(gcLogANSIFile);
         MozillaUnRegisterDebugFILE(gcLogANSIFile);
         fclose(gcLogANSIFile);
 
         // Strip off "incomplete-".
         nsCOMPtr<nsIFile> gcLogFileFinalDestination =
             CreateTempFile("gc-edges");
-        if (NS_WARN_IF(!gcLogFileFinalDestination))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(gcLogFileFinalDestination);
 
         nsAutoString gcLogFileFinalDestinationName;
         gcLogFileFinalDestination->GetLeafName(gcLogFileFinalDestinationName);
-        if (NS_WARN_IF(gcLogFileFinalDestinationName.IsEmpty()))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(!gcLogFileFinalDestinationName.IsEmpty());
 
         gcLogFile->MoveTo(/* directory */ nullptr, gcLogFileFinalDestinationName);
 
         // Log to the error console.
         nsCOMPtr<nsIConsoleService> cs =
             do_GetService(NS_CONSOLESERVICE_CONTRACTID);
         if (cs) {
             nsAutoString gcLogPath;
@@ -1259,22 +1255,20 @@ public:
             nsString msg = NS_LITERAL_STRING("Garbage Collector log dumped to ") +
                            gcLogPath;
             cs->LogStringMessage(msg.get());
         }
 
         // Open a file for dumping the CC graph.  We again prefix with
         // "incomplete-".
         mOutFile = CreateTempFile("incomplete-cc-edges");
-        if (NS_WARN_IF(!mOutFile))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(mOutFile);
         MOZ_ASSERT(!mStream);
         mOutFile->OpenANSIFileDesc("w", &mStream);
-        if (NS_WARN_IF(!mStream))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(mStream);
         MozillaRegisterDebugFILE(mStream);
 
         fprintf(mStream, "# WantAllTraces=%s\n", mWantAllTraces ? "true" : "false");
 
         return NS_OK;
     }
     NS_IMETHOD NoteRefCountedObject(uint64_t aAddress, uint32_t refCount,
                                     const char *aObjectDescription)
@@ -1389,23 +1383,21 @@ public:
 
             MozillaUnRegisterDebugFILE(mStream);
             fclose(mStream);
             mStream = nullptr;
 
             // Strip off "incomplete-" from the log file's name.
             nsCOMPtr<nsIFile> logFileFinalDestination =
                 CreateTempFile("cc-edges");
-            if (NS_WARN_IF(!logFileFinalDestination))
-                return NS_ERROR_UNEXPECTED;
+            NS_ENSURE_STATE(logFileFinalDestination);
 
             nsAutoString logFileFinalDestinationName;
             logFileFinalDestination->GetLeafName(logFileFinalDestinationName);
-            if (NS_WARN_IF(logFileFinalDestinationName.IsEmpty()))
-                return NS_ERROR_UNEXPECTED;
+            NS_ENSURE_STATE(!logFileFinalDestinationName.IsEmpty());
 
             mOutFile->MoveTo(/* directory = */ nullptr,
                              logFileFinalDestinationName);
             mOutFile = nullptr;
 
             // Log to the error console.
             nsCOMPtr<nsIConsoleService> cs =
                 do_GetService(NS_CONSOLESERVICE_CONTRACTID);
@@ -1418,18 +1410,17 @@ public:
                 cs->LogStringMessage(msg.get());
             }
         }
         return NS_OK;
     }
     NS_IMETHOD ProcessNext(nsICycleCollectorHandler* aHandler,
                            bool* aCanContinue)
     {
-        if (NS_WARN_IF(!aHandler) || NS_WARN_IF(!mWantAfterProcessing))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(aHandler && mWantAfterProcessing);
         CCGraphDescriber* d = mDescribers.popFirst();
         if (d) {
             switch (d->mType) {
                 case CCGraphDescriber::eRefCountedObject:
                     aHandler->NoteRefCountedObject(d->mAddress,
                                                    d->mCnt,
                                                    d->mName);
                     break;
@@ -1519,18 +1510,17 @@ private:
 
 NS_IMPL_ISUPPORTS1(nsCycleCollectorLogger, nsICycleCollectorListener)
 
 nsresult
 nsCycleCollectorLoggerConstructor(nsISupports* aOuter,
                                   const nsIID& aIID,
                                   void* *aInstancePtr)
 {
-    if (NS_WARN_IF(aOuter))
-        return NS_ERROR_NO_AGGREGATION;
+    NS_ENSURE_TRUE(!aOuter, NS_ERROR_NO_AGGREGATION);
 
     nsISupports *logger = new nsCycleCollectorLogger();
 
     return logger->QueryInterface(aIID, aInstancePtr);
 }
 
 ////////////////////////////////////////////////////////////////////////
 // Bacon & Rajan's |MarkRoots| routine.
@@ -2443,18 +2433,17 @@ class CycleCollectorReporter MOZ_FINAL :
         do {                                                                  \
             size_t amount = _amount;  /* evaluate |_amount| only once */      \
             if (amount > 0) {                                                 \
                 nsresult rv;                                                  \
                 rv = aCb->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
                                    nsIMemoryReporter::KIND_HEAP,              \
                                    nsIMemoryReporter::UNITS_BYTES, _amount,   \
                                    NS_LITERAL_CSTRING(_desc), aClosure);      \
-                if (NS_WARN_IF(NS_FAILED(rv)))                                \
-                    return rv;                                                \
+                NS_ENSURE_SUCCESS(rv, rv);                                    \
             }                                                                 \
         } while (0)
 
         REPORT("explicit/cycle-collector/collector-object", objectSize,
                "Memory used for the cycle collector object itself.");
 
         REPORT("explicit/cycle-collector/graph-nodes", graphNodesSize,
                "Memory used for the nodes of the cycle collector's graph. "

--- a/xpcom/base/nsDebugImpl.cpp
+++ b/xpcom/base/nsDebugImpl.cpp
@@ -560,18 +560,17 @@ Break(const char *aMsg)
 #endif
 }
 
 static const nsDebugImpl kImpl;
 
 nsresult
 nsDebugImpl::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
 {
-  if (NS_WARN_IF(outer))
-    return NS_ERROR_NO_AGGREGATION;
+  NS_ENSURE_NO_AGGREGATION(outer);
 
   return const_cast<nsDebugImpl*>(&kImpl)->
     QueryInterface(aIID, aInstancePtr);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 nsresult

--- a/xpcom/base/nsErrorService.cpp
+++ b/xpcom/base/nsErrorService.cpp
@@ -60,18 +60,17 @@ nsInt2StrHashtable::Remove(uint32_t key)
 
 ////////////////////////////////////////////////////////////////////////////////
 
 NS_IMPL_ISUPPORTS1(nsErrorService, nsIErrorService)
 
 nsresult
 nsErrorService::Create(nsISupports* outer, const nsIID& aIID, void* *aInstancePtr)
 {
-    if (NS_WARN_IF(outer))
-        return NS_ERROR_NO_AGGREGATION;
+    NS_ENSURE_NO_AGGREGATION(outer);
     nsRefPtr<nsErrorService> serv = new nsErrorService();
     return serv->QueryInterface(aIID, aInstancePtr);
 }
 
 NS_IMETHODIMP
 nsErrorService::RegisterErrorStringBundle(int16_t errorModule, const char *stringBundleURL)
 {
     return mErrorStringBundleURLMap.Put(errorModule, stringBundleURL);

--- a/xpcom/base/nsGZFileWriter.cpp
+++ b/xpcom/base/nsGZFileWriter.cpp
@@ -28,71 +28,64 @@ nsGZFileWriter::~nsGZFileWriter()
   if (mInitialized && !mFinished) {
     Finish();
   }
 }
 
 NS_IMETHODIMP
 nsGZFileWriter::Init(nsIFile* aFile)
 {
-  if (NS_WARN_IF(mInitialized) ||
-      NS_WARN_IF(mFinished))
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_FALSE(mInitialized, NS_ERROR_FAILURE);
+  NS_ENSURE_FALSE(mFinished, NS_ERROR_FAILURE);
 
   // Get a FILE out of our nsIFile.  Convert that into a file descriptor which
   // gzip can own.  Then close our FILE, leaving only gzip's fd open.
 
   FILE* file;
   nsresult rv = aFile->OpenANSIFileDesc("wb", &file);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   mGZFile = gzdopen(dup(fileno(file)), "wb");
   fclose(file);
 
   // gzdopen returns nullptr on error.
-  if (NS_WARN_IF(!mGZFile))
-    return NS_ERROR_FAILURE;
-
+  NS_ENSURE_TRUE(mGZFile, NS_ERROR_FAILURE);
   mInitialized = true;
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGZFileWriter::Write(const nsACString& aStr)
 {
-  if (NS_WARN_IF(!mInitialized) ||
-      NS_WARN_IF(mFinished))
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED);
+  NS_ENSURE_FALSE(mFinished, NS_ERROR_FAILURE);
 
   // gzwrite uses a return value of 0 to indicate failure.  Otherwise, it
   // returns the number of uncompressed bytes written.  To ensure we can
   // distinguish between success and failure, don't call gzwrite when we have 0
   // bytes to write.
   if (aStr.IsEmpty()) {
     return NS_OK;
   }
 
   // gzwrite never does a short write -- that is, the return value should
   // always be either 0 or aStr.Length(), and we shouldn't have to call it
   // multiple times in order to get it to read the whole buffer.
   int rv = gzwrite(mGZFile, aStr.BeginReading(), aStr.Length());
-  if (NS_WARN_IF(rv != static_cast<int>(aStr.Length())))
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(rv == static_cast<int>(aStr.Length()), NS_ERROR_FAILURE);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsGZFileWriter::Finish()
 {
-  if (NS_WARN_IF(!mInitialized) ||
-      NS_WARN_IF(mFinished))
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_TRUE(mInitialized, NS_ERROR_NOT_INITIALIZED);
+  NS_ENSURE_FALSE(mFinished, NS_ERROR_FAILURE);
 
   mFinished = true;
   gzclose(mGZFile);
 
   // Ignore errors from gzclose; it's not like there's anything we can do about
   // it, at this point!
   return NS_OK;
 }

--- a/xpcom/base/nsIMemoryReporter.idl
+++ b/xpcom/base/nsIMemoryReporter.idl
@@ -530,18 +530,17 @@ public:
     return NS_OK;
   }
 
   NS_IMETHOD CollectReports(nsIMemoryReporterCallback* aCallback,
                             nsISupports* aData)
   {
     int64_t amount;
     nsresult rv = GetAmount(&amount);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     return aCallback->Callback(EmptyCString(), mNameAndPath, mKind, mUnits,
                                amount, mDescription, aData);
   }
 
 protected:
   NS_IMETHOD GetAmount(int64_t* aAmount)
   {

--- a/xpcom/base/nsMacUtilsImpl.cpp
+++ b/xpcom/base/nsMacUtilsImpl.cpp
@@ -84,18 +84,17 @@ nsresult nsMacUtilsImpl::GetArchString(n
 
   archString.Assign(mBinaryArchs);
 
   return (archString.IsEmpty() ? NS_ERROR_FAILURE : NS_OK);
 }
 
 NS_IMETHODIMP nsMacUtilsImpl::GetIsUniversalBinary(bool *aIsUniversalBinary)
 {
-  if (NS_WARN_IF(!aIsUniversalBinary))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(aIsUniversalBinary);
   *aIsUniversalBinary = false;
 
   nsAutoString archString;
   nsresult rv = GetArchString(archString);
   if (NS_FAILED(rv))
     return rv;
 
   // The delimiter char in the arch string is '-', so if that character

--- a/xpcom/base/nsMemoryImpl.cpp
+++ b/xpcom/base/nsMemoryImpl.cpp
@@ -88,18 +88,17 @@ nsMemoryImpl::IsLowMemoryPlatform(bool *
     *result = false;
 #endif
     return NS_OK;
 }
 
 /*static*/ nsresult
 nsMemoryImpl::Create(nsISupports* outer, const nsIID& aIID, void **aResult)
 {
-    if (NS_WARN_IF(outer))
-        return NS_ERROR_NO_AGGREGATION;
+    NS_ENSURE_NO_AGGREGATION(outer);
     return sGlobalMemory.QueryInterface(aIID, aResult);
 }
 
 nsresult
 nsMemoryImpl::FlushMemory(const PRUnichar* aReason, bool aImmediate)
 {
     nsresult rv = NS_OK;
 

--- a/xpcom/base/nsMemoryInfoDumper.cpp
+++ b/xpcom/base/nsMemoryInfoDumper.cpp
@@ -411,28 +411,25 @@ public:
     if (NS_SUCCEEDED(rv)) {
       rv = XRE_GetFileFromPath(dirPath.get(), getter_AddRefs(file));
       if (NS_FAILED(rv)) {
         LOG("FifoWatcher failed to open file \"%s\"", dirPath.get());
         return -1;
       }
     } else {
       rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(file));
-      if (NS_WARN_IF(NS_FAILED(rv)))
-        return -1;
+      NS_ENSURE_SUCCESS(rv, -1);
     }
 
     rv = file->AppendNative(NS_LITERAL_CSTRING("debug_info_trigger"));
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return -1;
+    NS_ENSURE_SUCCESS(rv, -1);
 
     nsAutoCString path;
     rv = file->GetNativePath(path);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return -1;
+    NS_ENSURE_SUCCESS(rv, -1);
 
     // unlink might fail because the file doesn't exist, or for other reasons.
     // But we don't care it fails; any problems will be detected later, when we
     // try to mkfifo or open the file.
     if (unlink(path.get())) {
       LOG("FifoWatcher::OpenFifo unlink failed; errno=%d.  "
           "Continuing despite error.", errno);
     }
@@ -604,18 +601,17 @@ nsMemoryInfoDumper::DumpGCAndCCLogsToFil
   return NS_OK;
 }
 
 namespace mozilla {
 
 #define DUMP(o, s) \
   do { \
     nsresult rv = (o)->Write(s); \
-    if (NS_WARN_IF(NS_FAILED(rv))) \
-      return rv; \
+    NS_ENSURE_SUCCESS(rv, rv); \
   } while (0)
 
 static nsresult
 DumpReport(nsIGZFileWriter *aWriter, bool aIsFirst,
   const nsACString &aProcess, const nsACString &aPath, int32_t aKind,
   int32_t aUnits, int64_t aAmount, const nsACString &aDescription)
 {
   DUMP(aWriter, aIsFirst ? "[" : ",");
@@ -679,18 +675,17 @@ public:
   DumpReportCallback() : mIsFirst(true) {}
 
   NS_IMETHOD Callback(const nsACString &aProcess, const nsACString &aPath,
       int32_t aKind, int32_t aUnits, int64_t aAmount,
       const nsACString &aDescription,
       nsISupports *aData)
   {
     nsCOMPtr<nsIGZFileWriter> writer = do_QueryInterface(aData);
-    if (NS_WARN_IF(!writer))
-      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(writer, NS_ERROR_FAILURE);
 
     nsresult rv = DumpReport(writer, mIsFirst, aProcess, aPath, aKind, aUnits,
                              aAmount, aDescription);
     mIsFirst = false;
     return rv;
   }
 
 private:
@@ -722,59 +717,53 @@ nsMemoryInfoDumper::OpenTempFile(const n
     if (env) {
       NS_NewNativeLocalFile(nsCString(env), /* followLinks = */ true, aFile);
     }
   }
 #endif
   nsresult rv;
   if (!*aFile) {
     rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, aFile);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
 #ifdef ANDROID
   // /data/local/tmp is a true tmp directory; anyone can create a file there,
   // but only the user which created the file can remove it.  We want non-root
   // users to be able to remove these files, so we write them into a
   // subdirectory of the temp directory and chmod 777 that directory.
   rv = (*aFile)->AppendNative(NS_LITERAL_CSTRING("memory-reports"));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // It's OK if this fails; that probably just means that the directory already
   // exists.
   (*aFile)->Create(nsIFile::DIRECTORY_TYPE, 0777);
 
   nsAutoCString dirPath;
   rv = (*aFile)->GetNativePath(dirPath);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   while (chmod(dirPath.get(), 0777) == -1 && errno == EINTR) {}
 #endif
 
   nsCOMPtr<nsIFile> file(*aFile);
 
   rv = file->AppendNative(aFilename);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   rv = file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0666);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
 #ifdef ANDROID
     // Make this file world-read/writable; the permissions passed to the
     // CreateUnique call above are not sufficient on Android, which runs with a
     // umask.
     nsAutoCString path;
     rv = file->GetNativePath(path);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     while (chmod(path.get(), 0666) == -1 && errno == EINTR) {}
 #endif
 
   return NS_OK;
 }
 
 #ifdef MOZ_DMD
@@ -807,18 +796,17 @@ DumpHeader(nsIGZFileWriter* aWriter)
   // over 200 KiB of memory.
   //
   DUMP(aWriter, "{\n  \"version\": 1,\n");
 
   DUMP(aWriter, "  \"hasMozMallocUsableSize\": ");
 
   nsCOMPtr<nsIMemoryReporterManager> mgr =
     do_GetService("@mozilla.org/memory-reporter-manager;1");
-  if (NS_WARN_IF(!mgr))
-    return NS_ERROR_UNEXPECTED;
+  NS_ENSURE_STATE(mgr);
 
   DUMP(aWriter, mgr->GetHasMozMallocUsableSize() ? "true" : "false");
   DUMP(aWriter, ",\n");
   DUMP(aWriter, "  \"reports\": ");
 
   return NS_OK;
 }
 
@@ -879,22 +867,21 @@ DumpProcessMemoryInfoToTempDir(const nsA
   nsCString mrFilename;
   MakeFilename("memory-report", aIdentifier, "json.gz", mrFilename);
 
   nsCOMPtr<nsIFile> mrTmpFile;
   nsresult rv;
   rv = nsMemoryInfoDumper::OpenTempFile(NS_LITERAL_CSTRING("incomplete-") +
                                         mrFilename,
                                         getter_AddRefs(mrTmpFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsRefPtr<nsGZFileWriter> mrWriter = new nsGZFileWriter();
   rv = mrWriter->Init(mrTmpFile);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Dump the memory reports to the file.
   DumpProcessMemoryReportsToGZFileWriter(mrWriter);
 
 #ifdef MOZ_DMD
   // Create a filename like dmd-<identifier>-<pid>.txt.gz, which will be used
   // if DMD is enabled.
   nsCString dmdFilename;
@@ -902,86 +889,74 @@ DumpProcessMemoryInfoToTempDir(const nsA
 
   // Open a new DMD file named |dmdFilename| in NS_OS_TEMP_DIR for writing,
   // and dump DMD output to it.  This must occur after the memory reporters
   // have been run (above), but before the memory-reports file has been
   // renamed (so scripts can detect the DMD file, if present).
 
   nsCOMPtr<nsIFile> dmdFile;
   rv = nsMemoryInfoDumper::OpenTempFile(dmdFilename, getter_AddRefs(dmdFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsRefPtr<nsGZFileWriter> dmdWriter = new nsGZFileWriter();
   rv = dmdWriter->Init(dmdFile);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Dump DMD output to the file.
 
   DMDWriteState state(dmdWriter);
   dmd::Writer w(DMDWrite, &state);
   dmd::Dump(w);
 
   rv = dmdWriter->Finish();
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 #endif  // MOZ_DMD
 
   // The call to Finish() deallocates the memory allocated by mrWriter's first
   // DUMP() call (within DumpProcessMemoryReportsToGZFileWriter()).  Because
   // that memory was live while the memory reporters ran and thus measured by
   // them -- by "heap-allocated" if nothing else -- we want DMD to see it as
   // well.  So we deliberately don't call Finish() until after DMD finishes.
   rv = mrWriter->Finish();
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Rename the memory reports file, now that we're done writing all the files.
   // Its final name is "memory-report<-identifier>-<pid>.json.gz".
 
   nsCOMPtr<nsIFile> mrFinalFile;
   rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(mrFinalFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
 #ifdef ANDROID
   rv = mrFinalFile->AppendNative(NS_LITERAL_CSTRING("memory-reports"));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 #endif
 
   rv = mrFinalFile->AppendNative(mrFilename);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   rv = mrFinalFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0600);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsAutoString mrActualFinalFilename;
   rv = mrFinalFile->GetLeafName(mrActualFinalFilename);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   rv = mrTmpFile->MoveTo(/* directory */ nullptr, mrActualFinalFilename);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Write a message to the console.
 
   nsCOMPtr<nsIConsoleService> cs =
     do_GetService(NS_CONSOLESERVICE_CONTRACTID, &rv);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsString path;
   mrTmpFile->GetPath(path);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   nsString msg = NS_LITERAL_STRING(
     "nsIMemoryInfoDumper dumped reports to ");
   msg.Append(path);
   return cs->LogStringMessage(msg.get());
 }
 
 NS_IMETHODIMP
@@ -1008,18 +983,17 @@ nsMemoryInfoDumper::DumpMemoryInfoToTemp
   if (aMinimizeMemoryUsage) {
     // Minimize memory usage, then run DumpMemoryInfoToTempDir again.
     nsRefPtr<DumpMemoryInfoToTempDirRunnable> callback =
       new DumpMemoryInfoToTempDirRunnable(identifier,
                                           /* minimizeMemoryUsage = */ false,
                                           /* dumpChildProcesses = */ false);
     nsCOMPtr<nsIMemoryReporterManager> mgr =
       do_GetService("@mozilla.org/memory-reporter-manager;1");
-    if (NS_WARN_IF(!mgr))
-      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(mgr, NS_ERROR_FAILURE);
     nsCOMPtr<nsICancelableRunnable> runnable;
     mgr->MinimizeMemoryUsage(callback, getter_AddRefs(runnable));
     return NS_OK;
   }
 
   return DumpProcessMemoryInfoToTempDir(identifier);
 }
 
@@ -1064,44 +1038,38 @@ nsMemoryInfoDumper::DumpMemoryReportsToN
   nsISupports* aFinishDumpingData)
 {
   MOZ_ASSERT(!aFilename.IsEmpty());
 
   // Create the file.
 
   nsCOMPtr<nsIFile> mrFile;
   nsresult rv = NS_NewLocalFile(aFilename, false, getter_AddRefs(mrFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   mrFile->InitWithPath(aFilename);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   bool exists;
   rv = mrFile->Exists(&exists);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   if (!exists) {
     rv = mrFile->Create(nsIFile::NORMAL_FILE_TYPE, 0644);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
   // Write the memory reports to the file.
 
   nsRefPtr<nsGZFileWriter> mrWriter = new nsGZFileWriter();
   rv = mrWriter->Init(mrFile);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   rv = DumpHeader(mrWriter);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   // Process reports and finish up.
   nsRefPtr<DumpReportCallback> dumpReport = new DumpReportCallback();
   nsRefPtr<FinishReportingCallback> finishReporting =
     new FinishReportingCallback(aFinishDumping, aFinishDumpingData);
   nsCOMPtr<nsIMemoryReporterManager> mgr =
     do_GetService("@mozilla.org/memory-reporter-manager;1");
   return mgr->GetReports(dumpReport, mrWriter, finishReporting, mrWriter);

--- a/xpcom/base/nsMemoryReporterManager.cpp
+++ b/xpcom/base/nsMemoryReporterManager.cpp
@@ -97,18 +97,17 @@ private:
     // statm's "shared" value actually counts pages backed by files, which has
     // little to do with whether the pages are actually shared.
     // /proc/self/smaps on the other hand appears to give us the correct
     // information.
 
     *aAmount = 0;
 
     FILE *f = fopen("/proc/self/smaps", "r");
-    if (NS_WARN_IF(!f))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(f);
 
     int64_t total = 0;
     char line[256];
     while (fgets(line, sizeof(line), f)) {
       long long val = 0;
       if (sscanf(line, "Private_Dirty: %lld kB", &val) == 1 ||
           sscanf(line, "Private_Clean: %lld kB", &val) == 1) {
         total += val * 1024; // convert from kB to bytes
@@ -748,18 +747,17 @@ public:
 
 #define REPORT(_path, _amount, _desc)                                         \
     do {                                                                      \
       nsresult rv;                                                            \
       rv = aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
                                    nsIMemoryReporter::KIND_HEAP,              \
                                    nsIMemoryReporter::UNITS_BYTES, _amount,   \
                                    NS_LITERAL_CSTRING(_desc), aData);         \
-      if (NS_WARN_IF(NS_FAILED(rv)))                                          \
-          return rv;                                                          \
+      NS_ENSURE_SUCCESS(rv, rv);                                              \
     } while (0)
 
     REPORT("explicit/dmd/stack-traces/used",
            sizes.mStackTracesUsed,
            "Memory used by stack traces which correspond to at least "
            "one heap block DMD is tracking.");
 
     REPORT("explicit/dmd/stack-traces/unused",
@@ -1281,18 +1279,17 @@ public:
         return NS_OK;
     }
 };
 NS_IMPL_ISUPPORTS1(ExplicitCallback, nsIHandleReportCallback)
 
 NS_IMETHODIMP
 nsMemoryReporterManager::GetExplicit(int64_t* aAmount)
 {
-    if (NS_WARN_IF(!aAmount))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aAmount);
     *aAmount = 0;
 #ifndef HAVE_JEMALLOC_STATS
     return NS_ERROR_NOT_AVAILABLE;
 #else
     bool more;
 
     // For each reporter we call CollectReports and filter out the
     // non-explicit, non-NONHEAP measurements (except for "heap-allocated").
@@ -1548,18 +1545,17 @@ private:
 };
 
 } // anonymous namespace
 
 NS_IMETHODIMP
 nsMemoryReporterManager::MinimizeMemoryUsage(nsIRunnable* aCallback,
                                              nsICancelableRunnable** aResult)
 {
-  if (NS_WARN_IF(!aResult))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(aResult);
 
   nsRefPtr<nsICancelableRunnable> runnable =
     new MinimizeMemoryUsageRunnable(aCallback);
   NS_ADDREF(*aResult = runnable);
 
   return NS_DispatchToMainThread(runnable);
 }
 
@@ -1572,29 +1568,27 @@ nsMemoryReporterManager::SizeOfTab(nsIDO
                                    int64_t* aStyleSize,
                                    int64_t* aOtherSize,
                                    int64_t* aTotalSize,
                                    double*  aJSMilliseconds,
                                    double*  aNonJSMilliseconds)
 {
     nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aTopWindow);
     nsCOMPtr<nsPIDOMWindow> piWindow = do_QueryInterface(aTopWindow);
-    if (NS_WARN_IF(!global) || NS_WARN_IF(!piWindow))
-      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(!!global && !!piWindow, NS_ERROR_FAILURE);
 
     TimeStamp t1 = TimeStamp::Now();
 
     // Measure JS memory consumption (and possibly some non-JS consumption, via
     // |jsPrivateSize|).
     size_t jsObjectsSize, jsStringsSize, jsPrivateSize, jsOtherSize;
     nsresult rv = mSizeOfTabFns.mJS(global->GetGlobalJSObject(),
                                     &jsObjectsSize, &jsStringsSize,
                                     &jsPrivateSize, &jsOtherSize);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     TimeStamp t2 = TimeStamp::Now();
 
     // Measure non-JS memory consumption.
     size_t domSize, styleSize, otherSize;
     mSizeOfTabFns.mNonJS(piWindow, &domSize, &styleSize, &otherSize);
 
     TimeStamp t3 = TimeStamp::Now();

--- a/xpcom/base/nsMessageLoop.cpp
+++ b/xpcom/base/nsMessageLoop.cpp
@@ -82,18 +82,17 @@ MessageLoopIdleTask::MessageLoopIdleTask
     mTimer = nullptr;
   }
 }
 
 nsresult
 MessageLoopIdleTask::Init(uint32_t aEnsureRunsAfterMS)
 {
   mTimer = do_CreateInstance("@mozilla.org/timer;1");
-  if (NS_WARN_IF(!mTimer))
-    return NS_ERROR_UNEXPECTED;
+  NS_ENSURE_STATE(mTimer);
 
   nsRefPtr<MessageLoopTimerCallback> callback =
     new MessageLoopTimerCallback(this);
 
   return mTimer->InitWithCallback(callback, aEnsureRunsAfterMS,
                                   nsITimer::TYPE_ONE_SHOT);
 }
 
@@ -149,13 +148,12 @@ nsMessageLoop::PostIdleTask(nsIRunnable*
   return NS_OK;
 }
 
 nsresult
 nsMessageLoopConstructor(nsISupports* aOuter,
                          const nsIID& aIID,
                          void** aInstancePtr)
 {
-  if (NS_WARN_IF(aOuter))
-    return NS_ERROR_NO_AGGREGATION;
+  NS_ENSURE_FALSE(aOuter, NS_ERROR_NO_AGGREGATION);
   nsISupports* messageLoop = new nsMessageLoop();
   return messageLoop->QueryInterface(aIID, aInstancePtr);
 }

--- a/xpcom/base/nsSystemInfo.cpp
+++ b/xpcom/base/nsSystemInfo.cpp
@@ -160,46 +160,43 @@ nsSystemInfo::Init()
       { PR_SI_RELEASE, "version" }
     };
 
     for (uint32_t i = 0; i < (sizeof(items) / sizeof(items[0])); i++) {
       char buf[SYS_INFO_BUFFER_LENGTH];
       if (PR_GetSystemInfo(items[i].cmd, buf, sizeof(buf)) == PR_SUCCESS) {
         rv = SetPropertyAsACString(NS_ConvertASCIItoUTF16(items[i].name),
                                    nsDependentCString(buf));
-        if (NS_WARN_IF(NS_FAILED(rv)))
-          return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
       }
       else {
         NS_WARNING("PR_GetSystemInfo failed");
       }
     }
 
     // Additional informations not available through PR_GetSystemInfo.
     SetInt32Property(NS_LITERAL_STRING("pagesize"), PR_GetPageSize());
     SetInt32Property(NS_LITERAL_STRING("pageshift"), PR_GetPageShift());
     SetInt32Property(NS_LITERAL_STRING("memmapalign"), PR_GetMemMapAlignment());
     SetInt32Property(NS_LITERAL_STRING("cpucount"), PR_GetNumberOfProcessors());
     SetUint64Property(NS_LITERAL_STRING("memsize"), PR_GetPhysicalMemorySize());
 
     for (uint32_t i = 0; i < ArrayLength(cpuPropItems); i++) {
         rv = SetPropertyAsBool(NS_ConvertASCIItoUTF16(cpuPropItems[i].name),
                                cpuPropItems[i].propfun());
-        if (NS_WARN_IF(NS_FAILED(rv)))
-          return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
     }
 
 #ifdef XP_WIN
     BOOL isWow64;
     BOOL gotWow64Value = IsWow64Process(GetCurrentProcess(), &isWow64);
     NS_WARN_IF_FALSE(gotWow64Value, "IsWow64Process failed");
     if (gotWow64Value) {
       rv = SetPropertyAsBool(NS_LITERAL_STRING("isWow64"), !!isWow64);
-      if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+      NS_ENSURE_SUCCESS(rv, rv);
     }
     nsAutoCString hddModel, hddRevision;
     if (NS_SUCCEEDED(GetProfileHDDInfo(hddModel, hddRevision))) {
       rv = SetPropertyAsACString(NS_LITERAL_STRING("profileHDDModel"), hddModel);
       NS_ENSURE_SUCCESS(rv, rv);
       rv = SetPropertyAsACString(NS_LITERAL_STRING("profileHDDRevision"),
                                  hddRevision);
       NS_ENSURE_SUCCESS(rv, rv);
@@ -208,18 +205,17 @@ nsSystemInfo::Init()
 
 #if defined(MOZ_WIDGET_GTK)
     // This must be done here because NSPR can only separate OS's when compiled, not libraries.
     char* gtkver = PR_smprintf("GTK %u.%u.%u", gtk_major_version, gtk_minor_version, gtk_micro_version);
     if (gtkver) {
       rv = SetPropertyAsACString(NS_LITERAL_STRING("secondaryLibrary"),
                                  nsDependentCString(gtkver));
       PR_smprintf_free(gtkver);
-      if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+      NS_ENSURE_SUCCESS(rv, rv);
     }
 #endif
 
 #ifdef MOZ_WIDGET_ANDROID
     if (mozilla::AndroidBridge::Bridge()) {
         nsAutoString str;
         if (mozilla::AndroidBridge::Bridge()->GetStaticStringField("android/os/Build", "MODEL", str))
             SetPropertyAsAString(NS_LITERAL_STRING("device"), str);

--- a/xpcom/build/Omnijar.cpp
+++ b/xpcom/build/Omnijar.cpp
@@ -140,30 +140,28 @@ Omnijar::GetURIString(Type aType, nsACSt
     // Return an empty string for APP in the unified case.
     if ((aType == APP) && sIsUnified) {
         return NS_OK;
     }
 
     nsAutoCString omniJarSpec;
     if (sPath[aType]) {
         nsresult rv = NS_GetURLSpecFromActualFile(sPath[aType], omniJarSpec);
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
 
         result = "jar:";
         if (sIsNested[aType])
             result += "jar:";
         result += omniJarSpec;
         result += "!";
         if (sIsNested[aType])
             result += "/" NS_STRINGIFY(OMNIJAR_NAME) "!";
     } else {
         nsCOMPtr<nsIFile> dir;
         nsDirectoryService::gService->Get(SPROP(aType), NS_GET_IID(nsIFile), getter_AddRefs(dir));
         nsresult rv = NS_GetURLSpecFromActualFile(dir, result);
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
     }
     result += "/";
     return NS_OK;
 }
 
 } /* namespace mozilla */

--- a/xpcom/build/nsXPCOMStrings.cpp
+++ b/xpcom/build/nsXPCOMStrings.cpp
@@ -35,18 +35,17 @@ NS_StringContainerInit2(nsStringContaine
   if (!aData)
   {
     new (&aContainer) nsString();
   }
   else
   {
     if (aDataLength == UINT32_MAX)
     {
-      if (NS_WARN_IF(aFlags & NS_STRING_CONTAINER_INIT_SUBSTRING))
-	return NS_ERROR_INVALID_ARG;
+      NS_ENSURE_ARG(!(aFlags & NS_STRING_CONTAINER_INIT_SUBSTRING));
       aDataLength = nsCharTraits<PRUnichar>::length(aData);
     }
 
     if (aFlags & (NS_STRING_CONTAINER_INIT_DEPEND |
                   NS_STRING_CONTAINER_INIT_ADOPT))
     {
       uint32_t flags;
       if (aFlags & NS_STRING_CONTAINER_INIT_SUBSTRING)
@@ -196,18 +195,17 @@ NS_CStringContainerInit2(nsCStringContai
   if (!aData)
   {
     new (&aContainer) nsCString();
   }
   else
   {
     if (aDataLength == UINT32_MAX)
     {
-      if (NS_WARN_IF(aFlags & NS_CSTRING_CONTAINER_INIT_SUBSTRING))
-	return NS_ERROR_INVALID_ARG;
+      NS_ENSURE_ARG(!(aFlags & NS_CSTRING_CONTAINER_INIT_SUBSTRING));
       aDataLength = nsCharTraits<char>::length(aData);
     }
 
     if (aFlags & (NS_CSTRING_CONTAINER_INIT_DEPEND |
                   NS_CSTRING_CONTAINER_INIT_ADOPT))
     {
       uint32_t flags;
       if (aFlags & NS_CSTRING_CONTAINER_INIT_SUBSTRING)

--- a/xpcom/build/nsXPComInit.cpp
+++ b/xpcom/build/nsXPComInit.cpp
@@ -214,32 +214,30 @@ NS_GENERIC_FACTORY_CONSTRUCTOR(nsIOUtil)
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsSecurityConsoleMessage)
 
 static nsresult
 nsThreadManagerGetSingleton(nsISupports* outer,
                             const nsIID& aIID,
                             void* *aInstancePtr)
 {
     NS_ASSERTION(aInstancePtr, "null outptr");
-    if (NS_WARN_IF(outer))
-        return NS_ERROR_NO_AGGREGATION;
+    NS_ENSURE_TRUE(!outer, NS_ERROR_NO_AGGREGATION);
 
     return nsThreadManager::get()->QueryInterface(aIID, aInstancePtr);
 }
 
 NS_GENERIC_FACTORY_CONSTRUCTOR(nsThreadPool)
 
 static nsresult
 nsXPTIInterfaceInfoManagerGetSingleton(nsISupports* outer,
                                        const nsIID& aIID,
                                        void* *aInstancePtr)
 {
     NS_ASSERTION(aInstancePtr, "null outptr");
-    if (NS_WARN_IF(outer))
-        return NS_ERROR_NO_AGGREGATION;
+    NS_ENSURE_TRUE(!outer, NS_ERROR_NO_AGGREGATION);
 
     nsCOMPtr<nsIInterfaceInfoManager> iim
         (XPTInterfaceInfoManager::GetSingleton());
     if (!iim)
         return NS_ERROR_FAILURE;
 
     return iim->QueryInterface(aIID, aInstancePtr);
 }
@@ -310,26 +308,26 @@ const mozilla::Module::ContractIDEntry k
 const mozilla::Module kXPCOMModule = { mozilla::Module::kVersion, kXPCOMCIDEntries, kXPCOMContracts };
 
 // gDebug will be freed during shutdown.
 static nsIDebug* gDebug = nullptr;
 
 EXPORT_XPCOM_API(nsresult)
 NS_GetDebug(nsIDebug** result)
 {
-    return nsDebugImpl::Create(nullptr,
-                               NS_GET_IID(nsIDebug),
+    return nsDebugImpl::Create(nullptr, 
+                               NS_GET_IID(nsIDebug), 
                                (void**) result);
 }
 
 EXPORT_XPCOM_API(nsresult)
 NS_GetTraceRefcnt(nsITraceRefcnt** result)
 {
-    return nsTraceRefcntImpl::Create(nullptr,
-                                     NS_GET_IID(nsITraceRefcnt),
+    return nsTraceRefcntImpl::Create(nullptr, 
+                                     NS_GET_IID(nsITraceRefcnt), 
                                      (void**) result);
 }
 
 EXPORT_XPCOM_API(nsresult)
 NS_InitXPCOM(nsIServiceManager* *result,
                              nsIFile* binDirectory)
 {
     return NS_InitXPCOM2(result, binDirectory, nullptr);
@@ -408,48 +406,48 @@ NS_InitXPCOM2(nsIServiceManager* *result
 
     NS_LogInit();
 
     // Set up chromium libs
     NS_ASSERTION(!sExitManager && !sMessageLoop, "Bad logic!");
 
     if (!AtExitManager::AlreadyRegistered()) {
         sExitManager = new AtExitManager();
+        NS_ENSURE_STATE(sExitManager);
     }
 
     if (!MessageLoop::current()) {
         sMessageLoop = new MessageLoopForUI(MessageLoop::TYPE_MOZILLA_UI);
+        NS_ENSURE_STATE(sMessageLoop);
     }
 
     if (XRE_GetProcessType() == GeckoProcessType_Default &&
         !BrowserProcessSubThread::GetMessageLoop(BrowserProcessSubThread::IO)) {
         scoped_ptr<BrowserProcessSubThread> ioThread(
             new BrowserProcessSubThread(BrowserProcessSubThread::IO));
+        NS_ENSURE_TRUE(ioThread.get(), NS_ERROR_OUT_OF_MEMORY);
 
         base::Thread::Options options;
         options.message_loop_type = MessageLoop::TYPE_IO;
-        if (NS_WARN_IF(!ioThread->StartWithOptions(options)))
-            return NS_ERROR_FAILURE;
+        NS_ENSURE_TRUE(ioThread->StartWithOptions(options), NS_ERROR_FAILURE);
 
         sIOThread = ioThread.release();
     }
 
     // Establish the main thread here.
     rv = nsThreadManager::get()->Init();
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    if (NS_FAILED(rv)) return rv;
 
     // Set up the timer globals/timer thread
     rv = nsTimerImpl::Startup();
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
 #ifndef ANDROID
     // If the locale hasn't already been setup by our embedder,
-    // get us out of the "C" locale and into the system
+    // get us out of the "C" locale and into the system 
     if (strcmp(setlocale(LC_ALL, nullptr), "C") == 0)
         setlocale(LC_ALL, "");
 #endif
 
 #if defined(XP_UNIX) || defined(XP_OS2)
     NS_StartupNativeCharsetUtils();
 #endif
 
@@ -490,31 +488,28 @@ NS_InitXPCOM2(nsIServiceManager* *result
         mozilla::Omnijar::Init();
     }
 
     if ((sCommandLineWasInitialized = !CommandLine::IsInitialized())) {
 #ifdef OS_WIN
         CommandLine::Init(0, nullptr);
 #else
         nsCOMPtr<nsIFile> binaryFile;
-        nsDirectoryService::gService->Get(NS_XPCOM_CURRENT_PROCESS_DIR,
-                                          NS_GET_IID(nsIFile),
+        nsDirectoryService::gService->Get(NS_XPCOM_CURRENT_PROCESS_DIR, 
+                                          NS_GET_IID(nsIFile), 
                                           getter_AddRefs(binaryFile));
-        if (NS_WARN_IF(!binaryFile))
-            return NS_ERROR_FAILURE;
-
+        NS_ENSURE_STATE(binaryFile);
+        
         rv = binaryFile->AppendNative(NS_LITERAL_CSTRING("nonexistent-executable"));
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
-
+        NS_ENSURE_SUCCESS(rv, rv);
+        
         nsCString binaryPath;
         rv = binaryFile->GetNativePath(binaryPath);
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
-
+        NS_ENSURE_SUCCESS(rv, rv);
+        
         static char const *const argv = { strdup(binaryPath.get()) };
         CommandLine::Init(1, &argv);
 #endif
     }
 
     NS_ASSERTION(nsComponentManagerImpl::gComponentManager == nullptr, "CompMgr not null at init");
 
     // Create the Component/Service Manager
@@ -568,17 +563,17 @@ NS_InitXPCOM2(nsIServiceManager* *result
     // Force layout to spin up so that nsContentUtils is available for cx stack
     // munging.
     nsCOMPtr<nsISupports> componentLoader = do_GetService("@mozilla.org/moz/jsloader;1");
 
     mozilla::scache::StartupCache::GetSingleton();
     mozilla::AvailableMemoryTracker::Activate();
 
     // Notify observers of xpcom autoregistration start
-    NS_CreateServicesFromCategory(NS_XPCOM_STARTUP_CATEGORY,
+    NS_CreateServicesFromCategory(NS_XPCOM_STARTUP_CATEGORY, 
                                   nullptr,
                                   NS_XPCOM_STARTUP_OBSERVER_ID);
 #ifdef XP_WIN
     CreateAnonTempFileRemover();
 #endif
 
     // The memory reporter manager is up and running -- register a reporter for
     // ICU's memory usage.
@@ -626,31 +621,28 @@ NS_ShutdownXPCOM(nsIServiceManager* serv
 namespace mozilla {
 
 nsresult
 ShutdownXPCOM(nsIServiceManager* servMgr)
 {
     // Make sure the hang monitor is enabled for shutdown.
     HangMonitor::NotifyActivity();
 
-    if (!NS_IsMainThread()) {
-        NS_RUNTIMEABORT("Shutdown on wrong thread");
-    }
+    NS_ENSURE_STATE(NS_IsMainThread());
 
     nsresult rv;
     nsCOMPtr<nsISimpleEnumerator> moduleLoaders;
 
     // Notify observers of xpcom shutting down
     {
         // Block it so that the COMPtr will get deleted before we hit
         // servicemanager shutdown
 
         nsCOMPtr<nsIThread> thread = do_GetCurrentThread();
-        if (NS_WARN_IF(!thread))
-            return NS_ERROR_UNEXPECTED;
+        NS_ENSURE_STATE(thread);
 
         nsRefPtr<nsObserverService> observerService;
         CallGetService("@mozilla.org/observer-service;1",
                        (nsObserverService**) getter_AddRefs(observerService));
 
         if (observerService)
         {
             (void) observerService->

--- a/xpcom/build/perfprobe.cpp
+++ b/xpcom/build/perfprobe.cpp
@@ -208,18 +208,17 @@ nsresult ProbeManager::StartSession(nsTA
                      /*MofImagePath:   Must be nullptr, says MSDN*/,
                      nullptr
                      /*MofResourceName:Must be nullptr, says MSDN*/,
                      &mRegistrationHandle
                      /*RegistrationHandle: Handler.
                       used only for unregistration*/
                      );
   delete[] probes;
-  if (NS_WARN_IF(result != ERROR_SUCCESS))
-    return NS_ERROR_UNEXPECTED;
+  NS_ENSURE_TRUE(result == ERROR_SUCCESS, NS_ERROR_UNEXPECTED);
   return NS_OK;
 }
 
 nsresult ProbeManager::StopSession()
 {
   LOG(("Probes: Stopping measures"));
   if (mSessionHandle != 0) {
     ULONG result = UnregisterTraceGuids(mSessionHandle);

--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -294,18 +294,17 @@ CategoryNode::DeleteLeaf(const char* aEn
 
   // we can just remove the entire hash entry without introspection
   mTable.RemoveEntry(aEntryName);
 }
 
 NS_METHOD 
 CategoryNode::Enumerate(nsISimpleEnumerator **_retval)
 {
-  if (NS_WARN_IF(!_retval))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(_retval);
 
   MutexAutoLock lock(mLock);
   EntryEnumerator* enumObj = EntryEnumerator::Create(mTable);
 
   if (!enumObj)
     return NS_ERROR_OUT_OF_MEMORY;
 
   *_retval = enumObj;
@@ -589,20 +588,19 @@ nsCategoryManager::NotifyObservers( cons
   NS_DispatchToMainThread(r);
 }
 
 NS_IMETHODIMP
 nsCategoryManager::GetCategoryEntry( const char *aCategoryName,
                                      const char *aEntryName,
                                      char **_retval )
 {
-  if (NS_WARN_IF(!aCategoryName) ||
-      NS_WARN_IF(!aEntryName) ||
-      NS_WARN_IF(!_retval))
-    return NS_ERROR_INVALID_ARG;;
+  NS_ENSURE_ARG_POINTER(aCategoryName);
+  NS_ENSURE_ARG_POINTER(aEntryName);
+  NS_ENSURE_ARG_POINTER(_retval);
 
   nsresult status = NS_ERROR_NOT_AVAILABLE;
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
     category = get_category(aCategoryName);
   }
@@ -684,19 +682,18 @@ nsCategoryManager::AddCategoryEntry(cons
   }
 }
 
 NS_IMETHODIMP
 nsCategoryManager::DeleteCategoryEntry( const char *aCategoryName,
                                         const char *aEntryName,
                                         bool aDontPersist)
 {
-  if (NS_WARN_IF(!aCategoryName) ||
-      NS_WARN_IF(!aEntryName))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(aCategoryName);
+  NS_ENSURE_ARG_POINTER(aEntryName);
 
   /*
     Note: no errors are reported since failure to delete
     probably won't hurt you, and returning errors seriously
     inconveniences JS clients
   */
 
   CategoryNode* category;
@@ -713,18 +710,17 @@ nsCategoryManager::DeleteCategoryEntry( 
   }
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsCategoryManager::DeleteCategory( const char *aCategoryName )
 {
-  if (NS_WARN_IF(!aCategoryName))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(aCategoryName);
 
   // the categories are arena-allocated, so we don't
   // actually delete them. We just remove all of the
   // leaf nodes.
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
@@ -739,19 +735,18 @@ nsCategoryManager::DeleteCategory( const
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsCategoryManager::EnumerateCategory( const char *aCategoryName,
                                       nsISimpleEnumerator **_retval )
 {
-  if (NS_WARN_IF(!aCategoryName) ||
-      NS_WARN_IF(!_retval))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(aCategoryName);
+  NS_ENSURE_ARG_POINTER(_retval);
 
   CategoryNode* category;
   {
     MutexAutoLock lock(mLock);
     category = get_category(aCategoryName);
   }
   
   if (!category) {
@@ -759,18 +754,17 @@ nsCategoryManager::EnumerateCategory( co
   }
 
   return category->Enumerate(_retval);
 }
 
 NS_IMETHODIMP 
 nsCategoryManager::EnumerateCategories(nsISimpleEnumerator **_retval)
 {
-  if (NS_WARN_IF(!_retval))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(_retval);
 
   MutexAutoLock lock(mLock);
   CategoryEnumerator* enumObj = CategoryEnumerator::Create(mTable);
 
   if (!enumObj)
     return NS_ERROR_OUT_OF_MEMORY;
 
   *_retval = enumObj;

--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -927,19 +927,18 @@ nsComponentManagerImpl::GetClassObject(c
 }
 
 
 NS_IMETHODIMP
 nsComponentManagerImpl::GetClassObjectByContractID(const char *contractID,
                                                    const nsIID &aIID,
                                                    void **aResult)
 {
-    if (NS_WARN_IF(!aResult) ||
-        NS_WARN_IF(!contractID))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(contractID);
 
     nsresult rv;
 
 
 #ifdef PR_LOGGING
     if (PR_LOG_TEST(nsComponentManagerLog, PR_LOG_DEBUG))
     {
         PR_LogPrint("nsComponentManager: GetClassObject(%s)", contractID);
@@ -1048,18 +1047,17 @@ nsComponentManagerImpl::CreateInstance(c
  * CreateInstance() with classid and iid.
  */
 NS_IMETHODIMP
 nsComponentManagerImpl::CreateInstanceByContractID(const char *aContractID,
                                                    nsISupports *aDelegate,
                                                    const nsIID &aIID,
                                                    void **aResult)
 {
-    if (NS_WARN_IF(!aContractID))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aContractID);
 
     // test this first, since there's no point in creating a component during
     // shutdown -- whether it's available or not would depend on the order it
     // occurs in the list
     if (gXPCOMShuttingDown) {
         // When processing shutdown, don't process new GetService() requests
 #ifdef SHOW_DENIED_ON_SHUTDOWN
         nsXPIDLCString iid;
@@ -1604,19 +1602,17 @@ nsComponentManagerImpl::IsCIDRegistered(
     *_retval = (nullptr != GetFactoryEntry(aClass));
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsComponentManagerImpl::IsContractIDRegistered(const char *aClass,
                                                bool *_retval)
 {
-    if (NS_WARN_IF(!aClass))
-        return NS_ERROR_INVALID_ARG;
-
+    NS_ENSURE_ARG_POINTER(aClass);
     nsFactoryEntry *entry = GetFactoryEntry(aClass, strlen(aClass));
 
     if (entry)
         *_retval = true;
     else
         *_retval = false;
     return NS_OK;
 }

--- a/xpcom/ds/nsHashPropertyBag.cpp
+++ b/xpcom/ds/nsHashPropertyBag.cpp
@@ -59,18 +59,17 @@ nsHashPropertyBag::GetProperty(const nsA
         return NS_ERROR_FAILURE;
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsHashPropertyBag::SetProperty(const nsAString& name, nsIVariant *value)
 {
-    if (NS_WARN_IF(!value))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(value);
 
     mPropertyHash.Put(name, value);
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsHashPropertyBag::DeleteProperty(const nsAString& name)

--- a/xpcom/ds/nsINIParserImpl.cpp
+++ b/xpcom/ds/nsINIParserImpl.cpp
@@ -46,18 +46,17 @@ nsINIParserFactory::CreateINIParser(nsIF
   return rv;
 }
 
 NS_IMETHODIMP
 nsINIParserFactory::CreateInstance(nsISupports* aOuter,
                                    REFNSIID aIID,
                                    void **aResult)
 {
-  if (NS_WARN_IF(aOuter))
-    return NS_ERROR_NO_AGGREGATION;
+  NS_ENSURE_NO_AGGREGATION(aOuter);
 
   // We are our own singleton.
   return QueryInterface(aIID, aResult);
 }
 
 NS_IMETHODIMP
 nsINIParserFactory::LockFactory(bool aLock)
 {

--- a/xpcom/ds/nsObserverService.cpp
+++ b/xpcom/ds/nsObserverService.cpp
@@ -145,55 +145,51 @@ ObserverServiceReporter::CollectReports(
             nsIMemoryReporter::UNITS_COUNT,
             suspect.referentCount,
             NS_LITERAL_CSTRING("A topic with a suspiciously large number of "
                                "referents.  This may be symptomatic of a leak "
                                "if the number of referents is high with "
                                "respect to the number of windows."),
             aClosure);
 
-      if (NS_WARN_IF(NS_FAILED(rv)))
-          return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
     }
 
     rv = cb->Callback(/* process */ EmptyCString(),
         NS_LITERAL_CSTRING("observer-service/referent/strong"),
         nsIMemoryReporter::KIND_OTHER,
         nsIMemoryReporter::UNITS_COUNT,
         referentCount.numStrong,
         NS_LITERAL_CSTRING("The number of strong references held by the "
                            "observer service."),
         aClosure);
 
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = cb->Callback(/* process */ EmptyCString(),
         NS_LITERAL_CSTRING("observer-service/referent/weak/alive"),
         nsIMemoryReporter::KIND_OTHER,
         nsIMemoryReporter::UNITS_COUNT,
         referentCount.numWeakAlive,
         NS_LITERAL_CSTRING("The number of weak references held by the "
                            "observer service that are still alive."),
         aClosure);
 
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = cb->Callback(/* process */ EmptyCString(),
         NS_LITERAL_CSTRING("observer-service/referent/weak/dead"),
         nsIMemoryReporter::KIND_OTHER,
         nsIMemoryReporter::UNITS_COUNT,
         referentCount.numWeakDead,
         NS_LITERAL_CSTRING("The number of weak references held by the "
                            "observer service that are dead."),
         aClosure);
 
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
 }
 
 } // namespace mozilla
 
 using namespace mozilla;
 
@@ -265,18 +261,17 @@ nsObserverService::Create(nsISupports* o
 NS_IMETHODIMP
 nsObserverService::AddObserver(nsIObserver* anObserver, const char* aTopic,
                                bool ownsWeak)
 {
     LOG(("nsObserverService::AddObserver(%p: %s)",
          (void*) anObserver, aTopic));
 
     NS_ENSURE_VALIDCALL
-    if (NS_WARN_IF(!anObserver) || NS_WARN_IF(!aTopic))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(anObserver && aTopic);
 
     if (mozilla::net::IsNeckoChild() && !strncmp(aTopic, "http-on-", 8)) {
       return NS_ERROR_NOT_IMPLEMENTED;
     }
 
     nsObserverList *observerList = mObserverTopicTable.PutEntry(aTopic);
     if (!observerList)
         return NS_ERROR_OUT_OF_MEMORY;
@@ -285,54 +280,51 @@ nsObserverService::AddObserver(nsIObserv
 }
 
 NS_IMETHODIMP
 nsObserverService::RemoveObserver(nsIObserver* anObserver, const char* aTopic)
 {
     LOG(("nsObserverService::RemoveObserver(%p: %s)",
          (void*) anObserver, aTopic));
     NS_ENSURE_VALIDCALL
-    if (NS_WARN_IF(!anObserver) || NS_WARN_IF(!aTopic))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(anObserver && aTopic);
 
     nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic);
     if (!observerList)
         return NS_ERROR_FAILURE;
 
     /* This death grip is to protect against stupid consumers who call
        RemoveObserver from their Destructor, see bug 485834/bug 325392. */
     nsCOMPtr<nsIObserver> kungFuDeathGrip(anObserver);
     return observerList->RemoveObserver(anObserver);
 }
 
 NS_IMETHODIMP
 nsObserverService::EnumerateObservers(const char* aTopic,
                                       nsISimpleEnumerator** anEnumerator)
 {
     NS_ENSURE_VALIDCALL
-    if (NS_WARN_IF(!anEnumerator) || NS_WARN_IF(!aTopic))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(aTopic && anEnumerator);
 
     nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic);
     if (!observerList)
         return NS_NewEmptyEnumerator(anEnumerator);
 
     return observerList->GetObserverList(anEnumerator);
 }
 
 // Enumerate observers of aTopic and call Observe on each.
 NS_IMETHODIMP nsObserverService::NotifyObservers(nsISupports *aSubject,
                                                  const char *aTopic,
                                                  const PRUnichar *someData)
 {
     LOG(("nsObserverService::NotifyObservers(%s)", aTopic));
 
     NS_ENSURE_VALIDCALL
-    if (NS_WARN_IF(!aTopic))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(aTopic);
 
     nsObserverList *observerList = mObserverTopicTable.GetEntry(aTopic);
     if (observerList)
         observerList->NotifyObservers(aSubject, aTopic, someData);
 
 #ifdef NOTIFY_GLOBAL_OBSERVERS
     observerList = mObserverTopicTable.GetEntry("*");
     if (observerList)

--- a/xpcom/ds/nsProperties.cpp
+++ b/xpcom/ds/nsProperties.cpp
@@ -10,54 +10,50 @@
 NS_IMPL_AGGREGATED(nsProperties)
 NS_INTERFACE_MAP_BEGIN_AGGREGATED(nsProperties)
     NS_INTERFACE_MAP_ENTRY(nsIProperties)
 NS_INTERFACE_MAP_END
 
 NS_IMETHODIMP
 nsProperties::Get(const char* prop, const nsIID & uuid, void* *result)
 {
-    if (NS_WARN_IF(!prop))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(prop);
 
     nsCOMPtr<nsISupports> value;
     if (!nsProperties_HashBase::Get(prop, getter_AddRefs(value))) {
         return NS_ERROR_FAILURE;
     }
     return (value) ? value->QueryInterface(uuid, result) : NS_ERROR_NO_INTERFACE;
 }
 
 NS_IMETHODIMP
 nsProperties::Set(const char* prop, nsISupports* value)
 {
-    if (NS_WARN_IF(!prop))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(prop);
     Put(prop, value);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsProperties::Undefine(const char* prop)
 {
-    if (NS_WARN_IF(!prop))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(prop);
 
     nsCOMPtr<nsISupports> value;
     if (!nsProperties_HashBase::Get(prop, getter_AddRefs(value)))
         return NS_ERROR_FAILURE;
 
     Remove(prop);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsProperties::Has(const char* prop, bool *result)
 {
-    if (NS_WARN_IF(!prop))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(prop);
 
     nsCOMPtr<nsISupports> value;
     *result = nsProperties_HashBase::Get(prop,
                                          getter_AddRefs(value));
     return NS_OK;
 }
 
 struct GetKeysEnumData
@@ -81,21 +77,22 @@ GetKeysEnumerate(const char *key, nsISup
 
     gkedp->next++;
     return PL_DHASH_NEXT;
 }
 
 NS_IMETHODIMP 
 nsProperties::GetKeys(uint32_t *count, char ***keys)
 {
-    if (NS_WARN_IF(!count) || NS_WARN_IF(!keys))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG(count);
+    NS_ENSURE_ARG(keys);
 
     uint32_t n = Count();
     char ** k = (char **) nsMemory::Alloc(n * sizeof(char *));
+    NS_ENSURE_TRUE(k, NS_ERROR_OUT_OF_MEMORY);
 
     GetKeysEnumData gked;
     gked.keys = k;
     gked.next = 0;
     gked.res = NS_OK;
 
     EnumerateRead(GetKeysEnumerate, &gked);
 

--- a/xpcom/ds/nsStringEnumerator.cpp
+++ b/xpcom/ds/nsStringEnumerator.cpp
@@ -79,16 +79,17 @@ private:
 NS_IMPL_ISUPPORTS3(nsStringEnumerator,
                    nsIStringEnumerator,
                    nsIUTF8StringEnumerator,
                    nsISimpleEnumerator)
 
 NS_IMETHODIMP
 nsStringEnumerator::HasMore(bool* aResult)
 {
+    NS_ENSURE_ARG_POINTER(aResult);
     *aResult = mIndex < Count();
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsStringEnumerator::HasMoreElements(bool* aResult)
 {
     return HasMore(aResult);
@@ -113,32 +114,30 @@ nsStringEnumerator::GetNext(nsISupports*
     }
     NS_ADDREF(*aResult);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsStringEnumerator::GetNext(nsAString& aResult)
 {
-    if (NS_WARN_IF(mIndex >= Count()))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_TRUE(mIndex < Count(), NS_ERROR_UNEXPECTED);
 
     if (mIsUnicode)
         aResult = mArray->ElementAt(mIndex++);
     else
         CopyUTF8toUTF16(mCArray->ElementAt(mIndex++), aResult);
     
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsStringEnumerator::GetNext(nsACString& aResult)
 {
-    if (NS_WARN_IF(mIndex >= Count()))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_TRUE(mIndex < Count(), NS_ERROR_UNEXPECTED);
     
     if (mIsUnicode)
         CopyUTF16toUTF8(mArray->ElementAt(mIndex++), aResult);
     else
         aResult = mCArray->ElementAt(mIndex++);
     
     return NS_OK;
 }
@@ -156,72 +155,72 @@ StringEnumeratorTail(T** aResult)
 //
 // constructors
 //
 
 nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult,
                        const nsTArray<nsString>* aArray, nsISupports* aOwner)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, aOwner);
     return StringEnumeratorTail(aResult);
 }
 
 
 nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                            const nsTArray<nsCString>* aArray, nsISupports* aOwner)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, aOwner);
     return StringEnumeratorTail(aResult);
 }
 
 nsresult
 NS_NewAdoptingStringEnumerator(nsIStringEnumerator** aResult,
                                nsTArray<nsString>* aArray)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, true);
     return StringEnumeratorTail(aResult);
 }
 
 nsresult
 NS_NewAdoptingUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                                    nsTArray<nsCString>* aArray)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, true);
     return StringEnumeratorTail(aResult);
 }
 
 // const ones internally just forward to the non-const equivalents
 nsresult
 NS_NewStringEnumerator(nsIStringEnumerator** aResult,
                        const nsTArray<nsString>* aArray)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, false);
     return StringEnumeratorTail(aResult);
 }
 
 nsresult
 NS_NewUTF8StringEnumerator(nsIUTF8StringEnumerator** aResult,
                            const nsTArray<nsCString>* aArray)
 {
-    if (NS_WARN_IF(!aResult) || NS_WARN_IF(!aArray))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aResult);
+    NS_ENSURE_ARG_POINTER(aArray);
     
     *aResult = new nsStringEnumerator(aArray, false);
     return StringEnumeratorTail(aResult);
 }
 

--- a/xpcom/ds/nsSupportsArray.cpp
+++ b/xpcom/ds/nsSupportsArray.cpp
@@ -580,18 +580,17 @@ nsSupportsArray::Enumerate(nsIEnumerator
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSupportsArray::Clone(nsISupportsArray** aResult)
 {
   nsCOMPtr<nsISupportsArray> newArray;
   nsresult rv = NS_NewISupportsArray(getter_AddRefs(newArray));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   uint32_t count = 0;
   Count(&count);
   for (uint32_t i = 0; i < count; i++) {
     if (!newArray->InsertElementAt(mArray[i], i)) {
       return NS_ERROR_OUT_OF_MEMORY;
     }
   }

--- a/xpcom/ds/nsSupportsPrimitives.cpp
+++ b/xpcom/ds/nsSupportsPrimitives.cpp
@@ -805,35 +805,33 @@ NS_IMPL_ISUPPORTS2(nsSupportsDependentCS
 
 nsSupportsDependentCString::nsSupportsDependentCString(const char* aStr)
     : mData(aStr)
 { }
 
 NS_IMETHODIMP
 nsSupportsDependentCString::GetType(uint16_t *aType)
 {
-    if (NS_WARN_IF(!aType))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aType);
 
     *aType = TYPE_CSTRING;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSupportsDependentCString::GetData(nsACString& aData)
 {
     aData = mData;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsSupportsDependentCString::ToString(char **_retval)
 {
-    if (NS_WARN_IF(!_retval))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(_retval);
 
     *_retval = ToNewCString(mData);
     if (!*_retval)
         return NS_ERROR_OUT_OF_MEMORY;
     
     return NS_OK;
 }
 

--- a/xpcom/ds/nsWindowsRegKey.cpp
+++ b/xpcom/ds/nsWindowsRegKey.cpp
@@ -98,68 +98,63 @@ nsWindowsRegKey::Create(uint32_t rootKey
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::OpenChild(const nsAString &path, uint32_t mode,
                            nsIWindowsRegKey **result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
   
   nsresult rv = child->Open((uintptr_t) mKey, path, mode);
   if (NS_FAILED(rv))
     return rv;
 
   child.swap(*result);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::CreateChild(const nsAString &path, uint32_t mode,
                              nsIWindowsRegKey **result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
   
   nsresult rv = child->Create((uintptr_t) mKey, path, mode);
   if (NS_FAILED(rv))
     return rv;
 
   child.swap(*result);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::GetChildCount(uint32_t *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD numSubKeys;
   LONG rv = RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, &numSubKeys,
                              nullptr, nullptr, nullptr, nullptr, nullptr,
                              nullptr, nullptr);
-  if (rv != ERROR_SUCCESS)
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_STATE(rv == ERROR_SUCCESS);
 
   *result = numSubKeys;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::GetChildName(uint32_t index, nsAString &result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   FILETIME lastWritten;
 
   PRUnichar nameBuf[MAX_KEY_NAME_LEN + 1];
   DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
 
   LONG rv = RegEnumKeyExW(mKey, index, nameBuf, &nameLen, nullptr, nullptr,
                           nullptr, &lastWritten);
@@ -169,18 +164,17 @@ nsWindowsRegKey::GetChildName(uint32_t i
   result.Assign(nameBuf, nameLen);
  
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::HasChild(const nsAString &name, bool *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   // Check for the existence of a child key by opening the key with minimal
   // rights.  Perhaps there is a more efficient way to do this?
 
   HKEY key;
   LONG rv = RegOpenKeyExW(mKey, PromiseFlatString(name).get(), 0,
                           STANDARD_RIGHTS_READ, &key);
 
@@ -188,35 +182,32 @@ nsWindowsRegKey::HasChild(const nsAStrin
     RegCloseKey(key);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::GetValueCount(uint32_t *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD numValues;
   LONG rv = RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, nullptr,
                              nullptr, nullptr, &numValues, nullptr, nullptr,
                              nullptr, nullptr);
-  if (rv != ERROR_SUCCESS)
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_STATE(rv == ERROR_SUCCESS);
 
   *result = numValues;
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::GetValueName(uint32_t index, nsAString &result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   PRUnichar nameBuf[MAX_VALUE_NAME_LEN];
   DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
 
   LONG rv = RegEnumValueW(mKey, index, nameBuf, &nameLen, nullptr, nullptr,
                           nullptr, nullptr);
   if (rv != ERROR_SUCCESS)
     return NS_ERROR_NOT_AVAILABLE;  // XXX what's the best error code here?
@@ -224,82 +215,77 @@ nsWindowsRegKey::GetValueName(uint32_t i
   result.Assign(nameBuf, nameLen);
 
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::HasValue(const nsAString &name, bool *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
                              nullptr, nullptr);
 
   *result = (rv == ERROR_SUCCESS);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::RemoveChild(const nsAString &name)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegDeleteKeyW(mKey, PromiseFlatString(name).get());
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::RemoveValue(const nsAString &name)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegDeleteValueW(mKey, PromiseFlatString(name).get());
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::GetValueType(const nsAString &name, uint32_t *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0,
                              (LPDWORD) result, nullptr, nullptr);
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::ReadStringValue(const nsAString &name, nsAString &result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD type, size;
 
   const nsString &flatName = PromiseFlatString(name);
 
   LONG rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, nullptr, &size);
   if (rv != ERROR_SUCCESS)
     return NS_ERROR_FAILURE;
 
   // This must be a string type in order to fetch the value as a string.
   // We're being a bit forgiving here by allowing types other than REG_SZ.
-  if (type != REG_SZ && type == REG_EXPAND_SZ && type == REG_MULTI_SZ)
-    return NS_ERROR_FAILURE;
+  NS_ENSURE_STATE(type == REG_SZ ||
+                  type == REG_EXPAND_SZ ||
+                  type == REG_MULTI_SZ);
 
   // The buffer size must be a multiple of 2.
-  if (size % 2 != 0)
-    return NS_ERROR_UNEXPECTED;
+  NS_ENSURE_STATE(size % 2 == 0);
 
   if (size == 0) {
     result.Truncate();
     return NS_OK;
   }
 
   // |size| may or may not include the terminating null character.
   DWORD resultLen = size / 2;
@@ -346,44 +332,41 @@ nsWindowsRegKey::ReadStringValue(const n
   }
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::ReadIntValue(const nsAString &name, uint32_t *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD size = sizeof(*result);
   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
                              (LPBYTE) result, &size);
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::ReadInt64Value(const nsAString &name, uint64_t *result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD size = sizeof(*result);
   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
                              (LPBYTE) result, &size);
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::ReadBinaryValue(const nsAString &name, nsACString &result)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   DWORD size;
   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0,
                              nullptr, nullptr, &size);
 
   if (rv != ERROR_SUCCESS)
     return NS_ERROR_FAILURE;
 
@@ -397,71 +380,66 @@ nsWindowsRegKey::ReadBinaryValue(const n
                         (LPBYTE) begin.get(), &size);
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::WriteStringValue(const nsAString &name, const nsAString &value)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   // Need to indicate complete size of buffer including null terminator.
   const nsString &flatValue = PromiseFlatString(value);
 
   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_SZ,
                            (const BYTE *) flatValue.get(),
                            (flatValue.Length() + 1) * sizeof(PRUnichar));
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::WriteIntValue(const nsAString &name, uint32_t value)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_DWORD,
                            (const BYTE *) &value, sizeof(value));
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::WriteInt64Value(const nsAString &name, uint64_t value)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_QWORD,
                            (const BYTE *) &value, sizeof(value));
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::WriteBinaryValue(const nsAString &name, const nsACString &value)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   const nsCString &flatValue = PromiseFlatCString(value);
   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_BINARY,
                            (const BYTE *) flatValue.get(), flatValue.Length());
 
   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 }
 
 NS_IMETHODIMP
 nsWindowsRegKey::StartWatching(bool recurse)
 {
-  if (NS_WARN_IF(!mKey))
-    return NS_ERROR_NOT_INITIALIZED;
+  NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
 
   if (mWatchEvent)
     return NS_OK;
   
   mWatchEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
   if (!mWatchEvent)
     return NS_ERROR_OUT_OF_MEMORY;
   

--- a/xpcom/glue/nsArrayEnumerator.cpp
+++ b/xpcom/glue/nsArrayEnumerator.cpp
@@ -175,16 +175,17 @@ nsCOMArrayEnumerator::operator new (size
     // create enough space such that mValueArray points to a large
     // enough value. Note that the initial value of size gives us
     // space for mValueArray[0], so we must subtract
     size += (aArray.Count() - 1) * sizeof(aArray[0]);
 
     // do the actual allocation
     nsCOMArrayEnumerator * result =
         static_cast<nsCOMArrayEnumerator*>(::operator new(size));
+    NS_ENSURE_TRUE(result, nullptr);
 
     // now need to copy over the values, and addref each one
     // now this might seem like a lot of work, but we're actually just
     // doing all our AddRef's ahead of time since GetNext() doesn't
     // need to AddRef() on the way out
     uint32_t i;
     uint32_t max = result->mArraySize = aArray.Count();
     for (i = 0; i<max; i++) {

--- a/xpcom/glue/nsCOMArray.cpp
+++ b/xpcom/glue/nsCOMArray.cpp
@@ -52,18 +52,17 @@ nsCOMArray_base::IndexOf(nsISupports* aO
 {
   return mArray.IndexOf(aObject, aStartIndex);
 }
 
 int32_t
 nsCOMArray_base::IndexOfObject(nsISupports* aObject) const
 {
     nsCOMPtr<nsISupports> supports = do_QueryInterface(aObject);
-    if (NS_WARN_IF(!supports))
-        return -1;
+    NS_ENSURE_TRUE(supports, -1);
 
     uint32_t i, count;
     int32_t retval = -1;
     count = mArray.Length();
     for (i = 0; i < count; ++i) {
         nsCOMPtr<nsISupports> arrayItem = do_QueryInterface(mArray[i]);
         if (arrayItem == supports) {
             retval = i;

--- a/xpcom/glue/nsComponentManagerUtils.cpp
+++ b/xpcom/glue/nsComponentManagerUtils.cpp
@@ -41,28 +41,26 @@ CallGetService(const char *aContractID, 
 #else
 
 #include "nsComponentManager.h"
 
 nsresult
 CallGetService(const nsCID &aCID, const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->nsComponentManagerImpl::GetService(aCID, aIID, aResult);
 }
 
 nsresult
 CallGetService(const char *aContractID, const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->
         nsComponentManagerImpl::GetServiceByContractID(aContractID,
                                                        aIID, aResult);
 }
 
 #endif
 
@@ -116,54 +114,50 @@ CallGetClassObject(const char *aContract
 
 #include "nsComponentManager.h"
 
 nsresult
 CallCreateInstance(const nsCID &aCID, nsISupports *aDelegate,
                    const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->
         nsComponentManagerImpl::CreateInstance(aCID, aDelegate, aIID, aResult);
 }
 
 nsresult
 CallCreateInstance(const char *aContractID, nsISupports *aDelegate,
                    const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->
         nsComponentManagerImpl::CreateInstanceByContractID(aContractID,
                                                            aDelegate, aIID,
                                                            aResult);
 }
 
 nsresult
 CallGetClassObject(const nsCID &aCID, const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->
         nsComponentManagerImpl::GetClassObject(aCID, aIID, aResult);
 }
 
 nsresult
 CallGetClassObject(const char *aContractID, const nsIID &aIID, void **aResult)
 {
     nsComponentManagerImpl *compMgr = nsComponentManagerImpl::gComponentManager;
-    if (NS_WARN_IF(!compMgr))
-        return NS_ERROR_NOT_INITIALIZED;
+    NS_ENSURE_TRUE(compMgr, NS_ERROR_NOT_INITIALIZED);
 
     return compMgr->
         nsComponentManagerImpl::GetClassObjectByContractID(aContractID, aIID,
                                                            aResult);
 }
 
 #endif
 

--- a/xpcom/glue/nsDebug.h
+++ b/xpcom/glue/nsDebug.h
@@ -7,55 +7,27 @@
 #define nsDebug_h___
 
 #ifndef nscore_h___
 #include "nscore.h"
 #endif
 
 #ifndef nsError_h__
 #include "nsError.h"
-#endif
+#endif 
 
 #include "nsXPCOM.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/Likely.h"
 
 #ifdef DEBUG
 #include "prprf.h"
 #endif
 
-/**
- * Warn if the given condition is true. The condition is evaluated in both
- * release and debug builds, and the result is an expression which can be
- * used in subsequent expressions, such as:
- *
- * if (NS_WARN_IF(NS_FAILED(rv))
- *   return rv;
- *
- * This explicit warning and return is preferred to the NS_ENSURE_* macros
- * which hide the warning and the return control flow.
- *
- * @note This is C++-only
- */
-#ifdef __cplusplus
 #ifdef DEBUG
-inline bool NS_warn_if_impl(bool condition, const char* expr, const char* file,
-                            int32_t line)
-{
-  if (MOZ_UNLIKELY(condition)) {
-    NS_DebugBreak(NS_DEBUG_WARNING, nullptr, expr, file, line);
-  }
-  return condition;
-}
-#define NS_WARN_IF(condition) \
-  NS_warn_if_impl(condition, #condition, __FILE__, __LINE__)
-#else
-#define NS_WARN_IF(condition) (bool)(condition)
-#endif
-#endif
 
 /**
  * Abort the execution of the program if the expression evaluates to
  * false.
  *
  * There is no status value returned from the macro.
  *
  * Note that the non-debug version of this macro does <b>not</b>
@@ -63,134 +35,128 @@ inline bool NS_warn_if_impl(bool conditi
  * as arguments to the macro will yield improper execution in a
  * non-debug build. For example:
  *
  *      NS_ABORT_IF_FALSE(0 == foo++, "yikes foo should be zero");
  *
  * Note also that the non-debug version of this macro does <b>not</b>
  * evaluate the message argument.
  */
-#ifdef DEBUG
 #define NS_ABORT_IF_FALSE(_expr, _msg)                        \
   do {                                                        \
     if (!(_expr)) {                                           \
       NS_DebugBreak(NS_DEBUG_ABORT, _msg, #_expr, __FILE__, __LINE__); \
     }                                                         \
   } while(0)
-#else
-#define NS_ABORT_IF_FALSE(_expr, _msg) do { /* nothing */ } while(0)
-#endif
 
 /**
  * Warn if a given condition is false.
  *
  * Program execution continues past the usage of this macro.
  *
  * Note also that the non-debug version of this macro does <b>not</b>
  * evaluate the message argument.
  */
-#ifdef DEBUG
 #define NS_WARN_IF_FALSE(_expr,_msg)                          \
   do {                                                        \
     if (!(_expr)) {                                           \
       NS_DebugBreak(NS_DEBUG_WARNING, _msg, #_expr, __FILE__, __LINE__); \
     }                                                         \
   } while(0)
-#else
-#define NS_WARN_IF_FALSE(_expr, _msg)  do { /* nothing */ } while(0)
-#endif
 
+/**
+ * Test a precondition for truth. If the expression is not true then
+ * trigger a program failure.
+ */
+#define NS_PRECONDITION(expr, str)                            \
+  do {                                                        \
+    if (!(expr)) {                                            \
+      NS_DebugBreak(NS_DEBUG_ASSERTION, str, #expr, __FILE__, __LINE__); \
+    }                                                         \
+  } while(0)
 
 /**
  * Test an assertion for truth. If the expression is not true then
  * trigger a program failure.
- *
- * Note that the non-debug version of this macro does <b>not</b>
- * evaluate the message argument.
  */
-#ifdef DEBUG
 #define NS_ASSERTION(expr, str)                               \
   do {                                                        \
     if (!(expr)) {                                            \
       NS_DebugBreak(NS_DEBUG_ASSERTION, str, #expr, __FILE__, __LINE__); \
     }                                                         \
   } while(0)
-#else
-#define NS_ASSERTION(expr, str)        do { /* nothing */ } while(0)
-#endif
 
 /**
- * NS_PRECONDITION/POSTCONDITION are synonyms for NS_ASSERTION.
+ * Test a post-condition for truth. If the expression is not true then
+ * trigger a program failure.
  */
-#define NS_PRECONDITION(expr, str) NS_ASSERTION(expr, str)
-#define NS_POSTCONDITION(expr, str) NS_ASSERTION(expr, str)
+#define NS_POSTCONDITION(expr, str)                           \
+  do {                                                        \
+    if (!(expr)) {                                            \
+      NS_DebugBreak(NS_DEBUG_ASSERTION, str, #expr, __FILE__, __LINE__); \
+    }                                                         \
+  } while(0)
+
+/**
+ * This macros triggers a program failure if executed. It indicates that
+ * an attempt was made to execute some unimplemented functionality.
+ */
+#define NS_NOTYETIMPLEMENTED(str)                             \
+  NS_DebugBreak(NS_DEBUG_ASSERTION, str, "NotYetImplemented", __FILE__, __LINE__)
 
 /**
  * This macros triggers a program failure if executed. It indicates that
  * an attempt was made to execute some unimplemented functionality.
  */
-#ifdef DEBUG
-#define NS_NOTYETIMPLEMENTED(str)                             \
-  NS_DebugBreak(NS_DEBUG_ASSERTION, str, "NotYetImplemented", __FILE__, __LINE__)
-#else
-#define NS_NOTYETIMPLEMENTED(str)      do { /* nothing */ } while(0)
-#endif
-
-/**
- * This macros triggers a program failure if executed. It indicates that
- * an attempt was made to execute a codepath which should not be reachable.
- */
-#ifdef DEBUG
 #define NS_NOTREACHED(str)                                    \
   NS_DebugBreak(NS_DEBUG_ASSERTION, str, "Not Reached", __FILE__, __LINE__)
-#else
-#define NS_NOTREACHED(str)             do { /* nothing */ } while(0)
-#endif
 
 /**
  * Log an error message.
  */
-#ifdef DEBUG
 #define NS_ERROR(str)                                         \
   NS_DebugBreak(NS_DEBUG_ASSERTION, str, "Error", __FILE__, __LINE__)
-#else
-#define NS_ERROR(str)                  do { /* nothing */ } while(0)
-#endif
 
 /**
  * Log a warning message.
  */
-#ifdef DEBUG
 #define NS_WARNING(str)                                       \
   NS_DebugBreak(NS_DEBUG_WARNING, str, nullptr, __FILE__, __LINE__)
-#else
-#define NS_WARNING(str)                do { /* nothing */ } while(0)
-#endif
+
+/**
+ * Trigger an abort
+ */
+#define NS_ABORT()                                            \
+  NS_DebugBreak(NS_DEBUG_ABORT, nullptr, nullptr, __FILE__, __LINE__)
 
 /**
- * Trigger an debug-only abort.
- *
- * @see NS_RUNTIMEABORT for release-mode asserts.
+ * Cause a break
  */
-#ifdef DEBUG
-#define NS_ABORT()                                            \
-  NS_DebugBreak(NS_DEBUG_ABORT, nullptr, nullptr, __FILE__, __LINE__)
-#else
-#define NS_ABORT()                     do { /* nothing */ } while(0)
-#endif
+#define NS_BREAK()                                            \
+  NS_DebugBreak(NS_DEBUG_BREAK, nullptr, nullptr, __FILE__, __LINE__)
+
+#else /* DEBUG */
 
 /**
- * Trigger a debugger breakpoint, only in debug builds.
+ * The non-debug version of these macros do not evaluate the
+ * expression or the message arguments to the macro.
  */
-#ifdef DEBUG
-#define NS_BREAK()                                            \
-  NS_DebugBreak(NS_DEBUG_BREAK, nullptr, nullptr, __FILE__, __LINE__)
-#else
+#define NS_ABORT_IF_FALSE(_expr, _msg) do { /* nothing */ } while(0)
+#define NS_WARN_IF_FALSE(_expr, _msg)  do { /* nothing */ } while(0)
+#define NS_PRECONDITION(expr, str)     do { /* nothing */ } while(0)
+#define NS_ASSERTION(expr, str)        do { /* nothing */ } while(0)
+#define NS_POSTCONDITION(expr, str)    do { /* nothing */ } while(0)
+#define NS_NOTYETIMPLEMENTED(str)      do { /* nothing */ } while(0)
+#define NS_NOTREACHED(str)             do { /* nothing */ } while(0)
+#define NS_ERROR(str)                  do { /* nothing */ } while(0)
+#define NS_WARNING(str)                do { /* nothing */ } while(0)
+#define NS_ABORT()                     do { /* nothing */ } while(0)
 #define NS_BREAK()                     do { /* nothing */ } while(0)
-#endif
+
+#endif /* ! DEBUG */
 
 /******************************************************************************
 ** Macros for static assertions.  These are used by the sixgill tool.
 ** When the tool is not running these macros are no-ops.
 ******************************************************************************/
 
 /* Avoid name collision if included with other headers defining annotations. */
 #ifndef HAVE_STATIC_ANNOTATIONS
@@ -259,33 +225,32 @@ inline bool NS_warn_if_impl(bool conditi
 #define NS_PRECONDITION(expr, str)   STATIC_ASSERT_RUNTIME(expr)
 #define NS_ASSERTION(expr, str)      STATIC_ASSERT_RUNTIME(expr)
 #define NS_POSTCONDITION(expr, str)  STATIC_ASSERT_RUNTIME(expr)
 
 #endif /* XGILL_PLUGIN */
 
 /******************************************************************************
 ** Macros for terminating execution when an unrecoverable condition is
-** reached.  These need to be compiled regardless of the DEBUG flag.
+** reached.  These need to be compiled regardless of the DEBUG flag. 
 ******************************************************************************/
 
 /**
  * Terminate execution <i>immediately</i>, and if possible on the current
  * platform, in such a way that execution can't be continued by other
  * code (e.g., by intercepting a signal).
  */
 #define NS_RUNTIMEABORT(msg)                                    \
   NS_DebugBreak(NS_DEBUG_ABORT, msg, nullptr, __FILE__, __LINE__)
 
 
-/* Macros for checking the trueness of an expression passed in within an
- * interface implementation.  These need to be compiled regardless of the
- * DEBUG flag. New code should use NS_WARN_IF(condition) instead!
- * @status deprecated
- */
+/* Macros for checking the trueness of an expression passed in within an 
+ * interface implementation.  These need to be compiled regardless of the */
+/* DEBUG flag
+******************************************************************************/
 
 #define NS_ENSURE_TRUE(x, ret)                                \
   do {                                                        \
     if (MOZ_UNLIKELY(!(x))) {                                 \
        NS_WARNING("NS_ENSURE_TRUE(" #x ") failed");           \
        return ret;                                            \
     }                                                         \
   } while(0)
@@ -370,16 +335,19 @@ inline bool NS_warn_if_impl(bool conditi
   NS_ENSURE_TRUE(((arg) >= min) && ((arg) <= max), NS_ERROR_INVALID_ARG)
 
 #define NS_ENSURE_STATE(state)                                \
   NS_ENSURE_TRUE(state, NS_ERROR_UNEXPECTED)
 
 #define NS_ENSURE_NO_AGGREGATION(outer)                       \
   NS_ENSURE_FALSE(outer, NS_ERROR_NO_AGGREGATION)
 
+#define NS_ENSURE_PROPER_AGGREGATION(outer, iid)              \
+  NS_ENSURE_FALSE(outer && !iid.Equals(NS_GET_IID(nsISupports)), NS_ERROR_INVALID_ARG)
+
 /*****************************************************************************/
 
 #ifdef XPCOM_GLUE
   #define NS_CheckThreadSafe(owningThread, msg)
 #else
   #define NS_CheckThreadSafe(owningThread, msg)                 \
     if (MOZ_UNLIKELY(owningThread != PR_GetCurrentThread())) {  \
       MOZ_CRASH(msg);                                           \

--- a/xpcom/glue/nsINIParser.cpp
+++ b/xpcom/glue/nsINIParser.cpp
@@ -60,18 +60,17 @@ nsINIParser::Init(nsIFile* aFile)
        pass FILE* across shared library boundaries, which may be using
        different CRTs */
 
     AutoFILE fd;
 
 #ifdef XP_WIN
     nsAutoString path;
     nsresult rv = aFile->GetPath(path);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     fd = _wfopen(path.get(), READ_BINARYMODE);
 #else
     nsAutoCString path;
     aFile->GetNativePath(path);
 
     fd = fopen(path.get(), READ_BINARYMODE);
 #endif

--- a/xpcom/glue/nsMemory.cpp
+++ b/xpcom/glue/nsMemory.cpp
@@ -14,18 +14,17 @@
 ////////////////////////////////////////////////////////////////////////////////
 // nsMemory static helper routines
 
 NS_COM_GLUE nsresult
 nsMemory::HeapMinimize(bool aImmediate)
 {
     nsCOMPtr<nsIMemory> mem;
     nsresult rv = NS_GetMemoryManager(getter_AddRefs(mem));
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     return mem->HeapMinimize(aImmediate);
 }
 
 NS_COM_GLUE void*
 nsMemory::Clone(const void* ptr, size_t size)
 {
     void* newPtr = NS_Alloc(size);

--- a/xpcom/glue/nsThreadUtils.cpp
+++ b/xpcom/glue/nsThreadUtils.cpp
@@ -65,61 +65,56 @@ NS_NewThread(nsIThread **result, nsIRunn
   nsCOMPtr<nsIThread> thread;
 #ifdef MOZILLA_INTERNAL_API
   nsresult rv = nsThreadManager::get()->
       nsThreadManager::NewThread(0, stackSize, getter_AddRefs(thread));
 #else
   nsresult rv;
   nsCOMPtr<nsIThreadManager> mgr =
       do_GetService(NS_THREADMANAGER_CONTRACTID, &rv);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   rv = mgr->NewThread(0, stackSize, getter_AddRefs(thread));
 #endif
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 
   if (event) {
     rv = thread->Dispatch(event, NS_DISPATCH_NORMAL);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
   }
 
   *result = nullptr;
   thread.swap(*result);
   return NS_OK;
 }
 
 NS_METHOD
 NS_GetCurrentThread(nsIThread **result)
 {
 #ifdef MOZILLA_INTERNAL_API
   return nsThreadManager::get()->nsThreadManager::GetCurrentThread(result);
 #else
   nsresult rv;
   nsCOMPtr<nsIThreadManager> mgr =
       do_GetService(NS_THREADMANAGER_CONTRACTID, &rv);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
   return mgr->GetCurrentThread(result);
 #endif
 }
 
 NS_METHOD
 NS_GetMainThread(nsIThread **result)
 {
 #ifdef MOZILLA_INTERNAL_API
   return nsThreadManager::get()->nsThreadManager::GetMainThread(result);
 #else
   nsresult rv;
   nsCOMPtr<nsIThreadManager> mgr =
       do_GetService(NS_THREADMANAGER_CONTRACTID, &rv);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
   return mgr->GetMainThread(result);
 #endif
 }
 
 #if defined(MOZILLA_INTERNAL_API) && defined(XP_WIN)
 extern DWORD gTLSThreadIDIndex;
 bool
 NS_IsMainThread()
@@ -161,50 +156,46 @@ NS_METHOD
 NS_DispatchToCurrentThread(nsIRunnable *event)
 {
 #ifdef MOZILLA_INTERNAL_API
   nsIThread *thread = NS_GetCurrentThread();
   if (!thread) { return NS_ERROR_UNEXPECTED; }
 #else
   nsCOMPtr<nsIThread> thread;
   nsresult rv = NS_GetCurrentThread(getter_AddRefs(thread));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
 #endif
   return thread->Dispatch(event, NS_DISPATCH_NORMAL);
 }
 
 NS_METHOD
 NS_DispatchToMainThread(nsIRunnable *event, uint32_t dispatchFlags)
 {
   nsCOMPtr<nsIThread> thread;
   nsresult rv = NS_GetMainThread(getter_AddRefs(thread));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
   return thread->Dispatch(event, dispatchFlags);
 }
 
 #ifndef XPCOM_GLUE_AVOID_NSPR
 NS_METHOD
 NS_ProcessPendingEvents(nsIThread *thread, PRIntervalTime timeout)
 {
   nsresult rv = NS_OK;
 
 #ifdef MOZILLA_INTERNAL_API
   if (!thread) {
     thread = NS_GetCurrentThread();
-    if (NS_WARN_IF(!thread))
-      return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(thread);
   }
 #else
   nsCOMPtr<nsIThread> current;
   if (!thread) {
     rv = NS_GetCurrentThread(getter_AddRefs(current));
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
     thread = current.get();
   }
 #endif
 
   PRIntervalTime start = PR_IntervalNow();
   for (;;) {
     bool processedEvent;
     rv = thread->ProcessNextEvent(false, &processedEvent);
@@ -229,38 +220,35 @@ NS_HasPendingEvents(nsIThread *thread)
 {
   if (!thread) {
 #ifndef MOZILLA_INTERNAL_API
     nsCOMPtr<nsIThread> current;
     NS_GetCurrentThread(getter_AddRefs(current));
     return hasPendingEvents(current);
 #else
     thread = NS_GetCurrentThread();
-    if (NS_WARN_IF(!thread))
-      return false;
+    NS_ENSURE_TRUE(thread, false);
 #endif
   }
   return hasPendingEvents(thread);
 }
 
 bool
 NS_ProcessNextEvent(nsIThread *thread, bool mayWait)
 {
 #ifdef MOZILLA_INTERNAL_API
   if (!thread) {
     thread = NS_GetCurrentThread();
-    if (NS_WARN_IF(!thread))
-      return false;
+    NS_ENSURE_TRUE(thread, false);
   }
 #else
   nsCOMPtr<nsIThread> current;
   if (!thread) {
     NS_GetCurrentThread(getter_AddRefs(current));
-    if (NS_WARN_IF(!current))
-      return false;
+    NS_ENSURE_TRUE(current, false);
     thread = current.get();
   }
 #endif
   bool val;
   return NS_SUCCEEDED(thread->ProcessNextEvent(mayWait, &val)) && val;
 }
 
 #ifndef XPCOM_GLUE_AVOID_NSPR

--- a/xpcom/glue/nsThreadUtils.h
+++ b/xpcom/glue/nsThreadUtils.h
@@ -66,18 +66,17 @@ NS_NewThread(nsIThread **result,
 template <size_t LEN>
 inline NS_METHOD
 NS_NewNamedThread(const char (&name)[LEN],
                   nsIThread **result,
                   nsIRunnable *initialEvent = nullptr,
                   uint32_t stackSize = nsIThreadManager::DEFAULT_STACK_SIZE)
 {
   nsresult rv = NS_NewThread(result, nullptr, stackSize);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv, rv);
   NS_SetThreadName<LEN>(*result, name);
   if (initialEvent) {
     rv = (*result)->Dispatch(initialEvent, NS_DISPATCH_NORMAL);
     NS_WARN_IF_FALSE(NS_SUCCEEDED(rv), "Initial event dispatch failed");
   }
 
   return rv;
 }

--- a/xpcom/io/Base64.cpp
+++ b/xpcom/io/Base64.cpp
@@ -158,18 +158,17 @@ EncodeInputStream(nsIInputStream *aInput
                   uint32_t aCount,
                   uint32_t aOffset)
 {
   nsresult rv;
   uint64_t count64 = aCount;
 
   if (!aCount) {
     rv = aInputStream->Available(&count64);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
     // if count64 is over 4GB, it will be failed at the below condition,
     // then will return NS_ERROR_OUT_OF_MEMORY
     aCount = (uint32_t)count64;
   }
 
   uint64_t countlong =
     (count64 + 2) / 3 * 4; // +2 due to integer math.
   if (countlong + aOffset > UINT32_MAX)

--- a/xpcom/io/CocoaFileUtils.mm
+++ b/xpcom/io/CocoaFileUtils.mm
@@ -11,50 +11,48 @@
 #include "nsDebug.h"
 
 namespace CocoaFileUtils {
 
 nsresult RevealFileInFinder(CFURLRef url)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
 
   NSAutoreleasePool* ap = [[NSAutoreleasePool alloc] init];
   BOOL success = [[NSWorkspace sharedWorkspace] selectFile:[(NSURL*)url path] inFileViewerRootedAtPath:@""];
   [ap release];
 
   return (success ? NS_OK : NS_ERROR_FAILURE);
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 
 nsresult OpenURL(CFURLRef url)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
 
   NSAutoreleasePool* ap = [[NSAutoreleasePool alloc] init];
   BOOL success = [[NSWorkspace sharedWorkspace] openURL:(NSURL*)url];
   [ap release];
 
   return (success ? NS_OK : NS_ERROR_FAILURE);
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 
 nsresult GetFileCreatorCode(CFURLRef url, OSType *creatorCode)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url) || NS_WARN_IF(!creatorCode))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
+  NS_ENSURE_ARG_POINTER(creatorCode);
 
   nsAutoreleasePool localPool;
 
   NSString *resolvedPath = [[(NSURL*)url path] stringByResolvingSymlinksInPath];
   if (!resolvedPath) {
     return NS_ERROR_FAILURE;
   }
 
@@ -73,34 +71,33 @@ nsresult GetFileCreatorCode(CFURLRef url
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 
 nsresult SetFileCreatorCode(CFURLRef url, OSType creatorCode)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
 
   NSAutoreleasePool* ap = [[NSAutoreleasePool alloc] init];
   NSDictionary* dict = [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedLong:creatorCode] forKey:NSFileHFSCreatorCode];
   BOOL success = [[NSFileManager defaultManager] setAttributes:dict ofItemAtPath:[(NSURL*)url path] error:nil];
   [ap release];
   return (success ? NS_OK : NS_ERROR_FAILURE);
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 
 nsresult GetFileTypeCode(CFURLRef url, OSType *typeCode)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url) || NS_WARN_IF(!typeCode))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
+  NS_ENSURE_ARG_POINTER(typeCode);
 
   nsAutoreleasePool localPool;
 
   NSString *resolvedPath = [[(NSURL*)url path] stringByResolvingSymlinksInPath];
   if (!resolvedPath) {
     return NS_ERROR_FAILURE;
   }
 
@@ -119,18 +116,17 @@ nsresult GetFileTypeCode(CFURLRef url, O
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;
 }
 
 nsresult SetFileTypeCode(CFURLRef url, OSType typeCode)
 {
   NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT;
 
-  if (NS_WARN_IF(!url))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG_POINTER(url);
 
   NSAutoreleasePool* ap = [[NSAutoreleasePool alloc] init];
   NSDictionary* dict = [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedLong:typeCode] forKey:NSFileHFSTypeCode];
   BOOL success = [[NSFileManager defaultManager] setAttributes:dict ofItemAtPath:[(NSURL*)url path] error:nil];
   [ap release];
   return (success ? NS_OK : NS_ERROR_FAILURE);
 
   NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;

--- a/xpcom/io/nsAnonymousTemporaryFile.cpp
+++ b/xpcom/io/nsAnonymousTemporaryFile.cpp
@@ -45,68 +45,60 @@ using namespace mozilla;
 //   3. Content processes can access the system temp dir
 //      (NS_GetSpecialDirectory fails on NS_APP_USER_PROFILE_LOCAL_50_DIR
 //      for content process for example, which is where we previously stored
 //      temp files on Windows). This argument applies to all platforms, not
 //      just Windows.
 static nsresult
 GetTempDir(nsIFile** aTempDir)
 {
-  if (NS_WARN_IF(!aTempDir))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG(aTempDir);
   nsCOMPtr<nsIFile> tmpFile;
   nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(tmpFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv,rv);
 
 #ifdef XP_WIN
   // On windows DELETE_ON_CLOSE is unreliable, so we store temporary files
   // in a subdir of the temp dir and delete that in an idle service observer
   // to ensure it's been cleared.
   rv = tmpFile->AppendNative(nsDependentCString("mozilla-temp-files"));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv,rv);    
   rv = tmpFile->Create(nsIFile::DIRECTORY_TYPE, 0700);
-  if (rv != NS_ERROR_FILE_ALREADY_EXISTS && NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_TRUE(rv == NS_ERROR_FILE_ALREADY_EXISTS || NS_SUCCEEDED(rv), rv);
 #endif
  
   tmpFile.forget(aTempDir);
 
   return NS_OK;
 }
 
 nsresult
 NS_OpenAnonymousTemporaryFile(PRFileDesc** aOutFileDesc)
 {
-  if (NS_WARN_IF(!aOutFileDesc))
-    return NS_ERROR_INVALID_ARG;
+  NS_ENSURE_ARG(aOutFileDesc);
   nsresult rv;
 
   nsCOMPtr<nsIFile> tmpFile;
   rv = GetTempDir(getter_AddRefs(tmpFile));
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv,rv);
 
   // Give the temp file a name with a random element. CreateUnique will also
   // append a counter to the name if it encounters a name collision. Adding
   // a random element to the name reduces the likelihood of a name collision,
   // so that CreateUnique() doesn't end up trying a lot of name variants in
   // its "try appending an incrementing counter" loop, as file IO can be
   // expensive on some mobile flash drives.
   nsAutoCString name("mozilla-temp-");
   name.AppendInt(rand());
 
   rv = tmpFile->AppendNative(name);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv,rv);
 
   rv = tmpFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0700);
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
+  NS_ENSURE_SUCCESS(rv,rv);
 
   rv = tmpFile->OpenNSPRFileDesc(PR_RDWR | nsIFile::DELETE_ON_CLOSE,
                                  PR_IRWXU, aOutFileDesc);
 
   return rv;    
 }
 
 #ifdef XP_WIN
@@ -149,29 +141,26 @@ public:
 
   nsresult Init() {
     // We add the idle observer in a timer, so that the app has enough
     // time to start up before we add the idle observer. If we register the
     // idle observer too early, it will be registered before the fake idle
     // service is installed when running in xpcshell, and this interferes with
     // the fake idle service, causing xpcshell-test failures.
     mTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
-    if (NS_WARN_IF(!mTimer))
-      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(mTimer != nullptr, NS_ERROR_FAILURE);
     nsresult rv = mTimer->Init(this,
                          SCHEDULE_TIMEOUT_MS,
                          nsITimer::TYPE_ONE_SHOT);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     // Register shutdown observer so we can cancel the timer if we shutdown before
     // the timer runs.
     nsCOMPtr<nsIObserverService> obsSrv = services::GetObserverService();
-    if (NS_WARN_IF(!obsSrv))
-      return NS_ERROR_FAILURE;
+    NS_ENSURE_TRUE(obsSrv != nullptr, NS_ERROR_FAILURE);
     return obsSrv->AddObserver(this, XPCOM_SHUTDOWN_TOPIC, false);
   }
 
   void Cleanup() {
     // Cancel timer.
     if (mTimer) {
       mTimer->Cancel();
       mTimer = nullptr;
@@ -217,18 +206,17 @@ public:
     if (!idleSvc)
       return NS_ERROR_FAILURE;
     return idleSvc->AddIdleObserver(this, TEMP_FILE_IDLE_TIME_S);
   }
 
   void RemoveAnonTempFileFiles() {
     nsCOMPtr<nsIFile> tmpDir;
     nsresult rv = GetTempDir(getter_AddRefs(tmpDir));
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return;
+    NS_ENSURE_SUCCESS_VOID(rv);
 
     // Remove the directory recursively.
     tmpDir->Remove(true);
   }
 
 private:
   nsCOMPtr<nsITimer> mTimer;
 };

--- a/xpcom/io/nsAppFileLocationProvider.cpp
+++ b/xpcom/io/nsAppFileLocationProvider.cpp
@@ -82,22 +82,20 @@ NS_IMPL_ISUPPORTS2(nsAppFileLocationProv
 
 //*****************************************************************************
 // nsAppFileLocationProvider::nsIDirectoryServiceProvider
 //*****************************************************************************
 
 NS_IMETHODIMP
 nsAppFileLocationProvider::GetFile(const char *prop, bool *persistent, nsIFile **_retval)
 {
-    if (NS_WARN_IF(!prop))
-        return NS_ERROR_INVALID_ARG;
-
     nsCOMPtr<nsIFile>  localFile;
     nsresult rv = NS_ERROR_FAILURE;
 
+    NS_ENSURE_ARG(prop);
     *_retval = nullptr;
     *persistent = true;
 
 #ifdef MOZ_WIDGET_COCOA
     FSRef fileRef;
     nsCOMPtr<nsILocalFileMac> macFile;
 #endif
     
@@ -247,18 +245,17 @@ nsAppFileLocationProvider::GetFile(const
         return localFile->QueryInterface(NS_GET_IID(nsIFile), (void**)_retval);
         
     return rv;
 }
 
 
 NS_METHOD nsAppFileLocationProvider::CloneMozBinDirectory(nsIFile **aLocalFile)
 {
-    if (NS_WARN_IF(!aLocalFile))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aLocalFile);
     nsresult rv;
 
     if (!mMozBinDirectory)
     {
         // Get the mozilla bin directory
         // 1. Check the directory service first for NS_XPCOM_CURRENT_PROCESS_DIR
         //    This will be set if a directory was passed to NS_InitXPCOM
         // 2. If that doesn't work, set it to be the current process directory
@@ -289,18 +286,17 @@ NS_METHOD nsAppFileLocationProvider::Clo
 // GetProductDirectory - Gets the directory which contains the application data folder
 //
 // UNIX   : ~/.mozilla/
 // WIN    : <Application Data folder on user's machine>\Mozilla
 // Mac    : :Documents:Mozilla:
 //----------------------------------------------------------------------------------------
 NS_METHOD nsAppFileLocationProvider::GetProductDirectory(nsIFile **aLocalFile, bool aLocal)
 {
-    if (NS_WARN_IF(!aLocalFile))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aLocalFile);
 
     nsresult rv;
     bool exists;
     nsCOMPtr<nsIFile> localDir;
 
 #if defined(MOZ_WIDGET_COCOA)
     FSRef fsRef;
     OSType folderType = aLocal ? (OSType) kCachedDataFolderType : (OSType) kDomainLibraryFolderType;
@@ -351,18 +347,17 @@ NS_METHOD nsAppFileLocationProvider::Get
 // GetDefaultUserProfileRoot - Gets the directory which contains each user profile dir
 //
 // UNIX   : ~/.mozilla/
 // WIN    : <Application Data folder on user's machine>\Mozilla\Profiles
 // Mac    : :Documents:Mozilla:Profiles:
 //----------------------------------------------------------------------------------------
 NS_METHOD nsAppFileLocationProvider::GetDefaultUserProfileRoot(nsIFile **aLocalFile, bool aLocal)
 {
-    if (NS_WARN_IF(!aLocalFile))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aLocalFile);
 
     nsresult rv;
     nsCOMPtr<nsIFile> localDir;
 
     rv = GetProductDirectory(getter_AddRefs(localDir), aLocal);
     if (NS_FAILED(rv)) return rv;
 
 #if defined(MOZ_WIDGET_COCOA) || defined(XP_OS2) || defined(XP_WIN)
@@ -416,18 +411,17 @@ class nsAppDirectoryEnumerator : public 
                 mNext = testFile;
         }
         *result = mNext != nullptr;
         return NS_OK;
     }
 
     NS_IMETHOD GetNext(nsISupports **result) 
     {
-        if (NS_WARN_IF(!result))
-            return NS_ERROR_INVALID_ARG;
+        NS_ENSURE_ARG_POINTER(result);
         *result = nullptr;
 
         bool hasMore;
         HasMoreElements(&hasMore);
         if (!hasMore)
             return NS_ERROR_FAILURE;
             
         *result = mNext;
@@ -512,18 +506,17 @@ class nsPathsDirectoryEnumerator : publi
 
   protected:
     const char *mEndPath;
 };
 
 NS_IMETHODIMP
 nsAppFileLocationProvider::GetFiles(const char *prop, nsISimpleEnumerator **_retval)
 {
-    if (NS_WARN_IF(!_retval))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(_retval);
     *_retval = nullptr;
     nsresult rv = NS_ERROR_FAILURE;
     
     if (!nsCRT::strcmp(prop, NS_APP_PLUGINS_DIR_LIST))
     {
 #ifdef MOZ_WIDGET_COCOA
         // As of Java for Mac OS X 10.5 Update 10, Apple has (in effect) deprecated Java Plugin2 on
         // on OS X 10.5, and removed the soft link to it from /Library/Internet Plug-Ins/.  Java

--- a/xpcom/io/nsBinaryStream.cpp
+++ b/xpcom/io/nsBinaryStream.cpp
@@ -29,34 +29,31 @@
 
 #include "jsfriendapi.h"
 
 NS_IMPL_ISUPPORTS3(nsBinaryOutputStream, nsIObjectOutputStream, nsIBinaryOutputStream, nsIOutputStream)
 
 NS_IMETHODIMP
 nsBinaryOutputStream::Flush() 
 { 
-    if (NS_WARN_IF(!mOutputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mOutputStream);
     return mOutputStream->Flush(); 
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::Close() 
 { 
-    if (NS_WARN_IF(!mOutputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mOutputStream);
     return mOutputStream->Close(); 
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::Write(const char *aBuf, uint32_t aCount, uint32_t *aActualBytes)
 {
-    if (NS_WARN_IF(!mOutputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mOutputStream);
     return mOutputStream->Write(aBuf, aCount, aActualBytes);
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::WriteFrom(nsIInputStream *inStr, uint32_t count, uint32_t *_retval)
 {
     NS_NOTREACHED("WriteFrom");
     return NS_ERROR_NOT_IMPLEMENTED;
@@ -67,42 +64,39 @@ nsBinaryOutputStream::WriteSegments(nsRe
 {
     NS_NOTREACHED("WriteSegments");
     return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::IsNonBlocking(bool *aNonBlocking)
 {
-    if (NS_WARN_IF(!mOutputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mOutputStream);
     return mOutputStream->IsNonBlocking(aNonBlocking);
 }
 
 nsresult
 nsBinaryOutputStream::WriteFully(const char *aBuf, uint32_t aCount)
 {
-    if (NS_WARN_IF(!mOutputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mOutputStream);
 
     nsresult rv;
     uint32_t bytesWritten;
 
     rv = mOutputStream->Write(aBuf, aCount, &bytesWritten);
     if (NS_FAILED(rv)) return rv;
     if (bytesWritten != aCount)
         return NS_ERROR_FAILURE;
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::SetOutputStream(nsIOutputStream *aOutputStream)
 {
-    if (NS_WARN_IF(!aOutputStream))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aOutputStream);
     mOutputStream = aOutputStream;
     mBufferAccess = do_QueryInterface(aOutputStream);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::WriteBoolean(bool aBoolean)
 {
@@ -246,58 +240,52 @@ nsBinaryOutputStream::WriteSingleRefObje
                                true);
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::WriteCompoundObject(nsISupports* aObject,
                                           const nsIID& aIID,
                                           bool aIsStrongRef)
 {
+    // Can't deal with weak refs
+    NS_ENSURE_TRUE(aIsStrongRef, NS_ERROR_UNEXPECTED);
+    
     nsCOMPtr<nsIClassInfo> classInfo = do_QueryInterface(aObject);
-    nsCOMPtr<nsISerializable> serializable = do_QueryInterface(aObject);
+    NS_ENSURE_TRUE(classInfo, NS_ERROR_NOT_AVAILABLE);
 
-    // Can't deal with weak refs
-    if (NS_WARN_IF(!aIsStrongRef))
-        return NS_ERROR_UNEXPECTED;
-    if (NS_WARN_IF(!classInfo) || NS_WARN_IF(!serializable))
-        return NS_ERROR_NOT_AVAILABLE;
+    nsCOMPtr<nsISerializable> serializable = do_QueryInterface(aObject);
+    NS_ENSURE_TRUE(serializable, NS_ERROR_NOT_AVAILABLE);
 
     nsCID cid;
     classInfo->GetClassIDNoAlloc(&cid);
 
     nsresult rv = WriteID(cid);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
-
+    NS_ENSURE_SUCCESS(rv, rv);
+    
     rv = WriteID(aIID);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     return serializable->Write(this);
 }
 
 NS_IMETHODIMP
 nsBinaryOutputStream::WriteID(const nsIID& aIID)
 {
     nsresult rv = Write32(aIID.m0);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = Write16(aIID.m1);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = Write16(aIID.m2);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     for (int i = 0; i < 8; ++i) {
         rv = Write8(aIID.m3[i]);
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP_(char*)
 nsBinaryOutputStream::GetBuffer(uint32_t aLength, uint32_t aAlignMask)
 {
@@ -313,26 +301,24 @@ nsBinaryOutputStream::PutBuffer(char* aB
         mBufferAccess->PutBuffer(aBuffer, aLength);
 }
 
 NS_IMPL_ISUPPORTS3(nsBinaryInputStream, nsIObjectInputStream, nsIBinaryInputStream, nsIInputStream)
 
 NS_IMETHODIMP
 nsBinaryInputStream::Available(uint64_t* aResult)
 {
-    if (NS_WARN_IF(!mInputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mInputStream);
     return mInputStream->Available(aResult);
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::Read(char* aBuffer, uint32_t aCount, uint32_t *aNumRead)
 {
-    if (NS_WARN_IF(!mInputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mInputStream);
 
     // mInputStream might give us short reads, so deal with that.
     uint32_t totalRead = 0;
 
     uint32_t bytesRead;
     do {
         nsresult rv = mInputStream->Read(aBuffer, aCount, &bytesRead);
         if (rv == NS_BASE_STREAM_WOULD_BLOCK && totalRead != 0) {
@@ -392,18 +378,17 @@ ReadSegmentForwardingThunk(nsIInputStrea
 
     return thunkClosure->mRealResult;
 }
 
 
 NS_IMETHODIMP
 nsBinaryInputStream::ReadSegments(nsWriteSegmentFun writer, void * closure, uint32_t count, uint32_t *_retval)
 {
-    if (NS_WARN_IF(!mInputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mInputStream);
 
     ReadSegmentsClosure thunkClosure = { this, closure, writer, NS_OK, 0 };
     
     // mInputStream might give us short reads, so deal with that.
     uint32_t bytesRead;
     do {
         nsresult rv = mInputStream->ReadSegments(ReadSegmentForwardingThunk,
                                                  &thunkClosure,
@@ -426,34 +411,31 @@ nsBinaryInputStream::ReadSegments(nsWrit
     *_retval = thunkClosure.mBytesRead;
 
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::IsNonBlocking(bool *aNonBlocking)
 {
-    if (NS_WARN_IF(!mInputStream))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_STATE(mInputStream);
     return mInputStream->IsNonBlocking(aNonBlocking);
 }
 
 NS_IMETHODIMP
-nsBinaryInputStream::Close()
-{
-    if (NS_WARN_IF(!mInputStream))
-        return NS_ERROR_UNEXPECTED;
-    return mInputStream->Close();
+nsBinaryInputStream::Close() 
+{ 
+    NS_ENSURE_STATE(mInputStream);
+    return mInputStream->Close(); 
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::SetInputStream(nsIInputStream *aInputStream)
 {
-    if (NS_WARN_IF(!aInputStream))
-        return NS_ERROR_INVALID_ARG;
+    NS_ENSURE_ARG_POINTER(aInputStream);
     mInputStream = aInputStream;
     mBufferAccess = do_QueryInterface(aInputStream);
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::ReadBoolean(bool* aBoolean)
 {
@@ -742,36 +724,33 @@ nsBinaryInputStream::ReadArrayBuffer(uin
     }
     uint8_t* data = JS_GetArrayBufferData(&aBuffer.toObject());
     if (!data) {
         return NS_ERROR_FAILURE;
     }
 
     uint32_t bytesRead;
     nsresult rv = Read(reinterpret_cast<char*>(data), aLength, &bytesRead);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
     if (bytesRead != aLength) {
         return NS_ERROR_FAILURE;
     }
     return NS_OK;
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::ReadObject(bool aIsStrongRef, nsISupports* *aObject)
 {
     nsCID cid;
     nsIID iid;
     nsresult rv = ReadID(&cid);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = ReadID(&iid);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     // HACK: Intercept old (pre-gecko6) nsIURI IID, and replace with
     // the updated IID, so that we're QI'ing to an actual interface.
     // (As soon as we drop support for upgrading from pre-gecko6, we can
     // remove this chunk.)
     static const nsIID oldURIiid =
         { 0x7a22cc0, 0xce5, 0x11d3,
           { 0x93, 0x31, 0x0, 0x10, 0x4b, 0xa0, 0xfd, 0x40 }};
@@ -790,49 +769,42 @@ nsBinaryInputStream::ReadObject(bool aIs
         iid.Equals(oldURIiid2) ||
         iid.Equals(oldURIiid3)) {
         const nsIID newURIiid = NS_IURI_IID;
         iid = newURIiid;
     }
     // END HACK
 
     nsCOMPtr<nsISupports> object = do_CreateInstance(cid, &rv);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     nsCOMPtr<nsISerializable> serializable = do_QueryInterface(object);
-    if (NS_WARN_IF(!serializable))
-        return NS_ERROR_UNEXPECTED;
+    NS_ENSURE_TRUE(serializable, NS_ERROR_UNEXPECTED);
 
     rv = serializable->Read(this);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);    
 
     return object->QueryInterface(iid, reinterpret_cast<void**>(aObject));
 }
 
 NS_IMETHODIMP
 nsBinaryInputStream::ReadID(nsID *aResult)
 {
     nsresult rv = Read32(&aResult->m0);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = Read16(&aResult->m1);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     rv = Read16(&aResult->m2);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-        return rv;
+    NS_ENSURE_SUCCESS(rv, rv);
 
     for (int i = 0; i < 8; ++i) {
         rv = Read8(&aResult->m3[i]);
-        if (NS_WARN_IF(NS_FAILED(rv)))
-            return rv;
+        NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
 }
 
 NS_IMETHODIMP_(char*)
 nsBinaryInputStream::GetBuffer(uint32_t aLength, uint32_t aAlignMask)
 {