ALL-IN-ONE: Optimization to previousBoundary() and nextBoundary()

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 22 matching lines @@
 #include "core/dom/Text.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/Position.h"
 #include "core/editing/PositionIterator.h"
 #include "core/editing/RenderedPosition.h"
 #include "core/editing/TextAffinity.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/iterators/BackwardsCharacterIterator.h"
 #include "core/editing/iterators/CharacterIterator.h"
+#include "core/editing/iterators/ProgressiveTextAccumulator.h"
 #include "core/editing/iterators/SimplifiedBackwardsTextIterator.h"
 #include "core/editing/iterators/TextIterator.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 623 matching lines @@
             forwardsIterator.copyTextTo(characters);
             int i = endOfFirstWordBoundaryContext(characters.data(), characters.size());
             string.append(characters.data(), i);
             suffixLength += i;
             if (static_cast<unsigned>(i) < characters.size())
                 break;
             forwardsIterator.advance();
         }
     }
 
-    SimplifiedBackwardsTextIteratorAlgorithm<Strategy> it(start, end);
+    ProgressiveTextAccumulator<SimplifiedBackwardsTextIteratorAlgorithm<Strategy>> it(start, end);
     unsigned next = 0;
     bool needMoreContext = false;
     while (!it.atEnd()) {
-        bool inTextSecurityMode = it.isInTextSecurityMode();
         // iterate to get chunks until the searchFunction returns a non-zero
         // value.
-        // TODO(xiaochengh): Iterative prepending has quadratic running time
-        // in the worst case. Should improve it to linear.
-        if (!inTextSecurityMode) {
-            it.copyTextTo(string);
-        } else {
-            // Treat bullets used in the text security mode as regular
-            // characters when looking for boundaries
-            Vector<UChar, 1024> iteratorString;
-            iteratorString.fill('x', it.length());
-            string.prepend(iteratorString.data(), iteratorString.size());
-        }
+        it.accumulateTextTo(string);
         // TODO(xiaochengh): The following line takes O(string.size()) time,
         // which makes the while loop take quadratic time in the worst case.
         // Should improve it in some way.
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, MayHaveMoreContext, needMoreContext);
         if (next)
             break;
         it.advance();
     }
     if (needMoreContext) {
         // The last search returned the beginning of the buffer and asked for
         // more context, but there is no earlier text. Force a search with
         // what's available.
         // TODO(xiaochengh): Do we have to search the whole string?
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
         ASSERT(!needMoreContext);
     }
 
     if (!next)
-        return createVisiblePosition(it.atEnd() ? it.startPosition() : pos);
+        return createVisiblePosition(it.iterator().atEnd() ? it.iterator().startPosition() : pos);
 
-    Node* node = it.startContainer();
-    if (node->isTextNode() && static_cast<int>(next) <= node->maxCharacterOffset()) {
+    Node* node = it.iterator().startContainer();
+    int boundaryOffset = it.unaccumulatedLengthInCurrentNode() + next;
+    if (node->isTextNode() && boundaryOffset <= node->maxCharacterOffset()) {
         // The next variable contains a usable index into a text node
-        return createVisiblePosition(PositionTemplate<Strategy>(node, next));
+        return createVisiblePosition(PositionTemplate<Strategy>(node, boundaryOffset));
     }
 
     // Use the character iterator to translate the next value into a DOM
     // position.
     BackwardsCharacterIteratorAlgorithm<Strategy> charIt(start, end);
     charIt.advance(string.size() - suffixLength - next);
     // TODO(yosin) charIt can get out of shadow host.
     return createVisiblePosition(charIt.endPosition());
 }
 
@@ skipping 23 matching lines @@
             string.prepend(characters.data() + i, length - i);
             prefixLength += length - i;
             if (i > 0)
                 break;
             backwardsIterator.advance();
         }
     }
 
     const PositionTemplate<Strategy> searchStart = PositionTemplate<Strategy>::editingPositionOf(start.anchorNode(), start.offsetInContainerNode());
     const PositionTemplate<Strategy> searchEnd = PositionTemplate<Strategy>::lastPositionInNode(boundary);
-    TextIteratorAlgorithm<Strategy> it(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
+    ProgressiveTextAccumulator<TextIteratorAlgorithm<Strategy>> it(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);

[yosin_UTC9, 2016/01/20 05:21:44]

We should have both |accumulator| and |it| rather than
|ProgressiveTextAccumulator| does both accumulation and iteration.
# It seems we don't need to have "Progressive" in class name, it is also
implementation detail.

Here is sketch:

TextIterator it(...);
TextAccumulator accumulator;

while (!it.atEnd()) {
  accumulator.extract(&it); // copy character from it with calling it.advance();
  const auto& string = accumulator.toString(); // construct new Vector<UChar>
  next = searchFunction(string.data(), string.size(), ...)
  ...
}

This model move character buffer management into |TextAccumulator| and we don't
need to make |Buffer| as template parameter.

     const unsigned invalidOffset = static_cast<unsigned>(-1);
     unsigned next = invalidOffset;
     unsigned offset = prefixLength;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to
         // it.
-        bool inTextSecurityMode = it.isInTextSecurityMode();
-        if (!inTextSecurityMode) {
-            it.copyTextTo(string);
-        } else {
-            // Treat bullets used in the text security mode as regular
-            // characters when looking for boundaries
-            Vector<UChar, 1024> iteratorString;
-            iteratorString.fill('x', it.length());
-            string.append(iteratorString.data(), iteratorString.size());
-        }
+        it.accumulateTextTo(string);
         next = searchFunction(string.data(), string.size(), offset, MayHaveMoreContext, needMoreContext);
         if (next != string.size())
             break;
         it.advance();
         if (!needMoreContext) {
             // When the search does not need more context, skip all examined
             // characters except the last one, in case it is a boundary.
             offset = string.size();
             U16_BACK_1(string.data(), 0, offset);
         }
     }
     if (needMoreContext) {
         // The last search returned the end of the buffer and asked for more
         // context, but there is no further text. Force a search with what's
         // available.
         // TODO(xiaochengh): Do we still have to search the whole string?
         next = searchFunction(string.data(), string.size(), prefixLength, DontHaveMoreContext, needMoreContext);
         ASSERT(!needMoreContext);
     }
 
     if (it.atEnd() && next == string.size()) {
-        pos = it.startPositionInCurrentContainer();
+        pos = it.iterator().startPositionInCurrentContainer();
     } else if (next != invalidOffset && next != prefixLength) {
         // Use the character iterator to translate the next value into a DOM
         // position.
         CharacterIteratorAlgorithm<Strategy> charIt(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
         charIt.advance(next - prefixLength - 1);
         pos = charIt.endPosition();
 
         if (charIt.characterAt(0) == '\n') {
             // TODO(yosin) workaround for collapsed range (where only start
             // position is correct) emitted for some emitted newlines
@@ skipping 2505 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInComposedTree previousPositionOf(const VisiblePositionInComposedTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink