Get rid of verify-with-timeout in spellcheck_test

third_party/WebKit/LayoutTests/editing/spelling/spellcheck_test.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 // This file provides
 // |spellcheck_test(sample, tester, expectedText, opt_title)| asynchronous test
 // to W3C test harness for easier writing of spellchecker test cases.
 //
@@ skipping 257 matching lines @@
    */
   serializeInternal(node) {
     if (isElement(node))
       return this.handleElementNode(node);
     if (isCharacterData(node))
       return this.handleCharacterData(node);
     throw new Error(`Unexpected node ${node}`);
   }
 }
 
+/**
+ * @param {!Document} document
+ * @return {boolean}
+ */
+function hasPendingSpellCheckRequest(document) {
+  return internals.lastSpellCheckRequestSequence(document) !==
+      internals.lastSpellCheckProcessedSequence(document);
+}
+
 /** @type {string} */
 const kTitle = 'title';
 /** @type {string} */
 const kCallback = 'callback';
 /** @type {string} */
 const kIsSpellcheckTest = 'isSpellcheckTest';
 
-/**
- * @param {!Test} testObject
- * @param {!Sample} sample
- * @param {string} expectedText
- * @param {number} remainingRetry
- * @param {number} retryInterval
- */
-function verifyMarkers(
-    testObject, sample, expectedText, remainingRetry, retryInterval) {
-  assert_not_equals(
-      window.internals, undefined,
-      'window.internals is required for running automated spellcheck tests.');
-
-  /** @type {!MarkerSerializer} */
-  const serializer = new MarkerSerializer({
-    spelling: '#',
-    grammar: '~'});
-
-  try {
-    assert_equals(serializer.serialize(sample.document), expectedText);
-    testObject.done();
-  } catch (error) {
-    if (remainingRetry <= 0)
-      throw error;
-
-    // Force invoking idle time spellchecker in case it has not been run yet.
-    if (window.testRunner)
-      window.testRunner.runIdleTasks(() => {});
-
-    // TODO(xiaochengh): We should make SpellCheckRequester::didCheck trigger
-    // something in JavaScript (e.g., a |Promise|), so that we can actively
-    // know the completion of spellchecking instead of passively waiting for
-    // markers to appear or disappear.
-    testObject.step_timeout(
-        () => verifyMarkers(testObject, sample, expectedText,
-                            remainingRetry - 1, retryInterval),
-        retryInterval);
-  }
-}
-
 // Spellchecker gets triggered not only by text and selection change, but also
 // by focus change. For example, misspelling markers in <INPUT> disappear when
 // the window loses focus, even though the selection does not change.
 // Therefore, we disallow spellcheck tests from running simultaneously to
 // prevent interference among them. If we call spellcheck_test while another
 // test is running, the new test will be added into testQueue waiting for the
 // completion of the previous test.
 
 /** @type {boolean} */
 var spellcheckTestRunning = false;
 /** @type {!Array<!Object>} */
 const testQueue = [];
 
