Rename innerTextElement/Value used in <input> and <textarea> to innerEditor.

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 85 matching lines @@
         return;
     }
 
     HTMLFormControlElementWithState::defaultEventHandler(event);
 }
 
 void HTMLTextFormControlElement::forwardEvent(Event* event)
 {
     if (event->type() == EventTypeNames::blur || event->type() == EventTypeNames::focus)
         return;
-    innerTextElement()->defaultEventHandler(event);
+    innerEditorElement()->defaultEventHandler(event);
 }
 
 String HTMLTextFormControlElement::strippedPlaceholder() const
 {
     // According to the HTML5 specification, we need to remove CR and LF from
     // the attribute value.
     const AtomicString& attributeValue = fastGetAttribute(placeholderAttr);
     if (!attributeValue.contains(newlineCharacter) && !attributeValue.contains(carriageReturn))
         return attributeValue;
 
@@ skipping 93 matching lines @@
 
 void HTMLTextFormControlElement::setRangeText(const String& replacement, unsigned start, unsigned end, const String& selectionMode, ExceptionState& exceptionState)
 {
     if (start > end) {
         exceptionState.throwDOMException(IndexSizeError, "The provided start value (" + String::number(start) + ") is larger than the provided end value (" + String::number(end) + ").");
         return;
     }
     if (hasAuthorShadowRoot())
         return;
 
-    String text = innerTextValue();
+    String text = innerEditorValue();
     unsigned textLength = text.length();
     unsigned replacementLength = replacement.length();
     unsigned newSelectionStart = selectionStart();
     unsigned newSelectionEnd = selectionEnd();
 
     start = std::min(start, textLength);
     end = std::min(end, textLength);
 
     if (start < end)
         text.replace(start, end - start, replacement);
     else
         text.insert(replacement, start);
 
-    setInnerTextValue(text);
+    setInnerEditorValue(text);
 
     // FIXME: What should happen to the value (as in value()) if there's no renderer?
     if (!renderer())
         return;
 
     subtreeHasChanged();
 
     if (equalIgnoringCase(selectionMode, "select")) {
         newSelectionStart = start;
         newSelectionEnd = start + replacementLength;
@@ skipping 33 matching lines @@
 void HTMLTextFormControlElement::setSelectionRange(int start, int end, TextFieldSelectionDirection direction)
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     if (!renderer() || !renderer()->isTextControl())
         return;
 
     end = std::max(end, 0);
     start = std::min(std::max(start, 0), end);
 
-    if (!hasVisibleTextArea(renderer(), innerTextElement())) {
+    if (!hasVisibleTextArea(renderer(), innerEditorElement())) {
         cacheSelection(start, end, direction);
         return;
     }
     VisiblePosition startPosition = visiblePositionForIndex(start);
     VisiblePosition endPosition;
     if (start == end)
         endPosition = startPosition;
     else
         endPosition = visiblePositionForIndex(end);
 
@@ skipping 10 matching lines @@
         newSelection = VisibleSelection(startPosition, endPosition);
     newSelection.setIsDirectional(direction != SelectionHasNoDirection);
 
     if (LocalFrame* frame = document().frame())
         frame->selection().setSelection(newSelection);
 }
 
 VisiblePosition HTMLTextFormControlElement::visiblePositionForIndex(int index) const
 {
     if (index <= 0)
-        return VisiblePosition(firstPositionInNode(innerTextElement()), DOWNSTREAM);
+        return VisiblePosition(firstPositionInNode(innerEditorElement()), DOWNSTREAM);
     RefPtrWillBeRawPtr<Range> range = Range::create(document());
-    range->selectNodeContents(innerTextElement(), ASSERT_NO_EXCEPTION);
+    range->selectNodeContents(innerEditorElement(), ASSERT_NO_EXCEPTION);
     CharacterIterator it(range.get());
     it.advance(index - 1);
     return VisiblePosition(it.range()->endPosition(), UPSTREAM);
 }
 
 int HTMLTextFormControlElement::indexForVisiblePosition(const VisiblePosition& pos) const
 {
     Position indexPosition = pos.deepEquivalent().parentAnchoredEquivalent();
     if (enclosingTextFormControl(indexPosition) != this)
         return 0;
     ASSERT(indexPosition.document());
     RefPtrWillBeRawPtr<Range> range = Range::create(*indexPosition.document());
-    range->setStart(innerTextElement(), 0, ASSERT_NO_EXCEPTION);
+    range->setStart(innerEditorElement(), 0, ASSERT_NO_EXCEPTION);
     range->setEnd(indexPosition.containerNode(), indexPosition.offsetInContainerNode(), ASSERT_NO_EXCEPTION);
     return TextIterator::rangeLength(range.get());
 }
 
 int HTMLTextFormControlElement::selectionStart() const
 {
     if (!isTextFormControl())
         return 0;
     if (document().focusedElement() != this)
         return m_cachedSelectionStart;
@@ skipping 83 matching lines @@
 
 PassRefPtrWillBeRawPtr<Range> HTMLTextFormControlElement::selection() const
 {
     if (!renderer() || !isTextFormControl())
         return nullptr;
 
     int start = m_cachedSelectionStart;
     int end = m_cachedSelectionEnd;
 
     ASSERT(start <= end);
-    HTMLElement* innerText = innerTextElement();
+    HTMLElement* innerText = innerEditorElement();
     if (!innerText)
         return nullptr;
 
     if (!innerText->firstChild())
         return Range::create(document(), innerText, 0, innerText, 0);
 
     int offset = 0;
     Node* startNode = 0;
     Node* endNode = 0;
     for (Node* node = innerText->firstChild(); node; node = NodeTraversal::next(*node, innerText)) {
@@ skipping 46 matching lines @@
         HTMLFormControlElementWithState::parseAttribute(name, value);
 }
 
 bool HTMLTextFormControlElement::lastChangeWasUserEdit() const
 {
     if (!isTextFormControl())
         return false;
     return m_lastChangeWasUserEdit;
 }
 
-void HTMLTextFormControlElement::setInnerTextValue(const String& value)
+void HTMLTextFormControlElement::setInnerEditorValue(const String& value)
 {
     ASSERT(!hasAuthorShadowRoot());
     if (!isTextFormControl() || hasAuthorShadowRoot())
         return;
 
-    bool textIsChanged = value != innerTextValue();
-    if (textIsChanged || !innerTextElement()->hasChildren()) {
+    bool textIsChanged = value != innerEditorValue();
+    if (textIsChanged || !innerEditorElement()->hasChildren()) {
         if (textIsChanged && renderer()) {
             if (AXObjectCache* cache = document().existingAXObjectCache())
                 cache->postNotification(this, AXObjectCache::AXValueChanged, false);
         }
-        innerTextElement()->setInnerText(value, ASSERT_NO_EXCEPTION);
+        innerEditorElement()->setInnerText(value, ASSERT_NO_EXCEPTION);
 
         if (value.endsWith('\n') || value.endsWith('\r'))
-            innerTextElement()->appendChild(HTMLBRElement::create(document()));
+            innerEditorElement()->appendChild(HTMLBRElement::create(document()));
     }
 }
 
 static String finishText(StringBuilder& result)
 {
     // Remove one trailing newline; there's always one that's collapsed out by rendering.
     size_t size = result.length();
     if (size && result[size - 1] == '\n')
         result.resize(--size);
     return result.toString();
 }
 
-String HTMLTextFormControlElement::innerTextValue() const
+String HTMLTextFormControlElement::innerEditorValue() const
 {
     ASSERT(!hasAuthorShadowRoot());
-    HTMLElement* innerText = innerTextElement();
-    if (!innerText || !isTextFormControl())
+    HTMLElement* innerEditor = innerEditorElement();
+    if (!innerEditor || !isTextFormControl())
         return emptyString();
 
     StringBuilder result;
-    for (Node* node = innerText; node; node = NodeTraversal::next(*node, innerText)) {
+    for (Node* node = innerEditor; node; node = NodeTraversal::next(*node, innerEditor)) {
         if (isHTMLBRElement(*node))
             result.append(newlineCharacter);
         else if (node->isTextNode())
             result.append(toText(node)->data());
     }
     return finishText(result);
 }
 
 static void getNextSoftBreak(RootInlineBox*& line, Node*& breakNode, unsigned& breakOffset)
 {
     RootInlineBox* next;
     for (; line; line = next) {
         next = line->nextRootBox();
         if (next && !line->endsWithBreak()) {
             ASSERT(line->lineBreakObj());
             breakNode = line->lineBreakObj()->node();
             breakOffset = line->lineBreakPos();
             line = next;
             return;
         }
     }
     breakNode = 0;
     breakOffset = 0;
 }
 
 String HTMLTextFormControlElement::valueWithHardLineBreaks() const
 {
     // FIXME: It's not acceptable to ignore the HardWrap setting when there is no renderer.
     // While we have no evidence this has ever been a practical problem, it would be best to fix it some day.
-    HTMLElement* innerText = innerTextElement();
+    HTMLElement* innerText = innerEditorElement();
     if (!innerText || !isTextFormControl())
         return value();
 
     RenderBlock* renderer = toRenderBlock(innerText->renderer());
     if (!renderer)
         return value();
 
     Node* breakNode;
     unsigned breakOffset;
     RootInlineBox* line = renderer->firstRootBox();
@@ skipping 65 matching lines @@
         if (equalIgnoringCase(dirAttributeValue, "auto")) {
             bool isAuto;
             TextDirection textDirection = element->directionalityIfhasDirAutoAttribute(isAuto);
             return textDirection == RTL ? "rtl" : "ltr";
         }
     }
 
     return "ltr";
 }
 
-HTMLElement* HTMLTextFormControlElement::innerTextElement() const
+HTMLElement* HTMLTextFormControlElement::innerEditorElement() const
 {
     return toHTMLElement(userAgentShadowRoot()->getElementById(ShadowElementNames::innerEditor()));
 }
 
 } // namespace Webcore