Bug 1297658 - Avoid unnecessary checking in memory reporters. r=erahm.
authorNicholas Nethercote <nnethercote@mozilla.com>
Wed, 24 Aug 2016 15:23:45 +1000
changeset 352457 7651ea2490e0f0d36757ee238fcf4446b1869d18
parent 352456 09a27892f811ba6099f85ecbaa3225fb836850be
child 352458 e5581710f5c9c2efe6aa032491bf0f9d0c69e5d1
push id6570
push userraliiev@mozilla.com
push dateMon, 14 Nov 2016 12:26:13 +0000
treeherdermozilla-beta@f455459b2ae5 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerserahm
bugs1297658
milestone51.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1297658 - Avoid unnecessary checking in memory reporters. r=erahm. This patch removes checking of all the callback calls in memory reporter CollectReport() functions, because it's not useful. The patch also does some associated clean-up. - Replaces some uses of nsIMemoryReporterCallback with the preferred nsIHandleReportCallback typedef. - Replaces aCallback/aCb/aClosure with aHandleRepor/aData for CollectReports() parameter names, for consistency. - Adds MOZ_MUST_USE/[must_use] in a few places in nsIMemoryReporter.idl. - Uses the MOZ_COLLECT_REPORT macro in all suitable places. Overall the patch reduces code size by ~300 lines and reduces the size of libxul by about 37 KiB on my Linux64 builds.
dom/base/File.cpp
dom/base/nsContentUtils.cpp
dom/base/nsFrameMessageManager.cpp
dom/base/nsHostObjectProtocolHandler.cpp
dom/base/nsScriptNameSpaceManager.cpp
dom/base/nsWindowMemoryReporter.cpp
dom/base/nsWindowMemoryReporter.h
dom/bindings/WebIDLGlobalNameHash.cpp
dom/canvas/CanvasRenderingContext2D.cpp
dom/canvas/WebGLMemoryTracker.cpp
dom/ipc/ContentChild.cpp
dom/ipc/ContentParent.cpp
dom/media/MediaDecoder.cpp
dom/media/MediaRecorder.cpp
dom/media/MediaStreamGraph.cpp
dom/media/webaudio/AudioBuffer.cpp
dom/media/webaudio/AudioContext.cpp
dom/media/webaudio/AudioContext.h
dom/workers/WorkerPrivate.cpp
extensions/spellcheck/hunspell/glue/mozHunspell.cpp
extensions/spellcheck/hunspell/glue/mozHunspell.h
gfx/gl/GfxTexturesReporter.h
gfx/layers/ipc/ISurfaceAllocator.h
gfx/layers/ipc/SharedBufferManagerParent.cpp
gfx/thebes/gfxASurface.cpp
gfx/thebes/gfxAndroidPlatform.cpp
gfx/thebes/gfxFont.cpp
gfx/thebes/gfxPlatformFontList.cpp
gfx/thebes/gfxUserFontSet.cpp
gfx/thebes/gfxUserFontSet.h
gfx/thebes/gfxWindowsPlatform.cpp
image/SurfaceCache.cpp
image/imgLoader.cpp
ipc/glue/SharedMemory.cpp
js/xpconnect/src/XPCJSMemoryReporter.h
js/xpconnect/src/XPCJSRuntime.cpp
js/xpconnect/src/xpcpublic.h
layout/base/nsStyleSheetService.cpp
layout/style/RuleProcessorCache.cpp
layout/style/nsLayoutStylesheetCache.cpp
modules/libpref/Preferences.cpp
netwerk/cache/nsCacheService.cpp
netwerk/cache2/CacheStorageService.cpp
netwerk/cookie/nsCookieService.cpp
netwerk/dns/nsDNSService2.cpp
netwerk/dns/nsEffectiveTLDService.cpp
netwerk/protocol/http/Http2Compression.cpp
startupcache/StartupCache.cpp
storage/mozStorageService.cpp
toolkit/components/aboutmemory/content/aboutMemory.js
toolkit/components/places/History.cpp
toolkit/components/telemetry/Telemetry.cpp
toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
xpcom/base/AvailableMemoryTracker.cpp
xpcom/base/CountingAllocatorBase.h
xpcom/base/SystemMemoryReporter.cpp
xpcom/base/nsCycleCollector.cpp
xpcom/base/nsIMemoryReporter.idl
xpcom/base/nsMemoryReporterManager.cpp
xpcom/build/XPCOMInit.cpp
xpcom/components/nsCategoryManager.cpp
xpcom/components/nsComponentManager.cpp
xpcom/ds/nsObserverService.cpp
xpcom/reflect/xptinfo/xptiInterfaceInfoManager.cpp
--- a/dom/base/File.cpp
+++ b/dom/base/File.cpp
@@ -1076,18 +1076,18 @@ MOZ_DEFINE_MALLOC_SIZE_OF(MemoryFileData
 class BlobImplMemoryDataOwnerMemoryReporter final
   : public nsIMemoryReporter
 {
   ~BlobImplMemoryDataOwnerMemoryReporter() {}
 
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
 
-  NS_IMETHOD CollectReports(nsIMemoryReporterCallback *aCallback,
-                            nsISupports *aClosure, bool aAnonymize) override
+  NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
+                            nsISupports* aData, bool aAnonymize) override
   {
     typedef BlobImplMemory::DataOwner DataOwner;
 
     StaticMutexAutoLock lock(DataOwner::sDataOwnerMutex);
 
     if (!DataOwner::sDataOwners) {
       return NS_OK;
     }
@@ -1108,46 +1108,44 @@ public:
         uint8_t digest[SHA1Sum::kHashSize]; // SHA1 digests are 20 bytes long.
         sha1.finish(digest);
 
         nsAutoCString digestString;
         for (size_t i = 0; i < sizeof(digest); i++) {
           digestString.AppendPrintf("%02x", digest[i]);
         }
 
-        nsresult rv = aCallback->Callback(
+        aHandleReport->Callback(
           /* process */ NS_LITERAL_CSTRING(""),
           nsPrintfCString(
             "explicit/dom/memory-file-data/large/file(length=%llu, sha1=%s)",
             owner->mLength, aAnonymize ? "<anonymized>" : digestString.get()),
           KIND_HEAP, UNITS_BYTES, size,
           nsPrintfCString(
             "Memory used to back a memory file of length %llu bytes.  The file "
             "has a sha1 of %s.\n\n"
             "Note that the allocator may round up a memory file's length -- "
             "that is, an N-byte memory file may take up more than N bytes of "
             "memory.",
             owner->mLength, digestString.get()),
-          aClosure);
-        NS_ENSURE_SUCCESS(rv, rv);
+          aData);
       }
     }
 
     if (smallObjectsTotal > 0) {
-      nsresult rv = aCallback->Callback(
+      aHandleReport->Callback(
         /* process */ NS_LITERAL_CSTRING(""),
         NS_LITERAL_CSTRING("explicit/dom/memory-file-data/small"),
         KIND_HEAP, UNITS_BYTES, smallObjectsTotal,
         nsPrintfCString(
           "Memory used to back small memory files (less than %d bytes each).\n\n"
           "Note that the allocator may round up a memory file's length -- "
           "that is, an N-byte memory file may take up more than N bytes of "
           "memory."),
-        aClosure);
-      NS_ENSURE_SUCCESS(rv, rv);
+        aData);
     }
 
     return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(BlobImplMemoryDataOwnerMemoryReporter, nsIMemoryReporter)
 
--- a/dom/base/nsContentUtils.cpp
+++ b/dom/base/nsContentUtils.cpp
@@ -391,20 +391,22 @@ public:
   {
     // We don't measure the |EventListenerManager| objects pointed to by the
     // entries because those references are non-owning.
     int64_t amount = sEventListenerManagersHash
                    ? sEventListenerManagersHash->ShallowSizeOfIncludingThis(
                        MallocSizeOf)
                    : 0;
 
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/dom/event-listener-managers-hash", KIND_HEAP, UNITS_BYTES,
       amount,
       "Memory used by the event listener manager's hash table.");
+
+    return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(DOMEventListenerManagersHashReporter, nsIMemoryReporter)
 
 class EventListenerManagerMapEntry : public PLDHashEntryHdr
 {
 public:
--- a/dom/base/nsFrameMessageManager.cpp
+++ b/dom/base/nsFrameMessageManager.cpp
@@ -1573,30 +1573,28 @@ MessageManagerReporter::CountReferents(n
   // participate in messages dispatched from parent message manager.
   for (uint32_t i = 0; i < aMessageManager->mChildManagers.Length(); ++i) {
     RefPtr<nsFrameMessageManager> mm =
       static_cast<nsFrameMessageManager*>(aMessageManager->mChildManagers[i]);
     CountReferents(mm, aReferentCount);
   }
 }
 
-static nsresult
+static void
 ReportReferentCount(const char* aManagerType,
                     const MessageManagerReferentCount& aReferentCount,
-                    nsIMemoryReporterCallback* aCb,
-                    nsISupports* aClosure)
+                    nsIHandleReportCallback* aHandleReport,
+                    nsISupports* aData)
 {
-#define REPORT(_path, _amount, _desc)                                         \
-    do {                                                                      \
-      nsresult rv;                                                            \
-      rv = aCb->Callback(EmptyCString(), _path,                               \
-                         nsIMemoryReporter::KIND_OTHER,                       \
-                         nsIMemoryReporter::UNITS_COUNT, _amount,             \
-                         _desc, aClosure);                                    \
-      NS_ENSURE_SUCCESS(rv, rv);                                              \
+#define REPORT(_path, _amount, _desc) \
+    do { \
+      aHandleReport->Callback(EmptyCString(), _path, \
+                              nsIMemoryReporter::KIND_OTHER, \
+                              nsIMemoryReporter::UNITS_COUNT, _amount, \
+                              _desc, aData); \
     } while (0)
 
   REPORT(nsPrintfCString("message-manager/referent/%s/strong", aManagerType),
          aReferentCount.mStrong,
          nsPrintfCString("The number of strong referents held by the message "
                          "manager in the %s manager.", aManagerType));
   REPORT(nsPrintfCString("message-manager/referent/%s/weak/alive", aManagerType),
          aReferentCount.mWeakAlive,
@@ -1617,51 +1615,44 @@ ReportReferentCount(const char* aManager
     REPORT(nsPrintfCString("message-manager-suspect/%s/referent(message=%s)",
                            aManagerType, suspect.get()), totalReferentCount,
            nsPrintfCString("A message in the %s message manager with a "
                            "suspiciously large number of referents (symptom "
                            "of a leak).", aManagerType));
   }
 
 #undef REPORT
-
-  return NS_OK;
 }
 
 NS_IMETHODIMP
-MessageManagerReporter::CollectReports(nsIMemoryReporterCallback* aCb,
-                                       nsISupports* aClosure, bool aAnonymize)
+MessageManagerReporter::CollectReports(nsIHandleReportCallback* aHandleReport,
+                                       nsISupports* aData, bool aAnonymize)
 {
-  nsresult rv;
-
   if (XRE_IsParentProcess()) {
     nsCOMPtr<nsIMessageBroadcaster> globalmm =
       do_GetService("@mozilla.org/globalmessagemanager;1");
     if (globalmm) {
       RefPtr<nsFrameMessageManager> mm =
         static_cast<nsFrameMessageManager*>(globalmm.get());
       MessageManagerReferentCount count;
       CountReferents(mm, &count);
-      rv = ReportReferentCount("global-manager", count, aCb, aClosure);
-      NS_ENSURE_SUCCESS(rv, rv);
+      ReportReferentCount("global-manager", count, aHandleReport, aData);
     }
   }
 
   if (nsFrameMessageManager::sParentProcessManager) {
     MessageManagerReferentCount count;
     CountReferents(nsFrameMessageManager::sParentProcessManager, &count);
-    rv = ReportReferentCount("parent-process-manager", count, aCb, aClosure);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportReferentCount("parent-process-manager", count, aHandleReport, aData);
   }
 
   if (nsFrameMessageManager::sChildProcessManager) {
     MessageManagerReferentCount count;
     CountReferents(nsFrameMessageManager::sChildProcessManager, &count);
-    rv = ReportReferentCount("child-process-manager", count, aCb, aClosure);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportReferentCount("child-process-manager", count, aHandleReport, aData);
   }
 
   return NS_OK;
 }
 
 } // namespace dom
 } // namespace mozilla
 
--- a/dom/base/nsHostObjectProtocolHandler.cpp
+++ b/dom/base/nsHostObjectProtocolHandler.cpp
@@ -164,21 +164,23 @@ class HostObjectURLsReporter final : pub
   ~HostObjectURLsReporter() {}
 
  public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "host-object-urls", KIND_OTHER, UNITS_COUNT,
       gDataTable ? gDataTable->Count() : 0,
       "The number of host objects stored for access via URLs "
       "(e.g. blobs passed to URL.createObjectURL).");
+
+    return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(HostObjectURLsReporter, nsIMemoryReporter)
 
 class BlobURLsReporter final : public nsIMemoryReporter
 {
  public:
--- a/dom/base/nsScriptNameSpaceManager.cpp
+++ b/dom/base/nsScriptNameSpaceManager.cpp
@@ -407,20 +407,22 @@ nsScriptNameSpaceManager::Observe(nsISup
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(ScriptNameSpaceManagerMallocSizeOf)
 
 NS_IMETHODIMP
 nsScriptNameSpaceManager::CollectReports(
   nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/script-namespace-manager", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(ScriptNameSpaceManagerMallocSizeOf),
     "Memory used for the script namespace manager.");
+
+  return NS_OK;
 }
 
 size_t
 nsScriptNameSpaceManager::SizeOfIncludingThis(
     mozilla::MallocSizeOf aMallocSizeOf) const
 {
   size_t n = 0;
 
--- a/dom/base/nsWindowMemoryReporter.cpp
+++ b/dom/base/nsWindowMemoryReporter.cpp
@@ -187,65 +187,65 @@ AppendWindowURI(nsGlobalWindow *aWindow,
   }
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(WindowsMallocSizeOf)
 
 // The key is the window ID.
 typedef nsDataHashtable<nsUint64HashKey, nsCString> WindowPaths;
 
-static nsresult
+static void
 ReportAmount(const nsCString& aBasePath, const char* aPathTail,
              size_t aAmount, const nsCString& aDescription,
              uint32_t aKind, uint32_t aUnits,
-             nsIMemoryReporterCallback* aCb,
-             nsISupports* aClosure)
+             nsIHandleReportCallback* aHandleReport,
+             nsISupports* aData)
 {
   if (aAmount == 0) {
-    return NS_OK;
+    return;
   }
 
   nsAutoCString path(aBasePath);
   path += aPathTail;
 
-  return aCb->Callback(EmptyCString(), path, aKind, aUnits,
-                       aAmount, aDescription, aClosure);
+  aHandleReport->Callback(
+    EmptyCString(), path, aKind, aUnits, aAmount, aDescription, aData);
 }
 
-static nsresult
+static void
 ReportSize(const nsCString& aBasePath, const char* aPathTail,
            size_t aAmount, const nsCString& aDescription,
-           nsIMemoryReporterCallback* aCb,
-           nsISupports* aClosure)
+           nsIHandleReportCallback* aHandleReport,
+           nsISupports* aData)
 {
-  return ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
-                      nsIMemoryReporter::KIND_HEAP,
-                      nsIMemoryReporter::UNITS_BYTES, aCb, aClosure);
+  ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
+               nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES,
+               aHandleReport, aData);
 }
 
-static nsresult
+static void
 ReportCount(const nsCString& aBasePath, const char* aPathTail,
             size_t aAmount, const nsCString& aDescription,
-            nsIMemoryReporterCallback* aCb,
-            nsISupports* aClosure)
+            nsIHandleReportCallback* aHandleReport,
+            nsISupports* aData)
 {
-  return ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
-                      nsIMemoryReporter::KIND_OTHER,
-                      nsIMemoryReporter::UNITS_COUNT, aCb, aClosure);
+  ReportAmount(aBasePath, aPathTail, aAmount, aDescription,
+               nsIMemoryReporter::KIND_OTHER, nsIMemoryReporter::UNITS_COUNT,
+               aHandleReport, aData);
 }
 
-static nsresult
+static void
 CollectWindowReports(nsGlobalWindow *aWindow,
                      amIAddonManager *addonManager,
                      nsWindowSizes *aWindowTotalSizes,
                      nsTHashtable<nsUint64HashKey> *aGhostWindowIDs,
                      WindowPaths *aWindowPaths,
                      WindowPaths *aTopWindowPaths,
-                     nsIMemoryReporterCallback *aCb,
-                     nsISupports *aClosure,
+                     nsIHandleReportCallback *aHandleReport,
+                     nsISupports *aData,
                      bool aAnonymize)
 {
   nsAutoCString windowPath("explicit/");
 
   // Avoid calling aWindow->GetTop() if there's no outer window.  It will work
   // just fine, but will spew a lot of warnings.
   nsGlobalWindow *top = nullptr;
   nsCOMPtr<nsIURI> location;
@@ -297,29 +297,23 @@ CollectWindowReports(nsGlobalWindow *aWi
 
   // Use |windowPath|, but replace "explicit/" with "event-counts/".
   nsCString censusWindowPath(windowPath);
   censusWindowPath.Replace(0, strlen("explicit"), "event-counts");
 
   // Remember the path for later.
   aWindowPaths->Put(aWindow->WindowID(), windowPath);
 
-#define REPORT_SIZE(_pathTail, _amount, _desc)                                \
-  do {                                                                        \
-    nsresult rv = ReportSize(windowPath, _pathTail, _amount,                  \
-                             NS_LITERAL_CSTRING(_desc), aCb, aClosure);       \
-    NS_ENSURE_SUCCESS(rv, rv);                                                \
-  } while (0)
+#define REPORT_SIZE(_pathTail, _amount, _desc) \
+  ReportSize(windowPath, _pathTail, _amount, NS_LITERAL_CSTRING(_desc), \
+             aHandleReport, aData);
 
-#define REPORT_COUNT(_pathTail, _amount, _desc)                               \
-  do {                                                                        \
-    nsresult rv = ReportCount(censusWindowPath, _pathTail, _amount,           \
-                              NS_LITERAL_CSTRING(_desc), aCb, aClosure);      \
-    NS_ENSURE_SUCCESS(rv, rv);                                                \
-  } while (0)
+#define REPORT_COUNT(_pathTail, _amount, _desc) \
+  ReportCount(censusWindowPath, _pathTail, _amount, NS_LITERAL_CSTRING(_desc), \
+              aHandleReport, aData);
 
   nsWindowSizes windowSizes(WindowsMallocSizeOf);
   aWindow->AddSizeOfIncludingThis(&windowSizes);
 
   REPORT_SIZE("/dom/element-nodes", windowSizes.mDOMElementNodesSize,
               "Memory used by the element nodes in a window's DOM.");
   aWindowTotalSizes->mDOMElementNodesSize += windowSizes.mDOMElementNodesSize;
 
@@ -434,42 +428,39 @@ CollectWindowReports(nsGlobalWindow *aWi
   if (frameSundriesSize > 0) {
     REPORT_SIZE("/layout/frames/sundries", frameSundriesSize,
                 "The sum of all memory used by frames which were too small "
                 "to be shown individually.");
   }
 
 #undef REPORT_SIZE
 #undef REPORT_COUNT
-
-  return NS_OK;
 }
 
 typedef nsTArray< RefPtr<nsGlobalWindow> > WindowArray;
 
 NS_IMETHODIMP
-nsWindowMemoryReporter::CollectReports(nsIMemoryReporterCallback* aCb,
-                                       nsISupports* aClosure, bool aAnonymize)
+nsWindowMemoryReporter::CollectReports(nsIHandleReportCallback* aHandleReport,
+                                       nsISupports* aData, bool aAnonymize)
 {
   nsGlobalWindow::WindowByIdTable* windowsById =
     nsGlobalWindow::GetWindowsTable();
   NS_ENSURE_TRUE(windowsById, NS_OK);
 
   // Hold on to every window in memory so that window objects can't be
   // destroyed while we're calling the memory reporter callback.
   WindowArray windows;
   for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) {
     windows.AppendElement(iter.Data());
   }
 
-  // Get the IDs of all the "ghost" windows, and call aCb->Callback() for each
-  // one.
+  // Get the IDs of all the "ghost" windows, and call aHandleReport->Callback()
+  // for each one.
   nsTHashtable<nsUint64HashKey> ghostWindows;
   CheckForGhostWindows(&ghostWindows);
-  nsresult rv = NS_OK;
   for (auto iter = ghostWindows.ConstIter(); !iter.Done(); iter.Next()) {
     nsGlobalWindow::WindowByIdTable* windowsById =
       nsGlobalWindow::GetWindowsTable();
     if (!windowsById) {
       NS_WARNING("Couldn't get window-by-id hashtable?");
       continue;
     }
 
@@ -478,62 +469,52 @@ nsWindowMemoryReporter::CollectReports(n
       NS_WARNING("Could not look up window?");
       continue;
     }
 
     nsAutoCString path;
     path.AppendLiteral("ghost-windows/");
     AppendWindowURI(window, path, aAnonymize);
 
-    nsresult callbackRv = aCb->Callback(
+    aHandleReport->Callback(
       /* process = */ EmptyCString(),
       path,
       nsIMemoryReporter::KIND_OTHER,
       nsIMemoryReporter::UNITS_COUNT,
       /* amount = */ 1,
       /* description = */ NS_LITERAL_CSTRING("A ghost window."),
-      aClosure);
-    if (NS_FAILED(callbackRv) && NS_SUCCEEDED(rv)) {
-      rv = callbackRv;
-    }
+      aData);
   }
-  NS_ENSURE_SUCCESS(rv, rv);
 
   WindowPaths windowPaths;
   WindowPaths topWindowPaths;
 
   // Collect window memory usage.
   nsWindowSizes windowTotalSizes(nullptr);
   nsCOMPtr<amIAddonManager> addonManager;
   if (XRE_IsParentProcess()) {
     // Only try to access the service from the main process.
     addonManager = do_GetService("@mozilla.org/addons/integration;1");
   }
   for (uint32_t i = 0; i < windows.Length(); i++) {
-    rv = CollectWindowReports(windows[i], addonManager,
-                              &windowTotalSizes, &ghostWindows,
-                              &windowPaths, &topWindowPaths, aCb,
-                              aClosure, aAnonymize);
-    NS_ENSURE_SUCCESS(rv, rv);
+    CollectWindowReports(windows[i], addonManager,
+                         &windowTotalSizes, &ghostWindows,
+                         &windowPaths, &topWindowPaths, aHandleReport,
+                         aData, aAnonymize);
   }
 
   // Report JS memory usage.  We do this from here because the JS memory
   // reporter needs to be passed |windowPaths|.
-  rv = xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths,
-                                       aCb, aClosure, aAnonymize);
-  NS_ENSURE_SUCCESS(rv, rv);
+  xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths,
+                                  aHandleReport, aData, aAnonymize);
 
-#define REPORT(_path, _amount, _desc)                                         \
-  do {                                                                        \
-    nsresult rv;                                                              \
-    rv = aCb->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path),             \
-                       KIND_OTHER, UNITS_BYTES, _amount,                      \
-                       NS_LITERAL_CSTRING(_desc), aClosure);                  \
-    NS_ENSURE_SUCCESS(rv, rv);                                                \
-  } while (0)
+#define REPORT(_path, _amount, _desc) \
+  aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
+                          KIND_OTHER, UNITS_BYTES, _amount, \
+                          NS_LITERAL_CSTRING(_desc), aData);
 
   REPORT("window-objects/dom/element-nodes", windowTotalSizes.mDOMElementNodesSize,
          "This is the sum of all windows' 'dom/element-nodes' numbers.");
 
   REPORT("window-objects/dom/text-nodes", windowTotalSizes.mDOMTextNodesSize,
          "This is the sum of all windows' 'dom/text-nodes' numbers.");
 
   REPORT("window-objects/dom/cdata-nodes", windowTotalSizes.mDOMCDATANodesSize,
@@ -640,17 +621,17 @@ nsWindowMemoryReporter::ObserveDOMWindow
 
   mDetachedWindows.Put(weakWindow, TimeStamp());
 
   AsyncCheckForGhostWindows();
 }
 
 // static
 void
-nsWindowMemoryReporter::CheckTimerFired(nsITimer* aTimer, void* aClosure)
+nsWindowMemoryReporter::CheckTimerFired(nsITimer* aTimer, void* aData)
 {
   if (sWindowReporter) {
     MOZ_ASSERT(!sWindowReporter->mCycleCollectorIsRunning);
     sWindowReporter->CheckForGhostWindows();
   }
 }
 
 void
--- a/dom/base/nsWindowMemoryReporter.h
+++ b/dom/base/nsWindowMemoryReporter.h
@@ -175,26 +175,28 @@ private:
     NS_DECL_ISUPPORTS
 
     static int64_t DistinguishedAmount();
 
     NS_IMETHOD
     CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                    bool aAnonymize) override
     {
-      return MOZ_COLLECT_REPORT(
+      MOZ_COLLECT_REPORT(
         "ghost-windows", KIND_OTHER, UNITS_COUNT, DistinguishedAmount(),
 "The number of ghost windows present (the number of nodes underneath "
 "explicit/window-objects/top(none)/ghost, modulo race conditions).  A ghost "
 "window is not shown in any tab, does not share a domain with any non-detached "
 "windows, and has met these criteria for at least "
 "memory.ghost_window_timeout_seconds, or has survived a round of "
 "about:memory's minimize memory usage button.\n\n"
 "Ghost windows can happen legitimately, but they are often indicative of "
 "leaks in the browser or add-ons.");
+
+      return NS_OK;
     }
   };
 
   // Protect ctor, use Init() instead.
   nsWindowMemoryReporter();
 
   /**
    * Get the number of seconds for which a window must satisfy ghost criteria
--- a/dom/bindings/WebIDLGlobalNameHash.cpp
+++ b/dom/bindings/WebIDLGlobalNameHash.cpp
@@ -118,20 +118,21 @@ public:
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount =
       sWebIDLGlobalNames ?
       sWebIDLGlobalNames->ShallowSizeOfIncludingThis(MallocSizeOf) : 0;
 
-    return MOZ_COLLECT_REPORT("explicit/dom/webidl-globalnames", KIND_HEAP,
-                              UNITS_BYTES, amount,
-                              "Memory used by the hash table for WebIDL's "
-                              "global names.");
+    MOZ_COLLECT_REPORT(
+      "explicit/dom/webidl-globalnames", KIND_HEAP, UNITS_BYTES, amount,
+      "Memory used by the hash table for WebIDL's global names.");
+
+    return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(WebIDLGlobalNamesHashReporter, nsIMemoryReporter)
 
 /* static */
 void
 WebIDLGlobalNameHash::Init()
