Minor fixes to 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 318 matching lines @@
 // 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 = [];
 
 /**
+ * @param {!Test} testObject
  * @param {!Sample|string} input
  * @param {function(!Document)|string} tester
  * @param {string} expectedText
- * @param {Object} args
  */
-function invokeSpellcheckTest(input, tester, expectedText, args) {
+function invokeSpellcheckTest(testObject, input, tester, expectedText) {
   spellcheckTestRunning = true;
 
-  async_test(testObject => {
+  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;
 
     // 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);
-  }, args[kTitle], args);
+  });
 }
 
 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;
 
-    if (testObj.status === testObj.PASS) {
-      if (testObj.properties[kCallback]) {
-        testObj.properties[kCallback](testObj.sample);
-      } else {
-        testObj.sample.remove();
-      }
-    }
-
     /** @type {Object} */
     const next = testQueue.shift();
     if (next === undefined)
       return;
-    invokeSpellcheckTest(next.input, next.tester,
-                         next.expectedText, next.args);
+    invokeSpellcheckTest(next.testObject, next.input,
+                         next.tester, next.expectedText);
 });
 
 /**
  * @param {Object=} passedArgs
  * @return {!Object}
  */
 function getTestArguments(passedArgs) {
   const args = {};
   args[kIsSpellcheckTest] = true;
   [kTitle, kCallback].forEach(key => args[key] = undefined);
@@ skipping 14 matching lines @@
  * @param {function(!Document)|string} tester
  * @param {string} expectedText
  * @param {Object=} opt_args
  */
 function spellcheckTest(input, tester, expectedText, opt_args) {
   if (window.testRunner)
     window.testRunner.setMockSpellCheckerEnabled(true);
 
   /** @type {!Object} */
   const args = getTestArguments(opt_args);
+  /** @type {!Test}  */
+  const testObject = async_test(args[kTitle], args);
 
   if (spellcheckTestRunning) {
     testQueue.push({
-        input: input, tester: tester,
-        expectedText: expectedText, args: args});
+        testObject: testObject, input: input,
+        tester: tester, expectedText: expectedText});
     return;
   }
 
-  invokeSpellcheckTest(input, tester, expectedText, args);
+  invokeSpellcheckTest(testObject, input, tester, expectedText);
 }
 
 // Export symbols
 window.spellcheck_test = spellcheckTest;
 })();