DevTools: Promisify timeline invocation calls in PerformanceTestRunner

Bug: 
Change-Id: I55707cbd5cfd5100b72ad6f4c2cd8195ba927b8d
Reviewed-on: https://chromium-review.googlesource.com/809497
Commit-Queue: Alexei Filippov <alph@chromium.org>
Reviewed-by: Andrey Kosyakov <caseq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#522239}

third_party/WebKit/LayoutTests/http/tests/devtools/elements/styles-4/styles-should-not-force-sync-style-recalc.js

@@ -34,13 +34,11 @@
   `);
 
   UI.context.setFlavor(Timeline.TimelinePanel, UI.panels.timeline);
-  PerformanceTestRunner.evaluateWithTimeline('performActions()', callback);
+  await PerformanceTestRunner.evaluateWithTimeline('performActions()');
 
-  function callback() {
-    PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
-      if (event.name === TimelineModel.TimelineModel.RecordType.UpdateLayoutTree)
-        TestRunner.addResult(event.name);
-    });
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
+    if (event.name === TimelineModel.TimelineModel.RecordType.UpdateLayoutTree)
+      TestRunner.addResult(event.name);
+  });
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/extensions/extensions-timeline-api.html

@@ -15,7 +15,7 @@ InspectorTest.enableTimelineExtensionAndStart = function(callback) {
     setting.set(true);
     TestRunner.addResult(`Provider short display name: ${provider.shortDisplayName()}`);
     TestRunner.addResult(`Provider long display name: ${provider.longDisplayName()}`);
-    PerformanceTestRunner.startTimeline(callback);
+    PerformanceTestRunner.startTimeline().then(callback);
 }
 
 }
@@ -73,7 +73,7 @@ function extension_startTimeline(callback)
 
 function extension_stopTimeline(callback)
 {
-    evaluateOnFrontend("PerformanceTestRunner.stopTimeline(reply);", callback);
+    evaluateOnFrontend("PerformanceTestRunner.stopTimeline().then(reply);", callback);
 }
 
 function extension_dumpFlameChart(callback)

third_party/WebKit/LayoutTests/http/tests/devtools/forced-layout-in-microtask.js

@@ -23,9 +23,7 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', onTimelineRecorded);
-  function onTimelineRecorded() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails('Layout');
-    TestRunner.completeTest();
-  }
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('Layout');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/service-workers/service-worker-v8-cache.js

@@ -27,19 +27,14 @@
   const scope = 'resources/v8-cache-iframe.html';
   const frameId = 'frame_id';
 
-  await new Promise(
-        (r) =>
-        PerformanceTestRunner.invokeAsyncWithTimeline(
-            'registerServiceWorkerAndwaitForActivated', r));
+  await PerformanceTestRunner.invokeAsyncWithTimeline('registerServiceWorkerAndwaitForActivated');
   TestRunner.addResult('--- Trace events while installing -------------');
   PerformanceTestRunner.printTimelineRecordsWithDetails(
       TimelineModel.TimelineModel.RecordType.CompileScript);
   TestRunner.addResult('-----------------------------------------------');
   await ApplicationTestRunner.waitForActivated(scope);
   await TestRunner.addIframe(scope, {id: frameId});
-  await new Promise(
-        (r) =>
-        PerformanceTestRunner.invokeAsyncWithTimeline('loadScript', r));
+  await PerformanceTestRunner.invokeAsyncWithTimeline('loadScript');
   TestRunner.addResult('--- Trace events while executing scripts ------');
   PerformanceTestRunner.printTimelineRecordsWithDetails(
       TimelineModel.TimelineModel.RecordType.CompileScript);

third_party/WebKit/LayoutTests/http/tests/devtools/tracing-session-id.js

@@ -12,16 +12,14 @@
       </p>
     `);
 
-  PerformanceTestRunner.evaluateWithTimeline('(function() {})', processTracingEvents);
+  await PerformanceTestRunner.evaluateWithTimeline('(function() {})');
 
