Support parsing BackgroundSpans and UnderlineSpans in Android IME's commitText()

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 249 matching lines @@
     document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     setSelectionOffsets(oldOffsets);
 
     // No DOM update after 'compositionend'.
     dispatchCompositionEndEvent(frame(), composing);
 
     return result;
   }
 
-  return replaceCompositionAndMoveCaret(composingText(), 0);
+  return replaceCompositionAndMoveCaret(composingText(), 0,
+                                        Vector<CompositionUnderline>());
 }
 
-bool InputMethodController::commitText(const String& text,
-                                       int relativeCaretPosition) {
-  if (hasComposition())
-    return replaceCompositionAndMoveCaret(text, relativeCaretPosition);
+bool InputMethodController::commitText(
+    const String& text,
+    const Vector<CompositionUnderline>& underlines,
+    int relativeCaretPosition) {
+  if (hasComposition()) {
+    return replaceCompositionAndMoveCaret(text, relativeCaretPosition,
+                                          underlines);
+  }
 
   // We should do nothing in this case, because:
   // 1. No need to insert text when text is empty.
   // 2. Shouldn't move caret when relativeCaretPosition == 0 to avoid
   // duplicate selection change event.
   if (!text.length() && !relativeCaretPosition)
     return false;
-  return insertTextAndMoveCaret(text, relativeCaretPosition);
+
+  return insertTextAndMoveCaret(text, relativeCaretPosition, underlines);
 }
 
 bool InputMethodController::replaceComposition(const String& text) {
   if (!hasComposition())
     return false;
 
   // Select the text that will be deleted or replaced.
   selectComposition();
 
   if (frame().selection().isNone())
@@ skipping 22 matching lines @@
   return true;
 }
 
 // relativeCaretPosition is relative to the end of the text.
 static int computeAbsoluteCaretPosition(size_t textStart,
                                         size_t textLength,
                                         int relativeCaretPosition) {
   return textStart + textLength + relativeCaretPosition;
 }
 
+void InputMethodController::addCompositionUnderlines(
+    const Vector<CompositionUnderline>& underlines,
+    ContainerNode* rootEditableElement,
+    unsigned offset) {
+  for (const auto& underline : underlines) {
+    unsigned underlineStart = offset + underline.startOffset();
+    unsigned underlineEnd = offset + underline.endOffset();
+
+    EphemeralRange ephemeralLineRange =
+        PlainTextRange(underlineStart, underlineEnd)
+            .createRange(*rootEditableElement);
+    if (ephemeralLineRange.isNull())
+      continue;
+
+    document().markers().addCompositionMarker(
+        ephemeralLineRange.startPosition(), ephemeralLineRange.endPosition(),
+        underline.color(), underline.thick(), underline.backgroundColor());
+  }
+}
+
 bool InputMethodController::replaceCompositionAndMoveCaret(
     const String& text,
-    int relativeCaretPosition) {
+    int relativeCaretPosition,
+    const Vector<CompositionUnderline>& underlines) {
   Element* rootEditableElement = frame().selection().rootEditableElement();
   if (!rootEditableElement)
     return false;
   DCHECK(hasComposition());
   PlainTextRange compositionRange =
       PlainTextRange::create(*rootEditableElement, *m_compositionRange);
   if (compositionRange.isNull())
     return false;
   int textStart = compositionRange.start();
 
   if (!replaceComposition(text))
     return false;
 
+  addCompositionUnderlines(underlines, rootEditableElement, textStart);
+
   int absoluteCaretPosition = computeAbsoluteCaretPosition(
       textStart, text.length(), relativeCaretPosition);
   if (!moveCaret(absoluteCaretPosition))
     return false;
 
   // No DOM update after 'compositionend'.
   dispatchCompositionEndEvent(frame(), text);
 
   return true;
 }
 
 bool InputMethodController::insertText(const String& text) {
   if (dispatchBeforeInputInsertText(document().focusedElement(), text) !=
       DispatchEventResult::NotCanceled)
     return false;
   editor().insertText(text, 0);
   return true;
 }
 
-bool InputMethodController::insertTextAndMoveCaret(const String& text,
-                                                   int relativeCaretPosition) {
+bool InputMethodController::insertTextAndMoveCaret(
+    const String& text,
+    int relativeCaretPosition,
+    const Vector<CompositionUnderline>& underlines) {
   PlainTextRange selectionRange = getSelectionOffsets();
   if (selectionRange.isNull())
     return false;
   int textStart = selectionRange.start();
 
   if (text.length()) {
     if (!insertText(text))
       return false;
+
+    Element* rootEditableElement = frame().selection().rootEditableElement();
+    if (rootEditableElement) {
+      addCompositionUnderlines(underlines, rootEditableElement, textStart);
+    }
   }
 
   int absoluteCaretPosition = computeAbsoluteCaretPosition(
       textStart, text.length(), relativeCaretPosition);
   return moveCaret(absoluteCaretPosition);
 }
 
 void InputMethodController::cancelComposition() {
   if (!hasComposition())
     return;
@@ skipping 189 matching lines @@
   // We shouldn't close typing in the middle of setComposition.
   setEditableSelectionOffsets(selectedRange, NotUserTriggered);
 
   if (underlines.isEmpty()) {
     document().markers().addCompositionMarker(
         m_compositionRange->startPosition(), m_compositionRange->endPosition(),
         Color::black, false,
         LayoutTheme::theme().platformDefaultCompositionBackgroundColor());
     return;
   }
+
+  // Can't use addCompositionUnderlines here because the ranges are constructed

[aelias_OOO_until_Jul13, 2017/01/10 01:45:35]

Is there a good reason for the difference that you know of?  Could we switch it
to use the same method?

[rlanday, 2017/01/10 05:02:17]

addCompositionUnderlines() takes a root element and an offset measured in plain
text characters which the underline offsets are added too. Here, the baseOffset
measures DOM child nodes of the base node, not plain text characters
(underline.startOffset() and underline.endOffset() are used the same way, I’m
not sure this is correct)...maybe we can consolidate it by passing a Position
instead of a base node? I'll take another look

[rlanday, 2017/01/10 19:25:10]

baseNode is guaranteed to be a text node (there's a check above), so
addCompositionUnderlines() actually works if I pass baseNode's parent
(baseOffset is the offset of baseNode relative to its parent, not an offset
added to baseNode like I think I thought it was)...I have updated the CL

+  // differently
   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;
     document().markers().addCompositionMarker(
         ephemeralLineRange.startPosition(), ephemeralLineRange.endPosition(),
         underline.color(), underline.thick(), underline.backgroundColor());
@@ skipping 29 matching lines @@
   const Position start = range.startPosition();
   if (rootEditableElementOf(start) != editable)
     return;
 
   const Position end = range.endPosition();
   if (rootEditableElementOf(end) != editable)
     return;
 
   clear();
 
-  for (const auto& underline : underlines) {
-    unsigned underlineStart = compositionStart + underline.startOffset();
-    unsigned underlineEnd = compositionStart + underline.endOffset();
-    EphemeralRange ephemeralLineRange =
-        PlainTextRange(underlineStart, underlineEnd).createRange(*editable);
-    if (ephemeralLineRange.isNull())
-      continue;
-    document().markers().addCompositionMarker(
-        ephemeralLineRange.startPosition(), ephemeralLineRange.endPosition(),
-        underline.color(), underline.thick(), underline.backgroundColor());
-  }
+  addCompositionUnderlines(underlines, editable, compositionStart);
 
   m_hasComposition = true;
   if (!m_compositionRange)
     m_compositionRange = Range::create(document());
   m_compositionRange->setStart(range.startPosition());
   m_compositionRange->setEnd(range.endPosition());
 }
 
 EphemeralRange InputMethodController::compositionEphemeralRange() const {
   if (!hasComposition())
@@ skipping 412 matching lines @@
   frame().chromeClient().resetInputMethod();
 }
 
 DEFINE_TRACE(InputMethodController) {
   visitor->trace(m_frame);
   visitor->trace(m_compositionRange);
   SynchronousMutationObserver::trace(visitor);
 }
 
 }  // namespace blink