Introduce ThreadedInputConnection behind a switch

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.content.res.Configuration;
 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.BaseInputConnection;
-import android.view.inputmethod.EditorInfo;
 
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.blink_public.web.WebInputEventModifier;
 import org.chromium.blink_public.web.WebInputEventType;
 import org.chromium.blink_public.web.WebTextInputFlags;
 import org.chromium.ui.base.ime.TextInputType;
 import org.chromium.ui.picker.InputDialogContainer;
@@ skipping 66 matching lines @@
         public void run() {
             hideSoftKeyboard();
         }
     };
 
     static char[] sSingleCharArray = new char[1];
     static KeyCharacterMap sKeyCharacterMap;
 
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
-    private AdapterInputConnection mInputConnection;
+    public ChromiumBaseInputConnection mInputConnection;
     private final ImeAdapterDelegate mViewEmbedder;
     private final Handler mHandler;
     private int mTextInputType;
     private int mTextInputFlags;
     private String mLastComposeText;
+    private final Object mLock = new Object();

[aelias_OOO_until_Jul13, 2015/09/30 00:10:04]

This lock doesn't seem to protect against anything.  As far as I can tell, all
the synchronized blocks using it will always be on the UI thread.  Can you
delete this?

[Changwan Ryu, 2016/01/19 07:31:53]

Removed.

 
     @VisibleForTesting
     int mLastSyntheticKeyCode;
 
     @VisibleForTesting
     boolean mIsShowWithoutHideOutstanding = false;
 
     /**
      * @param wrapper InputMethodManagerWrapper that should receive all the call directed to
      *                InputMethodManager.
      * @param embedder The view that is used for callbacks from ImeAdapter.
      */
     public ImeAdapter(InputMethodManagerWrapper wrapper, ImeAdapterDelegate embedder) {
         mInputMethodManagerWrapper = wrapper;
         mViewEmbedder = embedder;
         mHandler = new Handler();
     }
 
     /**
-     * Default factory for AdapterInputConnection classes.
-     */
-    public static class AdapterInputConnectionFactory {
-        public AdapterInputConnection get(View view, ImeAdapter imeAdapter,
-                Editable editable, EditorInfo outAttrs) {
-            return new AdapterInputConnection(view, imeAdapter, editable, outAttrs);
-        }
-    }
-
-    /**
      * Overrides the InputMethodManagerWrapper that ImeAdapter uses to make calls to
      * InputMethodManager.
      * @param immw InputMethodManagerWrapper that should be used to call InputMethodManager.
      */
     @VisibleForTesting
     public void setInputMethodManagerWrapper(InputMethodManagerWrapper immw) {
         mInputMethodManagerWrapper = immw;
     }
 
     /**
      * Should be only used by AdapterInputConnection.
      * @return InputMethodManagerWrapper that should receive all the calls directed to
      *         InputMethodManager.
      */
     InputMethodManagerWrapper getInputMethodManagerWrapper() {
         return mInputMethodManagerWrapper;
     }
 
     /**
      * Set the current active InputConnection when a new InputConnection is constructed.
      * @param inputConnection The input connection that is currently used with IME.
      */
