Bug 1539502 - [devtools] Warn when late allocations happen when recording memory leaking. r=jdescottes

Differential Revision: https://phabricator.services.mozilla.com/D127778

Author: ochameau

devtools/client/framework/test/allocations/browser_allocations_browser_console.js

@@ -33,6 +33,11 @@ async function testScript() {
 
   // Close
   await BrowserConsoleManager.toggleBrowserConsole();
+
+  // Browser console still cleanup stuff after the resolution of toggleBrowserConsole.
+  // So wait for a little while to ensure it completes all cleanups.
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 500));
 }
 
 add_task(async function() {

devtools/client/framework/test/allocations/browser_allocations_target.js

@@ -22,6 +22,10 @@ async function testScript(tab) {
 
   // destroy the commands to also destroy the dedicated client.
   await commands.destroy();
+
+  // Spin the event loop to ensure commands destruction is fully completed
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 0));
 }
 
 add_task(async function() {

devtools/client/framework/test/allocations/browser_allocations_toolbox.js

@@ -20,6 +20,10 @@ async function testScript(tab) {
   await new Promise(resolve => setTimeout(resolve, 1000));
 
   await toolbox.destroy();
+
+  // Spin the event loop to ensure toolbox destroy is fully completed
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  await new Promise(resolve => setTimeout(resolve, 0));
 }
 
 add_task(async function() {

devtools/shared/test-helpers/allocation-tracker.js

@@ -186,9 +186,31 @@ exports.allocationTracker = function({
         this.flushAllocations();
       }
 
+      // In the content process we watch for all globals.
+      // Disable allocation record immediately, as we get some allocation reported by the allocation-tracker itself.
+      if (watchAllGlobals) {
+        dbg.memory.allocationSamplingProbability = 0.0;
+      }
+
       // Before computing allocations, re-do some GCs in order to free all what is to-be-freed.
       await this.doGC();
 
+      // If we are in the parent process, we watch only for devtools globals.
+      // So we can more safely assert that no allocation occured while doing the GCs.
+      // If means that the test we are recording is having pending operation which aren't properly recorded.
+      if (!watchAllGlobals) {
+        const allocations = dbg.memory.drainAllocationsLog();
+        if (allocations.length > 0) {
+          this.logAllocationLog(
+            allocations,
+            "Allocation that happened during the GC"
+          );
+          console.error(
+            "Allocation happened during the GC. Are you waiting correctly before calling stopRecordingAllocations?"
+          );
+        }
+      }
+
       const memory = this.getAllocatedMemory();
       const objects = this.stillAllocatedObjects();
 
@@ -379,11 +401,15 @@ exports.allocationTracker = function({
      * Reported allocations may have been freed.
      * Use `logAllocationSitesDiff` to know what hasn't been freed.
      */
-    logAllocationLog() {
-      const allocations = dbg.memory.drainAllocationsLog();
+    logAllocationLog(allocations, msg = "") {
+      if (!allocations) {
+        allocations = dbg.memory.drainAllocationsLog();
+      }
       const sources = this.allocationsToSources(allocations);
       return this.logAllocationSites(
-        "all allocations (which may be freed or are still allocated)",
+        msg
+          ? msg
+          : "all allocations (which may be freed or are still allocated)",
         sources
       );
     },