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 339 matching lines @@
   if (!selection.isNone() && !m_compositionRange->collapsed()) {
     if (selection.start().compareTo(m_compositionRange->startPosition()) >= 0 &&
         selection.end().compareTo(m_compositionRange->endPosition()) <= 0)
       return;
   }
 
   cancelComposition();
   frame().chromeClient().didCancelCompositionOnSelectionChange();
 }
 
+static size_t computeCommonPrefixLength(const String& str1,
+                                        const String& str2) {
+  const size_t maxCommonPrefixLength = std::min(str1.length(), str2.length());
+  for (size_t index = 0; index < maxCommonPrefixLength; ++index) {
+    if (str1[index] != str2[index])
+      return index;
+  }
+  return maxCommonPrefixLength;
+}
+
+static size_t computeCommonSuffixLength(const String& str1,
+                                        const String& str2) {
+  const size_t length1 = str1.length();
+  const size_t length2 = str2.length();
+  const size_t maxCommonSuffixLength = std::min(length1, length2);
+  for (size_t index = 0; index < maxCommonSuffixLength; ++index) {
+    if (str1[length1 - index - 1] != str2[length2 - index - 1])
+      return index;
+  }
+  return maxCommonSuffixLength;
+}
+
+static size_t computeCommonGraphemeClusterPrefixLengthForSetComposition(
+    const String& oldText,
+    const String& newText,
+    const Element* rootEditableElement) {
+  const size_t commonPrefixLength = computeCommonPrefixLength(oldText, newText);
+
+  // For grapheme cluster, we should adjust it for grapheme boundary.
+  const EphemeralRange& range =
+      PlainTextRange(0, commonPrefixLength).createRange(*rootEditableElement);
+  if (range.isNull())
+    return 0;
+  const Position& position = range.endPosition();
+  const Position& adjustedPosition = previousPositionOf(
+      nextPositionOf(position, PositionMoveType::GraphemeCluster),
+      PositionMoveType::GraphemeCluster);
+  DCHECK_EQ(position.anchorNode(), adjustedPosition.anchorNode());
+  DCHECK_GE(position.computeOffsetInContainerNode(),
+            adjustedPosition.computeOffsetInContainerNode());
+  const int diff = position.computeOffsetInContainerNode() -
+                   adjustedPosition.computeOffsetInContainerNode();
+  return commonPrefixLength - static_cast<size_t>(diff);
+}
+
+static size_t computeCommonGraphemeClusterSuffixLengthForSetComposition(
+    const String& oldText,
+    const String& newText,
+    const Element* rootEditableElement) {
+  const size_t commonSuffixLength = computeCommonSuffixLength(oldText, newText);
+
+  // For grapheme cluster, we should adjust it for grapheme boundary.
+  const EphemeralRange& range =
+      PlainTextRange(0, oldText.length() - commonSuffixLength)
+          .createRange(*rootEditableElement);
+  if (range.isNull())
+    return 0;
+  const Position& position = range.endPosition();
+  const Position& adjustedPosition = nextPositionOf(
+      previousPositionOf(position, PositionMoveType::GraphemeCluster),
+      PositionMoveType::GraphemeCluster);
+  DCHECK_EQ(position.anchorNode(), adjustedPosition.anchorNode());
+  DCHECK_GE(adjustedPosition.computeOffsetInContainerNode(),
+            position.computeOffsetInContainerNode());
+  const int diff = adjustedPosition.computeOffsetInContainerNode() -
+                   position.computeOffsetInContainerNode();
+  return commonSuffixLength - static_cast<size_t>(diff);
+}
+
+void InputMethodController::setCompositionWithIncrementalText(
+    const String& text,
+    const Vector<CompositionUnderline>& underlines,
+    int selectionStart,
+    int selectionEnd) {
+  Element* editable = frame().selection().rootEditableElement();

[yosin_UTC9, 2016/10/12 08:12:52]

Just in case, please add
DCHECK_GE(selectionStart, 0);
DCHECK_LE(selectionStart, selectionEnd);

[yabinh, 2016/10/12 08:18:40]

Done.

[yabinh, 2016/10/12 09:14:08]

I just found that selectionStart and selectionEnd are relative to
getSelectionOffsets().start(), so they can be negative. Even if selectionStart +
getSelectionOffsets().start() < 0, it can still work, because we will clamp the
selection at 0.

+  if (!editable)
+    return;
+
+  String composing = composingText();
+  const size_t commonPrefixLength =
+      computeCommonGraphemeClusterPrefixLengthForSetComposition(composing, text,
+                                                                editable);
+
+  // We should ignore common prefix when finding common suffix.
+  const size_t commonSuffixLength =
+      computeCommonGraphemeClusterSuffixLengthForSetComposition(
+          composing.right(composing.length() - commonPrefixLength),
+          text.right(text.length() - commonPrefixLength), editable);
+
+  const bool inserting =
+      text.length() > commonPrefixLength + commonSuffixLength;
+  const bool deleting =
+      composing.length() > commonPrefixLength + commonSuffixLength;
+
+  if (inserting || deleting) {
+    // Select the text to be deleted.
+    const size_t compositionStart =
+        PlainTextRange::create(*editable, compositionEphemeralRange()).start();
+    const size_t deletionStart = compositionStart + commonPrefixLength;
+    const size_t deletionEnd =
+        compositionStart + composing.length() - commonSuffixLength;
+    const EphemeralRange& deletionRange =
+        PlainTextRange(deletionStart, deletionEnd).createRange(*editable);
+    VisibleSelection selection;
+    selection.setWithoutValidation(deletionRange.startPosition(),
+                                   deletionRange.endPosition());
+    Document* const currentDocument = frame().document();
+    frame().selection().setSelection(selection, 0);
+    clear();
+
+    // FrameSeleciton::setSelection() can change document associate to |frame|.
+    if (currentDocument != frame().document())
+      return;
+    if (!currentDocument->focusedElement())
+      return;
+
+    // Insert the incremental text.
+    const size_t insertionLength =
+        text.length() - commonPrefixLength - commonSuffixLength;
+    const String& insertingText =
+        text.substring(commonPrefixLength, insertionLength);
+    insertTextDuringCompositionWithEvents(frame(), insertingText,
+                                          TypingCommand::PreventSpellChecking,
+                                          TypingCommand::TextCompositionUpdate);
+
+    // Event handlers might destroy document.
+    if (currentDocument != frame().document())
+      return;
+
+    // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
+    // needs to be audited. see http://crbug.com/590369 for more details.
+    frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+
+    // Now recreate the composition starting at its original start, and
+    // apply the specified final selection offsets.
+    setCompositionFromExistingText(underlines, compositionStart,
+                                   compositionStart + text.length());
+  }
+
+  selectComposition();
+
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited. see http://crbug.com/590369 for more details.
+  frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
+
+  const PlainTextRange& selectedRange = createSelectionRangeForSetComposition(
+      selectionStart, selectionEnd, text.length());
+  // We shouldn't close typing in the middle of setComposition.
+  setEditableSelectionOffsets(selectedRange, NotUserTriggered);
+  m_isDirty = true;
+}
+
 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()) {
+    return setCompositionWithIncrementalText(text, underlines, selectionStart,
+                                             selectionEnd);
+  }
+
   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 96 matching lines @@
     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 {
+  const int selectionOffsetsStart =
+      static_cast<int>(getSelectionOffsets().start());
+  const int start = selectionOffsetsStart + selectionStart;
+  const 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());
 
@@ skipping 168 matching lines @@
       new RangeVector(1, m_frame->selection().firstRange()));
   TypingCommand::deleteSelection(*frame().document());
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
 }
 
 }  // namespace blink