Selection API: collapse() should recreate an internal Range.

third_party/WebKit/LayoutTests/editing/selection/modify_move/resources/move-by-word-visually.js

 function nodeOfWordBreak(nodeAndOffset)
 {
     var node = document.getElementById(nodeAndOffset[0]).firstChild;
     if (nodeAndOffset.length == 3) {
         var childIndex = nodeAndOffset[2];
         for (var i = 0; i < childIndex - 1; ++i) {
             node = node.nextSibling;
         }
     }
     return node;
@@ skipping 36 matching lines @@
         wordBreaks.push(result[1]);
     }
     if (wordBreaks.length == 0) {
         wordBreaks = title.split(' ');
     }
     return wordBreaks;
 }
 
 function moveByWord(sel, test, searchDirection, dir)
 {
-    var prevOffset = sel.anchorOffset;
-    var prevNode = sel.anchorNode;
+    var prevOffset = internals.visibleSelectionAnchorOffset;
+    var prevNode = internals.visibleSelectionAnchorNode;
     var positions = [];
-    positions.push({ node: sel.anchorNode, offset: sel.anchorOffset });
+    positions.push({ node: prevNode, offset: prevOffset });
 
     while (1) {
         sel.modify('move', searchDirection, 'word');
-        if (prevNode == sel.anchorNode && prevOffset == sel.anchorOffset)
+        if (prevNode == internals.visibleSelectionAnchorNode && prevOffset == internals.visibleSelectionAnchorOffset)
             break;
-        positions.push({ node: sel.anchorNode, offset: sel.anchorOffset });
-        prevNode = sel.anchorNode;
-        prevOffset = sel.anchorOffset;
+        prevNode = internals.visibleSelectionAnchorNode;
+        prevOffset = internals.visibleSelectionAnchorOffset;
+        positions.push({ node: prevNode, offset: prevOffset });
     };
 
     var wordBreaks = collectWordBreaks(test, searchDirection);
     if (wordBreaks == TEST_FOR_CRASH)
         return;
     validateData(positions, wordBreaks);
 }
 
 function moveByWordOnEveryChar(sel, test, searchDirection, dir)
 {
     var wordBreaks = collectWordBreaks(test, searchDirection);
     var wordBreakIndex = 1;
-    var prevOffset = sel.anchorOffset;
-    var prevNode = sel.anchorNode;
+    var prevOffset = internals.visibleSelectionAnchorOffset;
+    var prevNode = internals.visibleSelectionAnchorNode;
 
     while (1) {
         sel.modify('move', searchDirection, 'word');
 
         if (wordBreaks != TEST_FOR_CRASH) {
             if (wordBreakIndex >= wordBreaks.length) {
-                assert_equals(sel.anchorNode, prevNode, 'expected to stay in the same position');
-                assert_equals(sel.anchorOffset, prevOffset, 'expected to stay in the same position');
+                assert_equals(internals.visibleSelectionAnchorNode, prevNode, 'expected to stay in the same position');
+                assert_equals(internals.visibleSelectionAnchorOffset, prevOffset, 'expected to stay in the same position');
             } else {
-                assert_true(positionEqualToWordBreak({ node: sel.anchorNode, offset: sel.anchorOffset }, wordBreaks[wordBreakIndex]), 'positionEqualToWordBreak of ' + wordBreakIndex);
+                assert_true(positionEqualToWordBreak({ node: internals.visibleSelectionAnchorNode, offset: internals.visibleSelectionAnchorOffset }, wordBreaks[wordBreakIndex]), 'positionEqualToWordBreak of ' + wordBreakIndex);
             }
         }
 
         // Restore position and move by 1 character.
         sel.collapse(prevNode, prevOffset);
         sel.modify('move', searchDirection, 'character');
-        if (prevNode == sel.anchorNode && prevOffset == sel.anchorOffset)
+        if (prevNode == internals.visibleSelectionAnchorNode && prevOffset == internals.visibleSelectionAnchorOffset)
             return;
 
+        prevNode = internals.visibleSelectionAnchorNode;
+        prevOffset = internals.visibleSelectionAnchorOffset;
         if (wordBreakIndex < wordBreaks.length &&
-            positionEqualToWordBreak({ node: sel.anchorNode, offset: sel.anchorOffset }, wordBreaks[wordBreakIndex])) {
+            positionEqualToWordBreak({ node: prevNode, offset: prevOffset }, wordBreaks[wordBreakIndex])) {
             ++wordBreakIndex;
         }
-
-        prevNode = sel.anchorNode;
-        prevOffset = sel.anchorOffset;
     };
 }
 
 function moveByWordForEveryPosition(sel, test, dir)
 {
     // Check ctrl-right-arrow works for every position.
     sel.collapse(test, 0);
     var direction = 'right';
     if (dir == 'rtl')
         direction = 'left';
     moveByWord(sel, test, direction, dir);
     sel.collapse(test, 0);
     moveByWordOnEveryChar(sel, test, direction, dir);
 
     sel.modify('move', 'forward', 'lineBoundary');
-    var position = { node: sel.anchorNode, offset: sel.anchorOffset };
+    var position = { node: internals.visibleSelectionAnchorNode, offset: internals.visibleSelectionAnchorOffset };
 
     // Check ctrl-left-arrow works for every position.
     if (dir == 'ltr')
         direction = 'left';
     else
         direction = 'right';
     moveByWord(sel, test, direction, dir);
 
     sel.collapse(position.node, position.offset);
     moveByWordOnEveryChar(sel, test, direction, dir);
 }
 
 function runTest() {
   div = document.createElement('div');
   div.id = 'log';
   document.body.appendChild(div);
 
   var tests = document.getElementsByClassName('test_move_by_word');
   var sel = getSelection();
   for (var testcase of tests) {
       test(function () {
+          assert_exists(window, 'internals');
           if (testcase.className.search('fix_width') != -1) {
               var span = document.getElementById('span_size');
               var length = span.offsetWidth;
               testcase.style.width = length + 'px';
           }
 
           if (testcase.getAttribute('dir') == 'ltr')
               moveByWordForEveryPosition(sel, testcase, 'ltr');
           else
               moveByWordForEveryPosition(sel, testcase, 'rtl');
       }, testcase.id);
   }
 }