Implement cold mode invocation for idle time spell checker

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 272 matching lines @@
   return internals.lastSpellCheckRequestSequence(document) !==
       internals.lastSpellCheckProcessedSequence(document);
 }
 
 /** @type {string} */
 const kTitle = 'title';
 /** @type {string} */
 const kCallback = 'callback';
 /** @type {string} */
 const kIsSpellcheckTest = 'isSpellcheckTest';
+/** @type {string} */
+const kNeedsFullCheck = 'needsFullCheck';
 
 // 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} */
@@ skipping 47 matching lines @@
         /** @type {!MarkerSerializer} */
         const serializer = new MarkerSerializer({
           spelling: '#',
           grammar: '~'});
 
         assert_equals(serializer.serialize(sample.document), expectedText);
         testObject.done();
       });
     };
 
-    if (internals.idleTimeSpellCheckerState !== undefined &&
-        internals.idleTimeSpellCheckerState(sample.document) === 'HotModeRequested') {
+    if (internals.idleTimeSpellCheckerState !== undefined) {
+      if (internals.idleTimeSpellCheckerState(sample.document) === 'HotModeRequested')
         internals.runIdleTimeSpellChecker(sample.document);
+      if (testObject.properties[kNeedsFullCheck]) {
+        while (internals.idleTimeSpellCheckerState(sample.document) !== 'Inactive')
+          internals.runIdleTimeSpellChecker(sample.document);
+      }
     }
 
     // For a test that does not create new spell check request, a synchronous
     // verification finishes everything.
     verificationForCurrentTest();
   });
 }
 
 add_result_callback(testObj => {
     if (!testObj.properties[kIsSpellcheckTest])
@@ skipping 27 matching lines @@
                          next.tester, next.expectedText);
 });
 
 /**
  * @param {Object=} passedArgs
  * @return {!Object}
  */
 function getTestArguments(passedArgs) {
   const args = {};
   args[kIsSpellcheckTest] = true;
-  [kTitle, kCallback].forEach(key => args[key] = undefined);
+  [kTitle, kCallback, kNeedsFullCheck].forEach(key => args[key] = undefined);
   if (!passedArgs)
     return args;
 
   if (typeof(passedArgs) === 'string') {
     args[kTitle] = passedArgs;
     return args;
   }
 
-  [kTitle, kCallback].forEach(key => args[key] = passedArgs[key]);
+  [kTitle, kCallback, kNeedsFullCheck].forEach(
+      key => args[key] = passedArgs[key]);
   return args;
 }
 
 /**
  * @param {!Sample|string} input
  * @param {function(!Document)|string} tester
  * @param {string} expectedText
  * @param {Object=} opt_args
  */
 function spellcheckTest(input, tester, expectedText, opt_args) {
@@ skipping 16 matching lines @@
   window.testRunner.setMockSpellCheckerEnabled(true);
   window.testRunner.setSpellCheckResolvedCallback(() => {
     if (verificationForCurrentTest)
       verificationForCurrentTest();
   });
 }
 
 // Export symbols
 window.spellcheck_test = spellcheckTest;
 })();