+// We need to ensure correct usage of testRunner.runIdleTasks() that:
+// 1. We don't call runIdleTasks if another runIdleTasks is called but the
+//    callback has not been invoked yet; Otherwise, the current call is ignored.
+// 2. When the callback is invoked, we only verify test cases whose testers
+//    finished before calling runIdleTasks(); Otherwise, the idle time spell
+//    check may have not been invoked at the verification time.
+
+/** @type {boolean} */
+var runIdleTasksRequested = false;
+/**
+ * @type {!Array<!Function>} Verification functions of test cases whose idle
+ * idle spell checkers are requested before the current call of runIdleTasks.
+ */
+var idleVerificationReadyQueue = [];
+/**
+ * @type {!Array<!Function>} Verification functions of test cases whose idle
+ * idle spell checkers are requested after the current call of runIdleTasks.
+ */
+var idleVerificationWaitingQueue = [];
+
+function batchIdleVerification() {
+  runIdleTasksRequested = false;
+  idleVerificationReadyQueue.forEach(func => func());
+  idleVerificationReadyQueue = idleVerificationWaitingQueue;
+  idleVerificationWaitingQueue = [];
+  if (idleVerificationReadyQueue.length) {
+    runIdleTasksRequested = true;
+    testRunner.runIdleTasks(batchIdleVerification);
+  }
+}
+
 /**
  * @param {!Test} testObject
  * @param {!Sample|string} input
  * @param {function(!Document)|string} tester
  * @param {string} expectedText
  */
 function invokeSpellcheckTest(testObject, input, tester, expectedText) {
   spellcheckTestRunning = true;
 
   testObject.step(() => {
     // TODO(xiaochengh): Merge the following part with |assert_selection|.
     /** @type {!Sample} */
     const sample = typeof(input) === 'string' ? new Sample(input) : input;
     testObject.sample = sample;
 
     if (typeof(tester) === 'function') {
       tester.call(window, sample.document);
     } else if (typeof(tester) === 'string') {
       const strings = tester.split(/ (.+)/);
       sample.document.execCommand(strings[0], false, strings[1]);
     } else {
       assert_unreached(`Invalid tester: ${tester}`);
     }
 
-    /** @type {number} */
-    const kMaxRetry = 10;
-    /** @type {number} */
-    const kRetryInterval = 50;
+    assert_not_equals(
+        window.testRunner, undefined,
+        'window.testRunner is required for automated spellcheck tests.');
+    assert_not_equals(
+        window.internals, undefined,
+        'window.internals is required for automated spellcheck tests.');
 
-    // TODO(xiaochengh): We should make SpellCheckRequester::didCheck trigger
-    // something in JavaScript (e.g., a |Promise|), so that we can actively know
-    // the completion of spellchecking instead of passively waiting for markers
-    // to appear or disappear.
-    testObject.step_timeout(
-        () => verifyMarkers(testObject, sample, expectedText,
-                            kMaxRetry, kRetryInterval),
-        kRetryInterval);
+    /** @type {!Function} */
+    const verification = () => {
+      testObject.step(() => {
+        if (hasPendingSpellCheckRequest(sample.document))
+          return;
+
+        /** @type {!MarkerSerializer} */
+        const serializer = new MarkerSerializer({
+          spelling: '#',
+          grammar: '~'});
+
+        assert_equals(serializer.serialize(sample.document), expectedText);
+        testObject.done();
+      });
+    }
+
+    // Verify when all spell check requests are resolved.
+    testRunner.setSpellCheckResolvedCallback(verification);
+
+    // For tests that do not expect new markers, verify with runIdleTasks.
+    if (runIdleTasksRequested) {
+      idleVerificationWaitingQueue.push(verification);
+      return;
+    }
+
+    idleVerificationReadyQueue.push(verification);
+    runIdleTasksRequested = true;
+    testRunner.runIdleTasks(batchIdleVerification);
   });
 }
 
 add_result_callback(testObj => {
     if (!testObj.properties[kIsSpellcheckTest])
       return;
 
     /** @type {boolean} */
     var shouldRemoveSample = false;
     if (testObj.status === testObj.PASS) {
       if (testObj.properties[kCallback])
         testObj.properties[kCallback](testObj.sample);
       else
         shouldRemoveSample = true;
     } else {
       if (window.testRunner)
         shouldRemoveSample = true;
     }
 
     if (shouldRemoveSample)
       testObj.sample.remove();
 
-    // This is the earliest timing when a new spellcheck_test can be started.
-    spellcheckTestRunning = false;
+    // We may be in a spellCheckResolvedCallback here, so removing the callback
+    // (and hence, all remaining tasks) must be done asynchronously.
+    setTimeout(() => {
+      if (window.testRunner)
+        testRunner.removeSpellCheckResolvedCallback();
 
-    /** @type {Object} */
-    const next = testQueue.shift();
-    if (next === undefined)
-      return;
-    invokeSpellcheckTest(next.testObject, next.input,
-                         next.tester, next.expectedText);
+      // This is the earliest timing when a new spellcheck_test can be started.
+      spellcheckTestRunning = false;
+
+      /** @type {Object} */
+      const next = testQueue.shift();
+      if (next === undefined)
+        return;
+      invokeSpellcheckTest(next.testObject, next.input,
+                           next.tester, next.expectedText);
+    }, 0);
 });
 
 /**
  * @param {Object=} passedArgs
  * @return {!Object}
  */
 function getTestArguments(passedArgs) {
   const args = {};
   args[kIsSpellcheckTest] = true;
   [kTitle, kCallback].forEach(key => args[key] = undefined);
@@ skipping 30 matching lines @@
         tester: tester, expectedText: expectedText});
     return;
   }
 
   invokeSpellcheckTest(testObject, input, tester, expectedText);
 }
 
 // Export symbols
 window.spellcheck_test = spellcheckTest;
 })();