-  function processTracingEvents() {
-    PerformanceTestRunner.tracingModel().sortedProcesses().forEach(function(process) {
-      process.sortedThreads().forEach(function(thread) {
-        thread.events().forEach(processEvent);
-      });
+  PerformanceTestRunner.tracingModel().sortedProcesses().forEach(function(process) {
+    process.sortedThreads().forEach(function(thread) {
+      thread.events().forEach(processEvent);
     });
-    TestRunner.completeTest();
-  }
+  });
+  TestRunner.completeTest();
 
   function processEvent(event) {
     var metadataEvents = [

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/anonymous-image-object.js

@@ -32,10 +32,7 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('doActions', onRecordingDone);
-
-  function onRecordingDone() {
-    TestRunner.addResult('DONE');
-    TestRunner.completeTest();
-  }
+  await PerformanceTestRunner.invokeAsyncWithTimeline('doActions');
+  TestRunner.addResult('DONE');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/console-timeline.js

@@ -82,30 +82,21 @@
   `);
 
   TestRunner.runTestSuite([
-    function testStartStopTimeline(next) {
-      PerformanceTestRunner.evaluateWithTimeline('startStopTimeline()', allEventsReceived);
-
-      function allEventsReceived() {
-        printTimelineAndTimestampEvents();
-        next();
-      }
+    async function testStartStopTimeline(next) {
+      await PerformanceTestRunner.evaluateWithTimeline('startStopTimeline()');
+      printTimelineAndTimestampEvents();
+      next();
     },
 
-    function testStartStopMultiple(next) {
-      PerformanceTestRunner.evaluateWithTimeline('startStopMultiple()', allEventsReceived);
-
-      function allEventsReceived() {
-        printTimelineAndTimestampEvents();
-        next();
-      }
+    async function testStartStopMultiple(next) {
+      await PerformanceTestRunner.evaluateWithTimeline('startStopMultiple()');
+      printTimelineAndTimestampEvents();
+      next();
     },
 
-    function testStartMultipleStopInsideEvals(next) {
-      PerformanceTestRunner.startTimeline(step1);
-
-      function step1() {
-        TestRunner.evaluateInPage('startMultiple()', step2);
-      }
+    async function testStartMultipleStopInsideEvals(next) {
+      await PerformanceTestRunner.startTimeline();
+      TestRunner.evaluateInPage('startMultiple()', step2);
 
       function step2() {
         TestRunner.evaluateInPage('stopTwo()', step3);
@@ -115,41 +106,29 @@
         TestRunner.evaluateInPage('stopOne()', step4);
       }
 
-      function step4() {
-        PerformanceTestRunner.stopTimeline(finish);
-      }
-
-      function finish() {
+      async function step4() {
+        await PerformanceTestRunner.stopTimeline();
         printTimelineAndTimestampEvents();
         next();
       }
     },
 
-    function testStopUnknown(next) {
-      PerformanceTestRunner.evaluateWithTimeline('stopUnknown()', allEventsReceived);
-
-      function allEventsReceived() {
-        printTimelineAndTimestampEvents();
-        next();
-      }
+    async function testStopUnknown(next) {
+      await PerformanceTestRunner.evaluateWithTimeline('stopUnknown()');
+      printTimelineAndTimestampEvents();
+      next();
     },
 
-    function testStartFromPanel(next) {
-      PerformanceTestRunner.evaluateWithTimeline('startStopTimeline()', finish);
-
-      function finish() {
-        printTimelineAndTimestampEvents();
-        next();
-      }
+    async function testStartFromPanel(next) {
+      await PerformanceTestRunner.evaluateWithTimeline('startStopTimeline()');
+      printTimelineAndTimestampEvents();
+      next();
     },
 
-    function testStopFromPanel(next) {
-      PerformanceTestRunner.evaluateWithTimeline('startTimeline()', finish);
-
-      function finish() {
-        printTimelineAndTimestampEvents();
-        next();
-      }
+    async function testStopFromPanel(next) {
+      await PerformanceTestRunner.evaluateWithTimeline('startTimeline()');
+      printTimelineAndTimestampEvents();
+      next();
     }
   ]);
 

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-gc-event.js

@@ -14,15 +14,13 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('produceGarbageForGCEvents', validate);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('produceGarbageForGCEvents');
 
-  function validate() {
-    var gcEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.MajorGC) ||
-        PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.MinorGC);
-    if (gcEvent)
-      TestRunner.addResult('SUCCESS: Found expected GC event record');
-    else
-      TestRunner.addResult('FAIL: GC event record wasn\'t found');
-    TestRunner.completeTest();
-  }
+  const gcEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.MajorGC) ||
+      PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.MinorGC);
+  if (gcEvent)
+    TestRunner.addResult('SUCCESS: Found expected GC event record');
+  else
+    TestRunner.addResult(`FAIL: GC event record wasn't found`);
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-microtasks.js

@@ -26,12 +26,9 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
-
-  function finish() {
-    var event = PerformanceTestRunner.timelineModel().mainThreadEvents().find(
-        e => e.name === TimelineModel.TimelineModel.RecordType.RunMicrotasks);
-    PerformanceTestRunner.printTraceEventProperties(event);
-    TestRunner.completeTest();
-  }
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
+  const event = PerformanceTestRunner.timelineModel().mainThreadEvents().find(
+      e => e.name === TimelineModel.TimelineModel.RecordType.RunMicrotasks);
+  PerformanceTestRunner.printTraceEventProperties(event);
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-runtime-stats.js

@@ -24,15 +24,13 @@
 
   Runtime.experiments.enableForTest('timelineV8RuntimeCallStats');
   Runtime.experiments.enableForTest('timelineShowAllEvents');
-  PerformanceTestRunner.evaluateWithTimeline('performActions()', finish);
+  await PerformanceTestRunner.evaluateWithTimeline('performActions()');
 
-  function finish() {
-    var frame = PerformanceTestRunner.timelineModel()
-                    .mainThreadEvents()
-                    .filter(e => e.name === TimelineModel.TimelineModel.RecordType.JSFrame)
-                    .map(e => e.args['data']['callFrame'])
-                    .find(frame => frame.functionName === 'FunctionCallback' && frame.url === 'native V8Runtime');
-    TestRunner.assertTrue(!!frame, 'FunctionCallback frame not found');
-    TestRunner.completeTest();
-  }
+  var frame = PerformanceTestRunner.timelineModel()
+                  .mainThreadEvents()
+                  .filter(e => e.name === TimelineModel.TimelineModel.RecordType.JSFrame)
+                  .map(e => e.args['data']['callFrame'])
+                  .find(frame => frame.functionName === 'FunctionCallback' && frame.url === 'native V8Runtime');
+  TestRunner.assertTrue(!!frame, 'FunctionCallback frame not found');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-script-id-expected.txt

 Test that checks location resolving mechanics for TimerInstall TimerRemove and FunctionCall events with scriptId.
        It expects two FunctionCall for InjectedScript, two TimerInstall events, two FunctionCall events and one TimerRemove event to be logged with performActions.js script name and some line number.
 
+detailsTextContent for TimerInstall event: 'performActions.js:32'
+details.textContent for TimerInstall event: 'performActions.js:32'
 detailsTextContent for TimerInstall event: 'performActions.js:33'
 details.textContent for TimerInstall event: 'performActions.js:33'
-detailsTextContent for TimerInstall event: 'performActions.js:34'
-details.textContent for TimerInstall event: 'performActions.js:34'
-detailsTextContent for FunctionCall event: 'performActions.js:38'
-details.textContent for FunctionCall event: 'intervalTimerWork @ performActions.js:38'
-detailsTextContent for FunctionCall event: 'performActions.js:38'
-details.textContent for FunctionCall event: 'intervalTimerWork @ performActions.js:38'
-detailsTextContent for TimerRemove event: 'performActions.js:41'
-details.textContent for TimerRemove event: 'performActions.js:41'
+detailsTextContent for FunctionCall event: 'performActions.js:37'
+details.textContent for FunctionCall event: 'intervalTimerWork @ performActions.js:37'
+detailsTextContent for FunctionCall event: 'performActions.js:37'
+details.textContent for FunctionCall event: 'intervalTimerWork @ performActions.js:37'
+detailsTextContent for TimerRemove event: 'performActions.js:40'
+details.textContent for TimerRemove event: 'performActions.js:40'
 

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-script-id.js

@@ -25,17 +25,16 @@
     }
   }
 
-  var source = performActions.toString();
-  source += '\n//# sourceURL=performActions.js';
-  TestRunner.evaluateInPage(source, startTimeline);
+  const source = performActions.toString() + '\n//# sourceURL=performActions.js';
+  await new Promise(resolve => TestRunner.evaluateInPage(source, resolve));
 
-  function startTimeline() {
-    PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
-  }
+  const linkifier = new Components.Linkifier();
+  const recordTypes = new Set(['TimerInstall', 'TimerRemove', 'FunctionCall']);
 
-  var linkifier = new Components.Linkifier();
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
+  PerformanceTestRunner.walkTimelineEventTree(formatter);
+  TestRunner.completeTest();
 
-  var recordTypes = new Set(['TimerInstall', 'TimerRemove', 'FunctionCall']);
   function formatter(event) {
     if (!recordTypes.has(event.name))
       return;
@@ -51,9 +50,4 @@
     TestRunner.addResult(
         'details.textContent for ' + event.name + ' event: \'' + details.textContent.replace(/VM[\d]+/, 'VM') + '\'');
   }
-
-  function finish() {
-    PerformanceTestRunner.walkTimelineEventTree(formatter);
-    TestRunner.completeTest();
-  }
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-script-tag-1.js

@@ -17,24 +17,17 @@
   `);
 
   UI.panels.timeline._disableCaptureJSProfileSetting.set(true);
-  PerformanceTestRunner.startTimeline(step1);
-  function step1() {
-    ConsoleTestRunner.addConsoleSniffer(step2);
-    TestRunner.evaluateInPage('performActions()');
-  }
+  await PerformanceTestRunner.startTimeline();
+  TestRunner.evaluateInPage('performActions()');
+  await ConsoleTestRunner.waitUntilMessageReceivedPromise();
+  await PerformanceTestRunner.stopTimeline();
 
-  function step2() {
-    PerformanceTestRunner.stopTimeline(step3);
-  }
-
-  function step3() {
-    PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
-      if (event.name === TimelineModel.TimelineModel.RecordType.EvaluateScript) {
-        PerformanceTestRunner.printTraceEventProperties(event);
-      } else if (event.name === TimelineModel.TimelineModel.RecordType.TimeStamp) {
-        TestRunner.addResult(`----> ${Timeline.TimelineUIUtils.eventTitle(event)}`);
-      }
-    });
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
+    if (event.name === TimelineModel.TimelineModel.RecordType.EvaluateScript) {
+      PerformanceTestRunner.printTraceEventProperties(event);
+    } else if (event.name === TimelineModel.TimelineModel.RecordType.TimeStamp) {
+      TestRunner.addResult(`----> ${Timeline.TimelineUIUtils.eventTitle(event)}`);
+    }
+  });
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-js/timeline-script-tag-2.js

@@ -16,18 +16,11 @@
       }
   `);
 
-  PerformanceTestRunner.startTimeline(step1);
-  function step1() {
-    ConsoleTestRunner.addConsoleSniffer(step2);
-    TestRunner.evaluateInPage('performActions()');
-  }
+  await PerformanceTestRunner.startTimeline();
+  TestRunner.evaluateInPage('performActions()');
+  await ConsoleTestRunner.waitUntilMessageReceivedPromise();
 
-  function step2() {
-    PerformanceTestRunner.stopTimeline(step3);
-  }
-
-  function step3() {
-    PerformanceTestRunner.printTimelineRecords('EvaluateScript');
-    TestRunner.completeTest();
-  }
+  await PerformanceTestRunner.stopTimeline();
+  PerformanceTestRunner.printTimelineRecords('EvaluateScript');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-layout/timeline-layout-reason.js

@@ -32,13 +32,11 @@
       }
   `);
 
-  PerformanceTestRunner.evaluateWithTimeline('performActions()', onTimelineRecorded);
-  function onTimelineRecorded() {
-    var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Layout);
-    var initiator = TimelineModel.TimelineData.forEvent(event).initiator();
-    TestRunner.addResult(
-        'layout invalidated: ' + TimelineModel.TimelineData.forEvent(initiator).stackTrace[0].functionName);
-    TestRunner.addResult('layout forced: ' + TimelineModel.TimelineData.forEvent(event).stackTrace[0].functionName);
-    TestRunner.completeTest();
-  }
+  await PerformanceTestRunner.evaluateWithTimeline('performActions()');
+  var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Layout);
+  var initiator = TimelineModel.TimelineData.forEvent(event).initiator();
+  TestRunner.addResult(
+      'layout invalidated: ' + TimelineModel.TimelineData.forEvent(initiator).stackTrace[0].functionName);
+  TestRunner.addResult('layout forced: ' + TimelineModel.TimelineData.forEvent(event).stackTrace[0].functionName);
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-layout/timeline-layout-with-invalidations.js

@@ -34,24 +34,22 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('display', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Layout, 0, 'first layout invalidations');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Layout, 1, 'second layout invalidations');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('display');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Layout, 0, 'first layout invalidations');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Layout, 1, 'second layout invalidations');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Layout, 0, 'first layout invalidations');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Layout, 1, 'second layout invalidations');
-        next();
-      });
+    async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Layout, 0, 'first layout invalidations');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Layout, 1, 'second layout invalidations');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-misc/timeline-animation-frame.js

@@ -22,12 +22,10 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails('RequestAnimationFrame');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('FireAnimationFrame');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('CancelAnimationFrame');
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.printTimelineRecordsWithDetails('RequestAnimationFrame');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('FireAnimationFrame');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('CancelAnimationFrame');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-misc/timeline-bound-function.js

@@ -21,17 +21,15 @@
       }
   `);
 
