Convert editing/spelling/spelling-huge-text.html with 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 95 matching lines @@
   }
 
   /**
    * @private
    * @param {string} string
    */
   emit(string) { this.strings_.push(string); }
 
   /**
    * @private
-   * @param {!Node} node
+   * @param {!CharacterData} node
    * @param {number} offset
+   * @return {number} The next offset at which a current active marker ends or
+   *                  a new marker starts. Returns node.data.length if there is
+   *                  no more markers.
    */
   advancedTo(node, offset) {
+    var nextCheckPoint = node.data.length;
     for (let type in this.markerTypes_) {
       // Handle the ending of the current active marker.
-      if (isAtRangeEnd(this.activeMarkerRanges_[type], node, offset)) {
-        this.activeMarkerRanges_[type] = null;
+      if (isAtRangeEnd(this.activeMarkerRanges_[type], node, offset))
         this.emit(this.markerTypes_[type]);
-      }
 
-      // Handle the starting of the next active marker.
-      if (this.activeMarkerRanges_[type])
-        return;
+      // Recompute the current active marker and the next check point
+      this.activeMarkerRanges_[type] = null;
       /** @type {number} */
       const markerCount = window.internals.markerCountForNode(node, type);
       for (let i = 0; i < markerCount; ++i) {
         const marker = window.internals.markerRangeForNode(node, type, i);
         assert_equals(
             marker.startContainer, node,
             'Internal error: marker range not starting in the annotated node.');
         assert_equals(
             marker.endContainer, node,
             'Internal error: marker range not ending in the annotated node.');
-        if (marker.startOffset === offset) {
-          assert_greater_than(marker.endOffset, offset,
-                              'Internal error: marker range is collapsed.');
+        assert_greater_than(marker.endOffset, marker.startOffset,
+                            'Internal error: marker range is collapsed.');
+        if (marker.startOffset <= offset && offset < marker.endOffset) {
           this.activeMarkerRanges_[type] = marker;
-          this.emit(this.markerTypes_[type]);
-          break;
+          nextCheckPoint = Math.min(nextCheckPoint, marker.endOffset);
+          // Handle the starting of the current active marker.
+          if (offset === marker.startOffset)
+            this.emit(this.markerTypes_[type]);
+        } else if (marker.startOffset > offset) {
+          nextCheckPoint = Math.min(nextCheckPoint, marker.startOffset);
         }
       }
     }
+    return nextCheckPoint;
   }
 
   /**
    * @private
    * @param {!CharacterData} node
    */
   handleCharacterData(node) {
     /** @type {string} */
     const text = node.nodeValue;
     /** @type {number} */
     const length = text.length;
-    for (let offset = 0; offset < length; ++offset) {
-      this.advancedTo(node, offset);
-      this.emit(text[offset]);
+    for (let offset = 0; offset < length;) {
+      const nextCheckPoint = this.advancedTo(node, offset);
+      this.emit(text.substring(offset, nextCheckPoint));
+      offset = nextCheckPoint;
     }
     this.advancedTo(node, length);
   }
 
   /**
    * @private
    * @param {!HTMLElement} element
    */
   handleInnerEditorOf(element) {
     /** @type {!ShadowRoot} */
@@ skipping 255 matching lines @@
         expectedText: expectedText, args: args});
     return;
   }
 
   invokeSpellcheckTest(input, tester, expectedText, args);
 }
 
 // Export symbols
 window.spellcheck_test = spellcheckTest;
 })();