-    void setInputConnection(AdapterInputConnection inputConnection) {
-        mInputConnection = inputConnection;
+    void setInputConnection(ChromiumBaseInputConnection inputConnection) {
+        synchronized (mLock) {
+            mInputConnection = inputConnection;
+        }
         mLastComposeText = null;
     }
 
+    boolean checkInputConnection(ChromiumBaseInputConnection inputConnection) {

[aelias_OOO_until_Jul13, 2015/09/30 00:10:04]

This method is unused, please delete.

[Changwan Ryu, 2016/01/19 07:31:53]

Removed

+        return mInputConnection == inputConnection;
+    }
+
     /**
      * Should be used only by AdapterInputConnection.
      * @return The input type of currently focused element.
      */
     int getTextInputType() {
         return mTextInputType;
     }
 
     /**
      * Should be used only by AdapterInputConnection.
@@ skipping 40 matching lines @@
         }
 
         if (mNativeImeAdapterAndroid != nativeImeAdapter || mTextInputType != textInputType) {
             // We have to attach immediately, even if we're going to delay the dismissing of
             // currently visible keyboard because otherwise we have a race condition: If the
             // native IME adapter gets destructed before the delayed-dismiss fires, we'll access
             // an object that has been already released.  http://crbug.com/447287
             attach(nativeImeAdapter, textInputType, textInputFlags, true);
 
             if (mTextInputType != TextInputType.NONE) {
-                mInputMethodManagerWrapper.restartInput(mViewEmbedder.getAttachedView());
+                restartInput();
                 if (showIfNeeded) {
                     showSoftKeyboard();
                 }
             }
         } else if (hasInputType() && showIfNeeded) {
             showSoftKeyboard();
         }
     }
 
     private void attach(long nativeImeAdapter, int textInputType, int textInputFlags,
@@ skipping 65 matching lines @@
         return type != TextInputType.NONE && !InputDialogContainer.isDialogInputType(type);
     }
 
     public boolean hasTextInputType() {
         return isTextInputType(mTextInputType);
     }
 
     public boolean dispatchKeyEvent(KeyEvent event) {
         Log.d(TAG, "dispatchKeyEvent: action [%d], keycode [%d]", event.getAction(),
                 event.getKeyCode());
-        if (mInputConnection != null) {
-            return mInputConnection.sendKeyEvent(event);
+        synchronized (mLock) {
+            if (mInputConnection != null) return mInputConnection.dispatchKeyEvent(event);
         }
         return translateAndSendNativeEvents(event);
     }
 
     private int shouldSendKeyEventWithKeyCode(String text) {
         if (text.length() != 1) return COMPOSITION_KEY_CODE;
 
         if (text.equals("\n")) {
             return KeyEvent.KEYCODE_ENTER;
         } else if (text.equals("\t")) {
@@ skipping 58 matching lines @@
         // The content has shrunk in length: assume that backspace was pressed.
         if (oldtext.length() > newtext.length() && oldtext.startsWith(newtext)) {
             return new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL);
         }
 
         // The content is unchanged or has undergone a complex change (i.e. not a simple tail
         // modification) so return an unknown key-code.
         return null;
     }
 
-    void sendKeyEventWithKeyCode(int keyCode, int flags) {
+    boolean sendKeyEventWithKeyCode(int keyCode, int flags) {
         long eventTime = SystemClock.uptimeMillis();
         mLastSyntheticKeyCode = keyCode;
-        translateAndSendNativeEvents(new KeyEvent(eventTime, eventTime,
-                KeyEvent.ACTION_DOWN, keyCode, 0, 0,
-                KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
-                flags));
-        translateAndSendNativeEvents(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
-                KeyEvent.ACTION_UP, keyCode, 0, 0,
-                KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
-                flags));
+        boolean result = translateAndSendNativeEvents(new KeyEvent(eventTime, eventTime,
+                KeyEvent.ACTION_DOWN, keyCode, 0, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, flags));
+        if (!result) return false;
+        result = translateAndSendNativeEvents(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
+                KeyEvent.ACTION_UP, keyCode, 0, 0, KeyCharacterMap.VIRTUAL_KEYBOARD, 0, flags));
+        return result;
     }
 
     // Calls from Java to C++
     // TODO: Add performance tracing to more complicated functions.
     boolean checkCompositionQueueAndCallNative(CharSequence text, int newCursorPosition,
             boolean isCommit) {
         if (mNativeImeAdapterAndroid == 0) return false;
         mViewEmbedder.onImeEvent();
 
         String textStr = text.toString();
@@ skipping 65 matching lines @@
             }
 
             mLastSyntheticKeyCode = keyCode;
         }
 
         mLastComposeText = textStr;
         return true;
     }
 
     @VisibleForTesting
-    protected void finishComposingText() {
+    protected boolean finishComposingText() {
         mLastComposeText = null;
-        if (mNativeImeAdapterAndroid == 0) return;
+        if (mNativeImeAdapterAndroid == 0) return false;
         nativeFinishComposingText(mNativeImeAdapterAndroid);
+        return true;
     }
 
     boolean translateAndSendNativeEvents(KeyEvent event) {
         if (mNativeImeAdapterAndroid == 0) return false;
 
         int action = event.getAction();
         if (action != KeyEvent.ACTION_DOWN && action != KeyEvent.ACTION_UP) {
             // action == KeyEvent.ACTION_MULTIPLE
             // TODO(bulach): confirm the actual behavior. Apparently:
             // If event.getKeyCode() == KEYCODE_UNKNOWN, we can send a
@@ skipping 57 matching lines @@
     boolean setComposingRegion(CharSequence text, int start, int end) {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeSetComposingRegion(mNativeImeAdapterAndroid, start, end);
         mLastComposeText = text != null ? text.toString() : null;
         return true;
     }
 
     @CalledByNative
     private void focusedNodeChanged(boolean isEditable) {
         Log.d(TAG, "focusedNodeChanged");
-        if (mInputConnection != null && isEditable) mInputConnection.restartInput();
+        if (isEditable) restartInput();
+    }
+
+    /**
+     * Restart input connection. You should call this function whenever you need to call
+     * InputMethodManager#restartInput().
+     */
+    public void restartInput() {
+        synchronized (mLock) {
+            if (mInputConnection != null) mInputConnection.restartInput();
+        }
+    }
+
+    /**
+     * Send a request to the native counterpart to give the latest text input state update.
+     */
+    boolean requestTextInputStateUpdate() {
+        if (mNativeImeAdapterAndroid == 0) return false;
+        nativeRequestTextInputStateUpdate(mNativeImeAdapterAndroid);
+        return true;
     }
 
     @CalledByNative
     private void populateUnderlinesFromSpans(CharSequence text, long underlines) {
         Log.d(TAG, "populateUnderlinesFromSpans: text [%s], underlines [%d]", text, underlines);
         if (!(text instanceof SpannableString)) return;
 
         SpannableString spannableString = ((SpannableString) text);
         CharacterStyle spans[] =
                 spannableString.getSpans(0, text.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() {
         Log.d(TAG, "cancelComposition");
-        if (mInputConnection != null) mInputConnection.restartInput();
+        restartInput();
         mLastComposeText = null;
     }
 
     @CalledByNative
     void detach() {
         Log.d(TAG, "detach");
         mHandler.removeCallbacks(mDismissInputRunnable);
         mNativeImeAdapterAndroid = 0;
         mTextInputType = 0;
     }
 
     private native boolean nativeSendSyntheticKeyEvent(long nativeImeAdapterAndroid,
             int eventType, long timestampMs, int keyCode, int modifiers, int unicodeChar);
-
     private native boolean nativeSendKeyEvent(long nativeImeAdapterAndroid, KeyEvent event,
             int action, int modifiers, long timestampMs, int keyCode, int scanCode,
             boolean isSystemKey, int unicodeChar);
-
     private static native void nativeAppendUnderlineSpan(long underlinePtr, int start, int end);
-
     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 nativeResetImeAdapter(long nativeImeAdapterAndroid);
+    private native void nativeRequestTextInputStateUpdate(long nativeImeAdapterAndroid);
 }