--- a/dom/canvas/CanvasRenderingContext2D.cpp
+++ b/dom/canvas/CanvasRenderingContext2D.cpp
@@ -173,21 +173,22 @@ class Canvas2dPixelsReporter final : pub
 {
   ~Canvas2dPixelsReporter() {}
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
-      "canvas-2d-pixels", KIND_OTHER, UNITS_BYTES,
-      gCanvasAzureMemoryUsed,
+    MOZ_COLLECT_REPORT(
+      "canvas-2d-pixels", KIND_OTHER, UNITS_BYTES, gCanvasAzureMemoryUsed,
       "Memory used by 2D canvases. Each canvas requires "
       "(width * height * 4) bytes.");
+
+    return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(Canvas2dPixelsReporter, nsIMemoryReporter)
 
 class CanvasRadialGradient : public CanvasGradient
 {
 public:
--- a/dom/canvas/WebGLMemoryTracker.cpp
+++ b/dom/canvas/WebGLMemoryTracker.cpp
@@ -12,86 +12,74 @@
 #include "WebGLRenderbuffer.h"
 #include "WebGLShader.h"
 #include "WebGLTexture.h"
 #include "WebGLUniformLocation.h"
 
 namespace mozilla {
 
 NS_IMETHODIMP
-WebGLMemoryTracker::CollectReports(nsIHandleReportCallback* handleReport,
-                                   nsISupports* data, bool)
+WebGLMemoryTracker::CollectReports(nsIHandleReportCallback* aHandleReport,
+                                   nsISupports* aData, bool)
 {
-#define REPORT(_path, _kind, _units, _amount, _desc)                         \
-    do {                                                                     \
-      nsresult rv;                                                           \
-      rv = handleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
-                                   _kind, _units, _amount,                   \
-                                   NS_LITERAL_CSTRING(_desc), data);         \
-      NS_ENSURE_SUCCESS(rv, rv);                                             \
-    } while (0)
+    MOZ_COLLECT_REPORT(
+        "webgl-texture-memory", KIND_OTHER, UNITS_BYTES, GetTextureMemoryUsed(),
+        "Memory used by WebGL textures. The OpenGL implementation is free to "
+        "store these textures in either video memory or main memory. This "
+        "measurement is only a lower bound, actual memory usage may be higher "
+        "for example if the storage is strided.");
+
+    MOZ_COLLECT_REPORT(
+        "webgl-texture-count", KIND_OTHER, UNITS_COUNT, GetTextureCount(),
+        "Number of WebGL textures.");
 
-    REPORT("webgl-texture-memory",
-           KIND_OTHER, UNITS_BYTES, GetTextureMemoryUsed(),
-           "Memory used by WebGL textures.The OpenGL"
-           " implementation is free to store these textures in either video"
-           " memory or main memory. This measurement is only a lower bound,"
-           " actual memory usage may be higher for example if the storage"
-           " is strided.");
+    MOZ_COLLECT_REPORT(
+        "webgl-buffer-memory", KIND_OTHER, UNITS_BYTES, GetBufferMemoryUsed(),
+        "Memory used by WebGL buffers. The OpenGL implementation is free to "
+        "store these buffers in either video memory or main memory. This "
+        "measurement is only a lower bound, actual memory usage may be higher "
+        "for example if the storage is strided.");
 
-    REPORT("webgl-texture-count",
-           KIND_OTHER, UNITS_COUNT, GetTextureCount(),
-           "Number of WebGL textures.");
-
-    REPORT("webgl-buffer-memory",
-           KIND_OTHER, UNITS_BYTES, GetBufferMemoryUsed(),
-           "Memory used by WebGL buffers. The OpenGL"
-           " implementation is free to store these buffers in either video"
-           " memory or main memory. This measurement is only a lower bound,"
-           " actual memory usage may be higher for example if the storage"
-           " is strided.");
+    MOZ_COLLECT_REPORT(
+        "explicit/webgl/buffer-cache-memory", KIND_HEAP, UNITS_BYTES,
+        GetBufferCacheMemoryUsed(),
+        "Memory used by WebGL buffer caches. The WebGL implementation caches "
+        "the contents of element array buffers only. This adds up with the "
+        "'webgl-buffer-memory' value, but contrary to it, this one represents "
+        "bytes on the heap, not managed by OpenGL.");
 
-    REPORT("explicit/webgl/buffer-cache-memory",
-           KIND_HEAP, UNITS_BYTES, GetBufferCacheMemoryUsed(),
-           "Memory used by WebGL buffer caches. The WebGL"
-           " implementation caches the contents of element array buffers"
-           " only.This adds up with the webgl-buffer-memory value, but"
-           " contrary to it, this one represents bytes on the heap,"
-           " not managed by OpenGL.");
+    MOZ_COLLECT_REPORT(
+        "webgl-buffer-count", KIND_OTHER, UNITS_COUNT, GetBufferCount(),
+        "Number of WebGL buffers.");
 
-    REPORT("webgl-buffer-count",
-           KIND_OTHER, UNITS_COUNT, GetBufferCount(),
-           "Number of WebGL buffers.");
+    MOZ_COLLECT_REPORT(
+        "webgl-renderbuffer-memory", KIND_OTHER, UNITS_BYTES,
+        GetRenderbufferMemoryUsed(),
+        "Memory used by WebGL renderbuffers. The OpenGL implementation is free "
+        "to store these renderbuffers in either video memory or main memory. "
+        "This measurement is only a lower bound, actual memory usage may be "
+        "higher, for example if the storage is strided.");
 
-    REPORT("webgl-renderbuffer-memory",
-           KIND_OTHER, UNITS_BYTES, GetRenderbufferMemoryUsed(),
-           "Memory used by WebGL renderbuffers. The OpenGL"
-           " implementation is free to store these renderbuffers in either"
-           " video memory or main memory. This measurement is only a lower"
-           " bound, actual memory usage may be higher for example if the"
-           " storage is strided.");
-
-    REPORT("webgl-renderbuffer-count",
-           KIND_OTHER, UNITS_COUNT, GetRenderbufferCount(),
-           "Number of WebGL renderbuffers.");
+    MOZ_COLLECT_REPORT(
+        "webgl-renderbuffer-count", KIND_OTHER, UNITS_COUNT,
+        GetRenderbufferCount(),
+        "Number of WebGL renderbuffers.");
 
-    REPORT("explicit/webgl/shader",
-           KIND_HEAP, UNITS_BYTES, GetShaderSize(),
-           "Combined size of WebGL shader ASCII sources and translation"
-           " logs cached on the heap.");
+    MOZ_COLLECT_REPORT(
+        "explicit/webgl/shader", KIND_HEAP, UNITS_BYTES, GetShaderSize(),
+        "Combined size of WebGL shader ASCII sources and translation logs "
+        "cached on the heap.");
 
-    REPORT("webgl-shader-count",
-           KIND_OTHER, UNITS_COUNT, GetShaderCount(),
-           "Number of WebGL shaders.");
+    MOZ_COLLECT_REPORT(
+        "webgl-shader-count", KIND_OTHER, UNITS_COUNT, GetShaderCount(),
+        "Number of WebGL shaders.");
 
-    REPORT("webgl-context-count",
-           KIND_OTHER, UNITS_COUNT, GetContextCount(),
-           "Number of WebGL contexts.");
-
-#undef REPORT
+    MOZ_COLLECT_REPORT(
+        "webgl-context-count", KIND_OTHER, UNITS_COUNT, GetContextCount(),
+        "Number of WebGL contexts.");
 
     return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(WebGLMemoryTracker, nsIMemoryReporter)
 
 StaticRefPtr<WebGLMemoryTracker> WebGLMemoryTracker::sUniqueInstance;
 
--- a/dom/ipc/ContentChild.cpp
+++ b/dom/ipc/ContentChild.cpp
@@ -975,73 +975,73 @@ ContentChild::AllocPMemoryReportRequestC
                                              const MaybeFileDesc& aDMDFile)
 {
   MemoryReportRequestChild *actor =
     new MemoryReportRequestChild(aAnonymize, aDMDFile);
   actor->AddRef();
   return actor;
 }
 
-class MemoryReportCallback final : public nsIMemoryReporterCallback
+class HandleReportCallback final : public nsIHandleReportCallback
 {
 public:
   NS_DECL_ISUPPORTS
 
-  explicit MemoryReportCallback(MemoryReportRequestChild* aActor,
+  explicit HandleReportCallback(MemoryReportRequestChild* aActor,
                                 const nsACString& aProcess)
   : mActor(aActor)
   , mProcess(aProcess)
   { }
 
   NS_IMETHOD Callback(const nsACString& aProcess, const nsACString &aPath,
                       int32_t aKind, int32_t aUnits, int64_t aAmount,
                       const nsACString& aDescription,
                       nsISupports* aUnused) override
   {
     MemoryReport memreport(mProcess, nsCString(aPath), aKind, aUnits,
                            aAmount, nsCString(aDescription));
     mActor->SendReport(memreport);
     return NS_OK;
   }
 private:
-  ~MemoryReportCallback() {}
+  ~HandleReportCallback() {}
 
   RefPtr<MemoryReportRequestChild> mActor;
   const nsCString mProcess;
 };
 
 NS_IMPL_ISUPPORTS(
-  MemoryReportCallback
-, nsIMemoryReporterCallback
+  HandleReportCallback
+, nsIHandleReportCallback
 )
 
-class MemoryReportFinishedCallback final : public nsIFinishReportingCallback
+class FinishReportingCallback final : public nsIFinishReportingCallback
 {
 public:
   NS_DECL_ISUPPORTS
 
-  explicit MemoryReportFinishedCallback(MemoryReportRequestChild* aActor)
+  explicit FinishReportingCallback(MemoryReportRequestChild* aActor)
   : mActor(aActor)
   {
   }
 
   NS_IMETHOD Callback(nsISupports* aUnused) override
   {
     bool sent = PMemoryReportRequestChild::Send__delete__(mActor);
     return sent ? NS_OK : NS_ERROR_FAILURE;
   }
 
 private:
-  ~MemoryReportFinishedCallback() {}
+  ~FinishReportingCallback() {}
 
   RefPtr<MemoryReportRequestChild> mActor;
 };
 
 NS_IMPL_ISUPPORTS(
-  MemoryReportFinishedCallback
+  FinishReportingCallback
 , nsIFinishReportingCallback
 )
 
 bool
 ContentChild::RecvPMemoryReportRequestConstructor(
   PMemoryReportRequestChild* aChild,
   const uint32_t& aGeneration,
   const bool& aAnonymize,
@@ -1071,24 +1071,25 @@ NS_IMETHODIMP MemoryReportRequestChild::
     do_GetService("@mozilla.org/memory-reporter-manager;1");
 
   nsCString process;
   child->GetProcessName(process);
   child->AppendProcessId(process);
 
   // Run the reporters.  The callback will turn each measurement into a
   // MemoryReport.
-  RefPtr<MemoryReportCallback> cb =
-    new MemoryReportCallback(this, process);
-  RefPtr<MemoryReportFinishedCallback> finished =
-    new MemoryReportFinishedCallback(this);
-
-  return mgr->GetReportsForThisProcessExtended(cb, nullptr, mAnonymize,
+  RefPtr<HandleReportCallback> handleReport =
+    new HandleReportCallback(this, process);
+  RefPtr<FinishReportingCallback> finishReporting =
+    new FinishReportingCallback(this);
+
+  return mgr->GetReportsForThisProcessExtended(handleReport, nullptr,
+                                               mAnonymize,
                                                FileDescriptorToFILE(mDMDFile, "wb"),
-                                               finished, nullptr);
+                                               finishReporting, nullptr);
 }
 
 bool
 ContentChild::DeallocPMemoryReportRequestChild(PMemoryReportRequestChild* actor)
 {
   static_cast<MemoryReportRequestChild*>(actor)->Release();
   return true;
 }
@@ -2696,17 +2697,17 @@ ContentChild::RecvNotifyProcessPriorityC
 
 bool
 ContentChild::RecvMinimizeMemoryUsage()
 {
   nsCOMPtr<nsIMemoryReporterManager> mgr =
     do_GetService("@mozilla.org/memory-reporter-manager;1");
   NS_ENSURE_TRUE(mgr, true);
 
-  mgr->MinimizeMemoryUsage(/* callback = */ nullptr);
+  Unused << mgr->MinimizeMemoryUsage(/* callback = */ nullptr);
   return true;
 }
 
 bool
 ContentChild::RecvNotifyPhoneStateChange(const nsString& aState)
 {
   nsCOMPtr<nsIObserverService> os = services::GetObserverService();
   if (os) {
--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -477,19 +477,20 @@ class ContentParentsMemoryReporter final
 public:
   NS_DECL_ISUPPORTS
   NS_DECL_NSIMEMORYREPORTER
 };
 
 NS_IMPL_ISUPPORTS(ContentParentsMemoryReporter, nsIMemoryReporter)
 
 NS_IMETHODIMP
-ContentParentsMemoryReporter::CollectReports(nsIMemoryReporterCallback* cb,
-                                             nsISupports* aClosure,
-                                             bool aAnonymize)
+ContentParentsMemoryReporter::CollectReports(
+  nsIHandleReportCallback* aHandleReport,
+  nsISupports* aData,
+  bool aAnonymize)
 {
   AutoTArray<ContentParent*, 16> cps;
   ContentParent::GetAllEvenIfDead(cps);
 
   for (uint32_t i = 0; i < cps.Length(); i++) {
     ContentParent* cp = cps[i];
     MessageChannel* channel = cp->GetIPCChannel();
 
@@ -517,25 +518,19 @@ ContentParentsMemoryReporter::CollectRep
                          static_cast<nsIContentParent*>(cp), refcnt);
 
     NS_NAMED_LITERAL_CSTRING(desc,
       "The number of unset IPC messages held in this ContentParent's "
       "channel.  A large value here might indicate that we're leaking "
       "messages.  Similarly, a ContentParent object for a process that's no "
       "longer running could indicate that we're leaking ContentParents.");
 
-    nsresult rv = cb->Callback(/* process */ EmptyCString(),
-                               path,
-                               KIND_OTHER,
-                               UNITS_COUNT,
-                               numQueuedMessages,
-                               desc,
-                               aClosure);
-
-    NS_ENSURE_SUCCESS(rv, rv);
+    aHandleReport->Callback(/* process */ EmptyCString(), path,
+                            KIND_OTHER, UNITS_COUNT,
+                            numQueuedMessages, desc, aData);
   }
 
   return NS_OK;
 }
 
 nsDataHashtable<nsStringHashKey, ContentParent*>* ContentParent::sAppContentParents;
 nsTArray<ContentParent*>* ContentParent::sNonAppContentParents;
 nsTArray<ContentParent*>* ContentParent::sPrivateContent;
--- a/dom/media/MediaDecoder.cpp
+++ b/dom/media/MediaDecoder.cpp
@@ -1757,32 +1757,23 @@ MediaMemoryTracker::CollectReports(nsIHa
   DecodersArray& decoders = Decoders();
   for (size_t i = 0; i < decoders.Length(); ++i) {
     MediaDecoder* decoder = decoders[i];
     video += decoder->SizeOfVideoQueue();
     audio += decoder->SizeOfAudioQueue();
     decoder->AddSizeOfResources(resourceSizes);
   }
 
-#define REPORT(_path, _amount, _desc)                                         \
-  do {                                                                        \
-      nsresult rv;                                                            \
-      rv = aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
-                                   KIND_HEAP, UNITS_BYTES, _amount,           \
-                                   NS_LITERAL_CSTRING(_desc), aData);         \
-      NS_ENSURE_SUCCESS(rv, rv);                                              \
-  } while (0)
+  MOZ_COLLECT_REPORT(
+    "explicit/media/decoded/video", KIND_HEAP, UNITS_BYTES, video,
+    "Memory used by decoded video frames.");
 
-  REPORT("explicit/media/decoded/video", video,
-         "Memory used by decoded video frames.");
-
-  REPORT("explicit/media/decoded/audio", audio,
-         "Memory used by decoded audio chunks.");
-
-#undef REPORT
+  MOZ_COLLECT_REPORT(
+    "explicit/media/decoded/audio", KIND_HEAP, UNITS_BYTES, audio,
+    "Memory used by decoded audio chunks.");
 
   return NS_OK;
 }
 
 MediaDecoderOwner*
 MediaDecoder::GetOwner() const
 {
   MOZ_ASSERT(NS_IsMainThread());
--- a/dom/media/MediaRecorder.cpp
+++ b/dom/media/MediaRecorder.cpp
@@ -78,27 +78,19 @@ public:
                  nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount = 0;
     RecordersArray& recorders = GetRecorders();
     for (size_t i = 0; i < recorders.Length(); ++i) {
       amount += recorders[i]->SizeOfExcludingThis(MallocSizeOf);
     }
 
-  #define MEMREPORT(_path, _amount, _desc)                                    \
-    do {                                                                      \
-      nsresult rv;                                                            \
-      rv = aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \
-                                   KIND_HEAP, UNITS_BYTES, _amount,           \
-                                   NS_LITERAL_CSTRING(_desc), aData);         \
-      NS_ENSURE_SUCCESS(rv, rv);                                              \
-    } while (0)
-
-    MEMREPORT("explicit/media/recorder", amount,
-              "Memory used by media recorder.");
+    MOZ_COLLECT_REPORT(
+      "explicit/media/recorder", KIND_HEAP, UNITS_BYTES, amount,
+      "Memory used by media recorder.");
 
     return NS_OK;
   }
 
 private:
   MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
   virtual ~MediaRecorderReporter();
   static StaticRefPtr<MediaRecorderReporter> sUniqueInstance;
--- a/dom/media/MediaStreamGraph.cpp
+++ b/dom/media/MediaStreamGraph.cpp
@@ -3493,25 +3493,19 @@ FinishCollectReports(nsIHandleReportCall
   MOZ_ASSERT(NS_IsMainThread());
 
   nsCOMPtr<nsIMemoryReporterManager> manager =
     do_GetService("@mozilla.org/memory-reporter-manager;1");
 
   if (!manager)
     return;
 
-#define REPORT(_path, _amount, _desc)                                       \
-  do {                                                                      \
-    nsresult rv;                                                            \
-    rv = aHandleReport->Callback(EmptyCString(), _path,                     \
-                                 KIND_HEAP, UNITS_BYTES, _amount,           \
-                                 NS_LITERAL_CSTRING(_desc), aData);         \
-    if (NS_WARN_IF(NS_FAILED(rv)))                                          \
-      return;                                                               \
-  } while (0)
+#define REPORT(_path, _amount, _desc) \
+  aHandleReport->Callback(EmptyCString(), _path, KIND_HEAP, UNITS_BYTES, \
+                          _amount, NS_LITERAL_CSTRING(_desc), aData);
 
   for (size_t i = 0; i < aAudioStreamSizes.Length(); i++) {
     const AudioNodeSizes& usage = aAudioStreamSizes[i];
     const char* const nodeType =
       usage.mNodeType ? usage.mNodeType : "<unknown>";
 
     nsPrintfCString enginePath("explicit/webaudio/audio-node/%s/engine-objects",
                                nodeType);
@@ -3522,19 +3516,18 @@ FinishCollectReports(nsIHandleReportCall
                                nodeType);
     REPORT(streamPath, usage.mStream,
            "Memory used by AudioNode stream objects (Web Audio).");
 
   }
 
   size_t hrtfLoaders = WebCore::HRTFDatabaseLoader::sizeOfLoaders(MallocSizeOf);
   if (hrtfLoaders) {
-
     REPORT(NS_LITERAL_CSTRING(
-              "explicit/webaudio/audio-node/PannerNode/hrtf-databases"),
+             "explicit/webaudio/audio-node/PannerNode/hrtf-databases"),
            hrtfLoaders,
            "Memory used by PannerNode databases (Web Audio).");
   }
 
 #undef REPORT
 
   manager->EndReport();
 }
--- a/dom/media/webaudio/AudioBuffer.cpp
+++ b/dom/media/webaudio/AudioBuffer.cpp
@@ -136,35 +136,30 @@ AudioBufferMemoryTracker::UnregisterAudi
   sMutex.AssertCurrentThreadOwns();
   mBuffers.RemoveEntry(aAudioBuffer);
   return mBuffers.Count();
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(AudioBufferMemoryTrackerMallocSizeOf)
 
 NS_IMETHODIMP
-AudioBufferMemoryTracker::CollectReports(nsIHandleReportCallback* handleReport,
-                                         nsISupports* data, bool)
+AudioBufferMemoryTracker::CollectReports(nsIHandleReportCallback* aHandleReport,
+                                         nsISupports* aData, bool)
 {
- size_t amount = 0;
- nsresult rv;
-
- for (auto iter = mBuffers.Iter(); !iter.Done(); iter.Next()) {
-   amount += iter.Get()->GetKey()->SizeOfIncludingThis(AudioBufferMemoryTrackerMallocSizeOf);
- }
+  size_t amount = 0;
 
- rv = handleReport->Callback(EmptyCString(),
-                             NS_LITERAL_CSTRING("explicit/webaudio/audiobuffer"),
-                             KIND_HEAP, UNITS_BYTES, amount,
-                             NS_LITERAL_CSTRING("Memory used by AudioBuffer"
-                                                " objects (Web Audio)"),
-                             data);
- NS_ENSURE_SUCCESS(rv, rv);
+  for (auto iter = mBuffers.Iter(); !iter.Done(); iter.Next()) {
+    amount += iter.Get()->GetKey()->SizeOfIncludingThis(AudioBufferMemoryTrackerMallocSizeOf);
+  }
 
- return NS_OK;
+  MOZ_COLLECT_REPORT(
+    "explicit/webaudio/audiobuffer", KIND_HEAP, UNITS_BYTES, amount,
+    "Memory used by AudioBuffer objects (Web Audio).");
+
+  return NS_OK;
 }
 
 AudioBuffer::AudioBuffer(AudioContext* aContext, uint32_t aNumberOfChannels,
                          uint32_t aLength, float aSampleRate,
                          already_AddRefed<ThreadSharedFloatArrayBufferList>
                            aInitialContents)
   : mOwnerWindow(do_GetWeakReference(aContext->GetOwner())),
     mSharedChannels(aInitialContents),
--- a/dom/media/webaudio/AudioContext.cpp
+++ b/dom/media/webaudio/AudioContext.cpp
@@ -1140,27 +1140,26 @@ AudioContext::CollectReports(nsIHandleRe
 {
   const nsLiteralCString
     nodeDescription("Memory used by AudioNode DOM objects (Web Audio).");
   for (auto iter = mAllNodes.ConstIter(); !iter.Done(); iter.Next()) {
     AudioNode* node = iter.Get()->GetKey();
     int64_t amount = node->SizeOfIncludingThis(MallocSizeOf);
     nsPrintfCString domNodePath("explicit/webaudio/audio-node/%s/dom-nodes",
                                 node->NodeType());
-    nsresult rv =
-      aHandleReport->Callback(EmptyCString(), domNodePath, KIND_HEAP,
-                              UNITS_BYTES, amount, nodeDescription, aData);
-    if (NS_WARN_IF(NS_FAILED(rv)))
-      return rv;
+    aHandleReport->Callback(EmptyCString(), domNodePath, KIND_HEAP, UNITS_BYTES,
+                            amount, nodeDescription, aData);
   }
 
   int64_t amount = SizeOfIncludingThis(MallocSizeOf);
-  return MOZ_COLLECT_REPORT("explicit/webaudio/audiocontext",
-                            KIND_HEAP, UNITS_BYTES, amount,
-                            "Memory used by AudioContext objects (Web Audio).");
+  MOZ_COLLECT_REPORT(
+    "explicit/webaudio/audiocontext", KIND_HEAP, UNITS_BYTES, amount,
+    "Memory used by AudioContext objects (Web Audio).");
+
+  return NS_OK;
 }
 
 BasicWaveFormCache*
 AudioContext::GetBasicWaveFormCache()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!mBasicWaveFormCache) {
     mBasicWaveFormCache = new BasicWaveFormCache(SampleRate());
--- a/dom/media/webaudio/AudioContext.h
+++ b/dom/media/webaudio/AudioContext.h
@@ -321,18 +321,17 @@ public:
   IMPL_EVENT_HANDLER(mozinterruptend)
 
 private:
   void DisconnectFromWindow();
   void RemoveFromDecodeQueue(WebAudioDecodeJob* aDecodeJob);
   void ShutdownDecoder();
 
   size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const;
-  NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
-                            nsISupports* aData, bool aAnonymize) override;
+  NS_DECL_NSIMEMORYREPORTER
 
   friend struct ::mozilla::WebAudioDecodeJob;
 
   bool CheckClosed(ErrorResult& aRv);
 
   nsTArray<MediaStream*> GetAllStreams() const;
 
 private:
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -2173,18 +2173,18 @@ public:
   : mMutex(aWorkerPrivate->mMutex), mWorkerPrivate(aWorkerPrivate),
     mAlreadyMappedToAddon(false)
   {
     aWorkerPrivate->AssertIsOnWorkerThread();
 
   }
 
   NS_IMETHOD
-  CollectReports(nsIMemoryReporterCallback* aCallback,
-                 nsISupports* aClosure, bool aAnonymize) override
+  CollectReports(nsIHandleReportCallback* aHandleReport,
+                 nsISupports* aData, bool aAnonymize) override
   {
     AssertIsOnMainThread();
 
     // Assumes that WorkerJSRuntimeStats will hold a reference to |path|, and
     // not a copy, as TryToMapAddon() may later modify it.
     nsCString path;
     WorkerJSRuntimeStats rtStats(path);
 
@@ -2217,19 +2217,19 @@ public:
       TryToMapAddon(path);
 
       if (!mWorkerPrivate->BlockAndCollectRuntimeStats(&rtStats, aAnonymize)) {
         // Returning NS_OK here will effectively report 0 memory.
         return NS_OK;
       }
     }
 
