Passing BackgroundColorSpan and UnderlineSpan from Clank to Blink.

content/browser/renderer_host/ime_adapter_android.cc

 // Copyright (c) 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.
 
 #include "content/browser/renderer_host/ime_adapter_android.h"
 
+#include <algorithm>
 #include <android/input.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/frame_tree.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
@@ skipping 33 matching lines @@
     int unicode_char) {
   blink::WebInputEvent::Type type = blink::WebInputEvent::Undefined;
   if (action == AKEY_EVENT_ACTION_DOWN)
     type = blink::WebInputEvent::RawKeyDown;
   else if (action == AKEY_EVENT_ACTION_UP)
     type = blink::WebInputEvent::KeyUp;
   return NativeWebKeyboardEvent(java_key_event, type, modifiers,
       time_ms / 1000.0, key_code, unicode_char, is_system_key);
 }
 
+// Uses JNI to iterate over |spanObjArray| obtianed from |spannableString|, and
+// populates a list of blink::WebCompositionUnderline with data from spans
+// that we care about (e.g., BackgroundColorSpan).
+void GetUnderlinesFromSpanArray(
+    JNIEnv* env,
+    jobject spannableString,
+    jobjectArray spanObjArray,
+    std::vector<blink::WebCompositionUnderline>* underlines) {
+  if (!spannableString || !spanObjArray)
+    return;
+
+  jclass clsSpannableString = env->FindClass("android/text/SpannableString");

[aurimas (slooooooooow), 2014/06/10 00:30:48]

In Chrome for Android we avoid using JNI FindClass and GetMethodID calls
directly with hardcoded strings as it often leads to bugs. Instead we using JNI
generator to create safe accessors. There is some info on this here:
http://www.chromium.org/developers/design-documents/android-jni

See comments below how to fix it.

[huangs, 2014/06/10 04:39:13]

Done.

+  jclass clsBackgroundColorSpan =
+      env->FindClass("android/text/style/BackgroundColorSpan");
+  if (!clsSpannableString || !clsBackgroundColorSpan)
+    return;
+
+  jmethodID midGetSpanStart = env->GetMethodID(
+      clsSpannableString, "getSpanStart", "(Ljava/lang/Object;)I");
+  jmethodID midGetSpanEnd = env->GetMethodID(
+      clsSpannableString, "getSpanEnd", "(Ljava/lang/Object;)I");
+  jmethodID midGetBackgroundColor = env->GetMethodID(
+      clsBackgroundColorSpan, "getBackgroundColor", "()I");
+
+  if (!midGetSpanStart || !midGetSpanEnd || !midGetBackgroundColor)
+    return;
+
+  jsize n = env->GetArrayLength(spanObjArray);
+  for (int i = 0; i < n; ++i) {
+    jobject spanObj = env->GetObjectArrayElement(spanObjArray, i);
+    if (env->IsInstanceOf(spanObj, clsBackgroundColorSpan) == JNI_FALSE)
+      continue;
+
+    jint start = env->CallIntMethod(spannableString, midGetSpanStart, spanObj);
+    jint end = env->CallIntMethod(spannableString, midGetSpanEnd, spanObj);
+    jint background = env->CallIntMethod(spanObj, midGetBackgroundColor);
+
+    underlines->push_back(blink::WebCompositionUnderline(
+            static_cast<int>(start),
+            static_cast<int>(end),
+            SK_ColorBLACK,
+            false,
+            background));
+  }
+}
+
 }  // anonymous namespace
 
 bool RegisterImeAdapter(JNIEnv* env) {
   if (!RegisterNativesImpl(env))
     return false;
 
   Java_ImeAdapter_initializeWebInputEvents(env,
                                            blink::WebInputEvent::RawKeyDown,
                                            blink::WebInputEvent::KeyUp,
                                            blink::WebInputEvent::Char,
@@ skipping 61 matching lines @@
     // roundtrip back to java such synthetic event.
     NativeWebKeyboardEvent char_event(blink::WebInputEvent::Char, modifiers,
                                       time_ms / 1000.0, key_code, unicode_char,
                                       is_system_key);
     char_event.skip_in_browser = key_down_text_insertion;
     rwhva_->SendKeyEvent(char_event);
   }
   return true;
 }
 
