Devtools: Await promises in inspector tests

A lot of our tests don't await promises which means they can rely on
ordering of tasks in the backend which is not guaranteed. Upcoming
work on the inspector task scheduler makes some of these tests
start to flake because they expect events to happen in a certain
order, even when they don't await those events.

These tests might already be flaky because of this but it's hard
to tell.

These aren't the only tests that don't await protocol messages but I
focused on tests that use Target.setAutoAttach or
runIfWaitingForDebugger as they trigger the flakiness.

Change-Id: I4709c47256ad7ff557a34d0def1721ceaa8af706
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1936289
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Mathias Bynens <mathias@chromium.org>
Cr-Commit-Position: refs/heads/master@{#719117}

third_party/blink/web_tests/http/tests/inspector-protocol/fetch/fetch-oopif.js

@@ -32,7 +32,7 @@
     subframeFetcher.setLogPrefix("[subframe] ");
     await subframeFetcher.enable();
     subframeFetcher.onRequest().continueRequest({});
-    dp1.Runtime.runIfWaitingForDebugger();
+    await dp1.Runtime.runIfWaitingForDebugger();
   });
 
   await session.evaluateAsync(`addFrame('http://devtools.oopif-a.test:8000/inspector-protocol/fetch/resources/frame-with-subresource.html')`);

third_party/blink/web_tests/http/tests/inspector-protocol/fetch/service-worker-interception.js

@@ -16,7 +16,7 @@
     swFetcher.setLogPrefix("[renderer] ");
     await swFetcher.enable();
     swFetcher.onRequest().continueRequest({});
-    dp1.Runtime.runIfWaitingForDebugger();
+    await dp1.Runtime.runIfWaitingForDebugger();
   });
 
   await dp.ServiceWorker.enable();
@@ -33,8 +33,9 @@
   }
 
   await waitForServiceWorkerActivation();
