--- a/devtools/client/performance/test/browser_perf-button-states.js
+++ b/devtools/client/performance/test/browser_perf-button-states.js
@@ -19,44 +19,44 @@ add_task(async function() {
   let { $, $$, EVENTS, PerformanceController, PerformanceView } = panel.panelWin;
 
   let recordButton = $("#main-record-button");
 
   checkRecordButtonsStates(false, false);
 
   let uiStartClick = once(PerformanceView, EVENTS.UI_START_RECORDING);
   let recordingStarted = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-started" }
+    expectedArgs: ["recording-started"]
   });
   let backendStartReady = once(PerformanceController,
                                EVENTS.BACKEND_READY_AFTER_RECORDING_START);
   let uiStateRecording = once(PerformanceView, EVENTS.UI_STATE_CHANGED, {
-    expectedArgs: { "1": "recording" }
+    expectedArgs: ["recording"]
   });
 
   click(recordButton);
   await uiStartClick;
 
   checkRecordButtonsStates(true, true);
 
   await recordingStarted;
 
   checkRecordButtonsStates(true, false);
 
   await backendStartReady;
   await uiStateRecording;
 
   let uiStopClick = once(PerformanceView, EVENTS.UI_STOP_RECORDING);
   let recordingStopped = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopped" }
+    expectedArgs: ["recording-stopped"]
   });
   let backendStopReady = once(PerformanceController,
                                EVENTS.BACKEND_READY_AFTER_RECORDING_STOP);
   let uiStateRecorded = once(PerformanceView, EVENTS.UI_STATE_CHANGED, {
-    expectedArgs: { "1": "recorded" }
+    expectedArgs: ["recorded"]
   });
 
   click(recordButton);
   await uiStopClick;
   await recordingStopped;
 
   checkRecordButtonsStates(false, false);
 

