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 329 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.
+    if (hasComposition() && text.length()) {
+        String composing = composingText();
+        size_t commonPrefixLength = 0;

[yabinh, 2016/09/26 10:10:32]

aelias@ suggests to use std::mismatch():
https://codereview.chromium.org/2073863003#msg3
std::mismatch() takes char*. If we assign |composing| to a local char* variable,
we'll get incorrect result, which is weird.

const char* composingText = composing.utf8().data();
LOG(ERROR)<<composing.utf8().data(); // correct
LOG(ERROR)<<composingText; // incorrect, garbled.

[Changwan Ryu, 2016/09/26 13:51:36]

std::mismatch accepts not only char* but any InputIterator, and it doesn't make
much sense to pass char* iterators here because there are many different UTF8 /
UTF16 characters that have common prefix bytes.

Probably a wrapper around existing UTF16CharIterator may do which already
handles surrogate pairs.
But if wrapper implementation is complicated, I'd prefer that you implement a
separate static UTF16CommonPrefix() function.
(BTW, do we still need to consider UTF8 other than test? Probably not.)

If you're concerned about incorrect utf8().data() logging, you may want to
generate from smallest possible text and get the hex data from the logcat to see
what's happened. I have no idea what could go wrong here.

[yabinh, 2016/09/27 04:30:22]

Done.
Implemented a separate static function.

+        while (commonPrefixLength < composing.length() && commonPrefixLength < text.length() && composing[commonPrefixLength] == text[commonPrefixLength])
+            commonPrefixLength++;
+
+        bool appending = text.length() > commonPrefixLength;
+        bool backspacing = composing.length() > commonPrefixLength;
+        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();
+
+            Element* target = frame().document()->focusedElement();
+            if (!target)
+                return;
+
+            // Apply the incremental change.
+            if (backspacing)
+                extendSelectionAndDelete(composing.length() - commonPrefixLength, 0);
+            if (appending)
+                commitText(text.substring(commonPrefixLength), 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();
+            PlainTextRange selectedRange = createSelectionRangeForSetComposition(selectionStart, selectionEnd, text.length());
+            // We shouldn't close typing in the middle of setComposition.
+            setEditableSelectionOffsets(selectedRange, NotUserTriggered);
+            m_isDirty = true;
+            return;
+        }
+    }
+
     selectComposition();
 
     if (frame().selection().isNone())
         return;
 
     Element* target = frame().document()->focusedElement();
     if (!target)
         return;
 
-    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited. see http://crbug.com/590369 for more details.
-    frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
-
-    int selectionOffsetsStart = static_cast<int>(getSelectionOffsets().start());
-    int start = selectionOffsetsStart + selectionStart;
-    int end = selectionOffsetsStart + selectionEnd;
-    PlainTextRange selectedRange = createRangeForSelection(start, end, text.length());
+    PlainTextRange selectedRange = createSelectionRangeForSetComposition(selectionStart, selectionEnd, text.length());
 
     // 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().
     //    Sending a compositionupdate event at this time ensures that at least one
     //    compositionupdate event is dispatched.
@@ skipping 82 matching lines @@
     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());
     }
 }
 
+PlainTextRange InputMethodController::createSelectionRangeForSetComposition(int selectionStart, int selectionEnd, size_t textLength) const
+{
+    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+    // needs to be audited. see http://crbug.com/590369 for more details.
+    frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+
+    int selectionOffsetsStart = static_cast<int>(getSelectionOffsets().start());
+    int start = selectionOffsetsStart + selectionStart;
+    int end = selectionOffsetsStart + selectionEnd;
+    return createRangeForSelection(start, end, textLength);
+}
+
 void InputMethodController::setCompositionFromExistingText(const Vector<CompositionUnderline>& underlines, unsigned compositionStart, unsigned compositionEnd)
 {
     Element* editable = frame().selection().rootEditableElement();
     if (!editable)
         return;
 
     DCHECK(!editable->document().needsLayoutTreeUpdate());
 
     const EphemeralRange range = PlainTextRange(compositionStart, compositionEnd).createRange(*editable);
     if (range.isNull())
@@ skipping 150 matching lines @@
     TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController)
 {
     visitor->trace(m_frame);
     visitor->trace(m_compositionRange);
 }
 
 } // namespace blink