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());
+    ASSERT(element);
+    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.offsetInContainerNode(), static_cast<int>(childNodes->length())));
+        break;
+    case Position::PositionIsAfterChildren:
+        offset = childNodes->length();
+        break;
+    case Position::PositionIsBeforeAnchor:
+    case Position::PositionIsAfterAnchor:
+        ASSERT_NOT_REACHED();

[Yuta Kitamura, 2014/07/04 06:12:35]

This assertion fails to ASSERT if the function exits at line
670. This is a precondition, so it should be placed in the
beginning of the function.

[yoichio, 2014/07/04 07:25:26]

Done.

+        break;
+    default:
+        break;
+    }
+
+    if (offset == childNodes->length())
+        return Position(element->lastChild(), 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* innerEditor, const Position& startPosition, const Position& endPosition, bool findStart)

[Yuta Kitamura, 2014/07/04 06:12:35]

Prefer enums to bools on function parameters. The caller passing
just "true" or "false" isn't very readable.

[yoichio, 2014/07/04 07:25:26]

Done.

+{
+    Vector<UChar> characters;
+    Vector<unsigned> lengthList;
+    Vector<Text*> textList;
+
+    if (startPosition.anchorNode()->isTextNode())
+        ASSERT(startPosition.anchorType() == Position::PositionIsOffsetInAnchor);
+    if (endPosition.anchorNode()->isTextNode())
+        ASSERT(endPosition.anchorType() == Position::PositionIsOffsetInAnchor);
+
+    // Trace text nodes.
+    for (Node* node = startPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerEditor)) {
+        bool isStartNode = node == startPosition.anchorNode();
+        bool isEndNode = node == endPosition.anchorNode();
+        if (node->isTextNode()) {
+            Text* text = toText(node);
+            const unsigned start = isStartNode ? startPosition.offsetInContainerNode() : 0;
+            const unsigned end = isEndNode ? endPosition.offsetInContainerNode() : 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') {

[Yuta Kitamura, 2014/07/04 06:12:35]

".data()" isn't necessary.

[yoichio, 2014/07/04 07:25:26]

Done.

+        // 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 remainingOffset = findStart ? start : end;
+    // Find position.
+    for (unsigned i = 0; i < lengthList.size(); ++i) {
+        if (remainingOffset <= lengthList[i])
+            return Position(textList[i], (textList[i] == startPosition.anchorNode()) ? remainingOffset + startPosition.offsetInContainerNode() : remainingOffset);
+        remainingOffset -= lengthList[i];
+    }
+
+    ASSERT_NOT_REACHED();
+    return Position();
+}
+
+Position HTMLTextFormControlElement::startOfWord(const Position& position)
+{
+    const HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
+    ASSERT(textFormControl);
+    HTMLElement* innerEditor = textFormControl->innerEditorElement();
+
+    const Position startPosition = startOfSentence(position);
+    if (startPosition == position)
+        return position;
+    const Position endPosition = (position.anchorNode() == innerEditor) ? innerNodePosition(position) : position;
+
+    return findWordBoundary(innerEditor, startPosition, endPosition, true);
+}
+
+Position HTMLTextFormControlElement::endOfWord(const Position& position)
+{
+    const HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
+    ASSERT(textFormControl);
+    HTMLElement* innerEditor = textFormControl->innerEditorElement();
+
+

[Yuta Kitamura, 2014/07/04 06:12:35]

nit: Unnecessary blank line.

[yoichio, 2014/07/04 07:25:26]

Done.

+    const Position endPosition = endOfSentence(position);
+    if (endPosition == position)
+        return position;
+    const Position startPosition = (position.anchorNode() == innerEditor) ? innerNodePosition(position) : position;
+
+    return findWordBoundary(innerEditor, startPosition, endPosition, false);
+}
+
+static int findLastLineBreak(const Text& text, int offset)
+{
+    for (; offset >= 0; --offset) {
+        if (text.data()[offset] == '\n')
+            return offset;

[Yuta Kitamura, 2014/07/04 06:12:35]

Use String::reverseFind().

[yoichio, 2014/07/04 07:25:26]

Done. Removed this function and inlined at call.

+    }
+    return -1;
+}
+
+static Position endOfPrevious(const Node& node, HTMLElement* innerEditor)
+{
+    Node* prev = NodeTraversal::previous(node, innerEditor);

[Yuta Kitamura, 2014/07/04 06:12:35]

Please don't use abbreviated word in names.

[yoichio, 2014/07/04 07:25:26]

Done.

+    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* innerEditor)
+{
+    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(), innerEditor), innerEditor);
+        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(), innerEditor), innerEditor);
+        }
+
+        if (offset <= textNode->length() && textNode->data()[offset - 1] == '\n') {
+            return Position(textNode, offset - 1);
+        }
+    }
+
+    return position;
+}
+
+static inline Position startOfInnerText(const HTMLTextFormControlElement* textFormControl)
+{
+    return Position(textFormControl->innerEditorElement(), 0, Position::PositionIsOffsetInAnchor);
+}
+
+Position HTMLTextFormControlElement::startOfSentence(const Position& position)
+{
+    HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
+    ASSERT(textFormControl);
+
+    HTMLElement* innerEditor = textFormControl->innerEditorElement();
+    if (!innerEditor->childNodes()->length())
+        return startOfInnerText(textFormControl);
+
+    const Position innerPosition = position.anchorNode() == innerEditor ? innerNodePosition(position) : position;
+    const Position pivotPosition = previousIfPositionIsAfterLineBreak(innerPosition, innerEditor);
+    if (pivotPosition.isNull())
+        return startOfInnerText(textFormControl);
+
+    for (Node* node = pivotPosition.anchorNode(); node; node = NodeTraversal::previous(*node, innerEditor)) {
+        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(textFormControl);
+}
+
+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* textFormControl)
+{
+    HTMLElement* innerEditor = textFormControl->innerEditorElement();
+    return Position(innerEditor, innerEditor->childNodes()->length(), Position::PositionIsOffsetInAnchor);
+}
+
+Position HTMLTextFormControlElement::endOfSentence(const Position& position)
+{
+    HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
+    ASSERT(textFormControl);
+
+    HTMLElement* innerEditor = textFormControl->innerEditorElement();
+    if (!innerEditor->childNodes()->length())
+        return startOfInnerText(textFormControl);
+
+    const Position pivotPosition = position.anchorNode() == innerEditor ? innerNodePosition(position) : position;
+    if (pivotPosition.isNull())
+        return startOfInnerText(textFormControl);
+
+    for (Node* node = pivotPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerEditor)) {
+        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(textFormControl);
+}
+
 } // namespace Webcore