Add functions searching a word boundary without VisualPosition to HTMLTextFormControlElement.

Source/core/html/HTMLTextFormControlElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 12 matching lines @@
  */
 
 #include "config.h"
 #include "core/html/HTMLTextFormControlElement.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/accessibility/AXObjectCache.h"
 #include "core/dom/Document.h"
+#include "core/dom/NodeList.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Text.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/TextIterator.h"
 #include "core/events/Event.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/shadow/ShadowElementNames.h"
 #include "core/rendering/RenderBlock.h"
 #include "core/rendering/RenderTheme.h"
 #include "platform/heap/Handle.h"
+#include "platform/text/TextBoundaries.h"
 #include "wtf/text/StringBuilder.h"
 
 namespace WebCore {
 
 using namespace HTMLNames;
 
 HTMLTextFormControlElement::HTMLTextFormControlElement(const QualifiedName& tagName, Document& doc, HTMLFormElement* form)
     : HTMLFormControlElementWithState(tagName, doc, form)
     , m_lastChangeWasUserEdit(false)
     , m_cachedSelectionStart(0)
@@ skipping 596 matching lines @@
     }
 
     return "ltr";
 }
 
 HTMLElement* HTMLTextFormControlElement::innerEditorElement() const
 {
     return toHTMLElement(userAgentShadowRoot()->getElementById(ShadowElementNames::innerEditor()));
 }
 
+static Position innerNodePosition(const Position& innerPosition)
+{
+    HTMLElement* element = toHTMLElement(innerPosition.anchorNode());
+    RefPtrWillBeRawPtr<NodeList> childNodes = element->childNodes();
+    if (!childNodes->length())
+        return Position(element, 0, Position::PositionIsOffsetInAnchor);
+
+    unsigned offset = 0;
+
+    switch (innerPosition.anchorType()) {
+    case Position::PositionIsOffsetInAnchor:
+        {
+            offset = std::max(0, std::min(innerPosition.computeOffsetInContainerNode(), (int)childNodes->length()));
+            break;
+        }
+    case Position::PositionIsAfterChildren:
+        {
+            offset = childNodes->length();
+            break;
+        }
+    default:
+        break;
+    }
+
+    if (offset == childNodes->length()) {
+        return Position(childNodes->item(childNodes->length() - 1), Position::PositionIsAfterAnchor);
+    }
+
+    Node* node = childNodes->item(offset);
+    if (node->isTextNode())
+        return Position(toText(node), 0);
+
+    return Position(node, Position::PositionIsBeforeAnchor);
+}
+
+static Position findWordBoundary(const HTMLElement* innerText, const Position& startPosition, const Position endPosition, bool findStart)

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |innerText| => |innerEditor|

[yoichio, 2014/07/03 04:32:19]

Done.

+{
+    Vector<UChar> characters;
+    Vector<unsigned> lengthList;
+    Vector<Text*> textList;
+    // Trace text nodes.
+    for (Node* node = startPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerText)) {
+        bool isStartNode = node == startPosition.anchorNode();
+        bool isEndNode = node == endPosition.anchorNode();
+        if (node->isTextNode()) {
+            Text* text = toText(node);
+            const unsigned start = isStartNode ? startPosition.computeOffsetInContainerNode() : 0;
+            const unsigned end = isEndNode ? endPosition.computeOffsetInContainerNode() : text->data().length();
+            for (unsigned offset = start; offset < end; ++offset)
+                characters.append(text->data()[offset]);
+            const unsigned length = end - start;
+
+            lengthList.append(length);
+            textList.append(text);
+        }
+
+        if (isEndNode)
+            break;
+    }
+
+    if (!characters.size())
+        return startPosition;
+
+    int start, end;
+    if (!findStart && characters.data()[0] == '\n') {
+        // findWordBoundary("\ntext", 0, &start, &end) assigns 1 to |end| but we expect 0 at the case.
+        start = 0;
+        end = 0;
+    } else {
+        findWordBoundary(characters.data(), characters.size(), findStart ? characters.size() : 0, &start, &end);
+    }
+    ASSERT(start >= 0);
+    ASSERT(end >= 0);
+    unsigned restOffset = findStart ? start : end;
+    // Find position.
+    for (unsigned i = 0; i < lengthList.size(); ++i) {
+        if (restOffset <= lengthList[i])
+            return Position(textList[i], (textList[i] == startPosition.anchorNode()) ? restOffset + startPosition.computeOffsetInContainerNode() : restOffset);
+        restOffset -= lengthList[i];
+    }
+
+    ASSERT_NOT_REACHED();
+    return Position();
+}
+
+Position HTMLTextFormControlElement::startOfWord(const Position& position)
+{
+    const HTMLTextFormControlElement* textForm = enclosingTextFormControl(position);
+    ASSERT(textForm);
+    HTMLElement* innerText = textForm->innerEditorElement();
+
+    const Position startPosition = startOfSentence(position);
+    if (startPosition == position)
+        return position;
+    const Position endPosition = (position.anchorNode() == innerText) ? innerNodePosition(position): position;
+
+    return findWordBoundary(innerText, startPosition, endPosition, true);
+}
+
+Position HTMLTextFormControlElement::endOfWord(const Position& position)
+{
+    const HTMLTextFormControlElement* textForm = enclosingTextFormControl(position);
+    ASSERT(textForm);
+    HTMLElement* innerText = textForm->innerEditorElement();
+
+
+    const Position endPosition = endOfSentence(position);
+    if (endPosition == position)
+        return position;
+    const Position startPosition = (position.anchorNode() == innerText) ? innerNodePosition(position) : position;
+
+    return findWordBoundary(innerText, startPosition, endPosition, false);
+}
+
+static int findLastLineBreak(const Text& text, int offset)
+{
+    for (; offset >= 0; offset--) {

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |--offset|

[yoichio, 2014/07/03 04:32:19]

Done.

+        if (text.data()[offset] == '\n')
+            return offset;
+    }
+    return -1;
+}
+
+static Position endOfPrevious(const Node& node, HTMLElement* innerText)
+{
+    Node* prev = NodeTraversal::previous(node, innerText);
+    if (!prev)
+        return Position();
+
+    if (prev->hasTagName(brTag))
+        return Position(prev, Position::PositionIsAfterAnchor);
+
+    if (prev->isTextNode()) {
+        Text* textNode = toText(prev);
+        return Position(textNode, textNode->length());
+    }
+
+    return Position();
+}
+
+static Position previousIfPositionIsAfterLineBreak(const Position& position, HTMLElement* innerText)
+{
+    if (position.isNull())
+        return Position();
+
+    // Move back if position is just after line break.
+    if (isHTMLBRElement(*position.anchorNode())) {
+        switch (position.anchorType()) {
+        case Position::PositionIsAfterAnchor:
+            return Position(position.anchorNode(), Position::PositionIsBeforeAnchor);
+        case Position::PositionIsBeforeAnchor:
+            return previousIfPositionIsAfterLineBreak(endOfPrevious(*position.anchorNode(), innerText), innerText);
+        default:
+            ASSERT_NOT_REACHED();
+        }
+    } else if (position.anchorNode()->isTextNode()) {
+        Text* textNode = toText(position.anchorNode());
+        unsigned offset = position.offsetInContainerNode();
+        if (textNode->length() == 0 || offset <= 0) {
+            return previousIfPositionIsAfterLineBreak(endOfPrevious(*position.anchorNode(), innerText), innerText);
+        }
+
+        if (offset <= textNode->length() && textNode->data()[offset - 1] == '\n') {
+            return Position(textNode, offset - 1);
+        }
+    }
+
+    return position;
+}
+
+static inline Position startOfInnerText(const HTMLTextFormControlElement* textForm)

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |textForm| => |textFormControl|