-    return xpc::ReportJSRuntimeExplicitTreeStats(rtStats, path,
-                                                 aCallback, aClosure,
-                                                 aAnonymize);
+    xpc::ReportJSRuntimeExplicitTreeStats(rtStats, path, aHandleReport, aData,
+                                          aAnonymize);
+    return NS_OK;
   }
 
 private:
   ~MemoryReporter()
   { }
 
   void
   Disable()
--- a/extensions/spellcheck/hunspell/glue/mozHunspell.cpp
+++ b/extensions/spellcheck/hunspell/glue/mozHunspell.cpp
@@ -476,19 +476,22 @@ nsresult mozHunspell::ConvertCharset(con
 
   return rv;
 }
 
 NS_IMETHODIMP
 mozHunspell::CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT("explicit/spell-check", KIND_HEAP, UNITS_BYTES,
-                            HunspellAllocator::MemoryAllocated(),
-                            "Memory used by the spell-checking engine.");
+  MOZ_COLLECT_REPORT(
+    "explicit/spell-check", KIND_HEAP, UNITS_BYTES,
+    HunspellAllocator::MemoryAllocated(),
+    "Memory used by the spell-checking engine.");
+
+  return NS_OK;
 }
 
 NS_IMETHODIMP mozHunspell::Check(const char16_t *aWord, bool *aResult)
 {
   NS_ENSURE_ARG_POINTER(aWord);
   NS_ENSURE_ARG_POINTER(aResult);
   NS_ENSURE_TRUE(mHunspell, NS_ERROR_FAILURE);
 
--- a/extensions/spellcheck/hunspell/glue/mozHunspell.h
+++ b/extensions/spellcheck/hunspell/glue/mozHunspell.h
@@ -96,18 +96,17 @@ public:
 
   nsresult Init();
 
   void LoadDictionaryList(bool aNotifyChildProcesses);
 
   // helper method for converting a word to the charset of the dictionary
   nsresult ConvertCharset(const char16_t* aStr, char ** aDst);
 
-  NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
-                            nsISupports* aData, bool aAnonymize) override;
+  NS_DECL_NSIMEMORYREPORTER
 
 protected:
   virtual ~mozHunspell();
 
   nsCOMPtr<mozIPersonalDictionary> mPersonalDictionary;
   nsCOMPtr<nsIUnicodeEncoder>      mEncoder;
   nsCOMPtr<nsIUnicodeDecoder>      mDecoder;
 
--- a/gfx/gl/GfxTexturesReporter.h
+++ b/gfx/gl/GfxTexturesReporter.h
@@ -45,25 +45,31 @@ public:
 
     static void UpdateWasteAmount(size_t delta) {
       sTileWasteAmount += delta;
     }
 
     NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData, bool aAnonymize) override
     {
-        MOZ_COLLECT_REPORT("gfx-tiles-waste", KIND_OTHER, UNITS_BYTES,
+        MOZ_COLLECT_REPORT(
+            "gfx-tiles-waste", KIND_OTHER, UNITS_BYTES,
             int64_t(sTileWasteAmount),
             "Memory lost due to tiles extending past content boundaries");
+
         MOZ_COLLECT_REPORT(
-            "gfx-textures", KIND_OTHER, UNITS_BYTES, int64_t(sAmount),
+            "gfx-textures", KIND_OTHER, UNITS_BYTES,
+            int64_t(sAmount),
             "Memory used for storing GL textures.");
+
         MOZ_COLLECT_REPORT(
-            "gfx-textures-peak", KIND_OTHER, UNITS_BYTES, int64_t(sPeakAmount),
+            "gfx-textures-peak", KIND_OTHER, UNITS_BYTES,
+            int64_t(sPeakAmount),
             "Peak memory used for storing GL textures.");
+
         return NS_OK;
     }
 
 private:
     static Atomic<size_t> sAmount;
     static Atomic<size_t> sPeakAmount;
     // Count the amount of memory lost to tile waste
     static Atomic<size_t> sTileWasteAmount;
--- a/gfx/layers/ipc/ISurfaceAllocator.h
+++ b/gfx/layers/ipc/ISurfaceAllocator.h
@@ -263,19 +263,21 @@ public:
   static void WillFree(void* aPointer)
   {
     sAmount -= MallocSizeOfOnFree(aPointer);
   }
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/gfx/heap-textures", KIND_HEAP, UNITS_BYTES, sAmount,
       "Heap memory shared between threads by texture clients and hosts.");
+
+    return NS_OK;
   }
 
 private:
   // Typically we use |size_t| in memory reporters, but in the past this
   // variable has sometimes gone negative due to missing DidAlloc() calls.
   // Therefore, we use a signed type so that any such negative values show up
   // as negative in about:memory, rather than as enormous positive numbers.
   static mozilla::Atomic<ptrdiff_t> sAmount;
--- a/gfx/layers/ipc/SharedBufferManagerParent.cpp
+++ b/gfx/layers/ipc/SharedBufferManagerParent.cpp
@@ -48,53 +48,47 @@ public:
     if (SharedBufferManagerParent::sManagerMonitor) {
       SharedBufferManagerParent::sManagerMonitor->Lock();
     }
     map<base::ProcessId, SharedBufferManagerParent*>::iterator it;
     for (it = SharedBufferManagerParent::sManagers.begin(); it != SharedBufferManagerParent::sManagers.end(); it++) {
       base::ProcessId pid = it->first;
       SharedBufferManagerParent *mgr = it->second;
       if (!mgr) {
-        printf_stderr("GrallocReporter::CollectReports() mgr is nullptr");
+        printf_stderr("GrallocReporter::CollectReports(): mgr is nullptr");
         continue;
       }
 
       nsAutoCString pidName;
       LinuxUtils::GetThreadName(pid, pidName);
 
       MutexAutoLock lock(mgr->mLock);
       std::map<int64_t, android::sp<android::GraphicBuffer> >::iterator buf_it;
       for (buf_it = mgr->mBuffers.begin(); buf_it != mgr->mBuffers.end(); buf_it++) {
-        nsresult rv;
         android::sp<android::GraphicBuffer> gb = buf_it->second;
         int bpp = android::bytesPerPixel(gb->getPixelFormat());
         int stride = gb->getStride();
         int height = gb->getHeight();
         int amount = bpp > 0
           ? (stride * height * bpp)
           // Special case for BSP specific formats (mainly YUV formats, count it as normal YUV buffer).
           : (stride * height * 3 / 2);
 
         nsPrintfCString gpath("gralloc/%s (pid=%d)/buffer(width=%d, height=%d, bpp=%d, stride=%d)",
             pidName.get(), pid, gb->getWidth(), height, bpp, stride);
 
-        rv = aHandleReport->Callback(EmptyCString(), gpath, KIND_OTHER, UNITS_BYTES, amount,
-            NS_LITERAL_CSTRING(
-              "Special RAM that can be shared between processes and directly accessed by "
-              "both the CPU and GPU. Gralloc memory is usually a relatively precious "
-              "resource, with much less available than generic RAM. When it's exhausted, "
-              "graphics performance can suffer. This value can be incorrect because of race "
-              "conditions."),
-            aData);
-        if (rv != NS_OK) {
-          if (SharedBufferManagerParent::sManagerMonitor) {
-            SharedBufferManagerParent::sManagerMonitor->Unlock();
-          }
-          return rv;
-        }
+        aHandleReport->Callback(
+          EmptyCString(), gpath, KIND_OTHER, UNITS_BYTES, amount,
+          NS_LITERAL_CSTRING(
+"Special RAM that can be shared between processes and directly accessed by "
+"both the CPU and GPU. Gralloc memory is usually a relatively precious "
+"resource, with much less available than generic RAM. When it's exhausted, "
+"graphics performance can suffer. This value can be incorrect because of race "
+"conditions."),
+          aData);
       }
     }
     if (SharedBufferManagerParent::sManagerMonitor) {
       SharedBufferManagerParent::sManagerMonitor->Unlock();
     }
     return NS_OK;
   }
 
--- a/gfx/thebes/gfxASurface.cpp
+++ b/gfx/thebes/gfxASurface.cpp
@@ -477,38 +477,36 @@ class SurfaceMemoryReporter final : publ
 public:
     static void AdjustUsedMemory(gfxSurfaceType aType, int32_t aBytes)
     {
         // A read-modify-write operation like += would require a memory barrier
         // here, which would defeat the purpose of using relaxed memory
         // ordering.  So separate out the read and write operations.
         sSurfaceMemoryUsed[size_t(aType)] = sSurfaceMemoryUsed[size_t(aType)] + aBytes;
     };
-    
+
     NS_DECL_ISUPPORTS
 
-    NS_IMETHOD CollectReports(nsIMemoryReporterCallback *aCb,
-                              nsISupports *aClosure, bool aAnonymize) override
+    NS_IMETHOD CollectReports(nsIHandleReportCallback *aHandleReport,
+                              nsISupports *aData, bool aAnonymize) override
     {
         const size_t len = ArrayLength(sSurfaceMemoryReporterAttrs);
         for (size_t i = 0; i < len; i++) {
             int64_t amount = sSurfaceMemoryUsed[i];
 
             if (amount != 0) {
                 const char *path = sSurfaceMemoryReporterAttrs[i].path;
                 const char *desc = sSurfaceMemoryReporterAttrs[i].description;
                 if (!desc) {
                     desc = sDefaultSurfaceDescription;
                 }
 
-                nsresult rv = aCb->Callback(EmptyCString(), nsCString(path),
-                                            KIND_OTHER, UNITS_BYTES,
-                                            amount,
-                                            nsCString(desc), aClosure);
-                NS_ENSURE_SUCCESS(rv, rv);
+                aHandleReport->Callback(
+                    EmptyCString(), nsCString(path), KIND_OTHER, UNITS_BYTES,
+                    amount, nsCString(desc), aData);
             }
         }
 
         return NS_OK;
     }
 };
 
 Atomic<size_t, Relaxed> SurfaceMemoryReporter::sSurfaceMemoryUsed[size_t(gfxSurfaceType::Max)];
--- a/gfx/thebes/gfxAndroidPlatform.cpp
+++ b/gfx/thebes/gfxAndroidPlatform.cpp
@@ -64,19 +64,21 @@ public:
     Realloc(FT_Memory, long cur_size, long new_size, void* p)
     {
         return CountingRealloc(p, new_size);
     }
 
     NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData, bool aAnonymize) override
     {
-        return MOZ_COLLECT_REPORT(
+        MOZ_COLLECT_REPORT(
             "explicit/freetype", KIND_HEAP, UNITS_BYTES, MemoryAllocated(),
             "Memory used by Freetype.");
+
+        return NS_OK;
     }
 };
 
 NS_IMPL_ISUPPORTS(FreetypeReporter, nsIMemoryReporter)
 
 template<> Atomic<size_t> CountingAllocatorBase<FreetypeReporter>::sAmount(0);
 
 static FT_MemoryRec_ sFreetypeMemoryRecord;
--- a/gfx/thebes/gfxFont.cpp
+++ b/gfx/thebes/gfxFont.cpp
@@ -91,34 +91,32 @@ uint32_t gGlyphExtentsSetupFallBackToTig
  */
 
 MOZ_DEFINE_MALLOC_SIZE_OF(FontCacheMallocSizeOf)
 
 NS_IMPL_ISUPPORTS(gfxFontCache::MemoryReporter, nsIMemoryReporter)
 
 NS_IMETHODIMP
 gfxFontCache::MemoryReporter::CollectReports(
-    nsIMemoryReporterCallback* aCb, nsISupports* aClosure, bool aAnonymize)
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
     FontCacheSizes sizes;
 
     gfxFontCache::GetCache()->AddSizeOfIncludingThis(&FontCacheMallocSizeOf,
                                                      &sizes);
 
-    aCb->Callback(EmptyCString(),
-                  NS_LITERAL_CSTRING("explicit/gfx/font-cache"),
-                  KIND_HEAP, UNITS_BYTES, sizes.mFontInstances,
-                  NS_LITERAL_CSTRING("Memory used for active font instances."),
-                  aClosure);
-
-    aCb->Callback(EmptyCString(),
-                  NS_LITERAL_CSTRING("explicit/gfx/font-shaped-words"),
-                  KIND_HEAP, UNITS_BYTES, sizes.mShapedWords,
-                  NS_LITERAL_CSTRING("Memory used to cache shaped glyph data."),
-                  aClosure);
+    MOZ_COLLECT_REPORT(
+        "explicit/gfx/font-cache", KIND_HEAP, UNITS_BYTES,
+        sizes.mFontInstances,
+        "Memory used for active font instances.");
+
+    MOZ_COLLECT_REPORT(
+        "explicit/gfx/font-shaped-words", KIND_HEAP, UNITS_BYTES,
+        sizes.mShapedWords,
+        "Memory used to cache shaped glyph data.");
 
     return NS_OK;
 }
 
 NS_IMPL_ISUPPORTS(gfxFontCache::Observer, nsIObserver)
 
 NS_IMETHODIMP
 gfxFontCache::Observer::Observe(nsISupports *aSubject,
--- a/gfx/thebes/gfxPlatformFontList.cpp
+++ b/gfx/thebes/gfxPlatformFontList.cpp
@@ -135,47 +135,41 @@ gfxFontListPrefObserver::Observe(nsISupp
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(FontListMallocSizeOf)
 
 NS_IMPL_ISUPPORTS(gfxPlatformFontList::MemoryReporter, nsIMemoryReporter)
 
 NS_IMETHODIMP
 gfxPlatformFontList::MemoryReporter::CollectReports(
-    nsIMemoryReporterCallback* aCb, nsISupports* aClosure, bool aAnonymize)
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
     FontListSizes sizes;
     sizes.mFontListSize = 0;
     sizes.mFontTableCacheSize = 0;
     sizes.mCharMapsSize = 0;
 
     gfxPlatformFontList::PlatformFontList()->AddSizeOfIncludingThis(&FontListMallocSizeOf,
                                                                     &sizes);
 
-    nsresult rv;
-    rv = aCb->Callback(EmptyCString(),
-                       NS_LITERAL_CSTRING("explicit/gfx/font-list"),
-                       KIND_HEAP, UNITS_BYTES, sizes.mFontListSize,
-                       NS_LITERAL_CSTRING("Memory used to manage the list of font families and faces."),
-                       aClosure);
-    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_COLLECT_REPORT(
+        "explicit/gfx/font-list", KIND_HEAP, UNITS_BYTES,
+        sizes.mFontListSize,
+        "Memory used to manage the list of font families and faces.");
 
-    rv = aCb->Callback(EmptyCString(),
-                       NS_LITERAL_CSTRING("explicit/gfx/font-charmaps"),
-                       KIND_HEAP, UNITS_BYTES, sizes.mCharMapsSize,
-                       NS_LITERAL_CSTRING("Memory used to record the character coverage of individual fonts."),
-                       aClosure);
-    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_COLLECT_REPORT(
+        "explicit/gfx/font-charmaps", KIND_HEAP, UNITS_BYTES,
+        sizes.mCharMapsSize,
+        "Memory used to record the character coverage of individual fonts.");
 
     if (sizes.mFontTableCacheSize) {
-        aCb->Callback(EmptyCString(),
-                      NS_LITERAL_CSTRING("explicit/gfx/font-tables"),
-                      KIND_HEAP, UNITS_BYTES, sizes.mFontTableCacheSize,
-                      NS_LITERAL_CSTRING("Memory used for cached font metrics and layout tables."),
-                      aClosure);
+        MOZ_COLLECT_REPORT(
+            "explicit/gfx/font-tables", KIND_HEAP, UNITS_BYTES,
+            sizes.mFontTableCacheSize,
+            "Memory used for cached font metrics and layout tables.");
     }
 
     return NS_OK;
 }
 
 gfxPlatformFontList::gfxPlatformFontList(bool aNeedFullnamePostscriptNames)
     : mFontFamilies(64), mOtherFamilyNames(16),
       mBadUnderlineFamilyNames(8), mSharedCmaps(8),
--- a/gfx/thebes/gfxUserFontSet.cpp
+++ b/gfx/thebes/gfxUserFontSet.cpp
@@ -1295,20 +1295,19 @@ gfxUserFontSet::UserFontCache::Shutdown(
     if (sUserFonts) {
         delete sUserFonts;
         sUserFonts = nullptr;
     }
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(UserFontsMallocSizeOf)
 
-nsresult
-gfxUserFontSet::UserFontCache::Entry::ReportMemory(nsIMemoryReporterCallback* aCb,
-                                                   nsISupports* aClosure,
-                                                   bool aAnonymize)
+void
+gfxUserFontSet::UserFontCache::Entry::ReportMemory(
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
     MOZ_ASSERT(mFontEntry);
     nsAutoCString path("explicit/gfx/user-fonts/font(");
 
     if (aAnonymize) {
         path.AppendPrintf("<anonymized-%p>", this);
     } else {
         NS_ConvertUTF16toUTF8 familyName(mFontEntry->mFamilyName);
@@ -1341,50 +1340,46 @@ gfxUserFontSet::UserFontCache::Entry::Re
                     spec.ReplaceChar('/', '\\');
                     path.AppendPrintf(", principal=%s", spec.get());
                 }
             }
         }
     }
     path.Append(')');
 
-    return aCb->
-        Callback(EmptyCString(), path,
-                 nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES,
-                 mFontEntry->ComputedSizeOfExcludingThis(UserFontsMallocSizeOf),
-                 NS_LITERAL_CSTRING("Memory used by @font-face resource."),
-                 aClosure);
+    aHandleReport->Callback(
+        EmptyCString(), path,
+        nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES,
+        mFontEntry->ComputedSizeOfExcludingThis(UserFontsMallocSizeOf),
+        NS_LITERAL_CSTRING("Memory used by @font-face resource."),
+        aData);
 }
 
 NS_IMPL_ISUPPORTS(gfxUserFontSet::UserFontCache::MemoryReporter,
                   nsIMemoryReporter)
 
 NS_IMETHODIMP
 gfxUserFontSet::UserFontCache::MemoryReporter::CollectReports(
-    nsIMemoryReporterCallback* aCb, nsISupports* aClosure, bool aAnonymize)
+    nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
     if (!sUserFonts) {
         return NS_OK;
     }
 
     for (auto it = sUserFonts->Iter(); !it.Done(); it.Next()) {
-        nsresult rv = it.Get()->ReportMemory(aCb, aClosure, aAnonymize);
-        if (NS_FAILED(rv)) {
-            return rv;
-        }
+        it.Get()->ReportMemory(aHandleReport, aData, aAnonymize);
     }
 
-    return aCb->
-        Callback(EmptyCString(),
-                 NS_LITERAL_CSTRING("explicit/gfx/user-fonts/cache-overhead"),
-                 nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES,
-                 sUserFonts->ShallowSizeOfIncludingThis(UserFontsMallocSizeOf),
-                 NS_LITERAL_CSTRING("Memory used by the @font-face cache, "
-                                    "not counting the actual font resources."),
-                 aClosure);
+    MOZ_COLLECT_REPORT(
+        "explicit/gfx/user-fonts/cache-overhead", KIND_HEAP, UNITS_BYTES,
+        sUserFonts->ShallowSizeOfIncludingThis(UserFontsMallocSizeOf),
+        "Memory used by the @font-face cache, not counting the actual font "
+        "resources.");
+
+    return NS_OK;
 }
 
 #ifdef DEBUG_USERFONT_CACHE
 
 void
 gfxUserFontSet::UserFontCache::Entry::Dump()
 {
     nsresult rv;
--- a/gfx/thebes/gfxUserFontSet.h
+++ b/gfx/thebes/gfxUserFontSet.h
@@ -443,19 +443,18 @@ public:
 
             enum { ALLOW_MEMMOVE = false };
 
             gfxFontEntry* GetFontEntry() const { return mFontEntry; }
 
             bool IsPersistent() const { return mPersistence == kPersistent; }
             bool IsPrivate() const { return mPrivate; }
 
-            nsresult ReportMemory(nsIMemoryReporterCallback* aCb,
-                                  nsISupports* aClosure,
-                                  bool aAnonymize);
+            void ReportMemory(nsIHandleReportCallback* aHandleReport,
+                              nsISupports* aData, bool aAnonymize);
 
 #ifdef DEBUG_USERFONT_CACHE
             void Dump();
 #endif
 
         private:
             static uint32_t
             HashFeatures(const nsTArray<gfxFontFeature>& aFeatures) {
--- a/gfx/thebes/gfxWindowsPlatform.cpp
+++ b/gfx/thebes/gfxWindowsPlatform.cpp
@@ -122,29 +122,25 @@ class GfxD2DVramReporter final : public 
     ~GfxD2DVramReporter() {}
 
 public:
     NS_DECL_ISUPPORTS
 
     NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData, bool aAnonymize) override
     {
-        nsresult rv;
-
-        rv = MOZ_COLLECT_REPORT(
+        MOZ_COLLECT_REPORT(
             "gfx-d2d-vram-draw-target", KIND_OTHER, UNITS_BYTES,
             Factory::GetD2DVRAMUsageDrawTarget(),
             "Video memory used by D2D DrawTargets.");
-        NS_ENSURE_SUCCESS(rv, rv);
 
-        rv = MOZ_COLLECT_REPORT(
+        MOZ_COLLECT_REPORT(
             "gfx-d2d-vram-source-surface", KIND_OTHER, UNITS_BYTES,
             Factory::GetD2DVRAMUsageSourceSurface(),
             "Video memory used by D2D SourceSurfaces.");
-        NS_ENSURE_SUCCESS(rv, rv);
 
         return NS_OK;
     }
 };
 
 NS_IMPL_ISUPPORTS(GfxD2DVramReporter, nsIMemoryReporter)
 
 #define GFX_USE_CLEARTYPE_ALWAYS "gfx.font_rendering.cleartype.always_use_for_content"
@@ -177,18 +173,18 @@ class GPUAdapterReporter final : public 
     }
 
     ~GPUAdapterReporter() {}
 
 public:
     NS_DECL_ISUPPORTS
 
     NS_IMETHOD
-    CollectReports(nsIMemoryReporterCallback* aCb,
-                   nsISupports* aClosure, bool aAnonymize) override
+    CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
+                   bool aAnonymize) override
     {
         HANDLE ProcessHandle = GetCurrentProcess();
 
         int64_t dedicatedBytesUsed = 0;
         int64_t sharedBytesUsed = 0;
         int64_t committedBytesUsed = 0;
         IDXGIAdapter *DXGIAdapter;
 
@@ -259,36 +255,30 @@ public:
                         }
                     }
                 }
             }
         }
 
         FreeLibrary(gdi32Handle);
 
-#define REPORT(_path, _amount, _desc)                                         \
-    do {                                                                      \
-      nsresult rv;                                                            \
-      rv = aCb->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path),           \
-                         KIND_OTHER, UNITS_BYTES, _amount,                    \
-                         NS_LITERAL_CSTRING(_desc), aClosure);                \
-      NS_ENSURE_SUCCESS(rv, rv);                                              \
-    } while (0)
+        MOZ_COLLECT_REPORT(
+            "gpu-committed", KIND_OTHER, UNITS_BYTES, committedBytesUsed,
+            "Memory committed by the Windows graphics system.");
 
-        REPORT("gpu-committed", committedBytesUsed,
-               "Memory committed by the Windows graphics system.");
+        MOZ_COLLECT_REPORT(
+            "gpu-dedicated", KIND_OTHER, UNITS_BYTES,
+            dedicatedBytesUsed,
+            "Out-of-process memory allocated for this process in a physical "
+            "GPU adapter's memory.");
 
-        REPORT("gpu-dedicated", dedicatedBytesUsed,
-               "Out-of-process memory allocated for this process in a "
-               "physical GPU adapter's memory.");
-
-        REPORT("gpu-shared", sharedBytesUsed,
-               "In-process memory that is shared with the GPU.");
-
-#undef REPORT
+        MOZ_COLLECT_REPORT(
+            "gpu-shared", KIND_OTHER, UNITS_BYTES,
+            sharedBytesUsed,
+            "In-process memory that is shared with the GPU.");
 
         return NS_OK;
     }
 };
 
 NS_IMPL_ISUPPORTS(GPUAdapterReporter, nsIMemoryReporter)
 
 Atomic<size_t> gfxWindowsPlatform::sD3D11SharedTextures;