--- a/devtools/client/performance/test/browser_perf-console-record-02.js
+++ b/devtools/client/performance/test/browser_perf-console-record-02.js
@@ -41,17 +41,17 @@ add_task(async function() {
   const selected = getSelectedRecording(panel);
   is(selected, recordings[0],
     "The first console recording should be selected.");
   is(selected.getLabel(), "rust",
     "The profile label for the first recording is correct.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   let stopped = waitForRecordingStoppedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true
   });
   await console.profileEnd("rust");
   await stopped;

--- a/devtools/client/performance/test/browser_perf-console-record-04.js
+++ b/devtools/client/performance/test/browser_perf-console-record-04.js
@@ -39,17 +39,17 @@ add_task(async function() {
   const selected = getSelectedRecording(panel);
   is(selected, recordings[0],
     "The profile from console should be selected as it's the only one.");
   is(selected.getLabel(), "rust",
     "The profile label for the first recording is correct.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   let stopped = waitForRecordingStoppedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true
   });
   await console.profileEnd("rust");
   await stopped;

--- a/devtools/client/performance/test/browser_perf-console-record-05.js
+++ b/devtools/client/performance/test/browser_perf-console-record-05.js
@@ -39,17 +39,17 @@ add_task(async function() {
   let selected = getSelectedRecording(panel);
   is(selected, recordings[0],
     "The profile from console should be selected as it's the only one.");
   is(selected.getLabel(), "rust",
     "The profile label for the first recording is correct.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   let stopped = waitForRecordingStoppedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true
   });
   await console.profileEnd("rust");
   await stopped;

--- a/devtools/client/performance/test/browser_perf-console-record-06.js
+++ b/devtools/client/performance/test/browser_perf-console-record-06.js
@@ -31,17 +31,17 @@ add_task(async function() {
 
   let recordings = PerformanceController.getRecordings();
   is(recordings.length, 1, "A recording found in the performance panel.");
   is(getSelectedRecording(panel), recordings[0],
     "The first console recording should be selected.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   started = waitForRecordingStartedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true,
     // only emitted when an in-progress recording is selected
     skipWaitingForOverview: true,
     // the view state won't switch to "console-recording" unless the new
@@ -53,17 +53,17 @@ add_task(async function() {
 
   recordings = PerformanceController.getRecordings();
   is(recordings.length, 2, "Two recordings found in the performance panel.");
   is(getSelectedRecording(panel), recordings[0],
     "The first console recording should still be selected.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   let stopped = waitForRecordingStoppedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true
   });
   await console.profileEnd("rust");
   await stopped;

--- a/devtools/client/performance/test/browser_perf-console-record-08.js
+++ b/devtools/client/performance/test/browser_perf-console-record-08.js
@@ -161,17 +161,17 @@ add_task(async function() {
     CONSOLE + RECORDING,
     CONSOLE
   ]);
   ok(OverviewView.isRendering(),
     "Should be rendering overview a recording in progress is selected.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   info("Ending console.profileEnd()...");
   stopped = waitForRecordingStoppedEvents(panel, {
     // only emitted for manual recordings
     skipWaitingForBackendReady: true,
     // only emitted when a finished recording is selected
     skipWaitingForOverview: true,
@@ -188,34 +188,34 @@ add_task(async function() {
     CONSOLE,
     CONSOLE
   ]);
   ok(OverviewView.isRendering(),
     "Should be rendering overview a recording in progress is selected.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   info("Recording 5 - Start one more manual recording.");
   await startRecording(panel);
   testRecordings(PerformanceController, [
     CONSOLE + RECORDING,
     MANUAL,
     CONSOLE,
     CONSOLE,
     MANUAL + RECORDING + SELECTED
   ]);
   ok(OverviewView.isRendering(),
     "Should be rendering overview a recording in progress is selected.");
 
   // Ensure overview is still rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   info("Recording 5 - Stop manual recording.");
   await stopRecording(panel);
   testRecordings(PerformanceController, [
     CONSOLE + RECORDING,
     MANUAL,
     CONSOLE,

--- a/devtools/client/performance/test/browser_perf-details-01-toggle.js
+++ b/devtools/client/performance/test/browser_perf-details-01-toggle.js
@@ -25,31 +25,31 @@ add_task(async function() {
 
   info("Checking views on startup.");
   checkViews(DetailsView, $, "waterfall");
 
   // Select calltree view.
   let viewChanged = once(DetailsView, EVENTS.UI_DETAILS_VIEW_SELECTED,
                          { spreadArgs: true });
   command($("toolbarbutton[data-view='js-calltree']"));
-  let [, viewName] = await viewChanged;
+  let [viewName] = await viewChanged;
   is(viewName, "js-calltree", "UI_DETAILS_VIEW_SELECTED fired with view name");
   checkViews(DetailsView, $, "js-calltree");
 
   // Select js flamegraph view.
   viewChanged = once(DetailsView, EVENTS.UI_DETAILS_VIEW_SELECTED, { spreadArgs: true });
   command($("toolbarbutton[data-view='js-flamegraph']"));
-  [, viewName] = await viewChanged;
+  [viewName] = await viewChanged;
   is(viewName, "js-flamegraph", "UI_DETAILS_VIEW_SELECTED fired with view name");
   checkViews(DetailsView, $, "js-flamegraph");
 
   // Select waterfall view.
   viewChanged = once(DetailsView, EVENTS.UI_DETAILS_VIEW_SELECTED, { spreadArgs: true });
   command($("toolbarbutton[data-view='waterfall']"));
-  [, viewName] = await viewChanged;
+  [viewName] = await viewChanged;
   is(viewName, "waterfall", "UI_DETAILS_VIEW_SELECTED fired with view name");
   checkViews(DetailsView, $, "waterfall");
 
   await teardownToolboxAndRemoveTab(panel);
 });
 
 function checkViews(DetailsView, $, currentView) {
   for (let viewName in DetailsView.components) {

--- a/devtools/client/performance/test/browser_perf-details-05-preserve-view.js
+++ b/devtools/client/performance/test/browser_perf-details-05-preserve-view.js
@@ -27,18 +27,19 @@ add_task(async function() {
   let rendered = once(JsCallTreeView, EVENTS.UI_JS_CALL_TREE_RENDERED);
   await DetailsView.selectView("js-calltree");
   await selected;
   await rendered;
 
   ok(DetailsView.isViewSelected(JsCallTreeView),
     "The js calltree view is now selected in the details view.");
 
-  let cleared = once(PerformanceController, EVENTS.RECORDING_SELECTED,
-                     { expectedArgs: { "1": null } });
+  let cleared = once(PerformanceController, EVENTS.RECORDING_SELECTED, {
+    expectedArgs: [null]
+  });
   await PerformanceController.clearRecordings();
   await cleared;
 
   await startRecording(panel);
   await stopRecording(panel, {
     expectedViewClass: "JsCallTreeView",
     expectedViewEvent: "UI_JS_CALL_TREE_RENDERED"
   });

--- a/devtools/client/performance/test/browser_perf-loading-01.js
+++ b/devtools/client/performance/test/browser_perf-loading-01.js
@@ -23,20 +23,20 @@ add_task(async function() {
 
   await startRecording(panel);
 
   is(getDurationLabelText(panel, 0),
     L10N.getStr("recordingsList.recordingLabel"),
     "The duration node should show the 'recording' message while recording");
 
   let recordingStopping = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopping" }
+    expectedArgs: ["recording-stopping"]
   });
   let recordingStopped = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopped" }
+    expectedArgs: ["recording-stopped"]
   });
   let everythingStopped = stopRecording(panel);
 
   await recordingStopping;
   is(getDurationLabelText(panel, 0),
     L10N.getStr("recordingsList.loadingLabel"),
     "The duration node should show the 'loading' message while stopping");
 

--- a/devtools/client/performance/test/browser_perf-loading-02.js
+++ b/devtools/client/performance/test/browser_perf-loading-02.js
@@ -28,20 +28,20 @@ add_task(async function() {
   let detailsPane = $("#details-pane");
 
   await startRecording(panel);
 
   is(detailsContainer.selectedPanel, recordingNotice,
     "The recording-notice is shown while recording.");
 
   let recordingStopping = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopping" }
+    expectedArgs: ["recording-stopping"]
   });
   let recordingStopped = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopped" }
+    expectedArgs: ["recording-stopped"]
   });
   let everythingStopped = stopRecording(panel);
 
   await recordingStopping;
   is(detailsContainer.selectedPanel, loadingNotice,
     "The loading-notice is shown while the record is stopping.");
 
   await recordingStopped;
@@ -52,20 +52,20 @@ add_task(async function() {
   await startRecording(panel);
 
   info("While the 2nd record is still going, switch to the first one.");
   let recordingSelected = once(PerformanceController, EVENTS.RECORDING_SELECTED);
   setSelectedRecording(panel, 0);
   await recordingSelected;
 
   recordingStopping = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopping" }
+    expectedArgs: ["recording-stopping"]
   });
   recordingStopped = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopped" }
+    expectedArgs: ["recording-stopped"]
   });
   everythingStopped = stopRecording(panel);
 
   await recordingStopping;
   is(detailsContainer.selectedPanel, detailsPane,
     "The details panel is still shown while the 2nd record is being stopped.");
   is(getSelectedRecordingIndex(panel), 0,
     "The first record is still selected.");

--- a/devtools/client/performance/test/browser_perf-overview-render-01.js
+++ b/devtools/client/performance/test/browser_perf-overview-render-01.js
@@ -19,16 +19,16 @@ add_task(async function() {
   });
 
   let { EVENTS, OverviewView } = panel.panelWin;
 
   await startRecording(panel);
 
   // Ensure overview keeps rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   ok(true, "Overview was rendered while recording.");
 
   await stopRecording(panel);
   await teardownToolboxAndRemoveTab(panel);
 });

--- a/devtools/client/performance/test/browser_perf-overview-render-02.js
+++ b/devtools/client/performance/test/browser_perf-overview-render-02.js
@@ -49,17 +49,17 @@ add_task(async function() {
     "The selection should not be enabled for the memory overview (1).");
   is(memory.selectionEnabled, false,
     "The selection should not be enabled for the memory overview (2).");
   is(memory.hasSelection(), false,
     "The memory overview shouldn't have a selection before recording.");
 
   // Ensure overview keeps rendering.
   await times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, 3, {
-    expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+    expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
   });
 
   ok("selectionEnabled" in framerate,
     "The selection should still not be enabled for the framerate overview (1).");
   is(framerate.selectionEnabled, false,
     "The selection should still not be enabled for the framerate overview (2).");
   is(framerate.hasSelection(), false,
     "The framerate overview still shouldn't have a selection before recording.");

--- a/devtools/client/performance/test/browser_perf-overview-selection-01.js
+++ b/devtools/client/performance/test/browser_perf-overview-selection-01.js
@@ -26,23 +26,23 @@ add_task(async function() {
   let duration = PerformanceController.getCurrentRecording().getDuration();
   let graph = OverviewView.graphs.get("timeline");
 
   // Select the first half of the graph.
 
   let rangeSelected = once(OverviewView, EVENTS.UI_OVERVIEW_RANGE_SELECTED,
                            { spreadArgs: true });
   dragStartCanvasGraph(graph, { x: 0 });
-  let [, { startTime, endTime }] = await rangeSelected;
+  let [{ startTime, endTime }] = await rangeSelected;
   is(endTime, duration, "The selected range is the entire graph, for now.");
 
   rangeSelected = once(OverviewView, EVENTS.UI_OVERVIEW_RANGE_SELECTED,
                        { spreadArgs: true });
   dragStopCanvasGraph(graph, { x: graph.width / 2 });
-  [, { startTime, endTime }] = await rangeSelected;
+  [{ startTime, endTime }] = await rangeSelected;
   is(endTime, duration / 2, "The selected range is half of the graph.");
 
   is(graph.hasSelection(), true,
     "A selection exists on the graph.");
   is(startTime, 0,
     "The UI_OVERVIEW_RANGE_SELECTED event fired with 0 as a `startTime`.");
   is(endTime, duration / 2,
     `The UI_OVERVIEW_RANGE_SELECTED event fired with ${duration / 2} as \`endTime\`.`);
@@ -53,17 +53,17 @@ add_task(async function() {
   is(actual.min, 0, "Graph selection starts at 0.");
   is(actual.max, duration / 2, `Graph selection ends at ${duration / 2}.`);
 
   // Listen to deselection.
 
   rangeSelected = once(OverviewView, EVENTS.UI_OVERVIEW_RANGE_SELECTED,
                        { spreadArgs: true });
   clickCanvasGraph(graph, { x: 3 * graph.width / 4 });
-  [, { startTime, endTime }] = await rangeSelected;
+  [{ startTime, endTime }] = await rangeSelected;
 
   is(graph.hasSelection(), false,
     "A selection no longer on the graph.");
   is(startTime, 0,
     "The UI_OVERVIEW_RANGE_SELECTED event fired with 0 as a `startTime`.");
   is(endTime, duration,
     "The UI_OVERVIEW_RANGE_SELECTED event fired with duration as `endTime`.");
 

--- a/devtools/client/performance/test/browser_perf-recording-notices-03.js
+++ b/devtools/client/performance/test/browser_perf-recording-notices-03.js
@@ -47,18 +47,17 @@ add_task(async function() {
   let CONSOLE_BUFFER_STATUS_MESSAGE =
     $("#console-recording-notice .buffer-status-message");
   let gPercent;
 
   // Start a manual recording.
   await startRecording(panel);
 
   await waitUntil(async function() {
-    [, gPercent] = await once(PerformanceView,
-                              EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
+    [gPercent] = await once(PerformanceView, EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
                               { spreadArgs: true });
     return gPercent > 0;
   });
 
   ok(true, "Buffer percentage increased in display (1).");
 
   let bufferUsage = PerformanceController.getBufferUsageForRecording(
     PerformanceController.getCurrentRecording());
@@ -66,18 +65,17 @@ add_task(async function() {
     "Container has [buffer-status=in-progress] or [buffer-status=full].");
   ok(NORMAL_BUFFER_STATUS_MESSAGE.value.includes(gPercent + "%"),
     "Buffer status text has correct percentage.");
 
   // Start a console profile.
   await console.profile("rust");
 
   await waitUntil(async function() {
-    [, gPercent] = await once(PerformanceView,
-                              EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
+    [gPercent] = await once(PerformanceView, EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
                               { spreadArgs: true });
     return gPercent > Math.floor(bufferUsage * 100);
   });
 
   ok(true, "Buffer percentage increased in display (2).");
 
   bufferUsage = PerformanceController.getBufferUsageForRecording(
     PerformanceController.getCurrentRecording());
@@ -87,18 +85,17 @@ add_task(async function() {
     "Buffer status text has correct percentage.");
 
   // Select the console recording.
   let selected = once(PerformanceController, EVENTS.RECORDING_SELECTED);
   setSelectedRecording(panel, 1);
   await selected;
 
   await waitUntil(async function() {
-    [, gPercent] = await once(PerformanceView,
-                              EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
+    [gPercent] = await once(PerformanceView, EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
                               { spreadArgs: true });
     return gPercent > 0;
   });
 
   ok(true, "Percentage updated for newly selected recording.");
 
   either(DETAILS_CONTAINER.getAttribute("buffer-status"), "in-progress", "full",
     "Container has [buffer-status=in-progress] or [buffer-status=full].");
@@ -108,17 +105,17 @@ add_task(async function() {
   // Stop the console profile, then select the original manual recording.
   await console.profileEnd("rust");
 
   selected = once(PerformanceController, EVENTS.RECORDING_SELECTED);
   setSelectedRecording(panel, 0);
   await selected;
 
   await waitUntil(async function() {
-    [, gPercent] = await once(PerformanceView,
+    [gPercent] = await once(PerformanceView,
                               EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
                               { spreadArgs: true });
     return gPercent > Math.floor(bufferUsage * 100);
   });
 
   ok(true, "Buffer percentage increased in display (3).");
 
   either(DETAILS_CONTAINER.getAttribute("buffer-status"), "in-progress", "full",

--- a/devtools/client/performance/test/browser_perf-recording-notices-04.js
+++ b/devtools/client/performance/test/browser_perf-recording-notices-04.js
@@ -36,18 +36,17 @@ add_task(async function() {
   let DETAILS_CONTAINER = $("#details-pane-container");
   let NORMAL_BUFFER_STATUS_MESSAGE = $("#recording-notice .buffer-status-message");
   let gPercent;
 
   // Start a manual recording.
   await startRecording(panel);
 
   await waitUntil(async function() {
-    [, gPercent] = await once(PerformanceView,
-                              EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
+    [gPercent] = await once(PerformanceView, EVENTS.UI_RECORDING_PROFILER_STATUS_RENDERED,
                               { spreadArgs: true });
     return gPercent == 100;
   });
 
   ok(true, "Buffer percentage increased in display.");
 
   let bufferUsage = PerformanceController.getBufferUsageForRecording(
     PerformanceController.getCurrentRecording());

--- a/devtools/client/performance/test/browser_perf-recordings-clear-02.js
+++ b/devtools/client/performance/test/browser_perf-recordings-clear-02.js
@@ -38,17 +38,17 @@ add_task(async function() {
     "The recordings list should have two recordings.");
   isnot(PerformanceView.getState(), "empty",
     "PerformanceView should not be in an empty state.");
   isnot(PerformanceController.getCurrentRecording(), null,
     "There should be a current recording.");
 
   let recordingDeleted = times(PerformanceController, EVENTS.RECORDING_DELETED, 2);
   let recordingStopped = once(PerformanceController, EVENTS.RECORDING_STATE_CHANGE, {
-    expectedArgs: { "1": "recording-stopped" }
+    expectedArgs: ["recording-stopped"]
   });
 
   PerformanceController.clearRecordings();
 
   await recordingDeleted;
   await recordingStopped;
 
   is(getRecordingsCount(panel), 0,

--- a/devtools/client/performance/test/browser_perf-telemetry-02.js
+++ b/devtools/client/performance/test/browser_perf-telemetry-02.js
@@ -27,22 +27,22 @@ add_task(async function() {
 
   await startRecording(panel);
   await stopRecording(panel);
 
   let file = FileUtils.getFile("TmpD", ["tmpprofile.json"]);
   file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, parseInt("666", 8));
 
   let exported = once(PerformanceController, EVENTS.RECORDING_EXPORTED);
-  await PerformanceController.exportRecording("",
-    PerformanceController.getCurrentRecording(), file);
+  await PerformanceController.exportRecording(PerformanceController.getCurrentRecording(),
+    file);
   await exported;
 
   ok(logs[EXPORTED], `A telemetry entry for ${EXPORTED} exists after exporting.`);
 
   let imported = once(PerformanceController, EVENTS.RECORDING_IMPORTED);
-  await PerformanceController.importRecording(null, file);
+  await PerformanceController.importRecording(file);
   await imported;
 
   ok(logs[IMPORTED], `A telemetry entry for ${IMPORTED} exists after importing.`);
 
   await teardownToolboxAndRemoveTab(panel);
 });

--- a/devtools/client/performance/test/helpers/actions.js
+++ b/devtools/client/performance/test/helpers/actions.js
@@ -45,27 +45,27 @@ exports.waitForRecordingStartedEvents = 
 
   return Promise.all([
     options.skipWaitingForBackendReady
       ? null
       : once(controller, EVENTS.BACKEND_READY_AFTER_RECORDING_START),
     options.skipWaitingForRecordingStarted
       ? null
       : once(controller, EVENTS.RECORDING_STATE_CHANGE, {
-        expectedArgs: { "1": "recording-started" }
+        expectedArgs: ["recording-started"]
       }),
     options.skipWaitingForViewState
       ? null
       : once(view, EVENTS.UI_STATE_CHANGED, {
-        expectedArgs: { "1": options.expectedViewState }
+        expectedArgs: [options.expectedViewState]
       }),
     options.skipWaitingForOverview
       ? null
       : once(overview, EVENTS.UI_OVERVIEW_RENDERED, {
-        expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+        expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
       }),
   ]);
 };
 
 /**
  * Waits for all the necessary events to be emitted after a recording finishes.
  */
 exports.waitForRecordingStoppedEvents = function(panel, options = {}) {
@@ -81,32 +81,32 @@ exports.waitForRecordingStoppedEvents = 
 
   return Promise.all([
     options.skipWaitingForBackendReady
       ? null
       : once(controller, EVENTS.BACKEND_READY_AFTER_RECORDING_STOP),
     options.skipWaitingForRecordingStop
       ? null
       : once(controller, EVENTS.RECORDING_STATE_CHANGE, {
-        expectedArgs: { "1": "recording-stopping" }
+        expectedArgs: ["recording-stopping"]
       }),
     options.skipWaitingForRecordingStop
       ? null
       : once(controller, EVENTS.RECORDING_STATE_CHANGE, {
-        expectedArgs: { "1": "recording-stopped" }
+        expectedArgs: ["recording-stopped"]
       }),
     options.skipWaitingForViewState
       ? null
       : once(view, EVENTS.UI_STATE_CHANGED, {
-        expectedArgs: { "1": options.expectedViewState }
+        expectedArgs: [options.expectedViewState]
       }),
     options.skipWaitingForOverview
       ? null
       : once(overview, EVENTS.UI_OVERVIEW_RENDERED, {
-        expectedArgs: { "1": Constants.FRAMERATE_GRAPH_HIGH_RES_INTERVAL }
+        expectedArgs: [Constants.FRAMERATE_GRAPH_HIGH_RES_INTERVAL]
       }),
     options.skipWaitingForSubview
       ? null
       : once(subview, EVENTS[options.expectedViewEvent]),
   ]);
 };
 
 /**
@@ -133,17 +133,17 @@ exports.waitForAllWidgetsRendered = (pan
  * Waits for rendering to happen on the performance tool's overview graph,
  * making sure some markers were also rendered.
  */
 exports.waitForOverviewRenderedWithMarkers = (panel, minTimes = 3, minMarkers = 1) => {
   let { EVENTS, OverviewView, PerformanceController } = panel.panelWin;
 
   return Promise.all([
     times(OverviewView, EVENTS.UI_OVERVIEW_RENDERED, minTimes, {
-      expectedArgs: { "1": Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL }
+      expectedArgs: [Constants.FRAMERATE_GRAPH_LOW_RES_INTERVAL]
     }),
     waitUntil(() =>
       PerformanceController.getCurrentRecording().getMarkers().length >= minMarkers
     ),
   ]);
 };
 
 /**

--- a/devtools/client/performance/test/helpers/event-utils.js
+++ b/devtools/client/performance/test/helpers/event-utils.js
@@ -44,27 +44,24 @@ exports.times = function(target, eventNa
       reject(new Error("Target is not a supported event listener."));
       return;
     }
 
     let [add, remove] = API;
 
     target[add](eventName, function onEvent(...args) {
       if ("expectedArgs" in options) {
-        for (let index of Object.keys(options.expectedArgs)) {
+        for (let [index, expectedValue] of options.expectedArgs.entries()) {
+          const isExpectedValueRegExp = expectedValue instanceof RegExp;
           if (
-            // Expected argument matches this regexp.
-            (options.expectedArgs[index] instanceof RegExp &&
-             !options.expectedArgs[index].exec(args[index])) ||
-            // Expected argument is not a regexp and equal to the received arg.
-            (!(options.expectedArgs[index] instanceof RegExp) &&
-             options.expectedArgs[index] != args[index])
+            (isExpectedValueRegExp && !expectedValue.exec(args[index])) ||
+            (!isExpectedValueRegExp && expectedValue != args[index])
           ) {
             dump(`Ignoring event '${eventName}' with unexpected argument at index ` +
-                 `${index}: ${args[index]}\n`);
+                 `${index}: ${args[index]} - expected ${expectedValue}\n`);
             return;
           }
         }
       }
       if (--receiveCount > 0) {
         dump(`Event: '${eventName}' on ${target} needs to be fired ${receiveCount} ` +
              `more time(s).\n`);
       } else if (!receiveCount) {