Passing BackgroundColorSpan and UnderlineSpan from Clank to Blink.

content/public/android/java/src/org/chromium/content/browser/input/ImeAdapter.java

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser.input;
 
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.text.Editable;
+import android.text.SpannableString;
+import android.text.style.BackgroundColorSpan;
+import android.text.style.CharacterStyle;
+import android.text.style.UnderlineSpan;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.EditorInfo;
 
 import com.google.common.annotations.VisibleForTesting;
 
+import java.lang.CharSequence;
+
 import org.chromium.base.CalledByNative;
 import org.chromium.base.JNINamespace;
 
 /**
  * Adapts and plumbs android IME service onto the chrome text input API.
  * ImeAdapter provides an interface in both ways native <-> java:
  * 1. InputConnectionAdapter notifies native code of text composition state and
  *    dispatch key events from java -> WebKit.
  * 2. Native ImeAdapter notifies java side to clear composition text.
  *
@@ skipping 293 matching lines @@
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
                 flags));
         translateAndSendNativeEvents(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
                 KeyEvent.ACTION_UP, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
                 flags));
     }
 
     // Calls from Java to C++
 
-    boolean checkCompositionQueueAndCallNative(String text, int newCursorPosition,
+    boolean checkCompositionQueueAndCallNative(CharSequence text, int newCursorPosition,
             boolean isCommit) {
         if (mNativeImeAdapterAndroid == 0) return false;
+        String textStr = text.toString();
 
         // Committing an empty string finishes the current composition.
-        boolean isFinish = text.isEmpty();
+        boolean isFinish = textStr.isEmpty();
         mViewEmbedder.onImeEvent(isFinish);
-        int keyCode = shouldSendKeyEventWithKeyCode(text);
+        int keyCode = shouldSendKeyEventWithKeyCode(textStr);
         long timeStampMs = SystemClock.uptimeMillis();
 
         if (keyCode != COMPOSITION_KEY_CODE) {
             sendKeyEventWithKeyCode(keyCode,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
         } else {
             nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeRawKeyDown,
                     timeStampMs, keyCode, 0);
             if (isCommit) {
-                nativeCommitText(mNativeImeAdapterAndroid, text);
+                nativeCommitText(mNativeImeAdapterAndroid, textStr);
             } else {
-                nativeSetComposingText(mNativeImeAdapterAndroid, text, newCursorPosition);
+                nativeSetComposingText(mNativeImeAdapterAndroid, text, textStr, newCursorPosition);
             }
             nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, sEventTypeKeyUp,
                     timeStampMs, keyCode, 0);
         }
 
         return true;
     }
 
     void finishComposingText() {
         if (mNativeImeAdapterAndroid == 0) return;
@@ skipping 152 matching lines @@
         sTextInputTypeNumber = textInputTypeNumber;
         sTextInputTypeContentEditable = textInputTypeContentEditable;
     }
 
     @CalledByNative
     private void focusedNodeChanged(boolean isEditable) {
         if (mInputConnection != null && isEditable) mInputConnection.restartInput();
     }
 
     @CalledByNative
+    private void populateUnderlinesFromSpans(CharSequence text, long underlines) {
+        String textStr = text.toString();
+        if (!(text instanceof SpannableString))

[aurimas (slooooooooow), 2014/06/10 20:06:35]

Can we add assert : text instanceof SpannableString if you are not sure that the
correct type will be passed in?

Also in java we either put if statement in one line or use curly braces. In this
case you can move "return;" to the same line as if.

[huangs, 2014/06/10 20:23:56]

I think here we should be robust rather than fragile, since |text| comes form
arbitrary Android IME stuff.

Replaced early "out-of-the-way check" return with surrounding if {}.

+            return;
+
+        SpannableString spannableString = ((SpannableString) text);
+        CharacterStyle spans[] =
+                spannableString.getSpans(0, textStr.length(), CharacterStyle.class);
+        for (CharacterStyle span : spans) {
+            if (span instanceof BackgroundColorSpan) {
+                nativeAppendBackgroundColorSpan(underlines, spannableString.getSpanStart(span),
+                    spannableString.getSpanEnd(span),
+                    ((BackgroundColorSpan) span).getBackgroundColor());
+            } else if (span instanceof UnderlineSpan) {
+                nativeAppendUnderlineSpan(underlines, spannableString.getSpanStart(span),
+                    spannableString.getSpanEnd(span));
+            }
+        }
+    }
+
+    @CalledByNative
     private void cancelComposition() {
         if (mInputConnection != null) mInputConnection.restartInput();
     }
 
     @CalledByNative
     void detach() {
         if (mDismissInput != null) mHandler.removeCallbacks(mDismissInput);
         mNativeImeAdapterAndroid = 0;
         mTextInputType = 0;
     }
 
     private native boolean nativeSendSyntheticKeyEvent(long nativeImeAdapterAndroid,
             int eventType, long timestampMs, int keyCode, int unicodeChar);
 
     private native boolean nativeSendKeyEvent(long nativeImeAdapterAndroid, KeyEvent event,
             int action, int modifiers, long timestampMs, int keyCode, boolean isSystemKey,
             int unicodeChar);
 
-    private native void nativeSetComposingText(long nativeImeAdapterAndroid, String text,
-            int newCursorPosition);
+    private static native void nativeAppendUnderlineSpan(long underlinePtr, int start, int end);
 
-    private native void nativeCommitText(long nativeImeAdapterAndroid, String text);
+    private static native void nativeAppendBackgroundColorSpan(long underlinePtr, int start,
+            int end, int backgroundColor);
+
+    private native void nativeSetComposingText(long nativeImeAdapterAndroid, CharSequence text,
+            String textStr, int newCursorPosition);
+
+    private native void nativeCommitText(long nativeImeAdapterAndroid, String textStr);
 
     private native void nativeFinishComposingText(long nativeImeAdapterAndroid);
 
     private native void nativeAttachImeAdapter(long nativeImeAdapterAndroid);
 
     private native void nativeSetEditableSelectionOffsets(long nativeImeAdapterAndroid,
             int start, int end);
 
     private native void nativeSetComposingRegion(long nativeImeAdapterAndroid, int start, int end);
 
     private native void nativeDeleteSurroundingText(long nativeImeAdapterAndroid,
             int before, int after);
 
     private native void nativeUnselect(long nativeImeAdapterAndroid);
     private native void nativeSelectAll(long nativeImeAdapterAndroid);
     private native void nativeCut(long nativeImeAdapterAndroid);
     private native void nativeCopy(long nativeImeAdapterAndroid);
     private native void nativePaste(long nativeImeAdapterAndroid);
     private native void nativeResetImeAdapter(long nativeImeAdapterAndroid);
 }