[yoichio, 2014/07/03 04:32:19]

Done.

+{
+    return Position(textForm->innerEditorElement(), 0, Position::PositionIsOffsetInAnchor);
+}
+
+Position HTMLTextFormControlElement::startOfSentence(const Position& position)
+{
+    HTMLTextFormControlElement* textForm = enclosingTextFormControl(position);

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |textForm| => |textFormControl|

[yoichio, 2014/07/03 04:32:19]

Done.

+    ASSERT(textForm);
+
+    HTMLElement* innerText = textForm->innerEditorElement();
+    if (!innerText->childNodes()->length())
+        return startOfInnerText(textForm);
+
+    const Position innerPosition = position.anchorNode() == innerText ? innerNodePosition(position): position;
+    const Position pivotPosition = previousIfPositionIsAfterLineBreak(innerPosition, innerText);
+    if (pivotPosition.isNull())
+        return startOfInnerText(textForm);
+
+    for (Node* node = pivotPosition.anchorNode(); node; node = NodeTraversal::previous(*node, innerText)) {
+        bool isPivotNode = (node == pivotPosition.anchorNode());
+
+        if (node->isTextNode()) {
+            Text* textNode = toText(node);
+            int lastLineBreak = findLastLineBreak(*textNode, isPivotNode ? pivotPosition.offsetInContainerNode() - 1 : (int)textNode->length() - 1);
+            if (lastLineBreak >= 0)
+                return Position(textNode, lastLineBreak + 1);
+        } else if (isHTMLBRElement(node) && (!isPivotNode || pivotPosition.anchorType() == Position::PositionIsAfterAnchor)) {
+            return Position(node, Position::PositionIsAfterAnchor);
+        }
+    }
+    return startOfInnerText(textForm);
+}
+
+static int findFirstLineBreak(const Text& text, int offset)
+{
+    for (; (unsigned)offset < text.length(); offset++) {
+        if (text.data()[offset] == '\n')
+            return offset;
+    }
+    return -1;
+}
+
+static Position endOfInnerText(const HTMLTextFormControlElement* textForm)

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |textForm| => |textFormControl|

[yoichio, 2014/07/03 04:32:19]

Done.

+{
+    HTMLElement* innerText = textForm->innerEditorElement();

[yosin_UTC9, 2014/07/03 04:05:10]

nit: |innerText|=>|innerEditor|

[yoichio, 2014/07/03 04:32:19]

Done.

+    return Position(innerText, innerText->childNodes()->length(), Position::PositionIsOffsetInAnchor);
+}
+
+Position HTMLTextFormControlElement::endOfSentence(const Position& position)
+{
+    HTMLTextFormControlElement* textForm = enclosingTextFormControl(position);
+    ASSERT(textForm);
+
+    HTMLElement* innerText = textForm->innerEditorElement();
+    if (!innerText->childNodes()->length())
+        return startOfInnerText(textForm);
+
+    const Position pivotPosition = position.anchorNode() == innerText ? innerNodePosition(position) : position;
+    if (pivotPosition.isNull())
+        return startOfInnerText(textForm);
+
+    for (Node* node = pivotPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerText)) {
+        bool isPivotNode = (node == pivotPosition.anchorNode());
+
+        if (node->isTextNode()) {
+            Text* textNode = toText(node);
+            int firstLineBreak = findFirstLineBreak(*textNode, isPivotNode ? pivotPosition.offsetInContainerNode() : 0);
+            if (firstLineBreak >= 0)
+                return Position(textNode, firstLineBreak + 1);
+        } else if (isHTMLBRElement(node)) {
+            return Position(node, Position::PositionIsAfterAnchor);
+        }
+    }
+    return endOfInnerText(textForm);
+}
+
 } // namespace Webcore