-  dp.Page.reload();
-  await dp.Page.onceLifecycleEvent(event => event.params.name === 'load');
+  const onLifecyclePromise = dp.Page.onceLifecycleEvent(event => event.params.name === 'load');
+  await dp.Page.reload();
+  await onLifecyclePromise;
 
   globalFetcher.onceRequest().fulfill({
     responseCode: 200,

third_party/blink/web_tests/http/tests/inspector-protocol/network/navigation-blocking-xorigin-iframe.js

@@ -7,14 +7,14 @@
   await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
 
   let interceptionLog = [];
-  function onRequestIntercepted(dp, e) {
+  async function onRequestIntercepted(dp, e) {
     const response = {interceptionId: e.params.interceptionId};
 
     if (e.params.request.url === 'http://devtools.oopif-b.test:8000/inspector-protocol/resources/test-page.html')
       response.errorReason = 'Aborted';
     interceptionLog.push(e.params.request.url + (response.errorReason ? `: ${response.errorReason}` : ''));
 
-    dp.Network.continueInterceptedRequest(response);
+    await dp.Network.continueInterceptedRequest(response);
   }
 
   let loadCount = 5;
@@ -22,26 +22,28 @@
   const loadPromise = new Promise(fulfill => loadCallback = fulfill);
 
   const allTargets = [];
-  function initalizeTarget(dp) {
+  async function initalizeTarget(dp) {
     allTargets.push(dp);
-    dp.Network.setRequestInterception({patterns: [{}]});
-    dp.Network.onRequestIntercepted(onRequestIntercepted.bind(this, dp));
-    dp.Network.enable();
-    dp.Page.enable();
+    await Promise.all([
+      dp.Network.setRequestInterception({patterns: [{}]}),
+      dp.Network.onRequestIntercepted(onRequestIntercepted.bind(this, dp)),
+      dp.Network.enable(),
+      dp.Page.enable()
+    ]);
     dp.Page.onFrameStoppedLoading(e => {
       if (!--loadCount)
         loadCallback();
     });
-    dp.Runtime.runIfWaitingForDebugger();
+    await dp.Runtime.runIfWaitingForDebugger();
   }
 
-  initalizeTarget(dp);
-  dp.Target.onAttachedToTarget(e => {
+  await initalizeTarget(dp);
+  dp.Target.onAttachedToTarget(async e => {
     const targetProtocol = session.createChild(e.params.sessionId).protocol;
-    initalizeTarget(targetProtocol);
+    await initalizeTarget(targetProtocol);
   });
 
-  dp.Page.navigate({url: 'http://127.0.0.1:8000/inspector-protocol/resources/iframe-navigation.html'});
+  await dp.Page.navigate({url: 'http://127.0.0.1:8000/inspector-protocol/resources/iframe-navigation.html'});
 
   let urls = [];
   function getURLsRecursively(frameTree) {

third_party/blink/web_tests/http/tests/inspector-protocol/page/frame-requested-navigation-subframe.js

@@ -10,11 +10,11 @@
   }
   dp.Page.onFrameNavigated(onFrameNavigated);
 
-  dp.Target.onAttachedToTarget(e => {
+  dp.Target.onAttachedToTarget(async e => {
     const dp2 = session.createChild(e.params.sessionId).protocol;
-    dp2.Page.enable();
+    await dp2.Page.enable();
     dp2.Page.onFrameNavigated(onFrameNavigated);
-    dp2.Runtime.runIfWaitingForDebugger();
+    await dp2.Runtime.runIfWaitingForDebugger();
   });
 
   await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});

third_party/blink/web_tests/http/tests/inspector-protocol/service-worker/network-extrainfo-main-request.js

@@ -14,7 +14,7 @@
   const swdp = session.createChild(attachedToTarget.params.sessionId).protocol;
   await swdp.Network.enable();
 
-  swdp.Runtime.runIfWaitingForDebugger();
+  await swdp.Runtime.runIfWaitingForDebugger();
 
   const [
     requestWillBeSent,

third_party/blink/web_tests/http/tests/inspector-protocol/target/wait-for-debugger.js

@@ -4,9 +4,11 @@
 
   await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true, flatten: true});
 
-  await dp.Page.enable();
-  dp.Network.enable();
-  dp.Network.setUserAgentOverride({userAgent: 'test'});
+  await Promise.all([
+    dp.Page.enable(),
+    dp.Network.enable()
+  ]);
+  await dp.Network.setUserAgentOverride({userAgent: 'test'});
   session.evaluate(`
     var iframe = document.createElement('iframe');
     iframe.src = 'http://devtools.oopif.test:8000/inspector-protocol/network/resources/echo-headers.php?headers=HTTP_USER_AGENT';
@@ -16,9 +18,9 @@
   let params = (await dp.Network.onceRequestWillBeSent()).params;
   let sessionId = (await dp.Target.onceAttachedToTarget()).params.sessionId;
   let dp1 = session.createChild(sessionId).protocol;
-  dp1.Network.enable();
-  dp1.Network.setUserAgentOverride({userAgent: 'test (subframe)'});
-  dp1.Runtime.runIfWaitingForDebugger();
+  await dp1.Network.enable();
+  await dp1.Network.setUserAgentOverride({userAgent: 'test (subframe)'});
+  await dp1.Runtime.runIfWaitingForDebugger();
   testRunner.log(`User-Agent = ${params.request.headers['User-Agent']}`);
   await dp1.Network.onceLoadingFinished();
   let content = (await dp1.Network.getResponseBody({requestId: params.requestId})).result.body;

third_party/blink/web_tests/inspector-protocol/debugger/debugger-step-into-dedicated-worker.js

@@ -2,7 +2,7 @@
   const {page, session, dp} = await testRunner.startBlank(
       `Tests that dedicated worker won't crash on attempt to step into. Bug 232392.`);
 
-  dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
+  await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
                            flatten: true});
   await session.evaluate(`
     window.worker = new Worker('${testRunner.url('resources/dedicated-worker-step-into.js')}');

third_party/blink/web_tests/inspector-protocol/debugger/debugger-worker-pause-task-order.js

 (async function(testRunner) {
   var {page, session, dp} = await testRunner.startBlank(
       'Tests that tasks order is not changed when worker is resumed.');
-  dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
+  await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
                            flatten: true});
 
   await session.evaluate(`
@@ -28,11 +28,11 @@
 
   await childSession.protocol.Debugger.enable();
 
-  childSession.protocol.Runtime.runIfWaitingForDebugger();
+  await childSession.protocol.Runtime.runIfWaitingForDebugger();
   await childSession.protocol.Debugger.oncePaused();
 
   await session.evaluate(`worker.postMessage(2)`);
-  childSession.protocol.Debugger.resume();
+  await childSession.protocol.Debugger.resume();
   await childSession.protocol.Debugger.oncePaused();
   const value = await childSession.evaluate('self.count');
   testRunner.log(`count must be 1: ${value}`);

third_party/blink/web_tests/inspector-protocol/debugger/suspend-setTimeout-on-pause-in-dedicated-worker.js

 (async function(testRunner) {
   const {page, session, dp} = await testRunner.startBlank('Tests that setTimeout callback will not fire while script execution is paused. Bug 377926.');
 
-  dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
+  await dp.Target.setAutoAttach({autoAttach: true, waitForDebuggerOnStart: true,
                            flatten: true});
   await session.evaluate(`
     window.worker = new Worker('${testRunner.url('resources/dedicated-worker-suspend-setTimeout.js')}');

third_party/blink/web_tests/inspector-protocol/worker/worker-constructor-async-stacks.js

@@ -9,9 +9,9 @@
   testRunner.log('Setup page session');
   const pageDebuggerId = (await dp.Debugger.enable()).result.debuggerId;
   debuggers.set(pageDebuggerId, dp.Debugger);
-  dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
   testRunner.log('Set breakpoint before worker created');
-  dp.Debugger.setBreakpointByUrl(
+  await dp.Debugger.setBreakpointByUrl(
       {url: 'test.js', lineNumber: 2, columnNumber: 13});
   session.evaluate(`
 var blob = new Blob(['console.log(239);//# sourceURL=worker.js'], {type: 'application/javascript'});
@@ -20,7 +20,7 @@ var worker = new Worker(URL.createObjectURL(blob));
 
   testRunner.log('Run stepInto with breakOnAsyncCall flag');
   await dp.Debugger.oncePaused();
-  dp.Debugger.stepInto({breakOnAsyncCall: true});
+  await dp.Debugger.stepInto({breakOnAsyncCall: true});
 
   testRunner.log('Setup worker session');
   const childSession = session.createChild(
@@ -29,8 +29,8 @@ var worker = new Worker(URL.createObjectURL(blob));
   const workerDebuggerId =
         (await childSession.protocol.Debugger.enable()).debuggerId;
   debuggers.set(workerDebuggerId, childSession.protocol.Debugger);
-  childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
-  childSession.protocol.Runtime.runIfWaitingForDebugger();
+  await childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await childSession.protocol.Runtime.runIfWaitingForDebugger();
 
   const {callFrames, asyncStackTrace, asyncStackTraceId} =
       (await childSession.protocol.Debugger.oncePaused()).params;

third_party/blink/web_tests/inspector-protocol/worker/worker-on-message-async-stacks.js

@@ -9,7 +9,7 @@
   testRunner.log('Setup page session');
   const pageDebuggerId = (await dp.Debugger.enable()).result.debuggerId;
   debuggers.set(pageDebuggerId, dp.Debugger);
-  dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
   session.evaluate(`
 var blob = new Blob(['postMessage(239);//# sourceURL=worker.js'], {type: 'application/javascript'});
 var worker = new Worker(URL.createObjectURL(blob));
@@ -22,19 +22,19 @@ worker.onmessage = (e) => console.log(e.data);
   const workerDebuggerId =
         (await childSession.protocol.Debugger.enable()).result.debuggerId;
   debuggers.set(workerDebuggerId, childSession.protocol.Debugger);
-  childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
 
   testRunner.log('Set breakpoint before postMessage');
-  childSession.protocol.Debugger.setBreakpointByUrl(
+  await childSession.protocol.Debugger.setBreakpointByUrl(
       {url: 'worker.js', lineNumber: 0, columnNumber: 0});
 
   testRunner.log('Run worker');
-  childSession.protocol.Runtime.runIfWaitingForDebugger();
+  await childSession.protocol.Runtime.runIfWaitingForDebugger();
 
   testRunner.log('Run stepInto with breakOnAsyncCall flag');
   await childSession.protocol.Debugger.oncePaused();
 
-  childSession.protocol.Debugger.stepInto({breakOnAsyncCall: true});
+  await childSession.protocol.Debugger.stepInto({breakOnAsyncCall: true});
 
   const {callFrames, asyncStackTraceId} = (await dp.Debugger.oncePaused()).params;
   await testRunner.logStackTrace(

third_party/blink/web_tests/inspector-protocol/worker/worker-post-message-async-stacks.js

@@ -9,9 +9,9 @@
   testRunner.log('Setup page session');
   const pageDebuggerId = (await dp.Debugger.enable()).result.debuggerId;
   debuggers.set(pageDebuggerId, dp.Debugger);
-  dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await dp.Debugger.setAsyncCallStackDepth({maxDepth: 32});
   testRunner.log('Set breakpoint before postMessage');
-  dp.Debugger.setBreakpointByUrl(
+  await dp.Debugger.setBreakpointByUrl(
       {url: 'test.js', lineNumber: 3, columnNumber: 7});
   session.evaluate(`
 var blob = new Blob(['onmessage = (e) => console.log(e.data);//# sourceURL=worker.js'], {type: 'application/javascript'});
@@ -21,7 +21,7 @@ worker.postMessage(42);
 
   testRunner.log('Run stepInto with breakOnAsyncCall flag');
   await dp.Debugger.oncePaused();
-  dp.Debugger.stepInto({breakOnAsyncCall: true});
+  await dp.Debugger.stepInto({breakOnAsyncCall: true});
 
   testRunner.log('Setup worker session');
   const childSession = session.createChild(
@@ -30,9 +30,9 @@ worker.postMessage(42);
   const workerDebuggerId =
         (await childSession.protocol.Debugger.enable()).result.debuggerId;
   debuggers.set(workerDebuggerId, childSession.protocol.Debugger);
-  childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
+  await childSession.protocol.Debugger.setAsyncCallStackDepth({maxDepth: 32});
   testRunner.log('Run worker');
-  childSession.protocol.Runtime.runIfWaitingForDebugger();
+  await childSession.protocol.Runtime.runIfWaitingForDebugger();
   const {callFrames, asyncStackTrace, asyncStackTraceId} =
       (await childSession.protocol.Debugger.oncePaused()).params;
   await testRunner.logStackTrace(