@@ -299,32 +289,28 @@ class D3DSharedTexturesReporter final : 
   ~D3DSharedTexturesReporter() {}
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback *aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    nsresult rv;
-
     if (gfxWindowsPlatform::sD3D11SharedTextures > 0) {
-      rv = MOZ_COLLECT_REPORT(
+      MOZ_COLLECT_REPORT(
         "d3d11-shared-textures", KIND_OTHER, UNITS_BYTES,
         gfxWindowsPlatform::sD3D11SharedTextures,
         "D3D11 shared textures.");
-      NS_ENSURE_SUCCESS(rv, rv);
     }
 
     if (gfxWindowsPlatform::sD3D9SharedTextures > 0) {
-      rv = MOZ_COLLECT_REPORT(
+      MOZ_COLLECT_REPORT(
         "d3d9-shared-textures", KIND_OTHER, UNITS_BYTES,
         gfxWindowsPlatform::sD3D9SharedTextures,
         "D3D9 shared textures.");
-      NS_ENSURE_SUCCESS(rv, rv);
     }
 
     return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(D3DSharedTexturesReporter, nsIMemoryReporter)
 
--- a/image/SurfaceCache.cpp
+++ b/image/SurfaceCache.cpp
@@ -809,39 +809,31 @@ public:
                  nsISupports*             aData,
                  bool                     aAnonymize) override
   {
     MutexAutoLock lock(mMutex);
 
     // We have explicit memory reporting for the surface cache which is more
     // accurate than the cost metrics we report here, but these metrics are
     // still useful to report, since they control the cache's behavior.
-    nsresult rv;
-
-    rv = MOZ_COLLECT_REPORT("imagelib-surface-cache-estimated-total",
-                            KIND_OTHER, UNITS_BYTES,
-                            (mMaxCost - mAvailableCost),
-                            "Estimated total memory used by the imagelib "
-                            "surface cache.");
-    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_COLLECT_REPORT(
+      "imagelib-surface-cache-estimated-total",
+      KIND_OTHER, UNITS_BYTES, (mMaxCost - mAvailableCost),
+"Estimated total memory used by the imagelib surface cache.");
 
-    rv = MOZ_COLLECT_REPORT("imagelib-surface-cache-estimated-locked",
-                            KIND_OTHER, UNITS_BYTES,
-                            mLockedCost,
-                            "Estimated memory used by locked surfaces in the "
-                            "imagelib surface cache.");
-    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_COLLECT_REPORT(
+      "imagelib-surface-cache-estimated-locked",
+      KIND_OTHER, UNITS_BYTES, mLockedCost,
+"Estimated memory used by locked surfaces in the imagelib surface cache.");
 
-    rv = MOZ_COLLECT_REPORT("imagelib-surface-cache-overflow-count",
-                            KIND_OTHER, UNITS_COUNT,
-                            mOverflowCount,
-                            "Count of how many times the surface cache has hit "
-                            "its capacity and been unable to insert a new "
-                            "surface.");
-    NS_ENSURE_SUCCESS(rv, rv);
+    MOZ_COLLECT_REPORT(
+      "imagelib-surface-cache-overflow-count",
+      KIND_OTHER, UNITS_COUNT, mOverflowCount,
+"Count of how many times the surface cache has hit its capacity and been "
+"unable to insert a new surface.");
 
     return NS_OK;
   }
 
   void CollectSizeOfSurfaces(const ImageKey                  aImageKey,
                              nsTArray<SurfaceMemoryCounter>& aCounters,
                              MallocSizeOf                    aMallocSizeOf)
   {
--- a/image/imgLoader.cpp
+++ b/image/imgLoader.cpp
@@ -68,17 +68,16 @@ class imgMemoryReporter final : public n
   ~imgMemoryReporter() { }
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    nsresult rv;
     nsTArray<ImageMemoryCounter> chrome;
     nsTArray<ImageMemoryCounter> content;
     nsTArray<ImageMemoryCounter> uncached;
 
     for (uint32_t i = 0; i < mKnownLoaders.Length(); i++) {
       for (auto iter = mKnownLoaders[i]->mChromeCache.Iter(); !iter.Done(); iter.Next()) {
         imgCacheEntry* entry = iter.UserData();
         RefPtr<imgRequest> req = entry->GetRequest();
@@ -96,27 +95,24 @@ public:
         nsPtrHashKey<imgRequest>* entry = iter.Get();
         RefPtr<imgRequest> req = entry->GetKey();
         RecordCounterForRequest(req, &uncached, req->HasConsumers());
       }
     }
 
     // Note that we only need to anonymize content image URIs.
 
-    rv = ReportCounterArray(aHandleReport, aData, chrome, "images/chrome");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = ReportCounterArray(aHandleReport, aData, content,
-                            "images/content", aAnonymize);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportCounterArray(aHandleReport, aData, chrome, "images/chrome");
+
+    ReportCounterArray(aHandleReport, aData, content, "images/content",
+                       aAnonymize);
 
     // Uncached images may be content or chrome, so anonymize them.
-    rv = ReportCounterArray(aHandleReport, aData, uncached,
-                            "images/uncached", aAnonymize);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportCounterArray(aHandleReport, aData, uncached, "images/uncached",
+                       aAnonymize);
 
     return NS_OK;
   }
 
   static int64_t ImagesContentUsedUncompressedDistinguishedAmount()
   {
     size_t n = 0;
     for (uint32_t i = 0; i < imgLoader::sMemReporter->mKnownLoaders.Length();
@@ -192,23 +188,22 @@ private:
   private:
     MemoryCounter mUsedRasterCounter;
     MemoryCounter mUnusedRasterCounter;
     MemoryCounter mUsedVectorCounter;
     MemoryCounter mUnusedVectorCounter;
   };
 
   // Reports all images of a single kind, e.g. all used chrome images.
-  nsresult ReportCounterArray(nsIHandleReportCallback* aHandleReport,
-                              nsISupports* aData,
-                              nsTArray<ImageMemoryCounter>& aCounterArray,
-                              const char* aPathPrefix,
-                              bool aAnonymize = false)
+  void ReportCounterArray(nsIHandleReportCallback* aHandleReport,
+                          nsISupports* aData,
+                          nsTArray<ImageMemoryCounter>& aCounterArray,
+                          const char* aPathPrefix,
+                          bool aAnonymize = false)
   {
-    nsresult rv;
     MemoryTotal summaryTotal;
     MemoryTotal nonNotableTotal;
 
     // Report notable images, and compute total and non-notable aggregate sizes.
     for (uint32_t i = 0; i < aCounterArray.Length(); i++) {
       ImageMemoryCounter& counter = aCounterArray[i];
 
       if (aAnonymize) {
@@ -222,43 +217,36 @@ private:
           counter.URI().AppendLiteral(" (truncated)");
         }
         counter.URI().ReplaceChar('/', '\\');
       }
 
       summaryTotal += counter;
 
       if (counter.IsNotable()) {
-        rv = ReportImage(aHandleReport, aData, aPathPrefix, counter);
-        NS_ENSURE_SUCCESS(rv, rv);
+        ReportImage(aHandleReport, aData, aPathPrefix, counter);
       } else {
         nonNotableTotal += counter;
       }
     }
 
     // Report non-notable images in aggregate.
-    rv = ReportTotal(aHandleReport, aData, /* aExplicit = */ true,
-                     aPathPrefix, "<non-notable images>/", nonNotableTotal);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportTotal(aHandleReport, aData, /* aExplicit = */ true,
+                aPathPrefix, "<non-notable images>/", nonNotableTotal);
 
     // Report a summary in aggregate, outside of the explicit tree.
-    rv = ReportTotal(aHandleReport, aData, /* aExplicit = */ false,
-                     aPathPrefix, "", summaryTotal);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return NS_OK;
+    ReportTotal(aHandleReport, aData, /* aExplicit = */ false,
+                aPathPrefix, "", summaryTotal);
   }
 
-  static nsresult ReportImage(nsIHandleReportCallback* aHandleReport,
-                              nsISupports* aData,
-                              const char* aPathPrefix,
-                              const ImageMemoryCounter& aCounter)
+  static void ReportImage(nsIHandleReportCallback* aHandleReport,
+                          nsISupports* aData,
+                          const char* aPathPrefix,
+                          const ImageMemoryCounter& aCounter)
   {
-    nsresult rv;
-
     nsAutoCString pathPrefix(NS_LITERAL_CSTRING("explicit/"));
     pathPrefix.Append(aPathPrefix);
     pathPrefix.Append(aCounter.Type() == imgIContainer::TYPE_RASTER
                         ? "/raster/"
                         : "/vector/");
     pathPrefix.Append(aCounter.IsUsed() ? "used/" : "unused/");
     pathPrefix.Append("image(");
     pathPrefix.AppendInt(aCounter.IntrinsicSize().width);
@@ -269,29 +257,25 @@ private:
     if (aCounter.URI().IsEmpty()) {
       pathPrefix.Append("<unknown URI>");
     } else {
       pathPrefix.Append(aCounter.URI());
     }
 
     pathPrefix.Append(")/");
 
-    rv = ReportSurfaces(aHandleReport, aData, pathPrefix, aCounter);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = ReportSourceValue(aHandleReport, aData, pathPrefix, aCounter.Values());
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return NS_OK;
+    ReportSurfaces(aHandleReport, aData, pathPrefix, aCounter);
+
+    ReportSourceValue(aHandleReport, aData, pathPrefix, aCounter.Values());
   }
 
-  static nsresult ReportSurfaces(nsIHandleReportCallback* aHandleReport,
-                                 nsISupports* aData,
-                                 const nsACString& aPathPrefix,
-                                 const ImageMemoryCounter& aCounter)
+  static void ReportSurfaces(nsIHandleReportCallback* aHandleReport,
+                             nsISupports* aData,
+                             const nsACString& aPathPrefix,
+                             const ImageMemoryCounter& aCounter)
   {
     for (const SurfaceMemoryCounter& counter : aCounter.Surfaces()) {
       nsAutoCString surfacePathPrefix(aPathPrefix);
       surfacePathPrefix.Append(counter.IsLocked() ? "locked/" : "unlocked/");
       surfacePathPrefix.Append("surface(");
       surfacePathPrefix.AppendInt(counter.Key().Size().width);
       surfacePathPrefix.Append("x");
       surfacePathPrefix.AppendInt(counter.Key().Size().height);
@@ -312,128 +296,103 @@ private:
       } else if (counter.Type() == SurfaceMemoryCounterType::COMPOSITING_PREV) {
         surfacePathPrefix.Append(", compositing prev frame");
       } else {
         MOZ_ASSERT_UNREACHABLE("Unknown counter type");
       }
 
       surfacePathPrefix.Append(")/");
 
-      nsresult rv = ReportValues(aHandleReport, aData, surfacePathPrefix,
-                                 counter.Values());
-      NS_ENSURE_SUCCESS(rv, rv);
+      ReportValues(aHandleReport, aData, surfacePathPrefix, counter.Values());
     }
-
-    return NS_OK;
   }
 
-  static nsresult ReportTotal(nsIHandleReportCallback* aHandleReport,
-                              nsISupports* aData,
-                              bool aExplicit,
-                              const char* aPathPrefix,
-                              const char* aPathInfix,
-                              const MemoryTotal& aTotal)
+  static void ReportTotal(nsIHandleReportCallback* aHandleReport,
+                          nsISupports* aData,
+                          bool aExplicit,
+                          const char* aPathPrefix,
+                          const char* aPathInfix,
+                          const MemoryTotal& aTotal)
   {
-    nsresult rv;
-
     nsAutoCString pathPrefix;
     if (aExplicit) {
       pathPrefix.Append("explicit/");
     }
     pathPrefix.Append(aPathPrefix);
 
     nsAutoCString rasterUsedPrefix(pathPrefix);
     rasterUsedPrefix.Append("/raster/used/");
     rasterUsedPrefix.Append(aPathInfix);
-    rv = ReportValues(aHandleReport, aData, rasterUsedPrefix,
-                      aTotal.UsedRaster());
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportValues(aHandleReport, aData, rasterUsedPrefix, aTotal.UsedRaster());
 
     nsAutoCString rasterUnusedPrefix(pathPrefix);
     rasterUnusedPrefix.Append("/raster/unused/");
     rasterUnusedPrefix.Append(aPathInfix);
-    rv = ReportValues(aHandleReport, aData, rasterUnusedPrefix,
-                      aTotal.UnusedRaster());
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportValues(aHandleReport, aData, rasterUnusedPrefix,
+                 aTotal.UnusedRaster());
 
     nsAutoCString vectorUsedPrefix(pathPrefix);
     vectorUsedPrefix.Append("/vector/used/");
     vectorUsedPrefix.Append(aPathInfix);
-    rv = ReportValues(aHandleReport, aData, vectorUsedPrefix,
-                      aTotal.UsedVector());
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportValues(aHandleReport, aData, vectorUsedPrefix, aTotal.UsedVector());
 
     nsAutoCString vectorUnusedPrefix(pathPrefix);
     vectorUnusedPrefix.Append("/vector/unused/");
     vectorUnusedPrefix.Append(aPathInfix);
-    rv = ReportValues(aHandleReport, aData, vectorUnusedPrefix,
-                      aTotal.UnusedVector());
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return NS_OK;
+    ReportValues(aHandleReport, aData, vectorUnusedPrefix,
+                 aTotal.UnusedVector());
   }
 
-  static nsresult ReportValues(nsIHandleReportCallback* aHandleReport,
-                               nsISupports* aData,
-                               const nsACString& aPathPrefix,
-                               const MemoryCounter& aCounter)
+  static void ReportValues(nsIHandleReportCallback* aHandleReport,
+                           nsISupports* aData,
+                           const nsACString& aPathPrefix,
+                           const MemoryCounter& aCounter)
   {
-    nsresult rv;
-
-    rv = ReportSourceValue(aHandleReport, aData, aPathPrefix, aCounter);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix,
-                     "decoded-heap",
-                     "Decoded image data which is stored on the heap.",
-                     aCounter.DecodedHeap());
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = ReportValue(aHandleReport, aData, KIND_NONHEAP, aPathPrefix,
-                     "decoded-nonheap",
-                     "Decoded image data which isn't stored on the heap.",
-                     aCounter.DecodedNonHeap());
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return NS_OK;
+    ReportSourceValue(aHandleReport, aData, aPathPrefix, aCounter);
+
+    ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix,
+                "decoded-heap",
+                "Decoded image data which is stored on the heap.",
+                aCounter.DecodedHeap());
+
+    ReportValue(aHandleReport, aData, KIND_NONHEAP, aPathPrefix,
+                "decoded-nonheap",
+                "Decoded image data which isn't stored on the heap.",
+                aCounter.DecodedNonHeap());
   }
 
-  static nsresult ReportSourceValue(nsIHandleReportCallback* aHandleReport,
-                                    nsISupports* aData,
-                                    const nsACString& aPathPrefix,
-                                    const MemoryCounter& aCounter)
+  static void ReportSourceValue(nsIHandleReportCallback* aHandleReport,
+                                nsISupports* aData,
+                                const nsACString& aPathPrefix,
+                                const MemoryCounter& aCounter)
   {
-    nsresult rv;
-
-    rv = ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix,
-                     "source",
-                     "Raster image source data and vector image documents.",
-                     aCounter.Source());
-
-    return rv;
+    ReportValue(aHandleReport, aData, KIND_HEAP, aPathPrefix,
+                "source",
+                "Raster image source data and vector image documents.",
+                aCounter.Source());
   }
 
-  static nsresult ReportValue(nsIHandleReportCallback* aHandleReport,
-                              nsISupports* aData,
-                              int32_t aKind,
-                              const nsACString& aPathPrefix,
-                              const char* aPathSuffix,
-                              const char* aDescription,
-                              size_t aValue)
+  static void ReportValue(nsIHandleReportCallback* aHandleReport,
+                          nsISupports* aData,
+                          int32_t aKind,
+                          const nsACString& aPathPrefix,
+                          const char* aPathSuffix,
+                          const char* aDescription,
+                          size_t aValue)
   {
     if (aValue == 0) {
-      return NS_OK;
+      return;
     }
 
     nsAutoCString desc(aDescription);
     nsAutoCString path(aPathPrefix);
     path.Append(aPathSuffix);
 
-    return aHandleReport->Callback(EmptyCString(), path, aKind, UNITS_BYTES,
-                                   aValue, desc, aData);
+    aHandleReport->Callback(EmptyCString(), path, aKind, UNITS_BYTES,
+                            aValue, desc, aData);
   }
 
   static void RecordCounterForRequest(imgRequest* aRequest,
                                       nsTArray<ImageMemoryCounter>* aArray,
                                       bool aIsUsed)
   {
     RefPtr<Image> image = aRequest->GetImage();
     if (!image) {
--- a/ipc/glue/SharedMemory.cpp
+++ b/ipc/glue/SharedMemory.cpp
@@ -23,28 +23,25 @@ class ShmemReporter final : public nsIMe
 
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
 
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    nsresult rv;
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "shmem-allocated", KIND_OTHER, UNITS_BYTES, gShmemAllocated,
       "Memory shared with other processes that is accessible (but not "
       "necessarily mapped).");
-    NS_ENSURE_SUCCESS(rv, rv);
 
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "shmem-mapped", KIND_OTHER, UNITS_BYTES, gShmemMapped,
       "Memory shared with other processes that is mapped into the address "
       "space.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
   }
 };
 
 NS_IMPL_ISUPPORTS(ShmemReporter, nsIMemoryReporter)
 
 SharedMemory::SharedMemory()
--- a/js/xpconnect/src/XPCJSMemoryReporter.h
+++ b/js/xpconnect/src/XPCJSMemoryReporter.h
@@ -16,18 +16,18 @@ namespace xpc {
 typedef nsDataHashtable<nsUint64HashKey, nsCString> WindowPaths;
 
 // This is very nearly an instance of nsIMemoryReporter, but it's not,
 // because it's invoked by nsWindowMemoryReporter in order to get |windowPaths|
 // in CollectReports.
 class JSReporter
 {
 public:
-    static nsresult CollectReports(WindowPaths* windowPaths,
-                                   WindowPaths* topWindowPaths,
-                                   nsIMemoryReporterCallback* cb,
-                                   nsISupports* closure,
-                                   bool anonymize);
+    static void CollectReports(WindowPaths* windowPaths,
+                               WindowPaths* topWindowPaths,
+                               nsIMemoryReporterCallback* handleReport,
+                               nsISupports* data,
+                               bool anonymize);
 };
 
 } // namespace xpc
 
 #endif
--- a/js/xpconnect/src/XPCJSRuntime.cpp
+++ b/js/xpconnect/src/XPCJSRuntime.cpp
@@ -1804,131 +1804,117 @@ class JSMainRuntimeTemporaryPeakReporter
     ~JSMainRuntimeTemporaryPeakReporter() {}
 
   public:
     NS_DECL_ISUPPORTS
 
     NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData, bool aAnonymize) override
     {
-        return MOZ_COLLECT_REPORT("js-main-runtime-temporary-peak",
-            KIND_OTHER, UNITS_BYTES,
+        MOZ_COLLECT_REPORT(
+            "js-main-runtime-temporary-peak", KIND_OTHER, UNITS_BYTES,
             JSMainRuntimeTemporaryPeakDistinguishedAmount(),
             "Peak transient data size in the main JSRuntime (the current size "
             "of which is reported as "
             "'explicit/js-non-window/runtime/temporary').");
+
+        return NS_OK;
     }
 };
 
 NS_IMPL_ISUPPORTS(JSMainRuntimeTemporaryPeakReporter, nsIMemoryReporter)
 
 // The REPORT* macros do an unconditional report.  The ZCREPORT* macros are for
 // compartments and zones; they aggregate any entries smaller than
 // SUNDRIES_THRESHOLD into the "sundries/gc-heap" and "sundries/malloc-heap"
 // entries for the compartment.
 
 #define SUNDRIES_THRESHOLD js::MemoryReportingSundriesThreshold()
 
-#define REPORT(_path, _kind, _units, _amount, _desc)                          \
-    do {                                                                      \
-        nsresult rv;                                                          \
-        rv = cb->Callback(EmptyCString(), _path,                              \
-                          nsIMemoryReporter::_kind,                           \
-                          nsIMemoryReporter::_units,                          \
-                          _amount,                                            \
-                          NS_LITERAL_CSTRING(_desc),                          \
-                          closure);                                           \
-        NS_ENSURE_SUCCESS(rv, rv);                                            \
-    } while (0)
-
-#define REPORT_BYTES(_path, _kind, _amount, _desc)                            \
+#define REPORT(_path, _kind, _units, _amount, _desc) \
+    handleReport->Callback(EmptyCString(), _path, \
+                           nsIMemoryReporter::_kind, \
+                           nsIMemoryReporter::_units, _amount, \
+                           NS_LITERAL_CSTRING(_desc), data); \
+
+#define REPORT_BYTES(_path, _kind, _amount, _desc) \
     REPORT(_path, _kind, UNITS_BYTES, _amount, _desc);
 
-#define REPORT_GC_BYTES(_path, _amount, _desc)                                \
-    do {                                                                      \
-        size_t amount = _amount;  /* evaluate _amount only once */            \
-        nsresult rv;                                                          \
-        rv = cb->Callback(EmptyCString(), _path,                              \
-                          nsIMemoryReporter::KIND_NONHEAP,                    \
-                          nsIMemoryReporter::UNITS_BYTES, amount,             \
-                          NS_LITERAL_CSTRING(_desc), closure);                \
-        NS_ENSURE_SUCCESS(rv, rv);                                            \
-        gcTotal += amount;                                                    \
+#define REPORT_GC_BYTES(_path, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::KIND_NONHEAP, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        gcTotal += amount; \
     } while (0)
 
 // Report compartment/zone non-GC (KIND_HEAP) bytes.
-#define ZCREPORT_BYTES(_path, _amount, _desc)                                 \
-    do {                                                                      \
-        /* Assign _descLiteral plus "" into a char* to prove that it's */     \
-        /* actually a literal. */                                             \
-        size_t amount = _amount;  /* evaluate _amount only once */            \
-        if (amount >= SUNDRIES_THRESHOLD) {                                   \
-            nsresult rv;                                                      \
-            rv = cb->Callback(EmptyCString(), _path,                          \
-                              nsIMemoryReporter::KIND_HEAP,                   \
-                              nsIMemoryReporter::UNITS_BYTES, amount,         \
-                              NS_LITERAL_CSTRING(_desc), closure);            \
-            NS_ENSURE_SUCCESS(rv, rv);                                        \
-        } else {                                                              \
-            sundriesMallocHeap += amount;                                     \
-        }                                                                     \
+#define ZCREPORT_BYTES(_path, _amount, _desc) \
+    do { \
+        /* Assign _descLiteral plus "" into a char* to prove that it's */ \
+        /* actually a literal. */ \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        if (amount >= SUNDRIES_THRESHOLD) { \
+            handleReport->Callback(EmptyCString(), _path, \
+                                   nsIMemoryReporter::KIND_HEAP, \
+                                   nsIMemoryReporter::UNITS_BYTES, amount, \
+                                   NS_LITERAL_CSTRING(_desc), data); \
+        } else { \
+            sundriesMallocHeap += amount; \
+        } \
     } while (0)
 
 // Report compartment/zone GC bytes.
-#define ZCREPORT_GC_BYTES(_path, _amount, _desc)                              \
-    do {                                                                      \
-        size_t amount = _amount;  /* evaluate _amount only once */            \
-        if (amount >= SUNDRIES_THRESHOLD) {                                   \
-            nsresult rv;                                                      \
-            rv = cb->Callback(EmptyCString(), _path,                          \
-                              nsIMemoryReporter::KIND_NONHEAP,                \
-                              nsIMemoryReporter::UNITS_BYTES, amount,         \
-                              NS_LITERAL_CSTRING(_desc), closure);            \
-            NS_ENSURE_SUCCESS(rv, rv);                                        \
-            gcTotal += amount;                                                \
-        } else {                                                              \
-            sundriesGCHeap += amount;                                         \
-        }                                                                     \
+#define ZCREPORT_GC_BYTES(_path, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        if (amount >= SUNDRIES_THRESHOLD) { \
+            handleReport->Callback(EmptyCString(), _path, \
+                                   nsIMemoryReporter::KIND_NONHEAP, \
+                                   nsIMemoryReporter::UNITS_BYTES, amount, \
+                                   NS_LITERAL_CSTRING(_desc), data); \
+            gcTotal += amount; \
+        } else { \
+            sundriesGCHeap += amount; \
+        } \
     } while (0)
 
 // Report runtime bytes.
-#define RREPORT_BYTES(_path, _kind, _amount, _desc)                           \
-    do {                                                                      \
-        size_t amount = _amount;  /* evaluate _amount only once */            \
-        nsresult rv;                                                          \
-        rv = cb->Callback(EmptyCString(), _path,                              \
-                          nsIMemoryReporter::_kind,                           \
-                          nsIMemoryReporter::UNITS_BYTES, amount,             \
-                          NS_LITERAL_CSTRING(_desc), closure);                \
-        NS_ENSURE_SUCCESS(rv, rv);                                            \
-        rtTotal += amount;                                                    \
+#define RREPORT_BYTES(_path, _kind, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::_kind, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        rtTotal += amount; \
     } while (0)
 
 // Report GC thing bytes.
-#define MREPORT_BYTES(_path, _kind, _amount, _desc)                           \
-    do {                                                                      \
-        size_t amount = _amount;  /* evaluate _amount only once */            \
-        nsresult rv;                                                          \
-        rv = cb->Callback(EmptyCString(), _path,                              \
-                          nsIMemoryReporter::_kind,                           \
-                          nsIMemoryReporter::UNITS_BYTES, amount,             \
-                          NS_LITERAL_CSTRING(_desc), closure);                \
-        NS_ENSURE_SUCCESS(rv, rv);                                            \
-        gcThingTotal += amount;                                               \
+#define MREPORT_BYTES(_path, _kind, _amount, _desc) \
+    do { \
+        size_t amount = _amount;  /* evaluate _amount only once */ \
+        handleReport->Callback(EmptyCString(), _path, \
+                               nsIMemoryReporter::_kind, \
+                               nsIMemoryReporter::UNITS_BYTES, amount, \
+                               NS_LITERAL_CSTRING(_desc), data); \
+        gcThingTotal += amount; \
     } while (0)
 
 MOZ_DEFINE_MALLOC_SIZE_OF(JSMallocSizeOf)
 
 namespace xpc {
 
-static nsresult
+static void
 ReportZoneStats(const JS::ZoneStats& zStats,
                 const xpc::ZoneStatsExtras& extras,
-                nsIMemoryReporterCallback* cb,
-                nsISupports* closure,
+                nsIHandleReportCallback* handleReport,
+                nsISupports* data,
                 bool anonymize,
                 size_t* gcTotalOut = nullptr)
 {
     const nsCString& pathPrefix = extras.pathPrefix;
     size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
 
     MOZ_ASSERT(!gcTotalOut == zStats.isTotals);
 
@@ -2157,25 +2143,23 @@ ReportZoneStats(const JS::ZoneStats& zSt
             KIND_HEAP, sundriesMallocHeap,
             "The sum of all 'malloc-heap' measurements that are too small to "
             "be worth showing individually.");
     }
 
     if (gcTotalOut)
         *gcTotalOut += gcTotal;
 
-    return NS_OK;
-
 #   undef STRING_LENGTH
 }
 
-static nsresult
+static void
 ReportClassStats(const ClassInfo& classInfo, const nsACString& path,
-                 nsIHandleReportCallback* cb,
-                 nsISupports* closure, size_t& gcTotal)
+                 nsIHandleReportCallback* handleReport,
+                 nsISupports* data, size_t& gcTotal)
 {
     // We deliberately don't use ZCREPORT_BYTES, so that these per-class values
     // don't go into sundries.
 
     if (classInfo.objectsGCHeap > 0) {
         REPORT_GC_BYTES(path + NS_LITERAL_CSTRING("objects/gc-heap"),
             classInfo.objectsGCHeap,
             "Objects, including fixed slots.");
@@ -2233,33 +2217,30 @@ ReportClassStats(const ClassInfo& classI
             "AOT-compiled asm.js code.");
     }
 
     if (classInfo.objectsMallocHeapMisc > 0) {
         REPORT_BYTES(path + NS_LITERAL_CSTRING("objects/malloc-heap/misc"),
             KIND_HEAP, classInfo.objectsMallocHeapMisc,
             "Miscellaneous object data.");
     }
-
-    return NS_OK;
 }
 
