Trybot test for losing style

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 79 matching lines @@
       << "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;
 
+  // LOG(ERROR)<<"aba: tagName:"<<target->tagName().utf8().data();
+  // LOG(ERROR)<<"aba: oldText:"<<oldText.utf8().data();
+  /*
+  String oldText2 = oldText;
+  // No need to preserve style for 'input' element, so we can delete the
+  // existing composition and insert new text.
+  if(target->tagName() == String("INPUT"))
+    oldText2 = emptyString();
+
+  if(!newText.isEmpty() && !oldText2.isEmpty()) {
+  DCHECK(oldText2 == frame.selectedText())<<"oldText:["<<oldText.utf8().data()
+      <<"] selected:["<<frame.selectedText().utf8().data()<<"]";
+  }
+
+  */
   // 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);
 
   if (beforeInputCancelable == InputEvent::EventCancelable::IsCancelable &&
       result != DispatchEventResult::NotCanceled)
     return;
 
   // 'beforeinput' event handler may destroy document.
   if (!frame.document())
     return;
 
   dispatchCompositionUpdateEvent(frame, text);
   // 'compositionupdate' event handler may destroy document.
   if (!frame.document())
     return;
 
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited. see http://crbug.com/590369 for more details.
+  frame.document()->updateStyleAndLayoutIgnorePendingStylesheets();
+
+  // needIncrementalInsertion?
+  const bool isIncrementalInsertion =
+      !frame.selectedText().isEmpty() && !text.isEmpty();
+  // or
+  // !frame.selectedText().isEmpty();
+  // patch set 30 works...
+
   switch (compositionType) {
     case TypingCommand::TextCompositionType::TextCompositionUpdate:
+    case TypingCommand::TextCompositionType::TextCompositionConfirm:
       TypingCommand::insertText(*frame.document(), text, options,
-                                compositionType);
+                                compositionType, isIncrementalInsertion);
       break;
-    case TypingCommand::TextCompositionType::TextCompositionConfirm:
     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,
                                                 TextEventInputComposition);
       break;
     default:
       NOTREACHED();
   }
@@ skipping 23 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;
 
+  // ???
+  // clear();  // do we need clear???

[yabinh, 2017/02/08 09:59:59]

It turns out that we should clear.

+
   // 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);
 
-  clear();
+    // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+    // needs to be audited. see http://crbug.com/590369 for more details.
+    document().updateStyleAndLayoutIgnorePendingStylesheets();
+  }
 
+  // LOG(ERROR) << "hyb: frame().selectedText():"
+  //<< frame().selectedText().utf8().data();
   insertTextDuringCompositionWithEvents(
       frame(), text, 0,
       TypingCommand::TextCompositionType::TextCompositionConfirm);
   // Event handler might destroy document.
   if (!isAvailable())
     return false;
 
   return true;
 }
 
@@ skipping 66 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());
+
+  // LOG(ERROR) << "hyb: frame().selectedText():"
+  //<< frame().selectedText().utf8().data();
   insertTextDuringCompositionWithEvents(
       frame(), 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);
@@ skipping 11 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;
-}
-
 // 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();
 
+  // LOG(ERROR) << "hyb: frame().selectedText():"
+  //<< frame().selectedText().utf8().data();
   insertTextDuringCompositionWithEvents(
       frame(), 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