-void ImeAdapterAndroid::SetComposingText(JNIEnv* env, jobject, jstring text,
-                                         int new_cursor_pos) {
+void ImeAdapterAndroid::SetComposingText(JNIEnv* env,
+                                         jobject,
+                                         jstring text,
+                                         int new_cursor_pos,
+                                         jobject spannableString,
+                                         jobjectArray spanObjArray) {
   RenderWidgetHostImpl* rwhi = GetRenderWidgetHostImpl();
   if (!rwhi)
     return;
 
   base::string16 text16 = ConvertJavaStringToUTF16(env, text);
   std::vector<blink::WebCompositionUnderline> underlines;
-  underlines.push_back(
-      blink::WebCompositionUnderline(0, text16.length(), SK_ColorBLACK,
-                                      false));
+
+  GetUnderlinesFromSpanArray(env, spannableString, spanObjArray, &underlines);

[aurimas (slooooooooow), 2014/06/10 00:30:49]

Here you should call Java_ImeAdapter_getUnderlinesFromSpan(spannableString,
&underlines).

In java you would write a function something like this:
@CalledByNative
void static getUnderlinesFromSpan(SpannableString string, long underlines) {
  for (Span s: ...) {
    nativeAppendUnderline(underlines, s.getStart(), s.getEnd(), s.getColor());
  }
}

And finally create a static function in ime_adapter_android.cc AppendUnderline
that would do push_back on that array with given values.

[huangs, 2014/06/10 04:39:13]

Done.  I'm looping over Object[] because in the near future I want to generalize
this code to handle UnderlineSpan as well.

+
+  // Default to simple underline if we find no spans that we care about.
+  if (underlines.empty()) {
+    underlines.push_back(
+        blink::WebCompositionUnderline(0, text16.length(), SK_ColorBLACK, false,
+            SK_ColorTRANSPARENT));
+  }
+  // Sort spans by |.startOffset|.
+  std::sort(underlines.begin(), underlines.end());
+
   // new_cursor_position is as described in the Android API for
   // InputConnection#setComposingText, whereas the parameters for
   // ImeSetComposition are relative to the start of the composition.
   if (new_cursor_pos > 0)
     new_cursor_pos = text16.length() + new_cursor_pos - 1;
 
   rwhi->ImeSetComposition(text16, underlines, new_cursor_pos, new_cursor_pos);
 }
 
 void ImeAdapterAndroid::CommitText(JNIEnv* env, jobject, jstring text) {
@@ skipping 46 matching lines @@
 }
 
 void ImeAdapterAndroid::SetComposingRegion(JNIEnv*, jobject,
                                            int start, int end) {
   RenderFrameHost* rfh = GetFocusedFrame();
   if (!rfh)
     return;
 
   std::vector<blink::WebCompositionUnderline> underlines;
   underlines.push_back(
-      blink::WebCompositionUnderline(0, end - start, SK_ColorBLACK, false));
+      blink::WebCompositionUnderline(0, end - start, SK_ColorBLACK, false,
+                                     SK_ColorTRANSPARENT));
 
   rfh->Send(new FrameMsg_SetCompositionFromExistingText(
       rfh->GetRoutingID(), start, end, underlines));
 }
 
 void ImeAdapterAndroid::DeleteSurroundingText(JNIEnv*, jobject,
                                               int before, int after) {
   RenderFrameHostImpl* rfh =
       static_cast<RenderFrameHostImpl*>(GetFocusedFrame());
   if (rfh)
@@ skipping 62 matching lines @@
 WebContents* ImeAdapterAndroid::GetWebContents() {
   RenderWidgetHostImpl* rwh = GetRenderWidgetHostImpl();
   if (!rwh)
     return NULL;
   if (!rwh->IsRenderView())
     return NULL;
   return WebContents::FromRenderViewHost(RenderViewHost::From(rwh));
 }
 
 }  // namespace content