-static nsresult
+static void
 ReportCompartmentStats(const JS::CompartmentStats& cStats,
                        const xpc::CompartmentStatsExtras& extras,
                        amIAddonManager* addonManager,
-                       nsIMemoryReporterCallback* cb,
-                       nsISupports* closure, size_t* gcTotalOut = nullptr)
+                       nsIHandleReportCallback* handleReport,
+                       nsISupports* data, size_t* gcTotalOut = nullptr)
 {
     static const nsDependentCString addonPrefix("explicit/add-ons/");
 
     size_t gcTotal = 0, sundriesGCHeap = 0, sundriesMallocHeap = 0;
     nsAutoCString cJSPathPrefix(extras.jsPathPrefix);
     nsAutoCString cDOMPathPrefix(extras.domPathPrefix);
-    nsresult rv;
 
     MOZ_ASSERT(!gcTotalOut == cStats.isTotals);
 
     // Only attempt to prefix if we got a location and the path wasn't already
     // prefixed.
     if (extras.location && addonManager &&
         cJSPathPrefix.Find(addonPrefix, false, 0, 0) != 0) {
         nsAutoCString addonId;
@@ -2277,29 +2258,27 @@ ReportCompartmentStats(const JS::Compart
         }
     }
 
     nsCString nonNotablePath = cJSPathPrefix;
     nonNotablePath += cStats.isTotals
                     ? NS_LITERAL_CSTRING("classes/")
                     : NS_LITERAL_CSTRING("classes/class(<non-notable classes>)/");
 
-    rv = ReportClassStats(cStats.classInfo, nonNotablePath, cb, closure,
-                          gcTotal);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportClassStats(cStats.classInfo, nonNotablePath, handleReport, data,
+                     gcTotal);
 
     for (size_t i = 0; i < cStats.notableClasses.length(); i++) {
         MOZ_ASSERT(!cStats.isTotals);
         const JS::NotableClassInfo& classInfo = cStats.notableClasses[i];
 
         nsCString classPath = cJSPathPrefix +
             nsPrintfCString("classes/class(%s)/", classInfo.className_);
 
-        rv = ReportClassStats(classInfo, classPath, cb, closure, gcTotal);
-        NS_ENSURE_SUCCESS(rv, rv);
+        ReportClassStats(classInfo, classPath, handleReport, data, gcTotal);
     }
 
     // Note that we use cDOMPathPrefix here.  This is because we measure orphan
     // DOM nodes in the JS reporter, but we want to report them in a "dom"
     // sub-tree rather than a "js" sub-tree.
     ZCREPORT_BYTES(cDOMPathPrefix + NS_LITERAL_CSTRING("orphan-nodes"),
         cStats.objectsPrivate,
         "Orphan DOM nodes, i.e. those that are only reachable from JavaScript "
@@ -2400,64 +2379,57 @@ ReportCompartmentStats(const JS::Compart
         REPORT_BYTES(cJSPathPrefix + NS_LITERAL_CSTRING("sundries/malloc-heap"),
             KIND_HEAP, sundriesMallocHeap,
             "The sum of all 'malloc-heap' measurements that are too small to "
             "be worth showing individually.");
     }
 
     if (gcTotalOut)
         *gcTotalOut += gcTotal;
-
-    return NS_OK;
 }
 
-static nsresult
+static void
 ReportScriptSourceStats(const ScriptSourceInfo& scriptSourceInfo,
                         const nsACString& path,
-                        nsIHandleReportCallback* cb, nsISupports* closure,
-                        size_t& rtTotal)
+                        nsIHandleReportCallback* handleReport,
+                        nsISupports* data, size_t& rtTotal)
 {
     if (scriptSourceInfo.misc > 0) {
         RREPORT_BYTES(path + NS_LITERAL_CSTRING("misc"),
             KIND_HEAP, scriptSourceInfo.misc,
             "Miscellaneous data relating to JavaScript source code.");
     }
-
-    return NS_OK;
 }
 
-static nsresult
+static void
 ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
                                  const nsACString& rtPath,
                                  amIAddonManager* addonManager,
-                                 nsIMemoryReporterCallback* cb,
-                                 nsISupports* closure,
+                                 nsIHandleReportCallback* handleReport,
+                                 nsISupports* data,
                                  bool anonymize,
                                  size_t* rtTotalOut)
 {
-    nsresult rv;
-
     size_t gcTotal = 0;
 
     for (size_t i = 0; i < rtStats.zoneStatsVector.length(); i++) {
         const JS::ZoneStats& zStats = rtStats.zoneStatsVector[i];
         const xpc::ZoneStatsExtras* extras =
           static_cast<const xpc::ZoneStatsExtras*>(zStats.extra);
-        rv = ReportZoneStats(zStats, *extras, cb, closure, anonymize, &gcTotal);
-        NS_ENSURE_SUCCESS(rv, rv);
+        ReportZoneStats(zStats, *extras, handleReport, data, anonymize,
+                        &gcTotal);
     }
 
     for (size_t i = 0; i < rtStats.compartmentStatsVector.length(); i++) {
         const JS::CompartmentStats& cStats = rtStats.compartmentStatsVector[i];
         const xpc::CompartmentStatsExtras* extras =
             static_cast<const xpc::CompartmentStatsExtras*>(cStats.extra);
 
-        rv = ReportCompartmentStats(cStats, *extras, addonManager, cb, closure,
-                                    &gcTotal);
-        NS_ENSURE_SUCCESS(rv, rv);
+        ReportCompartmentStats(cStats, *extras, addonManager, handleReport,
+                               data, &gcTotal);
     }
 
     // Report the rtStats.runtime numbers under "runtime/", and compute their
     // total for later.
 
     size_t rtTotal = 0;
 
     RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/runtime-object"),
@@ -2496,19 +2468,18 @@ ReportJSRuntimeExplicitTreeStats(const J
     RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/script-data"),
         KIND_HEAP, rtStats.runtime.scriptData,
         "The table holding script data shared in the runtime.");
 
     nsCString nonNotablePath =
         rtPath + nsPrintfCString("runtime/script-sources/source(scripts=%d, <non-notable files>)/",
                                  rtStats.runtime.scriptSourceInfo.numScripts);
 
-    rv = ReportScriptSourceStats(rtStats.runtime.scriptSourceInfo,
-                                 nonNotablePath, cb, closure, rtTotal);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportScriptSourceStats(rtStats.runtime.scriptSourceInfo,
+                            nonNotablePath, handleReport, data, rtTotal);
 
     for (size_t i = 0; i < rtStats.runtime.notableScriptSources.length(); i++) {
         const JS::NotableScriptSourceInfo& scriptSourceInfo =
             rtStats.runtime.notableScriptSources[i];
 
         // Escape / to \ before we put the filename into the memory reporter
         // path, because we don't want any forward slashes in the string to
         // count as path separators. Consumers of memory reporters (e.g.
@@ -2522,19 +2493,18 @@ ReportJSRuntimeExplicitTreeStats(const J
             escapedFilename.Append(filename);
             escapedFilename.ReplaceSubstring("/", "\\");
         }
 
         nsCString notablePath = rtPath +
             nsPrintfCString("runtime/script-sources/source(scripts=%d, %s)/",
                             scriptSourceInfo.numScripts, escapedFilename.get());
 
-        rv = ReportScriptSourceStats(scriptSourceInfo, notablePath,
-                                     cb, closure, rtTotal);
-        NS_ENSURE_SUCCESS(rv, rv);
+        ReportScriptSourceStats(scriptSourceInfo, notablePath,
+                                handleReport, data, rtTotal);
     }
 
     RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/ion"),
         KIND_NONHEAP, rtStats.runtime.code.ion,
         "Code generated by the IonMonkey JIT.");
 
     RREPORT_BYTES(rtPath + NS_LITERAL_CSTRING("runtime/code/baseline"),
         KIND_NONHEAP, rtStats.runtime.code.baseline,
@@ -2610,35 +2580,33 @@ ReportJSRuntimeExplicitTreeStats(const J
 
     REPORT_GC_BYTES(rtPath + NS_LITERAL_CSTRING("gc-heap/chunk-admin"),
         rtStats.gcHeapChunkAdmin,
         "Bookkeeping information within GC chunks.");
 
     // gcTotal is the sum of everything we've reported for the GC heap.  It
     // should equal rtStats.gcHeapChunkTotal.
     MOZ_ASSERT(gcTotal == rtStats.gcHeapChunkTotal);
-
-    return NS_OK;
 }
 
-nsresult
+void
 ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
                                  const nsACString& rtPath,
-                                 nsIMemoryReporterCallback* cb,
-                                 nsISupports* closure,
+                                 nsIHandleReportCallback* handleReport,
+                                 nsISupports* data,
                                  bool anonymize,
                                  size_t* rtTotalOut)
 {
     nsCOMPtr<amIAddonManager> am;
     if (XRE_IsParentProcess()) {
         // Only try to access the service from the main process.
         am = do_GetService("@mozilla.org/addons/integration;1");
     }
-    return ReportJSRuntimeExplicitTreeStats(rtStats, rtPath, am.get(),
-                                            cb, closure, anonymize, rtTotalOut);
+    ReportJSRuntimeExplicitTreeStats(rtStats, rtPath, am.get(), handleReport,
+                                     data, anonymize, rtTotalOut);
 }
 
 
 } // namespace xpc
 
 class JSMainRuntimeCompartmentsReporter final : public nsIMemoryReporter
 {
 
@@ -2659,30 +2627,31 @@ class JSMainRuntimeCompartmentsReporter 
         GetCompartmentName(c, path, &data->anonymizeID, /* replaceSlashes = */ true);
         path.Insert(js::IsSystemCompartment(c)
                     ? NS_LITERAL_CSTRING("js-main-runtime-compartments/system/")
                     : NS_LITERAL_CSTRING("js-main-runtime-compartments/user/"),
                     0);
         mozilla::Unused << data->paths.append(path);
     }
 
-    NS_IMETHOD CollectReports(nsIMemoryReporterCallback* cb,
-                              nsISupports* closure, bool anonymize) override
+    NS_IMETHOD CollectReports(nsIHandleReportCallback* handleReport,
+                              nsISupports* data, bool anonymize) override
     {
         // First we collect the compartment paths.  Then we report them.  Doing
-        // the two steps interleaved is a bad idea, because calling |cb|
-        // from within CompartmentCallback() leads to all manner of assertions.
-
-        Data data;
-        data.anonymizeID = anonymize ? 1 : 0;
+        // the two steps interleaved is a bad idea, because calling
+        // |handleReport| from within CompartmentCallback() leads to all manner
+        // of assertions.
+
+        Data d;
+        d.anonymizeID = anonymize ? 1 : 0;
         JS_IterateCompartments(nsXPConnect::GetRuntimeInstance()->Context(),
-                               &data, CompartmentCallback);
-
-        for (size_t i = 0; i < data.paths.length(); i++)
-            REPORT(nsCString(data.paths[i]), KIND_OTHER, UNITS_COUNT, 1,
+                               &d, CompartmentCallback);
+
+        for (size_t i = 0; i < d.paths.length(); i++)
+            REPORT(nsCString(d.paths[i]), KIND_OTHER, UNITS_COUNT, 1,
                 "A live compartment in the main JSRuntime.");
 
         return NS_OK;
     }
 };
 
 NS_IMPL_ISUPPORTS(JSMainRuntimeCompartmentsReporter, nsIMemoryReporter)
 
@@ -2869,21 +2838,21 @@ class XPCJSRuntimeStats : public JS::Run
 
         MOZ_ASSERT(StartsWithExplicit(extras->jsPathPrefix));
         MOZ_ASSERT(StartsWithExplicit(extras->domPathPrefix));
 
         cstats->extra = extras;
     }
 };
 
-nsresult
+void
 JSReporter::CollectReports(WindowPaths* windowPaths,
                            WindowPaths* topWindowPaths,
-                           nsIMemoryReporterCallback* cb,
-                           nsISupports* closure,
+                           nsIHandleReportCallback* handleReport,
+                           nsISupports* data,
                            bool anonymize)
 {
     XPCJSRuntime* xpcrt = nsXPConnect::GetRuntimeInstance();
 
     // In the first step we get all the stats and stash them in a local
     // data structure.  In the second step we pass all the stashed stats to
     // the callback.  Separating these steps is important because the
     // callback may be a JS function, and executing JS while getting these
@@ -2896,52 +2865,49 @@ JSReporter::CollectReports(WindowPaths* 
     }
     bool getLocations = !!addonManager;
     XPCJSRuntimeStats rtStats(windowPaths, topWindowPaths, getLocations,
                               anonymize);
     OrphanReporter orphanReporter(XPCConvert::GetISupportsFromJSObject);
     if (!JS::CollectRuntimeStats(xpcrt->Context(), &rtStats, &orphanReporter,
                                  anonymize))
     {
-        return NS_ERROR_FAILURE;
+        return;
     }
 
     size_t xpcJSRuntimeSize = xpcrt->SizeOfIncludingThis(JSMallocSizeOf);
 
     size_t wrappedJSSize = xpcrt->GetMultiCompartmentWrappedJSMap()->SizeOfWrappedJS(JSMallocSizeOf);
 
     XPCWrappedNativeScope::ScopeSizeInfo sizeInfo(JSMallocSizeOf);
     XPCWrappedNativeScope::AddSizeOfAllScopesIncludingThis(&sizeInfo);
 
     mozJSComponentLoader* loader = mozJSComponentLoader::Get();
     size_t jsComponentLoaderSize = loader ? loader->SizeOfIncludingThis(JSMallocSizeOf) : 0;
 
     // This is the second step (see above).  First we report stuff in the
     // "explicit" tree, then we report other stuff.
 
-    nsresult rv;
     size_t rtTotal = 0;
-    rv = xpc::ReportJSRuntimeExplicitTreeStats(rtStats,
-                                               NS_LITERAL_CSTRING("explicit/js-non-window/"),
-                                               addonManager, cb, closure,
-                                               anonymize, &rtTotal);
-    NS_ENSURE_SUCCESS(rv, rv);
+    xpc::ReportJSRuntimeExplicitTreeStats(rtStats,
+                                          NS_LITERAL_CSTRING("explicit/js-non-window/"),
+                                          addonManager, handleReport, data,
+                                          anonymize, &rtTotal);
 
     // Report the sums of the compartment numbers.
     xpc::CompartmentStatsExtras cExtrasTotal;
     cExtrasTotal.jsPathPrefix.AssignLiteral("js-main-runtime/compartments/");
     cExtrasTotal.domPathPrefix.AssignLiteral("window-objects/dom/");
-    rv = ReportCompartmentStats(rtStats.cTotals, cExtrasTotal, addonManager,
-                                cb, closure);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportCompartmentStats(rtStats.cTotals, cExtrasTotal, addonManager,
+                           handleReport, data);
 
     xpc::ZoneStatsExtras zExtrasTotal;
     zExtrasTotal.pathPrefix.AssignLiteral("js-main-runtime/zones/");
-    rv = ReportZoneStats(rtStats.zTotals, zExtrasTotal, cb, closure, anonymize);
-    NS_ENSURE_SUCCESS(rv, rv);
+    ReportZoneStats(rtStats.zTotals, zExtrasTotal, handleReport, data,
+                    anonymize);
 
     // Report the sum of the runtime/ numbers.
     REPORT_BYTES(NS_LITERAL_CSTRING("js-main-runtime/runtime"),
         KIND_OTHER, rtTotal,
         "The sum of all measurements under 'explicit/js-non-window/runtime/'.");
 
     // Report the numbers for memory outside of compartments.
 
@@ -3068,18 +3034,16 @@ JSReporter::CollectReports(WindowPaths* 
 
     REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/proto-iface-cache"),
         KIND_HEAP, sizeInfo.mProtoAndIfaceCacheSize,
         "Prototype and interface binding caches.");
 
     REPORT_BYTES(NS_LITERAL_CSTRING("explicit/xpconnect/js-component-loader"),
         KIND_HEAP, jsComponentLoaderSize,
         "XPConnect's JS component loader.");
-
-    return NS_OK;
 }
 
 static nsresult
 JSSizeOfTab(JSObject* objArg, size_t* jsObjectsSize, size_t* jsStringsSize,
             size_t* jsPrivateSize, size_t* jsOtherSize)
 {
     JSContext* cx = nsXPConnect::GetRuntimeInstance()->Context();
     JS::RootedObject obj(cx, objArg);
--- a/js/xpconnect/src/xpcpublic.h
+++ b/js/xpconnect/src/xpcpublic.h
@@ -412,21 +412,21 @@ private:
     CompartmentStatsExtras(const CompartmentStatsExtras& other) = delete;
     CompartmentStatsExtras& operator=(const CompartmentStatsExtras& other) = delete;
 };
 
 // This reports all the stats in |rtStats| that belong in the "explicit" tree,
 // (which isn't all of them).
 // @see ZoneStatsExtras
 // @see CompartmentStatsExtras
-nsresult
+void
 ReportJSRuntimeExplicitTreeStats(const JS::RuntimeStats& rtStats,
                                  const nsACString& rtPath,
-                                 nsIMemoryReporterCallback* cb,
-                                 nsISupports* closure,
+                                 nsIMemoryReporterCallback* handleReport,
+                                 nsISupports* data,
                                  bool anonymize,
                                  size_t* rtTotal = nullptr);
 
 /**
  * Throws an exception on cx and returns false.
  */
 bool
 Throw(JSContext* cx, nsresult rv);
--- a/layout/base/nsStyleSheetService.cpp
+++ b/layout/base/nsStyleSheetService.cpp
@@ -357,20 +357,22 @@ nsStyleSheetService::GetInstance()
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(StyleSheetServiceMallocSizeOf)
 
 NS_IMETHODIMP
 nsStyleSheetService::CollectReports(nsIHandleReportCallback* aHandleReport,
                                     nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/layout/style-sheet-service", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(StyleSheetServiceMallocSizeOf),
     "Memory used for style sheets held by the style sheet service.");
+
+  return NS_OK;
 }
 
 size_t
 nsStyleSheetService::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
 {
   size_t n = aMallocSizeOf(this);
   for (auto& sheetArray : mSheets) {
     n += sheetArray.ShallowSizeOfExcludingThis(aMallocSizeOf);
--- a/layout/style/RuleProcessorCache.cpp
+++ b/layout/style/RuleProcessorCache.cpp
@@ -19,20 +19,22 @@ using namespace mozilla;
 NS_IMPL_ISUPPORTS(RuleProcessorCache, nsIMemoryReporter)
 
 MOZ_DEFINE_MALLOC_SIZE_OF(RuleProcessorCacheMallocSizeOf)
 
 NS_IMETHODIMP
 RuleProcessorCache::CollectReports(nsIHandleReportCallback* aHandleReport,
                                    nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/layout/rule-processor-cache", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(RuleProcessorCacheMallocSizeOf),
     "Memory used for cached rule processors.");
+
+  return NS_OK;
 }
 
 RuleProcessorCache::~RuleProcessorCache()
 {
   UnregisterWeakMemoryReporter(this);
 
   for (Entry& e : mEntries) {
     for (DocumentEntry& de : e.mDocumentEntries) {
--- a/layout/style/nsLayoutStylesheetCache.cpp
+++ b/layout/style/nsLayoutStylesheetCache.cpp
@@ -257,20 +257,22 @@ nsLayoutStylesheetCache::Shutdown()
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(LayoutStylesheetCacheMallocSizeOf)
 
 NS_IMETHODIMP
 nsLayoutStylesheetCache::CollectReports(nsIHandleReportCallback* aHandleReport,
                                         nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/layout/style-sheet-cache", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(LayoutStylesheetCacheMallocSizeOf),
     "Memory used for some built-in style sheets.");
+
+  return NS_OK;
 }
 
 
 size_t
 nsLayoutStylesheetCache::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
 {
   size_t n = aMallocSizeOf(this);
 
--- a/modules/libpref/Preferences.cpp
+++ b/modules/libpref/Preferences.cpp
@@ -312,33 +312,23 @@ protected:
   static const uint32_t kSuspectReferentCount = 1000;
 };
 
 NS_IMPL_ISUPPORTS(PreferenceServiceReporter, nsIMemoryReporter)
 
 MOZ_DEFINE_MALLOC_SIZE_OF(PreferenceServiceMallocSizeOf)
 
 NS_IMETHODIMP
-PreferenceServiceReporter::CollectReports(nsIMemoryReporterCallback* aCb,
-                                          nsISupports* aClosure,
-                                          bool aAnonymize)
+PreferenceServiceReporter::CollectReports(
+  nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize)
 {
-#define REPORT(_path, _kind, _units, _amount, _desc)                          \
-    do {                                                                      \
-      nsresult rv;                                                            \
-      rv = aCb->Callback(EmptyCString(), _path, _kind,                        \
-                         _units, _amount, NS_LITERAL_CSTRING(_desc),          \
-                         aClosure);                                           \
-      NS_ENSURE_SUCCESS(rv, rv);                                              \
-    } while (0)
-
-  REPORT(NS_LITERAL_CSTRING("explicit/preferences"),
-         KIND_HEAP, UNITS_BYTES,
-         Preferences::SizeOfIncludingThisAndOtherStuff(PreferenceServiceMallocSizeOf),
-         "Memory used by the preferences system.");
+  MOZ_COLLECT_REPORT(
+    "explicit/preferences", KIND_HEAP, UNITS_BYTES,
+    Preferences::SizeOfIncludingThisAndOtherStuff(PreferenceServiceMallocSizeOf),
+    "Memory used by the preferences system.");
 
   nsPrefBranch* rootBranch =
     static_cast<nsPrefBranch*>(Preferences::GetRootBranch());
   if (!rootBranch) {
     return NS_OK;
   }
 
   size_t numStrong = 0;
@@ -380,37 +370,41 @@ PreferenceServiceReporter::CollectReport
   for (uint32_t i = 0; i < suspectPreferences.Length(); i++) {
     nsCString& suspect = suspectPreferences[i];
     uint32_t totalReferentCount = 0;
     prefCounter.Get(suspect, &totalReferentCount);
 
     nsPrintfCString suspectPath("preference-service-suspect/"
                                 "referent(pref=%s)", suspect.get());
 
-    REPORT(suspectPath,
-           KIND_OTHER, UNITS_COUNT, totalReferentCount,
-           "A preference with a suspiciously large number "
-           "referents (symptom of a leak).");
+    aHandleReport->Callback(
+      /* process = */ EmptyCString(),
+      suspectPath, KIND_OTHER, UNITS_COUNT, totalReferentCount,
+      NS_LITERAL_CSTRING(
+        "A preference with a suspiciously large number referents (symptom of a "
+        "leak)."),
+      aData);
   }
 
-  REPORT(NS_LITERAL_CSTRING("preference-service/referent/strong"),
-         KIND_OTHER, UNITS_COUNT, numStrong,
-         "The number of strong referents held by the preference service.");
+  MOZ_COLLECT_REPORT(
+    "preference-service/referent/strong", KIND_OTHER, UNITS_COUNT,
+    numStrong,
+    "The number of strong referents held by the preference service.");
 
-  REPORT(NS_LITERAL_CSTRING("preference-service/referent/weak/alive"),
-         KIND_OTHER, UNITS_COUNT, numWeakAlive,
-         "The number of weak referents held by the preference service "
-         "that are still alive.");
+  MOZ_COLLECT_REPORT(
+    "preference-service/referent/weak/alive", KIND_OTHER, UNITS_COUNT,
+    numWeakAlive,
+    "The number of weak referents held by the preference service that are "
+    "still alive.");
 
-  REPORT(NS_LITERAL_CSTRING("preference-service/referent/weak/dead"),
-         KIND_OTHER, UNITS_COUNT, numWeakDead,
-         "The number of weak referents held by the preference service "
-         "that are dead.");
-
-#undef REPORT
+  MOZ_COLLECT_REPORT(
+    "preference-service/referent/weak/dead", KIND_OTHER, UNITS_COUNT,
+    numWeakDead,
+    "The number of weak referents held by the preference service that are "
+    "dead.");
 
   return NS_OK;
 }
 
 namespace {
 class AddPreferencesMemoryReporterRunnable : public Runnable
 {
   NS_IMETHOD Run() override
--- a/netwerk/cache/nsCacheService.cpp
+++ b/netwerk/cache/nsCacheService.cpp
@@ -3195,26 +3195,18 @@ nsCacheService::CollectReports(nsIHandle
     if (mDiskDevice) {
         nsCacheServiceAutoLock
             lock(LOCK_TELEM(NSCACHESERVICE_DISKDEVICEHEAPSIZE));
         disk = mDiskDevice->SizeOfIncludingThis(DiskCacheDeviceMallocSizeOf);
     }
 
     size_t memory = mMemoryDevice ? mMemoryDevice->TotalSize() : 0;
 
-#define REPORT(_path, _amount, _desc)                                         \
-    do {                                                                      \
-        nsresult rv;                                                          \
-        rv = aHandleReport->Callback(EmptyCString(),                          \
-                                     NS_LITERAL_CSTRING(_path),               \
-                                     KIND_HEAP, UNITS_BYTES, _amount,         \
-                                     NS_LITERAL_CSTRING(_desc), aData);       \
-        NS_ENSURE_SUCCESS(rv, rv);                                            \
-    } while (0)
-
-    REPORT("explicit/network/disk-cache", disk,
-           "Memory used by the network disk cache.");
-
-    REPORT("explicit/network/memory-cache", memory,
-           "Memory used by the network memory cache.");
+    MOZ_COLLECT_REPORT(
+        "explicit/network/disk-cache", KIND_HEAP, UNITS_BYTES, disk,
+        "Memory used by the network disk cache.");
+
+    MOZ_COLLECT_REPORT(
+        "explicit/network/memory-cache", KIND_HEAP, UNITS_BYTES, memory,
+        "Memory used by the network memory cache.");
 
     return NS_OK;
 }
--- a/netwerk/cache2/CacheStorageService.cpp
+++ b/netwerk/cache2/CacheStorageService.cpp
@@ -2108,44 +2108,36 @@ CacheStorageService::SizeOfExcludingThis
 
 size_t
 CacheStorageService::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) const
 {
   return mallocSizeOf(this) + SizeOfExcludingThis(mallocSizeOf);
 }
 
 NS_IMETHODIMP
-CacheStorageService::CollectReports(nsIMemoryReporterCallback* aHandleReport,
+CacheStorageService::CollectReports(nsIHandleReportCallback* aHandleReport,
                                     nsISupports* aData, bool aAnonymize)
 {
-  nsresult rv;
-
-  rv = MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/network/cache2/io", KIND_HEAP, UNITS_BYTES,
     CacheFileIOManager::SizeOfIncludingThis(MallocSizeOf),
     "Memory used by the cache IO manager.");
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
 
-  rv = MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/network/cache2/index", KIND_HEAP, UNITS_BYTES,
     CacheIndex::SizeOfIncludingThis(MallocSizeOf),
     "Memory used by the cache index.");
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
 
   MutexAutoLock lock(mLock);
 
   // Report the service instance, this doesn't report entries, done lower
-  rv = MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/network/cache2/service", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(MallocSizeOf),
     "Memory used by the cache storage service.");
-  if (NS_WARN_IF(NS_FAILED(rv)))
-    return rv;
 
   // Report all entries, each storage separately (by the context key)
   //
   // References are:
   // sGlobalEntryTables to N CacheEntryTable
   // CacheEntryTable to N CacheEntry
   // CacheEntry to 1 CacheFile
   // CacheFile to
@@ -2177,19 +2169,17 @@ CacheStorageService::CollectReports(nsIM
       }
 
       // These key names are not privacy-sensitive.
       aHandleReport->Callback(
         EmptyCString(),
         nsPrintfCString("explicit/network/cache2/%s-storage(%s)",
           table->Type() == CacheEntryTable::MEMORY_ONLY ? "memory" : "disk",
           iter1.Key().BeginReading()),
-        nsIMemoryReporter::KIND_HEAP,
-        nsIMemoryReporter::UNITS_BYTES,
-        size,
+        nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES, size,
         NS_LITERAL_CSTRING("Memory used by the cache storage."),
         aData);
     }
   }
 
   return NS_OK;
 }
 