-  PerformanceTestRunner.evaluateWithTimeline('performActions()', finish);
+  await PerformanceTestRunner.evaluateWithTimeline('performActions()');
 
-  function finish() {
-    PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
-      if (event.name !== TimelineModel.TimelineModel.RecordType.FunctionCall)
-        return;
-      var data = event.args['data'];
-      var scriptName = data.scriptName;
-      var scriptNameShort = scriptName.substring(scriptName.lastIndexOf('/') + 1);
-      TestRunner.addResult(`${event.name} ${scriptNameShort}: ${data.scriptLine}`);
-    });
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.timelineModel().mainThreadEvents().forEach(event => {
+    if (event.name !== TimelineModel.TimelineModel.RecordType.FunctionCall)
+      return;
+    var data = event.args['data'];
+    var scriptName = data.scriptName;
+    var scriptNameShort = scriptName.substring(scriptName.lastIndexOf('/') + 1);
+    TestRunner.addResult(`${event.name} ${scriptNameShort}: ${data.scriptLine}`);
+  });
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-misc/timeline-event-causes.js

@@ -17,7 +17,7 @@
   }
 
   TestRunner.runTestSuite([
-    function testTimerInstall(next) {
+    async function testTimerInstall(next) {
       function setTimeoutFunction() {
         return new Promise((fulfill) => setTimeout(fulfill, 0));
       }
@@ -26,23 +26,22 @@
       source += '\n//# sourceURL=setTimeoutFunction.js';
       TestRunner.evaluateInPage(source);
 
-      PerformanceTestRunner.invokeAsyncWithTimeline('setTimeoutFunction', finishAndRunNextTest);
-      function finishAndRunNextTest() {
-        var linkifier = new Components.Linkifier();
-        var event = PerformanceTestRunner.findTimelineEvent('TimerFire');
-        TestRunner.check(event, 'Should receive a TimerFire event.');
-        var contentHelper = new Timeline.TimelineDetailsContentHelper(
-            PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
-        Timeline.TimelineUIUtils._generateCauses(
-            event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
-        var causes = contentHelper.element.deepTextContent();
-        TestRunner.check(causes, 'Should generate causes');
-        checkStringContains(causes, 'Timer Installed\nPromise @ setTimeoutFunction.js:');
-        next();
-      }
+      await PerformanceTestRunner.invokeAsyncWithTimeline('setTimeoutFunction');
+
+      var linkifier = new Components.Linkifier();
+      var event = PerformanceTestRunner.findTimelineEvent('TimerFire');
+      TestRunner.check(event, 'Should receive a TimerFire event.');
+      var contentHelper = new Timeline.TimelineDetailsContentHelper(
+          PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
+      Timeline.TimelineUIUtils._generateCauses(
+          event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
+      var causes = contentHelper.element.deepTextContent();
+      TestRunner.check(causes, 'Should generate causes');
+      checkStringContains(causes, 'Timer Installed\nPromise @ setTimeoutFunction.js:');
+      next();
     },
 
-    function testRequestAnimationFrame(next) {
+    async function testRequestAnimationFrame(next) {
       function requestAnimationFrameFunction(callback) {
         return new Promise((fulfill) => requestAnimationFrame(fulfill));
       }
@@ -51,23 +50,21 @@
       source += '\n//# sourceURL=requestAnimationFrameFunction.js';
       TestRunner.evaluateInPage(source);
 
-      PerformanceTestRunner.invokeAsyncWithTimeline('requestAnimationFrameFunction', finishAndRunNextTest);
-      function finishAndRunNextTest() {
-        var linkifier = new Components.Linkifier();
-        var event = PerformanceTestRunner.findTimelineEvent('FireAnimationFrame');
-        TestRunner.check(event, 'Should receive a FireAnimationFrame event.');
-        var contentHelper = new Timeline.TimelineDetailsContentHelper(
-            PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
-        Timeline.TimelineUIUtils._generateCauses(
-            event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
-        var causes = contentHelper.element.deepTextContent();
-        TestRunner.check(causes, 'Should generate causes');
-        checkStringContains(causes, 'Animation Frame Requested\nPromise @ requestAnimationFrameFunction.js:');
-        next();
-      }
+      await PerformanceTestRunner.invokeAsyncWithTimeline('requestAnimationFrameFunction');
+      var linkifier = new Components.Linkifier();
+      var event = PerformanceTestRunner.findTimelineEvent('FireAnimationFrame');
+      TestRunner.check(event, 'Should receive a FireAnimationFrame event.');
+      var contentHelper = new Timeline.TimelineDetailsContentHelper(
+          PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
+      Timeline.TimelineUIUtils._generateCauses(
+          event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
+      var causes = contentHelper.element.deepTextContent();
+      TestRunner.check(causes, 'Should generate causes');
+      checkStringContains(causes, 'Animation Frame Requested\nPromise @ requestAnimationFrameFunction.js:');
+      next();
     },
 
-    function testStyleRecalc(next) {
+    async function testStyleRecalc(next) {
       function styleRecalcFunction() {
         var element = document.getElementById('testElement');
         element.style.backgroundColor = 'papayawhip';
@@ -78,23 +75,21 @@
       source += '\n//# sourceURL=styleRecalcFunction.js';
       TestRunner.evaluateInPage(source);
 
-      PerformanceTestRunner.evaluateWithTimeline('styleRecalcFunction()', finishAndRunNextTest);
-      function finishAndRunNextTest() {
-        var linkifier = new Components.Linkifier();
-        var event = PerformanceTestRunner.findTimelineEvent('UpdateLayoutTree');
-        TestRunner.check(event, 'Should receive a UpdateLayoutTree event.');
-        var contentHelper = new Timeline.TimelineDetailsContentHelper(
-            PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
-        Timeline.TimelineUIUtils._generateCauses(
-            event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
-        var causes = contentHelper.element.deepTextContent();
-        TestRunner.check(causes, 'Should generate causes');
-        checkStringContains(causes, 'First Invalidated\nstyleRecalcFunction @ styleRecalcFunction.js:');
-        next();
-      }
+      await PerformanceTestRunner.evaluateWithTimeline('styleRecalcFunction()');
+      var linkifier = new Components.Linkifier();
+      var event = PerformanceTestRunner.findTimelineEvent('UpdateLayoutTree');
+      TestRunner.check(event, 'Should receive a UpdateLayoutTree event.');
+      var contentHelper = new Timeline.TimelineDetailsContentHelper(
+          PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
+      Timeline.TimelineUIUtils._generateCauses(
+          event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
+      var causes = contentHelper.element.deepTextContent();
+      TestRunner.check(causes, 'Should generate causes');
+      checkStringContains(causes, 'First Invalidated\nstyleRecalcFunction @ styleRecalcFunction.js:');
+      next();
     },
 
-    function testLayout(next) {
+    async function testLayout(next) {
       function layoutFunction() {
         var element = document.getElementById('testElement');
         element.style.width = '200px';
@@ -105,21 +100,19 @@
       source += '\n//# sourceURL=layoutFunction.js';
       TestRunner.evaluateInPage(source);
 
-      PerformanceTestRunner.evaluateWithTimeline('layoutFunction()', finishAndRunNextTest);
-      function finishAndRunNextTest() {
-        var linkifier = new Components.Linkifier();
-        var event = PerformanceTestRunner.findTimelineEvent('Layout');
-        TestRunner.check(event, 'Should receive a Layout event.');
-        var contentHelper = new Timeline.TimelineDetailsContentHelper(
-            PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
-        Timeline.TimelineUIUtils._generateCauses(
-            event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
-        var causes = contentHelper.element.deepTextContent();
-        TestRunner.check(causes, 'Should generate causes');
-        checkStringContains(causes, 'Layout Forced\nlayoutFunction @ layoutFunction.js:');
-        checkStringContains(causes, 'First Layout Invalidation\nlayoutFunction @ layoutFunction.js:');
-        next();
-      }
+      await PerformanceTestRunner.evaluateWithTimeline('layoutFunction()');
+      var linkifier = new Components.Linkifier();
+      var event = PerformanceTestRunner.findTimelineEvent('Layout');
+      TestRunner.check(event, 'Should receive a Layout event.');
+      var contentHelper = new Timeline.TimelineDetailsContentHelper(
+          PerformanceTestRunner.timelineModel().targetByEvent(event), linkifier, true);
+      Timeline.TimelineUIUtils._generateCauses(
+          event, PerformanceTestRunner.timelineModel().targetByEvent(event), null, contentHelper);
+      var causes = contentHelper.element.deepTextContent();
+      TestRunner.check(causes, 'Should generate causes');
+      checkStringContains(causes, 'Layout Forced\nlayoutFunction @ layoutFunction.js:');
+      checkStringContains(causes, 'First Layout Invalidation\nlayoutFunction @ layoutFunction.js:');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-misc/timeline-node-reference.js

@@ -30,8 +30,11 @@
       }
   `);
 
-  TestRunner.evaluateInPage('var unused = document.body.offsetWidth;', function() {
-    PerformanceTestRunner.evaluateWithTimeline('performActions()', onTimelineRecorded);
+  TestRunner.evaluateInPage('var unused = document.body.offsetWidth;', async function() {
+    const records = await PerformanceTestRunner.evaluateWithTimeline('performActions()');
+    const layoutEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Layout);
+    UI.context.addFlavorChangeListener(SDK.DOMNode, onSelectedNodeChanged);
+    clickValueLink(layoutEvent, 'Layout root');
   });
 
   async function clickValueLink(event, row) {
@@ -46,12 +49,6 @@
     }
   }
 
-  function onTimelineRecorded(records) {
-    var layoutEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Layout);
-    UI.context.addFlavorChangeListener(SDK.DOMNode, onSelectedNodeChanged);
-    clickValueLink(layoutEvent, 'Layout root');
-  }
-
   function onSelectedNodeChanged() {
     var node = UI.panels.elements.selectedDOMNode();
     // We may first get an old selected node while switching to the Elements panel.

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-misc/timeline-trivial.js

@@ -8,9 +8,7 @@
   await TestRunner.showPanel('timeline');
 
   /* This test seems silly, but originally it tickled bug 31080 */
-  function callback() {
-    TestRunner.addResult('Timeline started');
-    TestRunner.completeTest();
-  }
-  PerformanceTestRunner.startTimeline(callback);
+  await PerformanceTestRunner.startTimeline();
+  TestRunner.addResult('Timeline started');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-network-received-data.js

@@ -24,16 +24,14 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', done);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function done() {
-    TestRunner.addResult('Script evaluated.');
-    var event = PerformanceTestRunner.findTimelineEvent('ResourceReceivedData');
-    if (event) {
-      var data = event.args['data'];
-      if (data && typeof data.encodedDataLength === 'number')
-        TestRunner.addResult('Resource received data has length, test passed.');
-    }
-    TestRunner.completeTest();
+  TestRunner.addResult('Script evaluated.');
+  var event = PerformanceTestRunner.findTimelineEvent('ResourceReceivedData');
+  if (event) {
+    var data = event.args['data'];
+    if (data && typeof data.encodedDataLength === 'number')
+      TestRunner.addResult('Resource received data has length, test passed.');
   }
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-network/timeline-network-resource.js

@@ -23,20 +23,18 @@
   var requestId;
   var scriptUrl = 'timeline-network-resource.js';
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    var model = PerformanceTestRunner.timelineModel();
-    model.mainThreadEvents().forEach(event => {
-      if (event.name === TimelineModel.TimelineModel.RecordType.ResourceSendRequest)
-        printSend(event);
-      else if (event.name === TimelineModel.TimelineModel.RecordType.ResourceReceiveResponse)
-        printReceive(event);
-      else if (event.name === TimelineModel.TimelineModel.RecordType.ResourceFinish)
-        printFinish(event);
-    });
-    TestRunner.completeTest();
-  }
+  var model = PerformanceTestRunner.timelineModel();
+  model.mainThreadEvents().forEach(event => {
+    if (event.name === TimelineModel.TimelineModel.RecordType.ResourceSendRequest)
+      printSend(event);
+    else if (event.name === TimelineModel.TimelineModel.RecordType.ResourceReceiveResponse)
+      printReceive(event);
+    else if (event.name === TimelineModel.TimelineModel.RecordType.ResourceFinish)
+      printFinish(event);
+  });
+  TestRunner.completeTest();
 
   function printEvent(event) {
     TestRunner.addResult('');

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/layer-tree.js

@@ -33,15 +33,11 @@
 
   UI.panels.timeline._captureLayersAndPicturesSetting.set(true);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('doActions', step1);
-  function step1() {
-    var frames = PerformanceTestRunner.timelineFrameModel().frames();
-    var lastFrame = PerformanceTestRunner.timelineFrameModel().frames().peekLast();
-    lastFrame.layerTree.layerTreePromise().then(TestRunner.safeWrap(layerTreeResolved));
-  }
+  await PerformanceTestRunner.invokeAsyncWithTimeline('doActions');
+  const frames = PerformanceTestRunner.timelineFrameModel().frames();
+  const lastFrame = PerformanceTestRunner.timelineFrameModel().frames().peekLast();
+  const layerTreeModel = await lastFrame.layerTree.layerTreePromise();
+  LayersTestRunner.dumpLayerTree(undefined, layerTreeModel.contentRoot());
 
-  function layerTreeResolved(layerTreeModel) {
-    LayersTestRunner.dumpLayerTree(undefined, layerTreeModel.contentRoot());
-    TestRunner.completeTest();
-  }
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/paint-profiler-update.js

@@ -36,25 +36,23 @@
   panel._captureLayersAndPicturesSetting.set(true);
   panel._onModeChanged();
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', onRecordingDone);
   var paintEvents = [];
-  function onRecordingDone() {
-    var events = PerformanceTestRunner.timelineModel()._mainThreadEvents;
-    for (var event of events) {
-      if (event.name === TimelineModel.TimelineModel.RecordType.Paint) {
-        paintEvents.push(event);
-        if (!TimelineModel.TimelineData.forEvent(event).picture)
-          TestRunner.addResult('Event without picture at ' + paintEvents.length);
-      }
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
+  var events = PerformanceTestRunner.timelineModel()._mainThreadEvents;
+  for (var event of events) {
+    if (event.name === TimelineModel.TimelineModel.RecordType.Paint) {
+      paintEvents.push(event);
+      if (!TimelineModel.TimelineData.forEvent(event).picture)
+        TestRunner.addResult('Event without picture at ' + paintEvents.length);
     }
+  }
 
-    if (paintEvents.length < 2)
-      throw new Error('FAIL: Expect at least two paint events');
+  if (paintEvents.length < 2)
+    throw new Error('FAIL: Expect at least two paint events');
 
-    TestRunner.addSniffer(
-        panel._flameChart._detailsView, '_appendDetailsTabsForTraceEventAndShowDetails', onRecordDetailsReady, false);
-    panel.select(Timeline.TimelineSelection.fromTraceEvent(paintEvents[0]));
-  }
+  TestRunner.addSniffer(
+      panel._flameChart._detailsView, '_appendDetailsTabsForTraceEventAndShowDetails', onRecordDetailsReady, false);
+  panel.select(Timeline.TimelineSelection.fromTraceEvent(paintEvents[0]));
 
   function onRecordDetailsReady() {
     var updateCount = 0;

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/timeline-paint-and-multiple-style-invalidations.js

@@ -35,20 +35,18 @@
   `);
 
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
-  PerformanceTestRunner.invokeAsyncWithTimeline('multipleStyleRecalcsAndDisplay', testMultipleStyleRecalcs);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('multipleStyleRecalcsAndDisplay');
 
-  function testMultipleStyleRecalcs() {
-    PerformanceTestRunner.dumpInvalidations(
-        TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first style recalc');
-    PerformanceTestRunner.dumpInvalidations(
-        TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second style recalc');
-    PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'first paint');
+  PerformanceTestRunner.dumpInvalidations(
+      TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first style recalc');
+  PerformanceTestRunner.dumpInvalidations(
+      TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second style recalc');
+  PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'first paint');
+  var thirdRecalc =
+      PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2);
+  TestRunner.assertTrue(thirdRecalc === undefined, 'There should be no additional style recalc records.');
+  var secondPaint = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint, 1);
+  TestRunner.assertTrue(secondPaint === undefined, 'There should be no additional paint records.');
 
-    var thirdRecalc =
-        PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2);
-    TestRunner.assertTrue(thirdRecalc === undefined, 'There should be no additional style recalc records.');
-    var secondPaint = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint, 1);
-    TestRunner.assertTrue(secondPaint === undefined, 'There should be no additional paint records.');
-    TestRunner.completeTest();
-  }
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/timeline-paint-with-layout-invalidations-on-deleted-node.js

@@ -35,26 +35,24 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('display', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'paint invalidations');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('display');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'paint invalidations');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay', function() {
-        // The first paint corresponds to the local frame and should have no invalidations.
-        var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
-        var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
-        TestRunner.assertEquals(firstInvalidations, null);
+    async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay');
+      // The first paint corresponds to the local frame and should have no invalidations.
+      var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
+      var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
+      TestRunner.assertEquals(firstInvalidations, null);
 
-        // The second paint corresponds to the subframe and should have our layout/style invalidations.
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
+      // The second paint corresponds to the subframe and should have our layout/style invalidations.
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
 
-        next();
-      });
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/timeline-paint-with-layout-invalidations.js

@@ -31,25 +31,23 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('display', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'paint invalidations');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('display');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.Paint, 0, 'paint invalidations');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay', function() {
-        // The first paint corresponds to the local frame and should have no invalidations.
-        var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
-        var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
-        TestRunner.assertEquals(firstInvalidations, null);
+   async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay');
+      // The first paint corresponds to the local frame and should have no invalidations.
+      var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
+      var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
+      TestRunner.assertEquals(firstInvalidations, null);
 
-        // The second paint corresponds to the subframe and should have our layout/style invalidations.
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
-        next();
-      });
+      // The second paint corresponds to the subframe and should have our layout/style invalidations.
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/timeline-paint-with-style-recalc-invalidations.js

@@ -29,26 +29,24 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('display', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Paint, 0, 'first paint invalidations');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('display');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Paint, 0, 'first paint invalidations');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay', function() {
-        // The first paint corresponds to the local frame and should have no invalidations.
-        var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
-        var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
-        TestRunner.assertEquals(firstInvalidations, null);
+    async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay');
+      // The first paint corresponds to the local frame and should have no invalidations.
+      var firstPaintEvent = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
+      var firstInvalidations = TimelineModel.InvalidationTracker.invalidationEventsFor(firstPaintEvent);
+      TestRunner.assertEquals(firstInvalidations, null);
 
-        // The second paint corresponds to the subframe and should have our style invalidations.
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
-        next();
-      });
+      // The second paint corresponds to the subframe and should have our style invalidations.
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.Paint, 1, 'second paint invalidations');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-paint/timeline-paint.js

@@ -23,37 +23,33 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('display', step1);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('display');
 
-  function step1() {
-    var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
-    if (event)
-      PerformanceTestRunner.printTraceEventProperties(event);
-    else
-      TestRunner.addResult('FAIL: no paint record found');
-    PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay', step3);
-  }
+  var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.Paint);
+  if (event)
+    PerformanceTestRunner.printTraceEventProperties(event);
+  else
+    TestRunner.addResult('FAIL: no paint record found');
+  await PerformanceTestRunner.invokeAsyncWithTimeline('updateSubframeAndDisplay');
 
-  function step3() {
-    var events = PerformanceTestRunner.timelineModel().mainThreadEvents().filter(
-        e => e.name === TimelineModel.TimelineModel.RecordType.Paint);
-    TestRunner.assertGreaterOrEqual(events.length, 2, 'Paint record with subframe paint not found');
-    var topQuad = events[0].args['data'].clip;
-    var subframePaint = events[1];
-    TestRunner.assertGreaterOrEqual(
-        events[0].endTime, subframePaint.endTime, 'Subframe paint is not a child of frame paint');
-    var subframeQuad = subframePaint.args['data'].clip;
-    TestRunner.assertEquals(8, topQuad.length);
-    TestRunner.assertEquals(8, subframeQuad.length);
-    TestRunner.assertGreaterOrEqual(subframeQuad[0], topQuad[0]);
-    TestRunner.assertGreaterOrEqual(subframeQuad[1], topQuad[1]);
-    TestRunner.assertGreaterOrEqual(topQuad[2], subframeQuad[2]);
-    TestRunner.assertGreaterOrEqual(subframeQuad[3], topQuad[3]);
-    TestRunner.assertGreaterOrEqual(topQuad[4], subframeQuad[4]);
-    TestRunner.assertGreaterOrEqual(topQuad[5], subframeQuad[5]);
-    TestRunner.assertGreaterOrEqual(subframeQuad[6], topQuad[6]);
-    TestRunner.assertGreaterOrEqual(topQuad[7], subframeQuad[7]);
+  var events = PerformanceTestRunner.timelineModel().mainThreadEvents().filter(
+      e => e.name === TimelineModel.TimelineModel.RecordType.Paint);
+  TestRunner.assertGreaterOrEqual(events.length, 2, 'Paint record with subframe paint not found');
+  var topQuad = events[0].args['data'].clip;
+  var subframePaint = events[1];
+  TestRunner.assertGreaterOrEqual(
+      events[0].endTime, subframePaint.endTime, 'Subframe paint is not a child of frame paint');
+  var subframeQuad = subframePaint.args['data'].clip;
+  TestRunner.assertEquals(8, topQuad.length);
+  TestRunner.assertEquals(8, subframeQuad.length);
+  TestRunner.assertGreaterOrEqual(subframeQuad[0], topQuad[0]);
+  TestRunner.assertGreaterOrEqual(subframeQuad[1], topQuad[1]);
+  TestRunner.assertGreaterOrEqual(topQuad[2], subframeQuad[2]);
+  TestRunner.assertGreaterOrEqual(subframeQuad[3], topQuad[3]);
+  TestRunner.assertGreaterOrEqual(topQuad[4], subframeQuad[4]);
+  TestRunner.assertGreaterOrEqual(topQuad[5], subframeQuad[5]);
+  TestRunner.assertGreaterOrEqual(subframeQuad[6], topQuad[6]);
+  TestRunner.assertGreaterOrEqual(topQuad[7], subframeQuad[7]);
 
-    TestRunner.completeTest();
-  }
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-receive-response-event.js

@@ -30,34 +30,32 @@
   UI.viewManager.showView('timeline');
   const panel = UI.panels.timeline;
   panel._disableCaptureJSProfileSetting.set(true);
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    var recordTypes = TimelineModel.TimelineModel.RecordType;
-    var typesToDump = new Set([
-      recordTypes.ResourceSendRequest, recordTypes.ResourceReceiveResponse, recordTypes.ResourceReceivedData,
-      recordTypes.ResourceFinish, recordTypes.EventDispatch, recordTypes.FunctionCall
-    ]);
-    let hasAlreadyDumptReceivedDataFor = new Map();
-    function dumpEvent(traceEvent, level) {
-      // Ignore stray paint & rendering events for better stability.
-      var categoryName = Timeline.TimelineUIUtils.eventStyle(traceEvent).category.name;
-      if (categoryName !== 'loading' && categoryName !== 'scripting')
+  var recordTypes = TimelineModel.TimelineModel.RecordType;
+  var typesToDump = new Set([
+    recordTypes.ResourceSendRequest, recordTypes.ResourceReceiveResponse, recordTypes.ResourceReceivedData,
+    recordTypes.ResourceFinish, recordTypes.EventDispatch, recordTypes.FunctionCall
+  ]);
+  let hasAlreadyDumptReceivedDataFor = new Map();
+  function dumpEvent(traceEvent, level) {
+    // Ignore stray paint & rendering events for better stability.
+    var categoryName = Timeline.TimelineUIUtils.eventStyle(traceEvent).category.name;
+    if (categoryName !== 'loading' && categoryName !== 'scripting')
+      return;
+    if (traceEvent.name === 'ResourceReceivedData') {
+      const requestId = traceEvent.args['data']['requestId'];
+      // Dump only the first ResourceReceivedData for a request for stability.
+      if (hasAlreadyDumptReceivedDataFor[requestId])
         return;
-      if (traceEvent.name === 'ResourceReceivedData') {
-        const requestId = traceEvent.args['data']['requestId'];
-        // Dump only the first ResourceReceivedData for a request for stability.
-        if (hasAlreadyDumptReceivedDataFor[requestId])
-          return;
-        hasAlreadyDumptReceivedDataFor[requestId] = true;
-      }
-
-      // Here and below: pretend coalesced record are just not there, as coalescation is time dependent and, hence, not stable.
-      // Filter out InjectedScript function call because they happen out of sync.
-      if (typesToDump.has(traceEvent.name) && (traceEvent.name !== 'FunctionCall' || traceEvent.args['data']['url']))
-        TestRunner.addResult('    '.repeat(level - 1) + traceEvent.name);
+      hasAlreadyDumptReceivedDataFor[requestId] = true;
     }
-    PerformanceTestRunner.walkTimelineEventTree(dumpEvent);
-    TestRunner.completeTest();
+
+    // Here and below: pretend coalesced record are just not there, as coalescation is time dependent and, hence, not stable.
+    // Filter out InjectedScript function call because they happen out of sync.
+    if (typesToDump.has(traceEvent.name) && (traceEvent.name !== 'FunctionCall' || traceEvent.args['data']['url']))
+      TestRunner.addResult('    '.repeat(level - 1) + traceEvent.name);
   }
+  PerformanceTestRunner.walkTimelineEventTree(dumpEvent);
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-script-parse.js

@@ -21,14 +21,12 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    const tracingModel = PerformanceTestRunner.tracingModel();
-    tracingModel.sortedProcesses().forEach(p => p.sortedThreads().forEach(t => t.events().forEach(event => {
-      if (event.name === TimelineModel.TimelineModel.RecordType.ParseScriptOnBackground)
-        PerformanceTestRunner.printTraceEventPropertiesWithDetails(event);
-    })));
-    TestRunner.completeTest();
-  }
+  const tracingModel = PerformanceTestRunner.tracingModel();
+  tracingModel.sortedProcesses().forEach(p => p.sortedThreads().forEach(t => t.events().forEach(event => {
+    if (event.name === TimelineModel.TimelineModel.RecordType.ParseScriptOnBackground)
+      PerformanceTestRunner.printTraceEventPropertiesWithDetails(event);
+  })));
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-style/timeline-style-recalc-all-invalidator-types.js

@@ -86,47 +86,41 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testClassName(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeClassNameAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
-        next();
-      });
+    async function testClassName(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeClassNameAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
+      next();
     },
 
-    function testIdWithoutStyleChange(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeIdWithoutStyleChangeAndDisplay', function() {
-        var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree);
-        TestRunner.assertTrue(!event, 'There should be no style recalculation for an id change without style changes.');
-        next();
-      });
+    async function testIdWithoutStyleChange(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeIdWithoutStyleChangeAndDisplay');
+      var event = PerformanceTestRunner.findTimelineEvent(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree);
+      TestRunner.assertTrue(!event, 'There should be no style recalculation for an id change without style changes.');
+      next();
     },
 
-    function testId(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeIdAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
-        next();
-      });
+    async function testId(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeIdAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
+      next();
     },
 
-    function testStyleAttributeChange(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeStyleAttributeAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
-        next();
-      });
+    async function testStyleAttributeChange(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeStyleAttributeAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
+      next();
     },
 
-    function testAttributeChange(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeAttributeAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
-        next();
-      });
+    async function testAttributeChange(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeAttributeAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
+      next();
     },
 
-    function testPseudoChange(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changePseudoAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
-        next();
-      });
+    async function testPseudoChange(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changePseudoAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0);
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-style/timeline-style-recalc-with-invalidations.js

@@ -50,32 +50,29 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
+      next();
     },
 
