Revert of Avoid style clobbering in setCompositionFromExistingText.

Source/core/editing/InputMethodController.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
@@ skipping 11 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/editing/InputMethodController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
+#include "core/dom/Range.h"
 #include "core/dom/Text.h"
-#include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/commands/TypingCommand.h"
-#include "core/editing/markers/DocumentMarkerController.h"
 #include "core/events/CompositionEvent.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLTextAreaElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutObject.h"
-#include "core/layout/LayoutTheme.h"
 #include "core/page/ChromeClient.h"
 
 namespace blink {
 
 InputMethodController::SelectionOffsetsScope::SelectionOffsetsScope(InputMethodController* inputMethodController)
     : m_inputMethodController(inputMethodController)
     , m_offsets(inputMethodController->getSelectionOffsets())
 {
 }
 
 InputMethodController::SelectionOffsetsScope::~SelectionOffsetsScope()
 {
     m_inputMethodController->setSelectionOffsets(m_offsets);
 }
 
 // ----------------------------
 
 PassOwnPtrWillBeRawPtr<InputMethodController> InputMethodController::create(LocalFrame& frame)
 {
     return adoptPtrWillBeNoop(new InputMethodController(frame));
 }
 
 InputMethodController::InputMethodController(LocalFrame& frame)
     : m_frame(&frame)
-    , m_isDirty(false)
-    , m_hasComposition(false)
+    , m_compositionStart(0)
+    , m_compositionEnd(0)
 {
 }
 
 InputMethodController::~InputMethodController()
 {
 }
 
 bool InputMethodController::hasComposition() const
 {
-    return m_hasComposition;
+    return m_compositionNode && m_compositionNode->isContentEditable();
 }
 
 inline Editor& InputMethodController::editor() const
 {
     return frame().editor();
 }
 
 void InputMethodController::clear()
 {
-    m_hasComposition = false;
-    if (m_compositionRange) {
-        m_compositionRange->setStart(frame().document(), 0);
-        m_compositionRange->collapse(true);
-    }
-    frame().document()->markers().removeMarkers(DocumentMarker::Composition);
-    m_isDirty = false;
+    m_compositionNode = nullptr;
+    m_customCompositionUnderlines.clear();
 }
 
 bool InputMethodController::insertTextForConfirmedComposition(const String& text)
 {
     return frame().eventHandler().handleTextInputEvent(text, 0, TextEventInputComposition);
 }
 
 void InputMethodController::selectComposition() const
 {
     const EphemeralRange range = compositionEphemeralRange();
     if (range.isNull())
         return;
 
     // The composition can start inside a composed character sequence, so we have to override checks.
     // See <http://bugs.webkit.org/show_bug.cgi?id=15781>
     VisibleSelection selection;
     selection.setWithoutValidation(range.startPosition(), range.endPosition());
     frame().selection().setSelection(selection, 0);
 }
 
 bool InputMethodController::confirmComposition()
 {
     if (!hasComposition())
         return false;
-    return confirmComposition(plainText(compositionEphemeralRange()));
+    return finishComposition(m_compositionNode->data().substring(m_compositionStart, m_compositionEnd - m_compositionStart), ConfirmComposition);
 }
 
 bool InputMethodController::confirmComposition(const String& text)
 {
     return finishComposition(text, ConfirmComposition);
 }
 
 bool InputMethodController::confirmCompositionOrInsertText(const String& text, ConfirmCompositionBehavior confirmBehavior)
 {
     if (!hasComposition()) {
@@ skipping 19 matching lines @@
 {
     finishComposition(emptyString(), CancelComposition);
 }
 
 void InputMethodController::cancelCompositionIfSelectionIsInvalid()
 {
     if (!hasComposition() || editor().preventRevealSelection())
         return;
 
     // Check if selection start and selection end are valid.
-    FrameSelection& selection = frame().selection();
-    if (!selection.isNone() && !m_compositionRange->collapsed()) {
-        Position start = selection.start();
-        Position end = selection.end();
-        if (selection.start().compareTo(m_compositionRange->startPosition()) >= 0
-            && selection.end().compareTo(m_compositionRange->endPosition()) <= 0)
-            return;
-    }
+    Position start = frame().selection().start();
+    Position end = frame().selection().end();
+    if (start.computeContainerNode() == m_compositionNode
+        && end.computeContainerNode() == m_compositionNode
+        && static_cast<unsigned>(start.computeOffsetInContainerNode()) >= m_compositionStart
+        && static_cast<unsigned>(end.computeOffsetInContainerNode()) <= m_compositionEnd)
+        return;
 
     cancelComposition();
     frame().chromeClient().didCancelCompositionOnSelectionChange();
 }
 
 bool InputMethodController::finishComposition(const String& text, FinishCompositionMode mode)
 {
     if (!hasComposition())
         return false;
 
@@ skipping 10 matching lines @@
         return false;
 
     // Dispatch a compositionend event to the focused node.
     // We should send this event before sending a TextEvent as written in Section 6.2.2 and 6.2.3 of
     // the DOM Event specification.
     if (Element* target = frame().document()->focusedElement()) {
         RefPtrWillBeRawPtr<CompositionEvent> event = CompositionEvent::create(EventTypeNames::compositionend, frame().domWindow(), text);
         target->dispatchEvent(event);
     }
 
-    bool dirty = m_isDirty || plainText(compositionEphemeralRange()) != text;
-
     // If text is empty, then delete the old composition here. If text is non-empty, InsertTextCommand::input
     // will delete the old composition with an optimized replace operation.
-    if (text.isEmpty() && mode != CancelComposition && dirty) {
+    if (text.isEmpty() && mode != CancelComposition) {
         ASSERT(frame().document());
         TypingCommand::deleteSelection(*frame().document(), 0);
     }
 
-    clear();
+    m_compositionNode = nullptr;
+    m_customCompositionUnderlines.clear();
 
-    if (dirty)
-        insertTextForConfirmedComposition(text);
+    insertTextForConfirmedComposition(text);
 
     if (mode == CancelComposition) {
         // An open typing command that disagrees about current selection would cause issues with typing later on.
         TypingCommand::closeTyping(m_frame);
     }
 
     return true;
 }
 
 void InputMethodController::setComposition(const String& text, const Vector<CompositionUnderline>& underlines, unsigned selectionStart, unsigned selectionEnd)
@@ skipping 10 matching lines @@
     if (frame().selection().isNone())
         return;
 
     if (Element* target = frame().document()->focusedElement()) {
         // Dispatch an appropriate composition event to the focused node.
         // We check the composition status and choose an appropriate composition event since this
         // function is used for three purposes:
         // 1. Starting a new composition.
         //    Send a compositionstart and a compositionupdate event when this function creates
         //    a new composition node, i.e.
-        //    !hasComposition() && !text.isEmpty().
+        //    m_compositionNode == 0 && !text.isEmpty().
         //    Sending a compositionupdate event at this time ensures that at least one
         //    compositionupdate event is dispatched.
         // 2. Updating the existing composition node.
         //    Send a compositionupdate event when this function updates the existing composition
-        //    node, i.e. hasComposition() && !text.isEmpty().
+        //    node, i.e. m_compositionNode != 0 && !text.isEmpty().
         // 3. Canceling the ongoing composition.
         //    Send a compositionend event when function deletes the existing composition node, i.e.
-        //    !hasComposition() && test.isEmpty().
+        //    m_compositionNode != 0 && test.isEmpty().
         RefPtrWillBeRawPtr<CompositionEvent> event = nullptr;
         if (!hasComposition()) {
             // We should send a compositionstart event only when the given text is not empty because this
             // function doesn't create a composition node when the text is empty.
             if (!text.isEmpty()) {
                 target->dispatchEvent(CompositionEvent::create(EventTypeNames::compositionstart, frame().domWindow(), frame().selectedText()));
                 event = CompositionEvent::create(EventTypeNames::compositionupdate, frame().domWindow(), text);
             }
         } else {
             if (!text.isEmpty())
                 event = CompositionEvent::create(EventTypeNames::compositionupdate, frame().domWindow(), text);
             else
                 event = CompositionEvent::create(EventTypeNames::compositionend, frame().domWindow(), text);
         }
         if (event.get())
             target->dispatchEvent(event);
     }
 
     // If text is empty, then delete the old composition here. If text is non-empty, InsertTextCommand::input
     // will delete the old composition with an optimized replace operation.
     if (text.isEmpty()) {
         ASSERT(frame().document());
         TypingCommand::deleteSelection(*frame().document(), TypingCommand::PreventSpellChecking);
     }
 
-    clear();
+    m_compositionNode = nullptr;
+    m_customCompositionUnderlines.clear();
 
     if (text.isEmpty())
         return;
     ASSERT(frame().document());
     TypingCommand::insertText(*frame().document(), text, TypingCommand::SelectInsertedText | TypingCommand::PreventSpellChecking, TypingCommand::TextCompositionUpdate);
 
     // Find out what node has the composition now.
     Position base = mostForwardCaretPosition(frame().selection().base());
     Node* baseNode = base.anchorNode();
     if (!baseNode || !baseNode->isTextNode())
         return;
 
     Position extent = frame().selection().extent();
     Node* extentNode = extent.anchorNode();
     if (baseNode != extentNode)
         return;
 
     unsigned extentOffset = extent.computeOffsetInContainerNode();
     unsigned baseOffset = base.computeOffsetInContainerNode();
     if (baseOffset + text.length() != extentOffset)
         return;
 
-    m_isDirty = true;
-    m_hasComposition = true;
-    if (!m_compositionRange)
-        m_compositionRange = Range::create(baseNode->document());
-    m_compositionRange->setStart(baseNode, baseOffset);
-    m_compositionRange->setEnd(baseNode, extentOffset);
-
+    m_compositionNode = toText(baseNode);
+    m_compositionStart = baseOffset;
+    m_compositionEnd = extentOffset;
+    m_customCompositionUnderlines = underlines;
+    for (auto& underline : m_customCompositionUnderlines) {
+        underline.startOffset += baseOffset;
+        underline.endOffset += baseOffset;
+    }
     if (baseNode->layoutObject())
         baseNode->layoutObject()->setShouldDoFullPaintInvalidation();
 
     unsigned start = std::min(baseOffset + selectionStart, extentOffset);
     unsigned end = std::min(std::max(start, baseOffset + selectionEnd), extentOffset);
     RefPtrWillBeRawPtr<Range> selectedRange = Range::create(baseNode->document(), baseNode, start, baseNode, end);
     frame().selection().setSelectedRange(selectedRange.get(), TextAffinity::Downstream, FrameSelection::NonDirectional, NotUserTriggered);
-
-    if (underlines.isEmpty()) {
-        frame().document()->markers().addCompositionMarker(m_compositionRange->startPosition(), m_compositionRange->endPosition(), Color::black, false, LayoutTheme::theme().platformDefaultCompositionBackgroundColor());
-        return;
-    }
-    for (const auto& underline : underlines) {
-        unsigned underlineStart = baseOffset + underline.startOffset;
-        unsigned underlineEnd = baseOffset + underline.endOffset;
-        EphemeralRange ephemeralLineRange = EphemeralRange(Position(baseNode, underlineStart), Position(baseNode, underlineEnd));
-        if (ephemeralLineRange.isNull())
-            continue;
-        frame().document()->markers().addCompositionMarker(ephemeralLineRange.startPosition(), ephemeralLineRange.endPosition(), underline.color, underline.thick, underline.backgroundColor);
-    }
 }
 
 void InputMethodController::setCompositionFromExistingText(const Vector<CompositionUnderline>& underlines, unsigned compositionStart, unsigned compositionEnd)
 {
     Element* editable = frame().selection().rootEditableElement();
-    if (!editable)
+    Position base = mostForwardCaretPosition(frame().selection().base());
+    Node* baseNode = base.anchorNode();
+    if (baseNode && editable->firstChild() == baseNode && editable->lastChild() == baseNode && baseNode->isTextNode()) {
+        m_compositionNode = nullptr;
+        m_customCompositionUnderlines.clear();
+
+        if (!base.isOffsetInAnchor())
+            return;
+        if (baseNode != frame().selection().extent().anchorNode())
+            return;
+
+        m_compositionNode = toText(baseNode);
+        const EphemeralRange range = PlainTextRange(compositionStart, compositionEnd).createRange(*editable);
+        if (range.isNull())
+            return;
+
+        m_compositionStart = range.startPosition().computeOffsetInContainerNode();
+        m_compositionEnd = range.endPosition().computeOffsetInContainerNode();
+        m_customCompositionUnderlines = underlines;
+        size_t numUnderlines = m_customCompositionUnderlines.size();
+        for (size_t i = 0; i < numUnderlines; ++i) {
+            m_customCompositionUnderlines[i].startOffset += m_compositionStart;
+            m_customCompositionUnderlines[i].endOffset += m_compositionStart;
+        }
+        if (baseNode->layoutObject())
+            baseNode->layoutObject()->setShouldDoFullPaintInvalidation();
         return;
-
-    const EphemeralRange range = PlainTextRange(compositionStart, compositionEnd).createRange(*editable);
-    if (range.isNull())
-        return;
-
-    const Position start = range.startPosition();
-    if (editableRootForPosition(start) != editable)
-        return;
-
-    const Position end = range.endPosition();
-    if (editableRootForPosition(end) != editable)
-        return;
-
-    clear();
-
-    for (const auto& underline : underlines) {
-        unsigned underlineStart = compositionStart + underline.startOffset;
-        unsigned underlineEnd = compositionStart + underline.endOffset;
-        EphemeralRange ephemeralLineRange = PlainTextRange(underlineStart, underlineEnd).createRange(*editable);
-        if (ephemeralLineRange.isNull())
-            continue;
-        frame().document()->markers().addCompositionMarker(ephemeralLineRange.startPosition(), ephemeralLineRange.endPosition(), underline.color, underline.thick, underline.backgroundColor);
     }
 
-    m_hasComposition = true;
-    if (!m_compositionRange)
-        m_compositionRange = Range::create(range.document());
-    m_compositionRange->setStart(range.startPosition());
-    m_compositionRange->setEnd(range.endPosition());
+    Editor::RevealSelectionScope revealSelectionScope(&editor());
+    SelectionOffsetsScope selectionOffsetsScope(this);
+    setSelectionOffsets(PlainTextRange(compositionStart, compositionEnd));
+    setComposition(frame().selectedText(), underlines, 0, 0);
 }
 
 EphemeralRange InputMethodController::compositionEphemeralRange() const
 {
     if (!hasComposition())
         return EphemeralRange();
-    return EphemeralRange(m_compositionRange.get());
+    unsigned length = m_compositionNode->length();
+    unsigned start = std::min(m_compositionStart, length);
+    unsigned end = std::min(std::max(start, m_compositionEnd), length);
+    if (start >= end)
+        return EphemeralRange();
+    return EphemeralRange(Position(m_compositionNode.get(), start), Position(m_compositionNode.get(), end));
 }
 
 PassRefPtrWillBeRawPtr<Range> InputMethodController::compositionRange() const
 {
-    return hasComposition() ? m_compositionRange : nullptr;
+    return createRange(compositionEphemeralRange());
 }
 
 PlainTextRange InputMethodController::getSelectionOffsets() const
 {
     RefPtrWillBeRawPtr<Range> range = firstRangeOf(frame().selection().selection());
     if (!range)
         return PlainTextRange();
     ContainerNode* editable = frame().selection().rootEditableElementOrTreeScopeRootNode();
     ASSERT(editable);
     return PlainTextRange::create(*editable, *range.get());
@@ skipping 47 matching lines @@
         if (before == 0)
             break;
         ++before;
     } while (frame().selection().start() == frame().selection().end() && before <= static_cast<int>(selectionOffsets.start()));
     TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController)
 {
     visitor->trace(m_frame);
-    visitor->trace(m_compositionRange);
+    visitor->trace(m_compositionNode);
 }
 
 } // namespace blink