--- a/netwerk/cookie/nsCookieService.cpp
+++ b/netwerk/cookie/nsCookieService.cpp
@@ -4825,13 +4825,15 @@ nsCookieService::SizeOfIncludingThis(moz
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(CookieServiceMallocSizeOf)
 
 NS_IMETHODIMP
 nsCookieService::CollectReports(nsIHandleReportCallback* aHandleReport,
                                 nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/cookie-service", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(CookieServiceMallocSizeOf),
     "Memory used by the cookie service.");
+
+  return NS_OK;
 }
--- a/netwerk/dns/nsDNSService2.cpp
+++ b/netwerk/dns/nsDNSService2.cpp
@@ -1052,14 +1052,16 @@ nsDNSService::SizeOfIncludingThis(mozill
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(DNSServiceMallocSizeOf)
 
 NS_IMETHODIMP
 nsDNSService::CollectReports(nsIHandleReportCallback* aHandleReport,
                              nsISupports* aData, bool aAnonymize)
 {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
         "explicit/network/dns-service", KIND_HEAP, UNITS_BYTES,
         SizeOfIncludingThis(DNSServiceMallocSizeOf),
         "Memory used for the DNS service.");
+
+    return NS_OK;
 }
 
--- a/netwerk/dns/nsEffectiveTLDService.cpp
+++ b/netwerk/dns/nsEffectiveTLDService.cpp
@@ -122,20 +122,22 @@ MOZ_DEFINE_MALLOC_SIZE_OF(EffectiveTLDSe
 // The amount of heap memory measured here is tiny. It used to be bigger when
 // nsEffectiveTLDService used a separate hash table instead of binary search.
 // Nonetheless, we keep this code here in anticipation of bug 1083971 which will
 // change ETLDEntries::entries to a heap-allocated array modifiable at runtime.
 NS_IMETHODIMP
 nsEffectiveTLDService::CollectReports(nsIHandleReportCallback* aHandleReport,
                                       nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/network/effective-TLD-service", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(EffectiveTLDServiceMallocSizeOf),
     "Memory used by the effective TLD service.");
+
+  return NS_OK;
 }
 
 size_t
 nsEffectiveTLDService::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   size_t n = aMallocSizeOf(this);
 
   // Measurement of the following members may be added later if DMD finds it is
--- a/netwerk/protocol/http/Http2Compression.cpp
+++ b/netwerk/protocol/http/Http2Compression.cpp
@@ -30,20 +30,22 @@ public:
   NS_DECL_THREADSAFE_ISUPPORTS
 
   HpackStaticTableReporter() {}
 
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/network/hpack/static-table", KIND_HEAP, UNITS_BYTES,
       gStaticHeaders->SizeOfIncludingThis(MallocSizeOf),
       "Memory usage of HPACK static table.");
+
+    return NS_OK;
   }
 
 private:
   MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
 
   ~HpackStaticTableReporter() {}
 };
 
@@ -57,24 +59,23 @@ public:
   explicit HpackDynamicTableReporter(Http2BaseCompressor* aCompressor)
     : mCompressor(aCompressor)
   {}
 
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    if (!mCompressor) {
-      return NS_OK;
+    if (mCompressor) {
+      MOZ_COLLECT_REPORT(
+        "explicit/network/hpack/dynamic-tables", KIND_HEAP, UNITS_BYTES,
+        mCompressor->SizeOfExcludingThis(MallocSizeOf),
+        "Aggregate memory usage of HPACK dynamic tables.");
     }
-
-    return MOZ_COLLECT_REPORT(
-      "explicit/network/hpack/dynamic-tables", KIND_HEAP, UNITS_BYTES,
-      mCompressor->SizeOfExcludingThis(MallocSizeOf),
-      "Aggregate memory usage of HPACK dynamic tables.");
+    return NS_OK;
   }
 
 private:
   MOZ_DEFINE_MALLOC_SIZE_OF(MallocSizeOf)
 
   ~HpackDynamicTableReporter() {}
 
   Http2BaseCompressor* mCompressor;
--- a/startupcache/StartupCache.cpp
+++ b/startupcache/StartupCache.cpp
@@ -53,35 +53,26 @@ namespace mozilla {
 namespace scache {
 
 MOZ_DEFINE_MALLOC_SIZE_OF(StartupCacheMallocSizeOf)
 
 NS_IMETHODIMP
 StartupCache::CollectReports(nsIHandleReportCallback* aHandleReport,
                              nsISupports* aData, bool aAnonymize)
 {
-#define REPORT(_path, _kind, _amount, _desc)                                \
-  do {                                                                      \
-    nsresult rv =                                                           \
-      aHandleReport->Callback(EmptyCString(),                               \
-                              NS_LITERAL_CSTRING(_path),                    \
-                              _kind, UNITS_BYTES, _amount,                  \
-                              NS_LITERAL_CSTRING(_desc), aData);            \
-    NS_ENSURE_SUCCESS(rv, rv);                                              \
-  } while (0)
+  MOZ_COLLECT_REPORT(
+    "explicit/startup-cache/mapping", KIND_NONHEAP, UNITS_BYTES,
+    SizeOfMapping(),
+    "Memory used to hold the mapping of the startup cache from file. "
+    "This memory is likely to be swapped out shortly after start-up.");
 
-  REPORT("explicit/startup-cache/mapping", KIND_NONHEAP,
-         SizeOfMapping(),
-         "Memory used to hold the mapping of the startup cache from file. "
-         "This memory is likely to be swapped out shortly after start-up.");
-
-  REPORT("explicit/startup-cache/data", KIND_HEAP,
-         HeapSizeOfIncludingThis(StartupCacheMallocSizeOf),
-         "Memory used by the startup cache for things other than the file "
-         "mapping.");
+  MOZ_COLLECT_REPORT(
+    "explicit/startup-cache/data", KIND_HEAP, UNITS_BYTES,
+    HeapSizeOfIncludingThis(StartupCacheMallocSizeOf),
+    "Memory used by the startup cache for things other than the file mapping.");
 
   return NS_OK;
 }
 
 #define STARTUP_CACHE_NAME "startupCache." SC_WORDSIZE "." SC_ENDIAN
 
 StartupCache*
 StartupCache::GetSingleton()
--- a/storage/mozStorageService.cpp
+++ b/storage/mozStorageService.cpp
@@ -85,52 +85,48 @@ StorageSQLiteDistinguishedAmount()
  *        "schema".
  * @param aDesc
  *        The memory report description.
  * @param aOption
  *        The SQLite constant for getting the measurement.
  * @param aTotal
  *        The accumulator for the measurement.
  */
-nsresult
+static void
 ReportConn(nsIHandleReportCallback *aHandleReport,
            nsISupports *aData,
            Connection *aConn,
            const nsACString &aPathHead,
            const nsACString &aKind,
            const nsACString &aDesc,
            int32_t aOption,
            size_t *aTotal)
 {
   nsCString path(aPathHead);
   path.Append(aKind);
   path.AppendLiteral("-used");
 
   int32_t val = aConn->getSqliteRuntimeStatus(aOption);
-  nsresult rv = aHandleReport->Callback(EmptyCString(), path,
-                                        nsIMemoryReporter::KIND_HEAP,
-                                        nsIMemoryReporter::UNITS_BYTES,
-                                        int64_t(val), aDesc, aData);
-  NS_ENSURE_SUCCESS(rv, rv);
+  aHandleReport->Callback(EmptyCString(), path,
+                          nsIMemoryReporter::KIND_HEAP,
+                          nsIMemoryReporter::UNITS_BYTES,
+                          int64_t(val), aDesc, aData);
   *aTotal += val;
-
-  return NS_OK;
 }
 
 // Warning: To get a Connection's measurements requires holding its lock.
 // There may be a delay getting the lock if another thread is accessing the
 // Connection.  This isn't very nice if CollectReports is called from the main
 // thread!  But at the time of writing this function is only called when
 // about:memory is loaded (not, for example, when telemetry pings occur) and
 // any delays in that case aren't so bad.
 NS_IMETHODIMP
 Service::CollectReports(nsIHandleReportCallback *aHandleReport,
                         nsISupports *aData, bool aAnonymize)
 {
-  nsresult rv;
   size_t totalConnSize = 0;
   {
     nsTArray<RefPtr<Connection> > connections;
     getConnections(connections);
 
     for (uint32_t i = 0; i < connections.Length(); i++) {
       RefPtr<Connection> &conn = connections[i];
 
@@ -146,55 +142,48 @@ Service::CollectReports(nsIHandleReportC
       pathHead.Append(conn->getFilename());
       pathHead.Append('/');
 
       SQLiteMutexAutoLock lockedScope(conn->sharedDBMutex);
 
       NS_NAMED_LITERAL_CSTRING(stmtDesc,
         "Memory (approximate) used by all prepared statements used by "
         "connections to this database.");
-      rv = ReportConn(aHandleReport, aData, conn, pathHead,
-                      NS_LITERAL_CSTRING("stmt"), stmtDesc,
-                      SQLITE_DBSTATUS_STMT_USED, &totalConnSize);
-      NS_ENSURE_SUCCESS(rv, rv);
+      ReportConn(aHandleReport, aData, conn, pathHead,
+                 NS_LITERAL_CSTRING("stmt"), stmtDesc,
+                 SQLITE_DBSTATUS_STMT_USED, &totalConnSize);
 
       NS_NAMED_LITERAL_CSTRING(cacheDesc,
         "Memory (approximate) used by all pager caches used by connections "
         "to this database.");
-      rv = ReportConn(aHandleReport, aData, conn, pathHead,
-                      NS_LITERAL_CSTRING("cache"), cacheDesc,
-                      SQLITE_DBSTATUS_CACHE_USED, &totalConnSize);
-      NS_ENSURE_SUCCESS(rv, rv);
+      ReportConn(aHandleReport, aData, conn, pathHead,
+                 NS_LITERAL_CSTRING("cache"), cacheDesc,
+                 SQLITE_DBSTATUS_CACHE_USED, &totalConnSize);
 
       NS_NAMED_LITERAL_CSTRING(schemaDesc,
         "Memory (approximate) used to store the schema for all databases "
         "associated with connections to this database.");
-      rv = ReportConn(aHandleReport, aData, conn, pathHead,
-                      NS_LITERAL_CSTRING("schema"), schemaDesc,
-                      SQLITE_DBSTATUS_SCHEMA_USED, &totalConnSize);
-      NS_ENSURE_SUCCESS(rv, rv);
+      ReportConn(aHandleReport, aData, conn, pathHead,
+                 NS_LITERAL_CSTRING("schema"), schemaDesc,
+                 SQLITE_DBSTATUS_SCHEMA_USED, &totalConnSize);
     }
 
 #ifdef MOZ_DMD
     if (::sqlite3_memory_used() != int64_t(gSqliteMemoryUsed)) {
       NS_WARNING("memory consumption reported by SQLite doesn't match "
                  "our measurements");
     }
 #endif
   }
 
   int64_t other = ::sqlite3_memory_used() - totalConnSize;
 
-  rv = aHandleReport->Callback(
-          EmptyCString(),
-          NS_LITERAL_CSTRING("explicit/storage/sqlite/other"),
-          KIND_HEAP, UNITS_BYTES, other,
-          NS_LITERAL_CSTRING("All unclassified sqlite memory."),
-          aData);
-  NS_ENSURE_SUCCESS(rv, rv);
+  MOZ_COLLECT_REPORT(
+    "explicit/storage/sqlite/other", KIND_HEAP, UNITS_BYTES, other,
+    "All unclassified sqlite memory.");
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //// Service
 
 NS_IMPL_ISUPPORTS(
--- a/toolkit/components/aboutmemory/content/aboutMemory.js
+++ b/toolkit/components/aboutmemory/content/aboutMemory.js
@@ -171,17 +171,17 @@ function updateTitleMainAndFooter(aTitle
       className = className + " " + aClassName;
     }
     msgElement = appendElementWithText(gMain, 'div', className, aMsg);
   }
 
   switch (aFooterAction) {
    case HIDE_FOOTER:   gFooter.classList.add('hidden');    break;
    case SHOW_FOOTER:   gFooter.classList.remove('hidden'); break;
-   default: assertInput(false, "bad footer action in updateTitleMainAndFooter");
+   default: assert(false, "bad footer action in updateTitleMainAndFooter");
   }
   return msgElement;
 }
 
 function updateMainAndFooter(aMsg, aFooterAction, aClassName)
 {
   return updateTitleMainAndFooter("", aMsg, aFooterAction, aClassName);
 }
--- a/toolkit/components/places/History.cpp
+++ b/toolkit/components/places/History.cpp
@@ -2235,21 +2235,23 @@ History::FetchPageInfo(VisitData& _place
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(HistoryMallocSizeOf)
 
 NS_IMETHODIMP
 History::CollectReports(nsIHandleReportCallback* aHandleReport,
                         nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/history-links-hashtable", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(HistoryMallocSizeOf),
     "Memory used by the hashtable that records changes to the visited state "
     "of links.");
+
+  return NS_OK;
 }
 
 size_t
 History::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOfThis)
 {
   return aMallocSizeOfThis(this) +
          mObservers.SizeOfExcludingThis(aMallocSizeOfThis);
 }
--- a/toolkit/components/telemetry/Telemetry.cpp
+++ b/toolkit/components/telemetry/Telemetry.cpp
@@ -751,20 +751,22 @@ private:
 TelemetryImpl*  TelemetryImpl::sTelemetry = nullptr;
 
 MOZ_DEFINE_MALLOC_SIZE_OF(TelemetryMallocSizeOf)
 
 NS_IMETHODIMP
 TelemetryImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
                               nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT(
+  MOZ_COLLECT_REPORT(
     "explicit/telemetry", KIND_HEAP, UNITS_BYTES,
     SizeOfIncludingThis(TelemetryMallocSizeOf),
     "Memory used by the telemetry system.");
+
+  return NS_OK;
 }
 
 void
 InitHistogramRecordingEnabled()
 {
   TelemetryHistogram::InitHistogramRecordingEnabled();
 }
 
--- a/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
+++ b/toolkit/components/url-classifier/nsUrlClassifierPrefixSet.cpp
@@ -272,22 +272,23 @@ NS_IMETHODIMP
 nsUrlClassifierPrefixSet::CollectReports(nsIHandleReportCallback* aHandleReport,
                                          nsISupports* aData, bool aAnonymize)
 {
   MOZ_ASSERT(NS_IsMainThread());
 
   // No need to get mLock here because this function does not directly touch
   // the class's data members. (SizeOfIncludingThis() will get mLock, however.)
 
-  size_t amount = SizeOfIncludingThis(UrlClassifierMallocSizeOf);
-
-  return aHandleReport->Callback(
-    EmptyCString(), mMemoryReportPath, KIND_HEAP, UNITS_BYTES, amount,
+  aHandleReport->Callback(
+    EmptyCString(), mMemoryReportPath, KIND_HEAP, UNITS_BYTES,
+    SizeOfIncludingThis(UrlClassifierMallocSizeOf),
     NS_LITERAL_CSTRING("Memory used by the prefix set for a URL classifier."),
     aData);
+
+  return NS_OK;
 }
 
 size_t
 nsUrlClassifierPrefixSet::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   MutexAutoLock lock(mLock);
 
   size_t n = 0;
--- a/xpcom/base/AvailableMemoryTracker.cpp
+++ b/xpcom/base/AvailableMemoryTracker.cpp
@@ -341,50 +341,45 @@ class LowEventsReporter final : public n
   ~LowEventsReporter() {}
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    nsresult rv;
-
     // We only do virtual-memory tracking on 32-bit builds.
     if (sizeof(void*) == 4) {
-      rv = MOZ_COLLECT_REPORT(
+      MOZ_COLLECT_REPORT(
         "low-memory-events/virtual", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
         LowMemoryEventsVirtualDistinguishedAmount(),
 "Number of low-virtual-memory events fired since startup. We fire such an "
 "event if we notice there is less than memory.low_virtual_mem_threshold_mb of "
 "virtual address space available (if zero, this behavior is disabled). The "
 "process will probably crash if it runs out of virtual address space, so "
 "this event is dire.");
-      NS_ENSURE_SUCCESS(rv, rv);
     }
 
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "low-commit-space-events", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
       sNumLowCommitSpaceEvents,
 "Number of low-commit-space events fired since startup. We fire such an "
 "event if we notice there is less than memory.low_commit_space_threshold_mb of "
 "commit space available (if zero, this behavior is disabled). Windows will "
 "likely kill the process if it runs out of commit space, so this event is "
 "dire.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "low-memory-events/physical", KIND_OTHER, UNITS_COUNT_CUMULATIVE,
       LowMemoryEventsPhysicalDistinguishedAmount(),
 "Number of low-physical-memory events fired since startup. We fire such an "
 "event if we notice there is less than memory.low_physical_memory_threshold_mb "
 "of physical memory available (if zero, this behavior is disabled).  The "
 "machine will start to page if it runs out of physical memory.  This may "
 "cause it to run slowly, but it shouldn't cause it to crash.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(LowEventsReporter, nsIMemoryReporter)
 
 #endif // defined(XP_WIN)
 
--- a/xpcom/base/CountingAllocatorBase.h
+++ b/xpcom/base/CountingAllocatorBase.h
@@ -20,20 +20,22 @@ namespace mozilla {
 //
 //   class MyMemoryReporter : public CountingAllocatorBase<MyMemoryReporter>
 //   {
 //     ...
 //     NS_IMETHOD
 //     CollectReports(nsIHandleReportCallback* aHandleReport,
 //                    nsISupports* aData, bool aAnonymize) override
 //     {
-//        return MOZ_COLLECT_REPORT(
+//        MOZ_COLLECT_REPORT(
 //          "explicit/path/to/somewhere", KIND_HEAP, UNITS_BYTES,
 //          MemoryAllocated(),
-//          "A description of what we are reporting."
+//          "A description of what we are reporting.");
+//
+//        return NS_OK;
 //     }
 //   };
 //
 //   ...somewhere later in the code...
 //   SetThirdPartyMemoryFunctions(MyMemoryReporter::CountingAlloc,
 //                                MyMemoryReporter::CountingFree);
 template<typename T>
 class CountingAllocatorBase
--- a/xpcom/base/SystemMemoryReporter.cpp
+++ b/xpcom/base/SystemMemoryReporter.cpp
@@ -135,83 +135,73 @@ IsAnonymous(const nsACString& aName)
 
 class SystemReporter final : public nsIMemoryReporter
 {
   ~SystemReporter() {}
 
 public:
   NS_DECL_THREADSAFE_ISUPPORTS
 
-#define REPORT_WITH_CLEANUP(_path, _units, _amount, _desc, _cleanup)          \
+#define REPORT(_path, _units, _amount, _desc)                                 \
   do {                                                                        \
-    size_t amount = _amount;  /* evaluate _amount only once */                \
-    if (amount > 0) {                                                         \
-      nsresult rvReport;                                                      \
-      rvReport = aHandleReport->Callback(NS_LITERAL_CSTRING("System"), _path, \
-                                   KIND_NONHEAP, _units, amount, _desc,       \
-                                   aData);                                    \
-      if (NS_WARN_IF(NS_FAILED(rvReport))) {                                  \
-        _cleanup;                                                             \
-        return rvReport;                                                      \
-      }                                                                       \
+    size_t __amount = _amount;  /* evaluate _amount only once */              \
+    if (__amount > 0) {                                                       \
+      aHandleReport->Callback(NS_LITERAL_CSTRING("System"), _path,            \
+                              KIND_OTHER, _units, __amount, _desc, aData);    \
     }                                                                         \
   } while (0)
 
-#define REPORT(_path, _amount, _desc) \
-  REPORT_WITH_CLEANUP(_path, UNITS_BYTES, _amount, _desc, (void)0)
-
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     // There is lots of privacy-sensitive data in /proc. Just skip this
     // reporter entirely when anonymization is required.
     if (aAnonymize) {
       return NS_OK;
     }
 
     if (!Preferences::GetBool("memory.system_memory_reporter")) {
       return NS_OK;
     }
 
     // Read relevant fields from /proc/meminfo.
     int64_t memTotal = 0, memFree = 0;
-    nsresult rv = ReadMemInfo(&memTotal, &memFree);
+    nsresult rv1 = ReadMemInfo(&memTotal, &memFree);
 
     // Collect per-process reports from /proc/<pid>/smaps.
     int64_t totalPss = 0;
-    rv = CollectProcessReports(aHandleReport, aData, &totalPss);
-    NS_ENSURE_SUCCESS(rv, rv);
+    nsresult rv2 = CollectProcessReports(aHandleReport, aData, &totalPss);
 
     // Report the non-process numbers.
-    int64_t other = memTotal - memFree - totalPss;
-    REPORT(NS_LITERAL_CSTRING("mem/other"), other, NS_LITERAL_CSTRING(
+    if (NS_SUCCEEDED(rv1) && NS_SUCCEEDED(rv2)) {
+      int64_t other = memTotal - memFree - totalPss;
+      REPORT(NS_LITERAL_CSTRING("mem/other"), UNITS_BYTES, other,
+             NS_LITERAL_CSTRING(
 "Memory which is neither owned by any user-space process nor free. Note that "
 "this includes memory holding cached files from the disk which can be "
 "reclaimed by the OS at any time."));
 
-    REPORT(NS_LITERAL_CSTRING("mem/free"), memFree, NS_LITERAL_CSTRING(
+      REPORT(NS_LITERAL_CSTRING("mem/free"), UNITS_BYTES, memFree,
+             NS_LITERAL_CSTRING(
 "Memory which is free and not being used for any purpose."));
+    }
 
     // Report reserved memory not included in memTotal.
-    rv = CollectPmemReports(aHandleReport, aData);
-    NS_ENSURE_SUCCESS(rv, rv);
+    CollectPmemReports(aHandleReport, aData);
 
     // Report zram usage statistics.
-    rv = CollectZramReports(aHandleReport, aData);
-    NS_ENSURE_SUCCESS(rv, rv);
+    CollectZramReports(aHandleReport, aData);
 
     // Report kgsl graphics memory usage.
-    rv = CollectKgslReports(aHandleReport, aData);
-    NS_ENSURE_SUCCESS(rv, rv);
+    CollectKgslReports(aHandleReport, aData);
 
     // Report ION memory usage.
-    rv = CollectIonReports(aHandleReport, aData);
-    NS_ENSURE_SUCCESS(rv, rv);
+    CollectIonReports(aHandleReport, aData);
 
-    return rv;
+    return NS_OK;
   }
 
 private:
   // These are the cross-cutting measurements across all processes.
   class ProcessSizes
   {
   public:
     void Add(const nsACString& aKey, size_t aSize)
@@ -227,19 +217,17 @@ private:
 
         nsAutoCString path("processes/");
         path.Append(key);
 
         nsAutoCString desc("This is the sum of all processes' '");
         desc.Append(key);
         desc.AppendLiteral("' numbers.");
 
-        aHandleReport->Callback(NS_LITERAL_CSTRING("System"), path,
-                                KIND_NONHEAP, UNITS_BYTES, amount,
-                                desc, aData);
+        REPORT(path, UNITS_BYTES, amount, desc);
       }
     }
 
   private:
     nsDataHashtable<nsCStringHashKey, size_t> mTagged;
   };
 
   nsresult ReadMemInfo(int64_t* aMemTotal, int64_t* aMemFree)
@@ -310,46 +298,39 @@ private:
         // Read the PSS values from the smaps file.
         nsPrintfCString smapsPath("/proc/%s/smaps", pidStr);
         f = fopen(smapsPath.get(), "r");
         if (!f) {
           // Processes can terminate between the readdir() call above and now,
           // so just skip if we can't open the file.
           continue;
         }
-        nsresult rv = ParseMappings(f, processName, aHandleReport, aData,
-                                    &processSizes, aTotalPss);
+        ParseMappings(f, processName, aHandleReport, aData, &processSizes,
+                      aTotalPss);
         fclose(f);
-        if (NS_FAILED(rv)) {
-          continue;
-        }
 
         // Report the open file descriptors for this process.
         nsPrintfCString procFdPath("/proc/%s/fd", pidStr);
-        rv = CollectOpenFileReports(aHandleReport, aData, procFdPath,
-                                    processName);
-        if (NS_FAILED(rv)) {
-          break;
-        }
+        CollectOpenFileReports(aHandleReport, aData, procFdPath, processName);
       }
     }
     closedir(d);
 
     // Report the "processes/" tree.
     processSizes.Report(aHandleReport, aData);
 
     return NS_OK;
   }
 
-  nsresult ParseMappings(FILE* aFile,
-                         const nsACString& aProcessName,
-                         nsIHandleReportCallback* aHandleReport,
-                         nsISupports* aData,
-                         ProcessSizes* aProcessSizes,
-                         int64_t* aTotalPss)
+  void ParseMappings(FILE* aFile,
+                     const nsACString& aProcessName,
+                     nsIHandleReportCallback* aHandleReport,
+                     nsISupports* aData,
+                     ProcessSizes* aProcessSizes,
+                     int64_t* aTotalPss)
   {
     // The first line of an entry in /proc/<pid>/smaps looks just like an entry
     // in /proc/<pid>/maps:
     //
     //   address           perms offset  dev   inode  pathname
     //   02366000-025d8000 rw-p 00000000 00:00 0      [heap]
     //
     // Each of the following lines contains a key and a value, separated
@@ -407,27 +388,26 @@ private:
         nsAutoCString name, description, tag;
         GetReporterNameAndDescription(currentPath.get(), perms, name, description, tag);
 
         nsAutoCString processMemPath("mem/processes/");
         processMemPath.Append(aProcessName);
         processMemPath.Append('/');
         processMemPath.Append(name);
 
-        REPORT(processMemPath, pss, description);
+        REPORT(processMemPath, UNITS_BYTES, pss, description);
 
         // Increment the appropriate aProcessSizes values, and the total.
         aProcessSizes->Add(tag, pss);
         *aTotalPss += pss;
       }
 
       // Now that we've seen the PSS, we're done with this entry.
       currentPath.SetIsVoid(true);
     }
-    return NS_OK;
   }
 
   void GetReporterNameAndDescription(const char* aPath,
                                      const char* aPerms,
                                      nsACString& aName,
                                      nsACString& aDesc,
                                      nsACString& aTag)
   {
@@ -560,37 +540,33 @@ private:
     // Append the permissions.  This is useful for non-verbose mode in
     // about:memory when the filename is long and goes of the right side of the
     // window.
     aDesc.AppendLiteral(" [");
     aDesc.Append(aPerms);
     aDesc.Append(']');
   }
 
-  nsresult CollectPmemReports(nsIHandleReportCallback* aHandleReport,
-                              nsISupports* aData)
+  void CollectPmemReports(nsIHandleReportCallback* aHandleReport,
+                          nsISupports* aData)
   {
     // The pmem subsystem allocates physically contiguous memory for
     // interfacing with hardware.  In order to ensure availability,
     // this memory is reserved during boot, and allocations are made
     // within these regions at runtime.
     //
     // There are typically several of these pools allocated at boot.
     // The /sys/kernel/pmem_regions directory contains a subdirectory
     // for each one.  Within each subdirectory, the files we care
     // about are "size" (the total amount of physical memory) and
     // "mapped_regions" (a list of the current allocations within that
     // area).
     DIR* d = opendir("/sys/kernel/pmem_regions");
     if (!d) {
-      if (NS_WARN_IF(errno != ENOENT)) {
-        return NS_ERROR_FAILURE;
-      }
-      // If ENOENT, system doesn't use pmem.
-      return NS_OK;
+      return;
     }
 
     struct dirent* ent;
     while ((ent = readdir(d))) {
       const char* name = ent->d_name;
       uint64_t size;
       int scanned;
 
@@ -643,35 +619,33 @@ private:
             if (NS_WARN_IF(scanned != 2)) {
               break;
             }
 
             nsPrintfCString path("mem/pmem/used/%s/segment(pid=%d, "
                                  "offset=0x%" PRIx64 ")", name, pid, mapStart);
             nsPrintfCString desc("Physical memory reserved for the \"%s\" pool "
                                  "and allocated to a buffer.", name);
-            REPORT_WITH_CLEANUP(path, UNITS_BYTES, mapLen, desc,
-                                (fclose(regionsFile), closedir(d)));
+            REPORT(path, UNITS_BYTES, mapLen, desc);
             freeSize -= mapLen;
           }
         }
         fclose(regionsFile);
       }
 
       nsPrintfCString path("mem/pmem/free/%s", name);
       nsPrintfCString desc("Physical memory reserved for the \"%s\" pool and "
                            "unavailable to the rest of the system, but not "
                            "currently allocated.", name);
-      REPORT_WITH_CLEANUP(path, UNITS_BYTES, freeSize, desc, closedir(d));
+      REPORT(path, UNITS_BYTES, freeSize, desc);
     }
     closedir(d);
-    return NS_OK;
   }
 