-    function multipleStyleRecalcs(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalc style invalidations');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalc style invalidations');
-        next();
-      });
+    async function multipleStyleRecalcs(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalc style invalidations');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalc style invalidations');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeSubframeStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
-        next();
-      });
+    async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeSubframeStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalc style invalidations');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-style/timeline-style-recalc-with-invalidator-invalidations.js

@@ -71,36 +71,33 @@
   Runtime.experiments.enableForTest('timelineInvalidationTracking');
 
   TestRunner.runTestSuite([
-    function testLocalFrame(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
-        next();
-      });
+    async function testLocalFrame(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
+      next();
     },
 
-    function multipleStyleRecalcs(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalculate styles');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalculate styles');
-        next();
-      });
+    async function multipleStyleRecalcs(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalculate styles');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalculate styles');
+      next();
     },
 
-    function testSubframe(next) {
-      PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleSubframeStylesAndDisplay', function() {
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalculate styles');
-        PerformanceTestRunner.dumpInvalidations(
-            TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalculate styles');
-        next();
-      });
+    async function testSubframe(next) {
+      await PerformanceTestRunner.invokeAsyncWithTimeline('changeMultipleSubframeStylesAndDisplay');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 0, 'first recalculate styles');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 1, 'second recalculate styles');
+      PerformanceTestRunner.dumpInvalidations(
+          TimelineModel.TimelineModel.RecordType.UpdateLayoutTree, 2, 'third recalculate styles');
+      next();
     }
   ]);
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-time/timeline-time.js

