Introduce InsertIncrementalTextCommand to respect existing style for composition

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 58 matching lines @@
 }
 
 // Used to insert/replace text during composition update and confirm
 // composition.
 // Procedure:
 //   1. Fire 'beforeinput' event for (TODO(chongz): deleted composed text) and
 //      inserted text
 //   2. Fire 'compositionupdate' event
 //   3. Fire TextEvent and modify DOM
 //   TODO(chongz): 4. Fire 'input' event
-void insertTextDuringCompositionWithEvents(
+void insertIncrementtalTextDuringCompositionWithEvents(
     LocalFrame& frame,
-    const String& text,
+    const String& oldText,
+    const String& newText,
     TypingCommand::Options options,
     TypingCommand::TextCompositionType compositionType) {
   DCHECK(compositionType ==
              TypingCommand::TextCompositionType::TextCompositionUpdate ||
          compositionType ==
              TypingCommand::TextCompositionType::TextCompositionConfirm ||
          compositionType ==
              TypingCommand::TextCompositionType::TextCompositionCancel)
       << "compositionType should be TextCompositionUpdate or "
          "TextCompositionConfirm  or TextCompositionCancel, but got "
       << static_cast<int>(compositionType);
   if (!frame.document())
     return;
 
   Element* target = frame.document()->focusedElement();
   if (!target)
     return;
 
   // TODO(chongz): Fire 'beforeinput' for the composed text being
   // replaced/deleted.
 
   // Only the last confirmed text is cancelable.
   InputEvent::EventCancelable beforeInputCancelable =
       (compositionType ==
        TypingCommand::TextCompositionType::TextCompositionUpdate)
           ? InputEvent::EventCancelable::NotCancelable
           : InputEvent::EventCancelable::IsCancelable;
   DispatchEventResult result = dispatchBeforeInputFromComposition(
-      target, InputEvent::InputType::InsertText, text, beforeInputCancelable);
+      target, InputEvent::InputType::InsertText, newText,
+      beforeInputCancelable);
 
   if (beforeInputCancelable == InputEvent::EventCancelable::IsCancelable &&
       result != DispatchEventResult::NotCanceled)
     return;
 
   // 'beforeinput' event handler may destroy document.
   if (!frame.document())
     return;
 
-  dispatchCompositionUpdateEvent(frame, text);
+  dispatchCompositionUpdateEvent(frame, newText);
   // 'compositionupdate' event handler may destroy document.
   if (!frame.document())
     return;
 
   switch (compositionType) {
     case TypingCommand::TextCompositionType::TextCompositionUpdate:
-      TypingCommand::insertText(*frame.document(), text, options,
-                                compositionType);
+      TypingCommand::insertIncrementalText(*frame.document(), oldText, newText,

[chongz, 2016/11/28 16:01:04]

Is it possible to utilize |FrameSelection::selectedText()| in
|TypingCommand::insertIncrementalText()|, such that we don't need to pass in
|oldText|?

https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/editing/F...

[yabinh, 2016/11/29 02:15:21]

Here, oldText refers to the previous composing text, which could be different
from the selected text.

[yabinh, 2016/12/02 08:41:55]

It turns out to be possible after a workaround. See patch set 4.

+                                           options, compositionType);
       break;
     case TypingCommand::TextCompositionType::TextCompositionConfirm:
+      // When there is previous composition, and call commitText()
+      // (or setComposition()) with empty text, |newText| will be empty. In that
+      // case, we should do nothing to avoid firing additional events.
+      if (newText.length()) {
+        TypingCommand::insertIncrementalText(*frame.document(), oldText,
+                                             newText, options, compositionType);
+      }
+      break;

[chongz, 2016/11/28 16:01:04]

We cannot simply remove 'textInput' event due to it's high usage (0.063%), IIRC
some apps such as Google Docs on Windows is still relying on it.

To remove it we will have to follow the "Launch Process: Deprecation"
(https://www.chromium.org/blink#TOC-Launch-Process:-Deprecation) as it's a web
exposed change.

For now I would fire a special 'textInput' event for confirm composition and do
the actual work here (similar to Drop), and plan for the deprecation&removal
after web had adopted to InputEvent (2~3 years maybe).

See Chromestatus:
https://www.chromestatus.com/metrics/feature/timeline/popularity/831

[yosin_UTC9, 2016/11/29 02:10:16]

Could you split use counter for 'textInput' into non-IME and IME? I hope
IME-textInput is less used.

[chongz, 2016/11/29 22:20:58]

Adding foolip@ for more input as he is the owner of |TextEvent|.

I'm not sure if we can split the use counter, but I'd assume the ratio to be
similar as JS has no way to distinguish IME/non-IME 'textInput' (e.g. no
|isComposing| field).

I checked Google Docs on Windows again and it seems to work as usual (they've
probably changed IME model), but I cannot figure out how 'textInput' was used in
the wild.

e.g. See HTTP Archive query for 'textInput':
https://docs.google.com/a/chromium.org/spreadsheets/d/1zFbRFKtQ-RKF3z5mLVfzs7...

[foolip, 2016/11/30 13:05:28]

I added a TODO in TextEvent.idl and a use counter, but I think it has to be the
input team who owns the fate of TextEvent. If there is any way to get rid of it,
that'd be great.

I can't quite see how TextEvent is affected in this CL, can someone spell it out
for me?

In any case, risky changes are best left done separately from the non-risky
ones, and outright removals of features do need deprecation and removal.
(Trivial things can bypass all process, of course.)

     case TypingCommand::TextCompositionType::TextCompositionCancel:
       // TODO(chongz): Use TypingCommand::insertText after TextEvent was
       // removed. (Removed from spec since 2012)
       // See TextEvent.idl.
-      frame.eventHandler().handleTextInputEvent(text, 0,
+      frame.eventHandler().handleTextInputEvent(newText, 0,
                                                 TextEventInputComposition);
       break;
     default:
       NOTREACHED();
   }
   // TODO(chongz): Fire 'input' event.
 }
 
 AtomicString getInputModeAttribute(Element* element) {
   if (!element)
@@ skipping 18 matching lines @@
   return element->fastGetAttribute(HTMLNames::inputmodeAttr).lower();
 }
 
 }  // anonymous namespace
 
 InputMethodController* InputMethodController::create(LocalFrame& frame) {
   return new InputMethodController(frame);
 }
 
 InputMethodController::InputMethodController(LocalFrame& frame)
-    : m_frame(&frame), m_isDirty(false), m_hasComposition(false) {}
+    : m_frame(&frame), m_hasComposition(false) {}
 
 InputMethodController::~InputMethodController() = default;
 
 bool InputMethodController::isAvailable() const {
   return frame().document();
 }
 
 Document& InputMethodController::document() const {
   DCHECK(isAvailable());
   return *frame().document();
 }
 
 bool InputMethodController::hasComposition() const {
   return m_hasComposition && !m_compositionRange->collapsed() &&
          m_compositionRange->isConnected();
 }
 
 inline Editor& InputMethodController::editor() const {
   return frame().editor();
 }
 
 void InputMethodController::clear() {
   m_hasComposition = false;
   if (m_compositionRange) {
     m_compositionRange->setStart(&document(), 0);
     m_compositionRange->collapse(true);
   }
   document().markers().removeMarkers(DocumentMarker::Composition);
-  m_isDirty = false;
 }
 
 void InputMethodController::contextDestroyed() {
   clear();
   m_compositionRange = nullptr;
 }
 
 void InputMethodController::documentAttached(Document* document) {
   DCHECK(document);
   setContext(document);
@@ skipping 48 matching lines @@
   // duplicate selection change event.
   if (!text.length() && !relativeCaretPosition)
     return false;
   return insertTextAndMoveCaret(text, relativeCaretPosition);
 }
 
 bool InputMethodController::replaceComposition(const String& text) {
   if (!hasComposition())
     return false;
 
-  // If the composition was set from existing text and didn't change, then
-  // there's nothing to do here (and we should avoid doing anything as that
-  // may clobber multi-node styled text).
-  if (!m_isDirty && composingText() == text) {
-    clear();
-    return true;
-  }
-
   // Select the text that will be deleted or replaced.
   selectComposition();
 
   if (frame().selection().isNone())
     return false;
 
   if (!isAvailable())
     return false;
 
   // 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())
+  if (text.isEmpty()) {
     TypingCommand::deleteSelection(document(), 0);
 
+    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+    // needs to be audited. see http://crbug.com/590369 for more details.
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+  }
+
+  const String& composing = composingText();
   clear();
 
-  insertTextDuringCompositionWithEvents(
-      frame(), text, 0,
+  insertIncrementtalTextDuringCompositionWithEvents(
+      frame(), composing, text, 0,
       TypingCommand::TextCompositionType::TextCompositionConfirm);
   // Event handler might destroy document.
   if (!isAvailable())
     return false;
 
   return true;
 }
 
 // relativeCaretPosition is relative to the end of the text.
 static int computeAbsoluteCaretPosition(size_t textStart,
@@ skipping 64 matching lines @@
     return;
 
   clear();
 
   // TODO(chongz): Figure out which InputType should we use here.
   dispatchBeforeInputFromComposition(
       document().focusedElement(),
       InputEvent::InputType::DeleteComposedCharacterBackward, nullAtom,
       InputEvent::EventCancelable::NotCancelable);
   dispatchCompositionUpdateEvent(frame(), emptyString());
-  insertTextDuringCompositionWithEvents(
-      frame(), emptyString(), 0,
+  insertIncrementtalTextDuringCompositionWithEvents(
+      frame(), emptyString(), emptyString(), 0,
       TypingCommand::TextCompositionType::TextCompositionCancel);
   // Event handler might destroy document.
   if (!isAvailable())
     return;
 
   // An open typing command that disagrees about current selection would cause
   // issues with typing later on.
   TypingCommand::closeTyping(m_frame);
 
   // No DOM update after 'compositionend'.
   dispatchCompositionEndEvent(frame(), emptyString());
 }
 
 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()) {
     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;
-}
-
 // If current position is at grapheme boundary, return 0; otherwise, return the
 // distance to its nearest left grapheme boundary.
 static size_t computeDistanceToLeftGraphemeBoundary(const Position& position) {
   const Position& adjustedPosition = previousPositionOf(
       nextPositionOf(position, PositionMoveType::GraphemeCluster),
       PositionMoveType::GraphemeCluster);
   DCHECK_EQ(position.anchorNode(), adjustedPosition.anchorNode());
   DCHECK_GE(position.computeOffsetInContainerNode(),
             adjustedPosition.computeOffsetInContainerNode());
   return static_cast<size_t>(position.computeOffsetInContainerNode() -
                              adjustedPosition.computeOffsetInContainerNode());
 }
 
-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 size_t diff = computeDistanceToLeftGraphemeBoundary(position);
-  DCHECK_GE(commonPrefixLength, diff);
-  return commonPrefixLength - diff;
-}
-
 // If current position is at grapheme boundary, return 0; otherwise, return the
 // distance to its nearest right grapheme boundary.
 static size_t computeDistanceToRightGraphemeBoundary(const Position& position) {
   const Position& adjustedPosition = nextPositionOf(
       previousPositionOf(position, PositionMoveType::GraphemeCluster),
       PositionMoveType::GraphemeCluster);
   DCHECK_EQ(position.anchorNode(), adjustedPosition.anchorNode());
   DCHECK_GE(adjustedPosition.computeOffsetInContainerNode(),
             position.computeOffsetInContainerNode());
   return static_cast<size_t>(adjustedPosition.computeOffsetInContainerNode() -
                              position.computeOffsetInContainerNode());
 }
 
-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 size_t diff = computeDistanceToRightGraphemeBoundary(position);
-  DCHECK_GE(commonSuffixLength, diff);
-  return commonSuffixLength - diff;
-}
-
-void InputMethodController::setCompositionWithIncrementalText(
-    const String& text,
-    const Vector<CompositionUnderline>& underlines,
-    int selectionStart,
-    int selectionEnd) {
-  Element* editable = frame().selection().rootEditableElement();
-  if (!editable)
-    return;
-
-  DCHECK_LE(selectionStart, selectionEnd);
-  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);
-    Document& currentDocument = document();
-    frame().selection().setSelection(
-        SelectionInDOMTree::Builder().setBaseAndExtent(deletionRange).build(),
-        0);
-    clear();
-
-    // FrameSeleciton::setSelection() can change document associate to |frame|.
-    if (!isAvailable() || currentDocument != 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 (!isAvailable() || currentDocument != document())
-      return;
-
-    // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
-    // needs to be audited. see http://crbug.com/590369 for more details.
-    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.
-  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
   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 = document().focusedElement();
   if (!target)
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
@@ skipping 46 matching lines @@
   if (!hasComposition()) {
     target->dispatchEvent(
         CompositionEvent::create(EventTypeNames::compositionstart,
                                  frame().domWindow(), frame().selectedText()));
     if (!isAvailable())
       return;
   }
 
   DCHECK(!text.isEmpty());
 
+  const String& composing = composingText();
   clear();
 
-  insertTextDuringCompositionWithEvents(
-      frame(), text,
+  insertIncrementtalTextDuringCompositionWithEvents(
+      frame(), composing, text,
       TypingCommand::SelectInsertedText | TypingCommand::PreventSpellChecking,
       TypingCommand::TextCompositionUpdate);
   // Event handlers might destroy document.
   if (!isAvailable())
     return;
 
   // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited. see http://crbug.com/590369 for more details.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   // 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(document());
   m_compositionRange->setStart(baseNode, baseOffset);
-  m_compositionRange->setEnd(baseNode, extentOffset);
+  m_compositionRange->setEnd(extentNode, extentOffset);
 
   if (baseNode->layoutObject())
     baseNode->layoutObject()->setShouldDoFullPaintInvalidation();
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited. see http://crbug.com/590369 for more details.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   // We shouldn't close typing in the middle of setComposition.
   setEditableSelectionOffsets(selectedRange, NotUserTriggered);
@@ skipping 481 matching lines @@
   return WebTextInputTypeNone;
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
   SynchronousMutationObserver::trace(visitor);
 }
 
 }  // namespace blink