-  nsresult
+  void
   CollectIonReports(nsIHandleReportCallback* aHandleReport,
                     nsISupports* aData)
   {
     // ION is a replacement for PMEM (and other similar allocators).
     //
     // More details from http://lwn.net/Articles/480055/
     //  "Like its PMEM-like predecessors, ION manages one or more memory pools,
     //   some of which are set aside at boot time to combat fragmentation or to
@@ -707,21 +681,17 @@ private:
     //   3) size   - The size of the allocation in bytes, read as as a uint64_t.
     const char* const kFormatString = "%63s %" SCNu32 " %" SCNu64;
     const int kNumFields = 3;
     const size_t kStringSize = 64;
     const char* const kIonIommuPath = "/sys/kernel/debug/ion/iommu";
 
     FILE* iommu = fopen(kIonIommuPath, "r");
     if (!iommu) {
-      if (NS_WARN_IF(errno != ENOENT)) {
-        return NS_ERROR_FAILURE;
-      }
-      // If ENOENT, system doesn't use ION.
-      return NS_OK;
+      return;
     }
 
     AutoFile iommuGuard(iommu);
 
     const size_t kBufferLen = 256;
     char buffer[kBufferLen];
     char client[kStringSize];
     uint32_t pid;
@@ -736,39 +706,35 @@ private:
     const char* const kSep = "----";
     const size_t kSepLen = 4;
 
     // Read non-orphaned entries.
     while (fgets(buffer, kBufferLen, iommu) &&
            strncmp(kSep, buffer, kSepLen) != 0) {
       if (sscanf(buffer, kFormatString, client, &pid, &size) == kNumFields) {
         nsPrintfCString entryPath("ion-memory/%s (pid=%d)", client, pid);
-        REPORT(entryPath,
-               size,
+        REPORT(entryPath, UNITS_BYTES, size,
                NS_LITERAL_CSTRING("An ION kernel memory allocation."));
       }
     }
 
     // Ignore the orphaned header.
     Unused << fgets(buffer, kBufferLen, iommu);
 
     // Read orphaned entries.
     while (fgets(buffer, kBufferLen, iommu) &&
            strncmp(kSep, buffer, kSepLen) != 0) {
       if (sscanf(buffer, kFormatString, client, &pid, &size) == kNumFields) {
         nsPrintfCString entryPath("ion-memory/%s (pid=%d)", client, pid);
-        REPORT(entryPath,
-               size,
+        REPORT(entryPath, UNITS_BYTES, size,
                NS_LITERAL_CSTRING("An ION kernel memory allocation."));
       }
     }
 
     // Ignore the rest of the file.
-
-    return NS_OK;
   }
 
   uint64_t
   ReadSizeFromFile(const char* aFilename)
   {
     FILE* sizeFile = fopen(aFilename, "r");
     if (NS_WARN_IF(!sizeFile)) {
       return 0;
@@ -776,38 +742,34 @@ private:
 
     uint64_t size = 0;
     Unused << fscanf(sizeFile, "%" SCNu64, &size);
     fclose(sizeFile);
 
     return size;
   }
 
-  nsresult
+  void
   CollectZramReports(nsIHandleReportCallback* aHandleReport,
                      nsISupports* aData)
   {
     // zram usage stats files can be found under:
     //  /sys/block/zram<id>
     //  |--> disksize        - Maximum amount of uncompressed data that can be
     //                         stored on the disk (bytes)
     //  |--> orig_data_size  - Uncompressed size of data in the disk (bytes)
     //  |--> compr_data_size - Compressed size of the data in the disk (bytes)
     //  |--> num_reads       - Number of attempted reads to the disk (count)
     //  |--> num_writes      - Number of attempted writes to the disk (count)
     //
     // Each file contains a single integer value in decimal form.
 
     DIR* d = opendir("/sys/block");
     if (!d) {
-      if (NS_WARN_IF(errno != ENOENT)) {
-        return NS_ERROR_FAILURE;
-      }
-
-      return NS_OK;
+      return;
     }
 
     struct dirent* ent;
     while ((ent = readdir(d))) {
       const char* name = ent->d_name;
 
       // Skip non-zram entries.
       if (strncmp("zram", name, 4) != 0) {
@@ -822,64 +784,58 @@ private:
       uint64_t origSize = ReadSizeFromFile(origSizeFile.get());
       uint64_t unusedSize = diskSize - origSize;
 
       nsPrintfCString diskUsedPath("zram-disksize/%s/used", name);
       nsPrintfCString diskUsedDesc(
         "The uncompressed size of data stored in \"%s.\" "
         "This excludes zero-filled pages since "
         "no memory is allocated for them.", name);
-      REPORT_WITH_CLEANUP(diskUsedPath, UNITS_BYTES, origSize,
-                          diskUsedDesc, closedir(d));
+      REPORT(diskUsedPath, UNITS_BYTES, origSize, diskUsedDesc);
 
       nsPrintfCString diskUnusedPath("zram-disksize/%s/unused", name);
       nsPrintfCString diskUnusedDesc(
         "The amount of uncompressed data that can still be "
         "be stored in \"%s\"", name);
-      REPORT_WITH_CLEANUP(diskUnusedPath, UNITS_BYTES, unusedSize,
-                          diskUnusedDesc, closedir(d));
+      REPORT(diskUnusedPath, UNITS_BYTES, unusedSize, diskUnusedDesc);
 
       // Report disk accesses.
       nsPrintfCString readsFile("/sys/block/%s/num_reads", name);
       nsPrintfCString writesFile("/sys/block/%s/num_writes", name);
 
       uint64_t reads = ReadSizeFromFile(readsFile.get());
       uint64_t writes = ReadSizeFromFile(writesFile.get());
 
       nsPrintfCString readsDesc(
         "The number of reads (failed or successful) done on "
         "\"%s\"", name);
       nsPrintfCString readsPath("zram-accesses/%s/reads", name);
-      REPORT_WITH_CLEANUP(readsPath, UNITS_COUNT_CUMULATIVE, reads,
-                          readsDesc, closedir(d));
+      REPORT(readsPath, UNITS_COUNT_CUMULATIVE, reads, readsDesc);
 
       nsPrintfCString writesDesc(
         "The number of writes (failed or successful) done "
         "on \"%s\"", name);
       nsPrintfCString writesPath("zram-accesses/%s/writes", name);
-      REPORT_WITH_CLEANUP(writesPath, UNITS_COUNT_CUMULATIVE, writes,
-                          writesDesc, closedir(d));
+      REPORT(writesPath, UNITS_COUNT_CUMULATIVE, writes, writesDesc);
 
       // Report compressed data size.
       nsPrintfCString comprSizeFile("/sys/block/%s/compr_data_size", name);
       uint64_t comprSize = ReadSizeFromFile(comprSizeFile.get());
 
       nsPrintfCString comprSizeDesc(
         "The compressed size of data stored in \"%s\"",
         name);
       nsPrintfCString comprSizePath("zram-compr-data-size/%s", name);
-      REPORT_WITH_CLEANUP(comprSizePath, UNITS_BYTES, comprSize,
-                          comprSizeDesc, closedir(d));
+      REPORT(comprSizePath, UNITS_BYTES, comprSize, comprSizeDesc);
     }
 
     closedir(d);
-    return NS_OK;
   }
 
-  nsresult
+  void
   CollectOpenFileReports(nsIHandleReportCallback* aHandleReport,
                          nsISupports* aData,
                          const nsACString& aProcPath,
                          const nsACString& aProcessName)
   {
     // All file descriptors opened by a process are listed under
     // /proc/<pid>/fd/<numerical_fd>. Each entry is a symlink that points to the
     // path that was opened. This can be an actual file, a socket, a pipe, an
@@ -887,20 +843,17 @@ private:
     const char kFilePrefix[] = "/";
     const char kSocketPrefix[] = "socket:";
     const char kPipePrefix[] = "pipe:";
     const char kAnonInodePrefix[] = "anon_inode:";
 
     const nsCString procPath(aProcPath);
     DIR* d = opendir(procPath.get());
     if (!d) {
-      if (NS_WARN_IF(errno != ENOENT && errno != EACCES)) {
-        return NS_ERROR_FAILURE;
-      }
-      return NS_OK;
+      return;
     }
 
     char linkPath[PATH_MAX + 1];
     struct dirent* ent;
     while ((ent = readdir(d))) {
       const char* fd = ent->d_name;
 
       // Skip "." and ".." (and any other dotfiles).
@@ -938,26 +891,24 @@ private:
 
 #undef CHECK_PREFIX
 
         const nsCString processName(aProcessName);
         nsPrintfCString entryPath("open-fds/%s/%s%s/%s",
                                   processName.get(), category, linkPath, fd);
         nsPrintfCString entryDescription("%s file descriptor opened by the process",
                                          descriptionPrefix);
-        REPORT_WITH_CLEANUP(entryPath, UNITS_COUNT, 1, entryDescription,
-                            closedir(d));
+        REPORT(entryPath, UNITS_COUNT, 1, entryDescription);
       }
     }
 
     closedir(d);
-    return NS_OK;
   }
 
-  nsresult
+  void
   CollectKgslReports(nsIHandleReportCallback* aHandleReport,
                      nsISupports* aData)
   {
     // Each process that uses kgsl memory will have an entry under
     // /sys/kernel/debug/kgsl/proc/<pid>/mem. This file format includes a
     // header and then entries with types as follows:
     //   gpuaddr useraddr size id  flags type usage sglen
     //   hexaddr hexaddr  int  int str   str  str   int
@@ -967,20 +918,17 @@ private:
     const char* const kScanFormat =
       "%" SCNx64 " %" SCNx64 " %" SCNu64 " %" SCNu64
       " %63s %63s %63s %" SCNu64;
     const int kNumFields = 8;
     const size_t kStringSize = 64;
 
     DIR* d = opendir("/sys/kernel/debug/kgsl/proc/");
     if (!d) {
-      if (NS_WARN_IF(errno != ENOENT && errno != EACCES)) {
-        return NS_ERROR_FAILURE;
-      }
-      return NS_OK;
+      return;
     }
 
     AutoDir dirGuard(d);
 
     struct dirent* ent;
     while ((ent = readdir(d))) {
       const char* pid = ent->d_name;
 
@@ -1017,26 +965,21 @@ private:
 
       // Bypass the header line.
       char buff[1024];
       Unused << fgets(buff, 1024, memFile);
 
       while (fscanf(memFile, kScanFormat, &gpuaddr, &useraddr, &size, &id,
                     flags, type, usage, &sglen) == kNumFields) {
         nsPrintfCString entryPath("kgsl-memory/%s/%s", procName.get(), usage);
-        REPORT(entryPath,
-               size,
+        REPORT(entryPath, UNITS_BYTES, size,
                NS_LITERAL_CSTRING("A kgsl graphics memory allocation."));
       }
     }
-
-    return NS_OK;
   }
-
-#undef REPORT
 };
 
 NS_IMPL_ISUPPORTS(SystemReporter, nsIMemoryReporter)
 
 void
 Init()
 {
   RegisterStrongMemoryReporter(new SystemReporter());
--- a/xpcom/base/nsCycleCollector.cpp
+++ b/xpcom/base/nsCycleCollector.cpp
@@ -3372,42 +3372,37 @@ NS_IMETHODIMP
 nsCycleCollector::CollectReports(nsIHandleReportCallback* aHandleReport,
                                  nsISupports* aData, bool aAnonymize)
 {
   size_t objectSize, graphSize, purpleBufferSize;
   SizeOfIncludingThis(CycleCollectorMallocSizeOf,
                       &objectSize, &graphSize,
                       &purpleBufferSize);
 
-#define REPORT(_path, _amount, _desc)                                     \
-    do {                                                                  \
-        size_t amount = _amount;  /* evaluate |_amount| only once */      \
-        if (amount > 0) {                                                 \
-            nsresult rv;                                                  \
-            rv = aHandleReport->Callback(EmptyCString(),                  \
-                                         NS_LITERAL_CSTRING(_path),       \
-                                         KIND_HEAP, UNITS_BYTES, _amount, \
-                                         NS_LITERAL_CSTRING(_desc),       \
-                                         aData);                          \
-            if (NS_WARN_IF(NS_FAILED(rv)))                                \
-                return rv;                                                \
-        }                                                                 \
-    } while (0)
-
-  REPORT("explicit/cycle-collector/collector-object", objectSize,
-         "Memory used for the cycle collector object itself.");
-
-  REPORT("explicit/cycle-collector/graph", graphSize,
-         "Memory used for the cycle collector's graph. "
-         "This should be zero when the collector is idle.");
-
-  REPORT("explicit/cycle-collector/purple-buffer", purpleBufferSize,
-         "Memory used for the cycle collector's purple buffer.");
-
-#undef REPORT
+  if (objectSize > 0) {
+    MOZ_COLLECT_REPORT(
+      "explicit/cycle-collector/collector-object", KIND_HEAP, UNITS_BYTES,
+      objectSize,
+      "Memory used for the cycle collector object itself.");
+  }
+
+  if (graphSize > 0) {
+    MOZ_COLLECT_REPORT(
+      "explicit/cycle-collector/graph", KIND_HEAP, UNITS_BYTES,
+      graphSize,
+      "Memory used for the cycle collector's graph. This should be zero when "
+      "the collector is idle.");
+  }
+
+  if (purpleBufferSize > 0) {
+    MOZ_COLLECT_REPORT(
+      "explicit/cycle-collector/purple-buffer", KIND_HEAP, UNITS_BYTES,
+      purpleBufferSize,
+      "Memory used for the cycle collector's purple buffer.");
+  }
 
   return NS_OK;
 };
 
 
 ////////////////////////////////////////////////////////////////////////
 // Collector implementation
 ////////////////////////////////////////////////////////////////////////
--- a/xpcom/base/nsIMemoryReporter.idl
+++ b/xpcom/base/nsIMemoryReporter.idl
@@ -206,17 +206,17 @@ interface nsIFinishReportingCallback : n
 };
 
 [scriptable, builtinclass, uuid(2998574d-8993-407a-b1a5-8ad7417653e1)]
 interface nsIMemoryReporterManager : nsISupports
 {
   /*
    * Initialize.
    */
-  void init();
+  [must_use] void init();
 
   /*
    * Register the given nsIMemoryReporter.  The Manager service will hold a
    * strong reference to the given reporter, and will be responsible for freeing
    * the reporter at shutdown.  You may manually unregister the reporter with
    * unregisterStrongReporter() at any point.
    */
   void registerStrongReporter(in nsIMemoryReporter reporter);
@@ -368,41 +368,41 @@ interface nsIMemoryReporterManager : nsI
    * of low-{virtual,physical}-memory events that have occurred since the
    * process started.
    *
    * |ghostWindows| (UNITS_COUNT)  The number of ghost windows.
    *
    * |pageFaultsHard| (UNITS_COUNT_CUMULATIVE)  The number of hard (a.k.a.
    * major) page faults that have occurred since the process started.
    */
-  readonly attribute int64_t vsize;
-  readonly attribute int64_t vsizeMaxContiguous;
-  readonly attribute int64_t resident;
-  readonly attribute int64_t residentFast;
-  readonly attribute int64_t residentPeak;
-  readonly attribute int64_t residentUnique;
+  [must_use] readonly attribute int64_t vsize;
+  [must_use] readonly attribute int64_t vsizeMaxContiguous;
+  [must_use] readonly attribute int64_t resident;
+  [must_use] readonly attribute int64_t residentFast;
+  [must_use] readonly attribute int64_t residentPeak;
+  [must_use] readonly attribute int64_t residentUnique;
 
-  readonly attribute int64_t heapAllocated;
-  readonly attribute int64_t heapOverheadFraction;
+  [must_use] readonly attribute int64_t heapAllocated;
+  [must_use] readonly attribute int64_t heapOverheadFraction;
 
-  readonly attribute int64_t JSMainRuntimeGCHeap;
-  readonly attribute int64_t JSMainRuntimeTemporaryPeak;
-  readonly attribute int64_t JSMainRuntimeCompartmentsSystem;
-  readonly attribute int64_t JSMainRuntimeCompartmentsUser;
+  [must_use] readonly attribute int64_t JSMainRuntimeGCHeap;
+  [must_use] readonly attribute int64_t JSMainRuntimeTemporaryPeak;
+  [must_use] readonly attribute int64_t JSMainRuntimeCompartmentsSystem;
+  [must_use] readonly attribute int64_t JSMainRuntimeCompartmentsUser;
 
-  readonly attribute int64_t imagesContentUsedUncompressed;
+  [must_use] readonly attribute int64_t imagesContentUsedUncompressed;
 
-  readonly attribute int64_t storageSQLite;
+  [must_use] readonly attribute int64_t storageSQLite;
 
-  readonly attribute int64_t lowMemoryEventsVirtual;
-  readonly attribute int64_t lowMemoryEventsPhysical;
+  [must_use] readonly attribute int64_t lowMemoryEventsVirtual;
+  [must_use] readonly attribute int64_t lowMemoryEventsPhysical;
 
-  readonly attribute int64_t ghostWindows;
+  [must_use] readonly attribute int64_t ghostWindows;
 
-  readonly attribute int64_t pageFaultsHard;
+  [must_use] readonly attribute int64_t pageFaultsHard;
 
   /*
    * This attribute indicates if moz_malloc_usable_size() works.
    */
   [infallible] readonly attribute boolean hasMozMallocUsableSize;
 
   /*
    * These attributes indicate DMD's status. "Enabled" means enabled at
@@ -411,28 +411,29 @@ interface nsIMemoryReporterManager : nsI
   [infallible] readonly attribute boolean isDMDEnabled;
   [infallible] readonly attribute boolean isDMDRunning;
 
   /*
    * Run a series of GC/CC's in an attempt to minimize the application's memory
    * usage.  When we're finished, we invoke the given runnable if it's not
    * null.
    */
-  void minimizeMemoryUsage(in nsIRunnable callback);
+  [must_use] void minimizeMemoryUsage(in nsIRunnable callback);
 
   /*
    * Measure the memory that is known to be owned by this tab, split up into
    * several broad categories.  Note that this will be an underestimate of the
    * true number, due to imperfect memory reporter coverage (corresponding to
    * about:memory's "heap-unclassified"), and due to some memory shared between
    * tabs not being counted.
    *
    * The time taken for the measurement (split into JS and non-JS parts) is
    * also returned.
    */
+  [must_use]
   void sizeOfTab(in mozIDOMWindowProxy window,
                  out int64_t jsObjectsSize, out int64_t jsStringsSize,
                  out int64_t jsOtherSize, out int64_t domSize,
                  out int64_t styleSize, out int64_t otherSize,
                  out int64_t totalSize,
                  out double jsMilliseconds, out double nonJSMilliseconds);
 };
 
@@ -497,25 +498,25 @@ DECL_REGISTER_DISTINGUISHED_AMOUNT(Infal
 
 DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, GhostWindows)
 
 #undef DECL_REGISTER_DISTINGUISHED_AMOUNT
 #undef DECL_UNREGISTER_DISTINGUISHED_AMOUNT
 
 // Likewise for per-tab measurement.
 
-typedef nsresult (*JSSizeOfTabFn)(JSObject* aObj,
-                                  size_t* aJsObjectsSize,
-                                  size_t* aJsStringSize,
-                                  size_t* aJsPrivateSize,
-                                  size_t* aJsOtherSize);
-typedef nsresult (*NonJSSizeOfTabFn)(nsPIDOMWindowOuter* aWindow,
-                                     size_t* aDomSize,
-                                     size_t* aStyleSize,
-                                     size_t* aOtherSize);
+typedef MOZ_MUST_USE nsresult (*JSSizeOfTabFn)(JSObject* aObj,
+                                               size_t* aJsObjectsSize,
+                                               size_t* aJsStringSize,
+                                               size_t* aJsPrivateSize,
+                                               size_t* aJsOtherSize);
+typedef MOZ_MUST_USE nsresult (*NonJSSizeOfTabFn)(nsPIDOMWindowOuter* aWindow,
+                                                  size_t* aDomSize,
+                                                  size_t* aStyleSize,
+                                                  size_t* aOtherSize);
 
 nsresult RegisterJSSizeOfTab(JSSizeOfTabFn aSizeOfTabFn);
 nsresult RegisterNonJSSizeOfTab(NonJSSizeOfTabFn aSizeOfTabFn);
 
 }
 
 #if defined(MOZ_DMD)
 #if !defined(MOZ_MEMORY)
@@ -564,15 +565,16 @@ nsresult RegisterNonJSSizeOfTab(NonJSSiz
   }
 #define MOZ_DEFINE_MALLOC_SIZE_OF_ON_FREE(fn)                                 \
   static size_t fn(const void* aPtr)                                          \
   {                                                                           \
       return moz_malloc_size_of(aPtr);                                        \
   }
 
 // This macro assumes the presence of appropriate |aHandleReport| and |aData|
-// variables.
+// variables. The (void) is there because we should always ignore the return
+// value of the callback, because callback failures aren't fatal.
 #define MOZ_COLLECT_REPORT(path, kind, units, amount, description)            \
-  aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(path),           \
-                          kind, units, amount,                                \
-                          NS_LITERAL_CSTRING(description), aData)
+  (void)aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(path),     \
+                                kind, units, amount,                          \
+                                NS_LITERAL_CSTRING(description), aData)
 
 %}