@@ -73,17 +73,15 @@
     }
   ]);
 
-  function performActions(actions, next) {
+  async function performActions(actions, next) {
     var namesToDump = new Set(['FunctionCall', 'ConsoleTime', 'TimeStamp']);
     function dumpName(event, level) {
       if (namesToDump.has(event.name))
         TestRunner.addResult('----'.repeat(level) + '> ' + Timeline.TimelineUIUtils.eventTitle(event));
     }
-    function callback() {
-      PerformanceTestRunner.walkTimelineEventTree(dumpName);
-      next();
-    }
     UI.panels.timeline._disableCaptureJSProfileSetting.set(true);
-    PerformanceTestRunner.evaluateWithTimeline(actions, TestRunner.safeWrap(callback), true);
-  }
+    await PerformanceTestRunner.evaluateWithTimeline(actions);
+    PerformanceTestRunner.walkTimelineEventTree(dumpName);
+    next();
+}
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-time/timeline-timer.js

@@ -27,14 +27,12 @@
   `);
 
   UI.panels.timeline._disableCaptureJSProfileSetting.set(true);
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails('TimerInstall');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('TimerFire');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('TimerRemove');
-    PerformanceTestRunner.printTimelineRecords('FunctionCall');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('EvaluateScript');
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.printTimelineRecordsWithDetails('TimerInstall');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('TimerFire');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('TimerRemove');
+  PerformanceTestRunner.printTimelineRecords('FunctionCall');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('EvaluateScript');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-time/timeline-usertiming.js

@@ -92,10 +92,9 @@
     });
   }
 
-  function performActions(actions, next) {
-    PerformanceTestRunner.evaluateWithTimeline(actions, _ => {
-      dumpUserTimings();
-      next();
-    });
+  async function performActions(actions, next) {
+    await PerformanceTestRunner.evaluateWithTimeline(actions);
+    dumpUserTimings();
+    next();
   }
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-xhr-event.js

@@ -21,11 +21,9 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails('XHRReadyStateChange');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('XHRLoad');
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.printTimelineRecordsWithDetails('XHRReadyStateChange');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('XHRLoad');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/timeline-xhr-response-type-blob-event.js

@@ -33,11 +33,9 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    PerformanceTestRunner.printTimelineRecords('XHRReadyStateChange');
-    PerformanceTestRunner.printTimelineRecords('XHRLoad');
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.printTimelineRecords('XHRReadyStateChange');
+  PerformanceTestRunner.printTimelineRecords('XHRLoad');
+  TestRunner.completeTest();
 })();

third_party/WebKit/LayoutTests/http/tests/devtools/tracing/websocket/timeline-websocket-event.js

@@ -14,13 +14,11 @@
       }
   `);
 
