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)
+  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,
+    Node* baseNode,
+    unsigned baseOffset) {
+  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());
+  }
+}
+
 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);

[rlanday, 2016/12/16 20:55:33]

I don't think the Voice IME actually ever replaces a composition span with text
containing underlines, I think it always blanks out the existing text first. So
I don't know that this actually works properly, but I assume we should support
this?

This code uses rootEditableElement() as opposed to the base node of the
selection. rootEditableElement() didn't seem to work properly in
insertTextAndMoveCaret() and I don't really understand why.

[rlanday, 2016/12/16 21:01:35]

I'm going to try to add a test case to InputMethodControllerTest.cpp that tests
this behavior, that should solve this problem...

[rlanday, 2016/12/16 21:01:35]

I'm going to try to add a test case to InputMethodControllerTest.cpp that tests
this behavior, that should solve this problem...

+
   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()) {
+    Position base = mostForwardCaretPosition(frame().selection().base());
+    Node* baseNode = base.anchorNode();
+
+    if (!baseNode)

[rlanday, 2016/12/16 20:55:33]

Note: if I add the baseNode->isTextNode() check that insertText() has, this
fails on a node whose path looks like this:
/HTML[0]/BODY[0]/FORM[@id="textform" and position()=0]/TEXTAREA[@id="text" and
position()=0]/#shadow-root[0]/DIV[@id="inner-editor"]

Not sure exactly what's going on.

+      return false;
+
+    unsigned baseOffset = base.computeOffsetInContainerNode();
+
     if (!insertText(text))
       return false;
+
+    addCompositionUnderlines(underlines, baseNode, baseOffset);
   }
 
   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;
   }
-  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());
-  }
+
+  addCompositionUnderlines(underlines, baseNode, baseOffset);
 }
 
 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;
@@ skipping 18 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