--- a/xpcom/base/nsMemoryReporterManager.cpp
+++ b/xpcom/base/nsMemoryReporterManager.cpp
@@ -959,23 +959,19 @@ public:
         if (entry->mKind.mIsStack) {
           path.AppendLiteral("+stack");
         }
       }
 
       // Append the segment count.
       path.AppendPrintf("(segments=%u)", entry->mCount);
 
-      nsresult rv;
-      rv = aHandleReport->Callback(
+      aHandleReport->Callback(
         EmptyCString(), path, KIND_OTHER, UNITS_BYTES, entry->mSize,
         NS_LITERAL_CSTRING("From MEMORY_BASIC_INFORMATION."), aData);
-      if (NS_WARN_IF(NS_FAILED(rv))) {
-        return rv;
-      }
     }
 
     return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(WindowsAddressSpaceReporter, nsIMemoryReporter)
 
 #endif  // XP_<PLATFORM>
@@ -987,22 +983,22 @@ class VsizeMaxContiguousReporter final :
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount;
-    nsresult rv = VsizeMaxContiguousDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-    return MOZ_COLLECT_REPORT(
-      "vsize-max-contiguous", KIND_OTHER, UNITS_BYTES, amount,
-      "Size of the maximum contiguous block of available virtual "
-      "memory.");
+    if (NS_SUCCEEDED(VsizeMaxContiguousDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "vsize-max-contiguous", KIND_OTHER, UNITS_BYTES, amount,
+        "Size of the maximum contiguous block of available virtual memory.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(VsizeMaxContiguousReporter, nsIMemoryReporter)
 #endif
 
 #ifdef HAVE_PRIVATE_REPORTER
 class PrivateReporter final : public nsIMemoryReporter
 {
@@ -1010,23 +1006,24 @@ class PrivateReporter final : public nsI
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount;
-    nsresult rv = PrivateDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-    return MOZ_COLLECT_REPORT(
-      "private", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(PrivateDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "private", KIND_OTHER, UNITS_BYTES, amount,
 "Memory that cannot be shared with other processes, including memory that is "
 "committed and marked MEM_PRIVATE, data that is not mapped, and executable "
 "pages that have been written to.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(PrivateReporter, nsIMemoryReporter)
 #endif
 
 #ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
 class VsizeReporter final : public nsIMemoryReporter
 {
@@ -1034,55 +1031,55 @@ class VsizeReporter final : public nsIMe
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount;
-    nsresult rv = VsizeDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "vsize", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(VsizeDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "vsize", KIND_OTHER, UNITS_BYTES, amount,
 "Memory mapped by the process, including code and data segments, the heap, "
 "thread stacks, memory explicitly mapped by the process via mmap and similar "
 "operations, and memory shared with other processes. This is the vsize figure "
 "as reported by 'top' and 'ps'.  This figure is of limited use on Mac, where "
 "processes share huge amounts of memory with one another.  But even on other "
 "operating systems, 'resident' is a much better measure of the memory "
 "resources used by the process.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(VsizeReporter, nsIMemoryReporter)
 
 class ResidentReporter final : public nsIMemoryReporter
 {
   ~ResidentReporter() {}
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount;
-    nsresult rv = ResidentDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "resident", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(ResidentDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "resident", KIND_OTHER, UNITS_BYTES, amount,
 "Memory mapped by the process that is present in physical memory, also known "
 "as the resident set size (RSS).  This is the best single figure to use when "
 "considering the memory resources used by the process, but it depends both on "
 "other processes being run and details of the OS kernel and so is best used "
 "for comparing the memory usage of a single process at different points in "
 "time.");
     }
+    return NS_OK;
+  }
 };
 NS_IMPL_ISUPPORTS(ResidentReporter, nsIMemoryReporter)
 
 #endif  // HAVE_VSIZE_AND_RESIDENT_REPORTERS
 
 #ifdef HAVE_RESIDENT_UNIQUE_REPORTER
 class ResidentUniqueReporter final : public nsIMemoryReporter
 {
@@ -1090,25 +1087,25 @@ class ResidentUniqueReporter final : pub
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount = 0;
-    nsresult rv = ResidentUniqueDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "resident-unique", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(ResidentUniqueDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "resident-unique", KIND_OTHER, UNITS_BYTES, amount,
 "Memory mapped by the process that is present in physical memory and not "
 "shared with any other processes.  This is also known as the process's unique "
 "set size (USS).  This is the amount of RAM we'd expect to be freed if we "
 "closed this process.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(ResidentUniqueReporter, nsIMemoryReporter)
 
 #endif // HAVE_RESIDENT_UNIQUE_REPORTER
 
 #ifdef HAVE_SYSTEM_HEAP_REPORTER
 
@@ -1118,25 +1115,25 @@ class SystemHeapReporter final : public 
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount;
-    nsresult rv = SystemHeapSize(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "system-heap-allocated", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(SystemHeapSize(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "system-heap-allocated", KIND_OTHER, UNITS_BYTES, amount,
 "Memory used by the system allocator that is currently allocated to the "
 "application. This is distinct from the jemalloc heap that Firefox uses for "
 "most or all of its heap allocations. Ideally this number is zero, but "
 "on some platforms we cannot force every heap allocation through jemalloc.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(SystemHeapReporter, nsIMemoryReporter)
 
 #endif // HAVE_SYSTEM_HEAP_REPORTER
 
 #ifdef XP_UNIX
 
@@ -1174,22 +1171,22 @@ class ResidentPeakReporter final : publi
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount = 0;
-    nsresult rv = ResidentPeakDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "resident-peak", KIND_OTHER, UNITS_BYTES, amount,
+    if (NS_SUCCEEDED(ResidentPeakDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "resident-peak", KIND_OTHER, UNITS_BYTES, amount,
 "The peak 'resident' value for the lifetime of the process.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(ResidentPeakReporter, nsIMemoryReporter)
 
 #define HAVE_PAGE_FAULT_REPORTERS 1
 
 class PageFaultsSoftReporter final : public nsIMemoryReporter
 {
@@ -1198,32 +1195,31 @@ class PageFaultsSoftReporter final : pub
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     struct rusage usage;
     int err = getrusage(RUSAGE_SELF, &usage);
-    if (err != 0) {
-      return NS_ERROR_FAILURE;
-    }
-    int64_t amount = usage.ru_minflt;
-
-    return MOZ_COLLECT_REPORT(
-      "page-faults-soft", KIND_OTHER, UNITS_COUNT_CUMULATIVE, amount,
+    if (err == 0) {
+      int64_t amount = usage.ru_minflt;
+      MOZ_COLLECT_REPORT(
+        "page-faults-soft", KIND_OTHER, UNITS_COUNT_CUMULATIVE, amount,
 "The number of soft page faults (also known as 'minor page faults') that "
 "have occurred since the process started.  A soft page fault occurs when the "
 "process tries to access a page which is present in physical memory but is "
 "not mapped into the process's address space.  For instance, a process might "
 "observe soft page faults when it loads a shared library which is already "
 "present in physical memory. A process may experience many thousands of soft "
 "page faults even when the machine has plenty of available physical memory, "
 "and because the OS services a soft page fault without accessing the disk, "
 "they impact performance much less than hard page faults.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(PageFaultsSoftReporter, nsIMemoryReporter)
 
 static MOZ_MUST_USE nsresult
 PageFaultsHardDistinguishedAmount(int64_t* aAmount)
 {
   struct rusage usage;
@@ -1241,31 +1237,31 @@ class PageFaultsHardReporter final : pub
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     int64_t amount = 0;
-    nsresult rv = PageFaultsHardDistinguishedAmount(&amount);
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    return MOZ_COLLECT_REPORT(
-      "page-faults-hard", KIND_OTHER, UNITS_COUNT_CUMULATIVE, amount,
+    if (NS_SUCCEEDED(PageFaultsHardDistinguishedAmount(&amount))) {
+      MOZ_COLLECT_REPORT(
+        "page-faults-hard", KIND_OTHER, UNITS_COUNT_CUMULATIVE, amount,
 "The number of hard page faults (also known as 'major page faults') that have "
 "occurred since the process started.  A hard page fault occurs when a process "
 "tries to access a page which is not present in physical memory. The "
 "operating system must access the disk in order to fulfill a hard page fault. "
 "When memory is plentiful, you should see very few hard page faults. But if "
 "the process tries to use more memory than your machine has available, you "
 "may see many thousands of hard page faults. Because accessing the disk is up "
 "to a million times slower than accessing RAM, the program may run very "
 "slowly when it is experiencing more than 100 or so hard page faults a "
 "second.");
+    }
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(PageFaultsHardReporter, nsIMemoryReporter)
 
 #endif  // XP_UNIX
 
 /**
  ** memory reporter implementation for jemalloc and OSX malloc,
@@ -1300,82 +1296,71 @@ public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     jemalloc_stats_t stats;
     jemalloc_stats(&stats);
 
-    nsresult rv;
-
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "heap-committed/allocated", KIND_OTHER, UNITS_BYTES, stats.allocated,
 "Memory mapped by the heap allocator that is currently allocated to the "
 "application.  This may exceed the amount of memory requested by the "
 "application because the allocator regularly rounds up request sizes. (The "
 "exact amount requested is not recorded.)");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "heap-allocated", KIND_OTHER, UNITS_BYTES, stats.allocated,
 "The same as 'heap-committed/allocated'.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     // We mark this and the other heap-overhead reporters as KIND_NONHEAP
     // because KIND_HEAP memory means "counted in heap-allocated", which
     // this is not.
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/heap-overhead/bin-unused", KIND_NONHEAP, UNITS_BYTES,
       stats.bin_unused,
 "Unused bytes due to fragmentation in the bins used for 'small' (<= 2 KiB) "
 "allocations. These bytes will be used if additional allocations occur.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     if (stats.waste > 0) {
-      rv = MOZ_COLLECT_REPORT(
+      MOZ_COLLECT_REPORT(
         "explicit/heap-overhead/waste", KIND_NONHEAP, UNITS_BYTES,
         stats.waste,
 "Committed bytes which do not correspond to an active allocation and which the "
 "allocator is not intentionally keeping alive (i.e., not "
 "'explicit/heap-overhead/{bookkeeping,page-cache,bin-unused}').");
-      NS_ENSURE_SUCCESS(rv, rv);
     }
 
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/heap-overhead/bookkeeping", KIND_NONHEAP, UNITS_BYTES,
       stats.bookkeeping,
 "Committed bytes which the heap allocator uses for internal data structures.");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "explicit/heap-overhead/page-cache", KIND_NONHEAP, UNITS_BYTES,
       stats.page_cache,
 "Memory which the allocator could return to the operating system, but hasn't. "
 "The allocator keeps this memory around as an optimization, so it doesn't "
 "have to ask the OS the next time it needs to fulfill a request. This value "
 "is typically not larger than a few megabytes.");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "heap-committed/overhead", KIND_OTHER, UNITS_BYTES,
       HeapOverhead(&stats),
 "The sum of 'explicit/heap-overhead/*'.");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "heap-mapped", KIND_OTHER, UNITS_BYTES, stats.mapped,
 "Amount of memory currently mapped. Includes memory that is uncommitted, i.e. "
 "neither in physical memory nor paged to disk.");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "heap-chunksize", KIND_OTHER, UNITS_BYTES, stats.chunksize,
       "Size of chunks.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(JemallocHeapReporter, nsIMemoryReporter)
 
 #endif  // HAVE_JEMALLOC_STATS
 
@@ -1394,26 +1379,23 @@ public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     size_t Main, Static;
     NS_SizeOfAtomTablesIncludingThis(MallocSizeOf, &Main, &Static);
 
-    nsresult rv;
-    rv = MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/atom-tables/main", KIND_HEAP, UNITS_BYTES, Main,
       "Memory used by the main atoms table.");
-    NS_ENSURE_SUCCESS(rv, rv);
-
-    rv = MOZ_COLLECT_REPORT(
+
+    MOZ_COLLECT_REPORT(
       "explicit/atom-tables/static", KIND_HEAP, UNITS_BYTES, Static,
       "Memory used by the static atoms table.");
-    NS_ENSURE_SUCCESS(rv, rv);
 
     return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(AtomTablesReporter, nsIMemoryReporter)
 
 #ifdef DEBUG
 
@@ -1428,20 +1410,22 @@ class DeadlockDetectorReporter final : p
   ~DeadlockDetectorReporter() {}
 
 public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/deadlock-detector", KIND_HEAP, UNITS_BYTES,
       BlockingResourceBase::SizeOfDeadlockDetector(MallocSizeOf),
       "Memory used by the deadlock detector.");
+
+    return NS_OK;
   }
 };
 NS_IMPL_ISUPPORTS(DeadlockDetectorReporter, nsIMemoryReporter)
 
 #endif
 
 #ifdef MOZ_DMD
 
@@ -1454,50 +1438,42 @@ public:
   NS_DECL_ISUPPORTS
 
   NS_IMETHOD CollectReports(nsIHandleReportCallback* aHandleReport,
                             nsISupports* aData, bool aAnonymize) override
   {
     dmd::Sizes sizes;
     dmd::SizeOf(&sizes);
 
-#define REPORT(_path, _amount, _desc)                                         \
-  do {                                                                        \
-    nsresult rv;                                                              \
-    rv = aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path),   \
-                                 KIND_HEAP, UNITS_BYTES, _amount,             \
-                                 NS_LITERAL_CSTRING(_desc), aData);           \
-    if (NS_WARN_IF(NS_FAILED(rv))) {                                          \
-      return 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",
-           sizes.mStackTracesUnused,
-           "Memory used by stack traces which don't correspond to any heap "
-           "blocks DMD is currently tracking.");
-
-    REPORT("explicit/dmd/stack-traces/table",
-           sizes.mStackTraceTable,
-           "Memory used by DMD's stack trace table.");
-
-    REPORT("explicit/dmd/live-block-table",
-           sizes.mLiveBlockTable,
-           "Memory used by DMD's live block table.");
-
-    REPORT("explicit/dmd/dead-block-list",
-           sizes.mDeadBlockTable,
-           "Memory used by DMD's dead block list.");
-
-#undef REPORT
+    MOZ_COLLECT_REPORT(
+      "explicit/dmd/stack-traces/used", KIND_HEAP, UNITS_BYTES,
+      sizes.mStackTracesUsed,
+      "Memory used by stack traces which correspond to at least "
+      "one heap block DMD is tracking.");
+
+    MOZ_COLLECT_REPORT(
+      "explicit/dmd/stack-traces/unused", KIND_HEAP, UNITS_BYTES,
+      sizes.mStackTracesUnused,
+      "Memory used by stack traces which don't correspond to any heap "
+      "blocks DMD is currently tracking.");
+
+    MOZ_COLLECT_REPORT(
+      "explicit/dmd/stack-traces/table", KIND_HEAP, UNITS_BYTES,
+      sizes.mStackTraceTable,
+      "Memory used by DMD's stack trace table.");
+
+    MOZ_COLLECT_REPORT(
+      "explicit/dmd/live-block-table", KIND_HEAP, UNITS_BYTES,
+      sizes.mLiveBlockTable,
+      "Memory used by DMD's live block table.");
+
+    MOZ_COLLECT_REPORT(
+      "explicit/dmd/dead-block-list", KIND_HEAP, UNITS_BYTES,
+      sizes.mDeadBlockTable,
+      "Memory used by DMD's dead block list.");
 
     return NS_OK;
   }
 
 private:
   ~DMDReporter() {}
 };
 NS_IMPL_ISUPPORTS(DMDReporter, nsIMemoryReporter)
@@ -1772,19 +1748,17 @@ nsMemoryReporterManager::DispatchReporte
   // Grab refs to everything used in the lambda function.
   RefPtr<nsMemoryReporterManager> self = this;
   nsCOMPtr<nsIMemoryReporter> reporter = aReporter;
   nsCOMPtr<nsIHandleReportCallback> handleReport = aHandleReport;
   nsCOMPtr<nsISupports> handleReportData = aHandleReportData;
 
   nsCOMPtr<nsIRunnable> event = NS_NewRunnableFunction(
     [self, reporter, aIsAsync, handleReport, handleReportData, aAnonymize] () {
-      reporter->CollectReports(handleReport,
-                               handleReportData,
-                               aAnonymize);
+      reporter->CollectReports(handleReport, handleReportData, aAnonymize);
       if (!aIsAsync) {
         self->EndReport();
       }
     });
 
   NS_DispatchToMainThread(event);
   mPendingReportersState->mReportsPending++;
 }
@@ -2598,17 +2572,20 @@ nsMemoryReporterManager::SizeOfTab(mozID
   if (NS_WARN_IF(NS_FAILED(rv))) {
     return rv;
   }
 
   TimeStamp t2 = TimeStamp::Now();
 
   // Measure non-JS memory consumption.
   size_t domSize, styleSize, otherSize;
-  mSizeOfTabFns.mNonJS(piWindow, &domSize, &styleSize, &otherSize);
+  rv = mSizeOfTabFns.mNonJS(piWindow, &domSize, &styleSize, &otherSize);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
 
   TimeStamp t3 = TimeStamp::Now();
 
   *aTotalSize = 0;
 #define DO(aN, n) { *aN = (n); *aTotalSize += (n); }
   DO(aJSObjectsSize, jsObjectsSize);
   DO(aJSStringsSize, jsStringsSize);
   DO(aJSOtherSize,   jsOtherSize);
--- a/xpcom/build/XPCOMInit.cpp
+++ b/xpcom/build/XPCOMInit.cpp
@@ -378,19 +378,21 @@ public:
     return CountingFree(aPtr);
   }
 
 private:
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/icu", KIND_HEAP, UNITS_BYTES, MemoryAllocated(),
       "Memory used by ICU, a Unicode and globalization support library.");
+
+    return NS_OK;
   }
 
   ~ICUReporter() {}
 };
 
 NS_IMPL_ISUPPORTS(ICUReporter, nsIMemoryReporter)
 
 /* static */ template<> Atomic<size_t>
@@ -403,19 +405,22 @@ class OggReporter final
 public:
   NS_DECL_ISUPPORTS
 
 private:
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/media/libogg", KIND_HEAP, UNITS_BYTES, MemoryAllocated(),
-      "Memory allocated through libogg for Ogg, Theora, and related media files.");
+      "Memory allocated through libogg for Ogg, Theora, and related media "
+      "files.");
+
+    return NS_OK;
   }
 
   ~OggReporter() {}
 };
 
 NS_IMPL_ISUPPORTS(OggReporter, nsIMemoryReporter)
 
 /* static */ template<> Atomic<size_t>
@@ -429,19 +434,21 @@ class VPXReporter final
 public:
   NS_DECL_ISUPPORTS
 
 private:
   NS_IMETHOD
   CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
                  bool aAnonymize) override
   {
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
       "explicit/media/libvpx", KIND_HEAP, UNITS_BYTES, MemoryAllocated(),
       "Memory allocated through libvpx for WebM media files.");
+
+    return NS_OK;
   }
 
   ~VPXReporter() {}
 };
 
 NS_IMPL_ISUPPORTS(VPXReporter, nsIMemoryReporter)
 
 /* static */ template<> Atomic<size_t>
--- a/xpcom/components/nsCategoryManager.cpp
+++ b/xpcom/components/nsCategoryManager.cpp
@@ -448,20 +448,22 @@ nsCategoryManager::get_category(const ch
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(CategoryManagerMallocSizeOf)
 
 NS_IMETHODIMP
 nsCategoryManager::CollectReports(nsIHandleReportCallback* aHandleReport,
                                   nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT("explicit/xpcom/category-manager",
-                            KIND_HEAP, UNITS_BYTES,
-                            SizeOfIncludingThis(CategoryManagerMallocSizeOf),
-                            "Memory used for the XPCOM category manager.");
+  MOZ_COLLECT_REPORT(
+    "explicit/xpcom/category-manager", KIND_HEAP, UNITS_BYTES,
+    SizeOfIncludingThis(CategoryManagerMallocSizeOf),
+    "Memory used for the XPCOM category manager.");
+
+  return NS_OK;
 }
 
 size_t
 nsCategoryManager::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
 {
   size_t n = aMallocSizeOf(this);
 
   n += PL_SizeOfArenaPoolExcludingPool(&mArena, aMallocSizeOf);
--- a/xpcom/components/nsComponentManager.cpp
+++ b/xpcom/components/nsComponentManager.cpp
@@ -1762,20 +1762,22 @@ nsComponentManagerImpl::ContractIDToCID(
 }
 
 MOZ_DEFINE_MALLOC_SIZE_OF(ComponentManagerMallocSizeOf)
 
 NS_IMETHODIMP
 nsComponentManagerImpl::CollectReports(nsIHandleReportCallback* aHandleReport,
                                        nsISupports* aData, bool aAnonymize)
 {
-  return MOZ_COLLECT_REPORT("explicit/xpcom/component-manager",
-                            KIND_HEAP, UNITS_BYTES,
-                            SizeOfIncludingThis(ComponentManagerMallocSizeOf),
-                            "Memory used for the XPCOM component manager.");
+  MOZ_COLLECT_REPORT(
+    "explicit/xpcom/component-manager", KIND_HEAP, UNITS_BYTES,
+    SizeOfIncludingThis(ComponentManagerMallocSizeOf),
+    "Memory used for the XPCOM component manager.");
+
+  return NS_OK;
 }
 
 size_t
 nsComponentManagerImpl::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf)
   const
 {
   size_t n = aMallocSizeOf(this);
 
--- a/xpcom/ds/nsObserverService.cpp
+++ b/xpcom/ds/nsObserverService.cpp
@@ -88,70 +88,46 @@ nsObserverService::CollectReports(nsIHan
     size_t topicTotal = topicNumStrong + topicNumWeakAlive + topicNumWeakDead;
     if (topicTotal > kSuspectReferentCount) {
       SuspectObserver suspect(observerList->GetKey(), topicTotal);
       suspectObservers.AppendElement(suspect);
     }
   }
 
   // These aren't privacy-sensitive and so don't need anonymizing.
-  nsresult rv;
   for (uint32_t i = 0; i < suspectObservers.Length(); i++) {
     SuspectObserver& suspect = suspectObservers[i];
     nsPrintfCString suspectPath("observer-service-suspect/referent(topic=%s)",
                                 suspect.mTopic);
-    rv = aHandleReport->Callback(
+    aHandleReport->Callback(
       /* process */ EmptyCString(),
       suspectPath, KIND_OTHER, UNITS_COUNT, suspect.mReferentCount,
       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."),
       aData);
-
-    if (NS_WARN_IF(NS_FAILED(rv))) {
-      return rv;
-    }
-  }
-
-  rv = aHandleReport->Callback(
-         /* process */ EmptyCString(),
-         NS_LITERAL_CSTRING("observer-service/referent/strong"),
-         KIND_OTHER, UNITS_COUNT, totalNumStrong,
-         NS_LITERAL_CSTRING("The number of strong references held by the "
-                            "observer service."),
-         aData);
-
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
   }
 
-  rv = aHandleReport->Callback(
-         /* process */ EmptyCString(),
-         NS_LITERAL_CSTRING("observer-service/referent/weak/alive"),
-         KIND_OTHER, UNITS_COUNT, totalNumWeakAlive,
-         NS_LITERAL_CSTRING("The number of weak references held by the "
-                            "observer service that are still alive."),
-         aData);
-
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
+  MOZ_COLLECT_REPORT(
+    "observer-service/referent/strong", KIND_OTHER, UNITS_COUNT,
+    totalNumStrong,
+    "The number of strong references held by the observer service.");
 
-  rv = aHandleReport->Callback(
-         /* process */ EmptyCString(),
-         NS_LITERAL_CSTRING("observer-service/referent/weak/dead"),
-         KIND_OTHER, UNITS_COUNT, totalNumWeakDead,
-         NS_LITERAL_CSTRING("The number of weak references held by the "
-                            "observer service that are dead."),
-         aData);
+  MOZ_COLLECT_REPORT(
+    "observer-service/referent/weak/alive", KIND_OTHER, UNITS_COUNT,
+    totalNumWeakAlive,
+    "The number of weak references held by the observer service that are "
+    "still alive.");
 
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
+  MOZ_COLLECT_REPORT(
+    "observer-service/referent/weak/dead", KIND_OTHER, UNITS_COUNT,
+    totalNumWeakDead,
+    "The number of weak references held by the observer service that are "
+    "dead.");
 
   return NS_OK;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // nsObserverService Implementation
 
 NS_IMPL_ISUPPORTS(nsObserverService,
--- a/xpcom/reflect/xptinfo/xptiInterfaceInfoManager.cpp
+++ b/xpcom/reflect/xptinfo/xptiInterfaceInfoManager.cpp
@@ -49,19 +49,21 @@ XPTInterfaceInfoManager::CollectReports(
 {
     size_t amount = SizeOfIncludingThis(XPTIMallocSizeOf);
 
     // Measure gXPTIStructArena here, too.  This is a bit grotty because it
     // doesn't belong to the XPTIInterfaceInfoManager, but there's no
     // obviously better place to measure it.
     amount += XPT_SizeOfArenaIncludingThis(gXPTIStructArena, XPTIMallocSizeOf);
 
-    return MOZ_COLLECT_REPORT(
+    MOZ_COLLECT_REPORT(
         "explicit/xpti-working-set", KIND_HEAP, UNITS_BYTES, amount,
         "Memory used by the XPCOM typelib system.");
+
+    return NS_OK;
 }
 
 // static
 XPTInterfaceInfoManager*
 XPTInterfaceInfoManager::GetSingleton()
 {
     if (!gInterfaceInfoManager) {
         gInterfaceInfoManager = new XPTInterfaceInfoManager();