-  PerformanceTestRunner.invokeAsyncWithTimeline('performActions', finish);
+  await PerformanceTestRunner.invokeAsyncWithTimeline('performActions');
 
-  function finish() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketCreate');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketSendHandshakeRequest');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketReceiveHandshakeResponse');
-    PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketDestroy');
-    TestRunner.completeTest();
-  }
+  PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketCreate');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketSendHandshakeRequest');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketReceiveHandshakeResponse');
+  PerformanceTestRunner.printTimelineRecordsWithDetails('WebSocketDestroy');
+  TestRunner.completeTest();
 })();

third_party/WebKit/Source/devtools/front_end/performance_test_runner/TimelineTestRunner.js

@@ -135,66 +135,50 @@ PerformanceTestRunner.runWhenTimelineIsReady = function(callback) {
   TestRunner.addSniffer(UI.panels.timeline, 'loadingComplete', () => callback());
 };
 
-PerformanceTestRunner.startTimeline = function(callback) {
-  return new Promise(resolve => {
-    var panel = UI.panels.timeline;
-    TestRunner.addSniffer(panel, '_recordingStarted', () => {
-      resolve();
-      if (callback)
-        callback();
-    });
-    panel._toggleRecording();
-  });
+PerformanceTestRunner.startTimeline = function() {
+  const panel = UI.panels.timeline;
+  panel._toggleRecording();
+  return TestRunner.addSnifferPromise(panel, '_recordingStarted');
 };
 
-PerformanceTestRunner.stopTimeline = function(callback) {
+PerformanceTestRunner.stopTimeline = function() {
   return new Promise(resolve => {
-    PerformanceTestRunner.runWhenTimelineIsReady(() => {
-      resolve();
-      if (callback)
-        callback();
-    });
+    PerformanceTestRunner.runWhenTimelineIsReady(resolve);
     UI.panels.timeline._toggleRecording();
   });
 };
 
-// TODO(alph): Replace callback with promise in all the tests.
-PerformanceTestRunner.evaluateWithTimeline = async function(actions, doneCallback) {
+PerformanceTestRunner.evaluateWithTimeline = async function(actions) {
   await PerformanceTestRunner.startTimeline();
   await TestRunner.evaluateInPageAnonymously(actions);
-  await PerformanceTestRunner.stopTimeline(doneCallback);
+  await PerformanceTestRunner.stopTimeline();
 };
 
-PerformanceTestRunner.invokeAsyncWithTimeline = async function(functionName, doneCallback) {
+PerformanceTestRunner.invokeAsyncWithTimeline = async function(functionName) {
   await PerformanceTestRunner.startTimeline();
   await TestRunner.callFunctionInPageAsync(functionName);
-  await PerformanceTestRunner.stopTimeline(doneCallback);
+  await PerformanceTestRunner.stopTimeline();
 };
 
-PerformanceTestRunner.performActionsAndPrint = function(actions, typeName, includeTimeStamps) {
-  function callback() {
-    PerformanceTestRunner.printTimelineRecordsWithDetails(typeName);
-
-    if (includeTimeStamps) {
-      TestRunner.addResult('Timestamp records: ');
-      PerformanceTestRunner.printTimestampRecords(typeName);
-    }
-
-    TestRunner.completeTest();
+PerformanceTestRunner.performActionsAndPrint = async function(actions, typeName, includeTimeStamps) {
+  await PerformanceTestRunner.evaluateWithTimeline(actions);
+  PerformanceTestRunner.printTimelineRecordsWithDetails(typeName);
+  if (includeTimeStamps) {
+    TestRunner.addResult('Timestamp records: ');
+    PerformanceTestRunner.printTimestampRecords(typeName);
   }
-
-  PerformanceTestRunner.evaluateWithTimeline(actions, callback);
+  TestRunner.completeTest();
 };
 
 PerformanceTestRunner.printTimelineRecords = function(name) {
-  for (let event of PerformanceTestRunner.timelineModel().inspectedTargetEvents()) {
+  for (const event of PerformanceTestRunner.timelineModel().inspectedTargetEvents()) {
     if (event.name === name)
       PerformanceTestRunner.printTraceEventProperties(event);
   }
 };
 
 PerformanceTestRunner.printTimelineRecordsWithDetails = function(name) {
-  for (let event of PerformanceTestRunner.timelineModel().inspectedTargetEvents()) {
+  for (const event of PerformanceTestRunner.timelineModel().inspectedTargetEvents()) {
     if (name === event.name)
       PerformanceTestRunner.printTraceEventPropertiesWithDetails(event);
   }