[WIP, not for review] Workaround for setComposition styling clobber

third_party/WebKit/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 294 matching lines @@
 
 void InputMethodController::setComposition(const String& text, const Vector<CompositionUnderline>& underlines, int selectionStart, int selectionEnd)
 {
     Editor::RevealSelectionScope revealSelectionScope(&editor());
 
     // Updates styles before setting selection for composition to prevent
     // inserting the previous composition text into text nodes oddly.
     // See https://bugs.webkit.org/show_bug.cgi?id=46868
     frame().document()->updateStyleAndLayoutTree();
 
+    // When the IME only wants to change a few characters at the end of the
+    // composition, only touch those characters in order to preserve rich text
+    // substructure.
+    String composing = composingText();
+    bool appending = composing.length() > 0 && composing == text.left(composing.length());
+    bool backspacing = text.length() > 0 && text == composing.left(text.length());

[Changwan Ryu, 2016/09/07 04:14:39]

FYI, this workaround is not going to work for Korean characters (and probably
many more). 

One possible Hangul composition sequence is as follows:
가나다라 -> 가나다람 -> 가나다라마 -> 가나다라맙 -> 가나다라마바

Hangul keyboards consider a consonant to be an ending consonant of the current
character until they see a vowel. And if a vowel follows, the consonant becomes
a starting consonant of a new character.

This is not appending nor backspacing in this case.

Can we extend the logic to actually check for the maximal leftmost (I mean
firstmost) characters?

[aelias_OOO_until_Jul13, 2016/09/07 05:11:49]

OK.  It looks like I can just use std::distance and std::mismatch for this
(http://codereview.stackexchange.com/questions/104477/fastest-c-code-to-get-co...
)

+    if (appending || backspacing) {
+        const EphemeralRange range = compositionEphemeralRange();
+        Element* editable = frame().selection().rootEditableElement();
+        if (!editable)
+            return;
+
+        // Move selection to the end of the composition.
+        PlainTextRange compositionPlainOffsets = PlainTextRange::create(*editable, range);
+        VisibleSelection selection;
+        selection.setWithoutValidation(range.endPosition(), range.endPosition());
+        frame().selection().setSelection(selection, 0);
+        clear();
+
+        // Apply the incremental change.
+        if (appending)
+            confirmCompositionOrInsertText(text.substring(composing.length()), DoNotKeepSelection);
+        else if (backspacing)
+            extendSelectionAndDelete(composing.length() - text.length(), 0);
+
+        // Now recreate the composition starting at its original start, and
+        // apply the specified final selection offsets.
+        setCompositionFromExistingText(underlines, compositionPlainOffsets.start(), compositionPlainOffsets.start() + text.length());
+        selectComposition();
+        setSelectionRangeForSetComposition(selectionStart, selectionEnd);
+        return;
+    }
+
     selectComposition();
 
     if (frame().selection().isNone())
         return;
 
     Element* target = frame().document()->focusedElement();
     if (!target)
         return;
 
     // Dispatch an appropriate composition event to the focused node.
@@ skipping 58 matching lines @@
     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);
 
     if (baseNode->layoutObject())
         baseNode->layoutObject()->setShouldDoFullPaintInvalidation();
 
+    setSelectionRangeForSetComposition(selectionStart, selectionEnd);
+
+    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::setSelectionRangeForSetComposition(int selectionStart, int selectionEnd)
+{
     // In case of exceeding the left boundary.
     int selectionOffsetsStart = static_cast<int>(getSelectionOffsets().start());
     int start = std::max(selectionOffsetsStart + selectionStart, 0);
     int end = std::max(selectionOffsetsStart + selectionEnd, start);
 
     Element* rootEditableElement = frame().selection().rootEditableElement();
     if (!rootEditableElement)
         return;
 
     // In case of exceeding the right boundary.
     // If both |value1| and |value2| exceed right boundary,
     // PlainTextRange(value1, value2)::createRange() will return a default
     // value, which is [0,0]. In order to get the correct Position in that case,
     // we should make sure |value1| is within range at least.
     const EphemeralRange& startRange = PlainTextRange(0, start).createRange(*rootEditableElement);
     const EphemeralRange& endRange = PlainTextRange(0, end).createRange(*rootEditableElement);
 
     // TODO(yabinh): There should be a better way to create |startPosition| and
     // |endPosition|. But for now, since we can't get |anchorNode| and |offset|,
     // we can't create the 2 Position objects directly. So we use
     // PlainTextRange::createRange as a workaround.
     const Position& startPosition = startRange.endPosition();
     const Position& endPosition = endRange.endPosition();
     const EphemeralRange selectedRange(startPosition, endPosition);
     frame().selection().setSelectedRange(selectedRange, TextAffinity::Downstream, SelectionDirectionalMode::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)
         return;
 
     const EphemeralRange range = PlainTextRange(compositionStart, compositionEnd).createRange(*editable);
     if (range.isNull())
@@ skipping 107 matching lines @@
     TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController)
 {
     visitor->trace(m_frame);
     visitor->trace(m_compositionRange);
 }
 
 } // namespace blink