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.ResultReceiver;
 import android.os.SystemClock;
-import android.text.Editable;
-import android.text.Selection;
 import android.text.SpannableString;
 import android.text.TextUtils;
 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.CommandLine;
 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.content.common.ContentSwitches;
 import org.chromium.ui.base.ime.TextInputType;
 import org.chromium.ui.picker.InputDialogContainer;
 
 /**
  * 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 46 matching lines @@
          * @return Object that should be called for all keyboard show and hide requests.
          */
         ResultReceiver getNewShowKeyboardReceiver();
     }
 
     static char[] sSingleCharArray = new char[1];
     static KeyCharacterMap sKeyCharacterMap;
 
     private long mNativeImeAdapterAndroid;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
-    private AdapterInputConnection mInputConnection;
-    private AdapterInputConnectionFactory mInputConnectionFactory;
+    private ChromiumBaseInputConnection mInputConnection;
+    private ChromiumBaseInputConnection.Factory mInputConnectionFactory;
+
     private final ImeAdapterDelegate mViewEmbedder;
 
-    // This holds the state of editable text (e.g. contents of <input>, contenteditable) of
-    // a focused element.
-    // Every time the user, IME, javascript (Blink), autofill etc. modifies the content, the new
-    // state must be reflected to this to keep consistency.
-    private final Editable mEditable;
-
     private int mTextInputType = TextInputType.NONE;
     private int mTextInputFlags;
 
     // Keep the current configuration to detect the change when onConfigurationChanged() is called.
     private Configuration mCurrentConfig;
 
+    private int mLastSelectionStart;
+    private int mLastSelectionEnd;
+
     /**
      * @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;
-        mInputConnectionFactory = new AdapterInputConnectionFactory();
-        mEditable = Editable.Factory.getInstance().newEditable("");
-        Selection.setSelection(mEditable, 0);
+        resetInputConnectionFactory();
         // Deep copy newConfig so that we can notice the difference.
         mCurrentConfig = new Configuration(
                 mViewEmbedder.getAttachedView().getResources().getConfiguration());
     }
 
-    /**
-     * Default factory for AdapterInputConnection classes.
-     */
-    static class AdapterInputConnectionFactory {
-        AdapterInputConnection get(View view, ImeAdapter imeAdapter, int initialSelStart,
-                int initialSelEnd, EditorInfo outAttrs) {
-            return new AdapterInputConnection(
-                    view, imeAdapter, initialSelStart, initialSelEnd, outAttrs);
+    void resetInputConnectionFactory() {
+        if (shouldUseImeThread()) {
+            mInputConnectionFactory =
+                    new ThreadedInputConnectionFactory(mInputMethodManagerWrapper);
+        } else {
+            mInputConnectionFactory = new ReplicaInputConnection.Factory();
         }
     }
 
+    private boolean shouldUseImeThread() {
+        if (CommandLine.getInstance().hasSwitch(ContentSwitches.DISABLE_IME_THREAD)) {
+            return false;
+        }
+        if (CommandLine.getInstance().hasSwitch(ContentSwitches.ENABLE_IME_THREAD)) {
+            return true;
+        }
+        return false;
+    }
+
     /**
      * @see View#onCreateInputConnection(EditorInfo)
      */
-    public AdapterInputConnection onCreateInputConnection(EditorInfo outAttrs) {
+    public ChromiumBaseInputConnection onCreateInputConnection(EditorInfo outAttrs) {
+        // InputMethodService evaluates fullscreen mode even when the new input connection is
+        // null. This makes sure IME doesn't enter fullscreen mode or open custom UI.
+        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
         // Without this line, some third-party IMEs will try to compose text even when
-        // not on an editable node. Even when we return null here, key events can still go through
-        // ImeAdapter#dispatchKeyEvent().
+        // not on an editable node. Even when we return null here, key events can still go
+        // through ImeAdapter#dispatchKeyEvent().
         if (mTextInputType == TextInputType.NONE) {
+            // Unblock if view loses focus, no input form or content editable is focused, or render
+            // crashes, or navigates to another page, etc.
+            // Even when InputConnection methods are blocked IMM can still call this.
+            if (mInputConnection != null) mInputConnection.unblockOnUiThread();
             mInputConnection = null;
             if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection returns null.");
-            // InputMethodService evaluates fullscreen mode even when the new input connection is
-            // null. This makes sure IME doesn't enter fullscreen mode or open custom UI.
-            outAttrs.imeOptions =
-                    EditorInfo.IME_FLAG_NO_FULLSCREEN | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
             return null;
         }
-
-        if (!isTextInputType(mTextInputType)) {
-            // Although onCheckIsTextEditor will return false in this case, the EditorInfo
-            // is still used by the InputMethodService. Need to make sure the IME doesn't
-            // enter fullscreen mode.
-            outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN;
-        }
-        int initialSelStart = Selection.getSelectionStart(mEditable);
-        int initialSelEnd = outAttrs.initialSelEnd = Selection.getSelectionEnd(mEditable);
-        mInputConnection = mInputConnectionFactory.get(
-                mViewEmbedder.getAttachedView(), this, initialSelStart, initialSelEnd, outAttrs);
-        if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection");
+        mInputConnection = mInputConnectionFactory.initializeAndGet(
+                mViewEmbedder.getAttachedView(), this, mTextInputType, mTextInputFlags,
+                mLastSelectionStart, mLastSelectionEnd, outAttrs);
+        if (DEBUG_LOGS) Log.w(TAG, "onCreateInputConnection: " + mInputConnection);
         return mInputConnection;
     }
 
     /**
      * Overrides the InputMethodManagerWrapper that ImeAdapter uses to make calls to
      * InputMethodManager.
      * @param immw InputMethodManagerWrapper that should be used to call InputMethodManager.
      */
     @VisibleForTesting
     public void setInputMethodManagerWrapperForTest(InputMethodManagerWrapper immw) {
         mInputMethodManagerWrapper = immw;
     }
 
     @VisibleForTesting
-    void setInputConnectionFactory(AdapterInputConnectionFactory factory) {
+    void setInputConnectionFactory(ChromiumBaseInputConnection.Factory factory) {
         mInputConnectionFactory = factory;
     }
 
-    /**
-     * 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;
+    @VisibleForTesting
+    ChromiumBaseInputConnection.Factory getInputConnectionFactoryForTest() {
+        return mInputConnectionFactory;
     }
 
     /**
      * Get the current input connection for testing purposes.
      */
     @VisibleForTesting
-    public AdapterInputConnection getInputConnectionForTest() {
+    public ChromiumBaseInputConnection getInputConnectionForTest() {
         return mInputConnection;
     }
 
-    /**
-     * @return The Editable instance that will be shared across AdapterInputConnection instances.
-     */
-    Editable getEditable() {
-        return mEditable;
-    }
-
-    /**
-     * Should be used only by AdapterInputConnection.
-     * @return The input type of currently focused element.
-     */
-    int getTextInputType() {
-        return mTextInputType;
-    }
-
-    /**
-     * Should be used only by AdapterInputConnection.
-     * @return The input flags of the currently focused element.
-     */
-    int getTextInputFlags() {
-        return mTextInputFlags;
-    }
-
     private static int getModifiers(int metaState) {
         int modifiers = 0;
         if ((metaState & KeyEvent.META_SHIFT_ON) != 0) {
             modifiers |= WebInputEventModifier.ShiftKey;
         }
         if ((metaState & KeyEvent.META_ALT_ON) != 0) {
             modifiers |= WebInputEventModifier.AltKey;
         }
         if ((metaState & KeyEvent.META_CTRL_ON) != 0) {
             modifiers |= WebInputEventModifier.ControlKey;
@@ skipping 45 matching lines @@
      * @param selectionEnd The character offset of the selection end, or the caret position if there
      *                     is no selection.
      * @param compositionStart The character offset of the composition start, or -1 if there is no
      *                         composition.
      * @param compositionEnd The character offset of the composition end, or -1 if there is no
      *                       selection.
      * @param isNonImeChange True when the update was caused by non-IME (e.g. Javascript).
      */
     public void updateState(String text, int selectionStart, int selectionEnd, int compositionStart,
             int compositionEnd, boolean isNonImeChange) {
+        mLastSelectionStart = selectionStart;
+        mLastSelectionEnd = selectionEnd;
         if (mInputConnection == null) return;
-        mInputConnection.updateState(text, selectionStart, selectionEnd, compositionStart,
-                compositionEnd, isNonImeChange);
+        boolean singleLine = mTextInputType != TextInputType.TEXT_AREA
+                && mTextInputType != TextInputType.CONTENT_EDITABLE;
+        mInputConnection.updateStateOnUiThread(text, selectionStart, selectionEnd, compositionStart,
+                compositionEnd, singleLine, isNonImeChange);
     }
 
     /**
      * Attaches the imeAdapter to its native counterpart. This is needed to start forwarding
      * keyboard events to WebKit.
      * @param nativeImeAdapter The pointer to the native ImeAdapter object.
      */
     public void attach(long nativeImeAdapter) {
         if (mNativeImeAdapterAndroid == nativeImeAdapter) return;
         if (mNativeImeAdapterAndroid != 0) {
@@ skipping 59 matching lines @@
             showSoftKeyboard();
         }
     }
 
     /**
      * Call this when view's focus has changed.
      * @param gainFocus True if we're gaining focus.
      */
     public void onViewFocusChanged(boolean gainFocus) {
         if (DEBUG_LOGS) Log.w(TAG, "onViewFocusChanged: gainFocus [%b]", gainFocus);
-        if (!gainFocus) hideKeyboard();
+        if (!gainFocus) reset();
     }
 
     /**
      * Move cursor to the end of the current selection.
      */
     public void moveCursorToSelectionEnd() {
         if (DEBUG_LOGS) Log.w(TAG, "movecursorToEnd");
         if (mInputConnection != null) {
-            int selectionEnd = Selection.getSelectionEnd(mEditable);
-            mInputConnection.setSelection(selectionEnd, selectionEnd);
+            mInputConnection.moveCursorToSelectionEndOnUiThread();
         }
     }
 
     @VisibleForTesting
     void setInputTypeForTest(int textInputType) {
         mTextInputType = textInputType;
     }
 
     private static boolean isTextInputType(int type) {
         return type != TextInputType.NONE && !InputDialogContainer.isDialogInputType(type);
     }
 
     public boolean hasTextInputType() {
         return isTextInputType(mTextInputType);
     }
 
+    /**
+     * See {@link View#dispatchKeyEvent(KeyEvent)}
+     */
     public boolean dispatchKeyEvent(KeyEvent event) {
         if (DEBUG_LOGS) Log.w(TAG, "dispatchKeyEvent: action [%d], keycode [%d]", event.getAction(),
                 event.getKeyCode());
-        if (mInputConnection != null) {
-            return mInputConnection.sendKeyEvent(event);
-        }
+        if (mInputConnection != null) return mInputConnection.sendKeyEventOnUiThread(event);
         return sendKeyEvent(event);
     }
 
     /**
+     * Resets IME adapter and hides keyboard. Note that this will also unblock input connection.
+     */
+    public void reset() {
+        if (DEBUG_LOGS) Log.w(TAG, "reset");
+        mTextInputType = TextInputType.NONE;
+        mTextInputFlags = 0;
+        // This will trigger unblocking if necessary.
+        hideKeyboard();
+    }
+
+    /**
      * Update selection to input method manager.
      *
      * @param selectionStart The selection start.
      * @param selectionEnd The selection end.
      * @param compositionStart The composition start.
      * @param compositionEnd The composition end.
      */
     void updateSelection(
             int selectionStart, int selectionEnd, int compositionStart, int compositionEnd) {
-        mInputMethodManagerWrapper.updateSelection(mViewEmbedder.getAttachedView(), selectionStart,
-                selectionEnd, compositionStart, compositionEnd);
+        mInputMethodManagerWrapper.updateSelection(mViewEmbedder.getAttachedView(),
+                selectionStart, selectionEnd, compositionStart, compositionEnd);
     }
 
     /**
      * Restart input (finish composition and change EditorInfo, such as input type).
      */
     void restartInput() {
+        // This will eventually cause input method manager to call View#onCreateInputConnection().
         mInputMethodManagerWrapper.restartInput(mViewEmbedder.getAttachedView());
-        if (mInputConnection != null) mInputConnection.onRestartInput();
+        if (mInputConnection != null) mInputConnection.onRestartInputOnUiThread();
     }
 
     /**
      * @see BaseInputConnection#performContextMenuAction(int)
      */
     boolean performContextMenuAction(int id) {
         if (DEBUG_LOGS) Log.w(TAG, "performContextMenuAction: id [%d]", id);
         return mViewEmbedder.performContextMenuAction(id);
     }
 
     boolean performEditorAction(int actionCode) {
         if (mNativeImeAdapterAndroid == 0) return false;
         if (actionCode == EditorInfo.IME_ACTION_NEXT) {
             sendSyntheticKeyPress(KeyEvent.KEYCODE_TAB,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE
                     | KeyEvent.FLAG_EDITOR_ACTION);
         } else {
             sendSyntheticKeyPress(KeyEvent.KEYCODE_ENTER,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE
                     | KeyEvent.FLAG_EDITOR_ACTION);
         }
         return true;
     }
 
+    void notifyUserAction() {
+        mInputMethodManagerWrapper.notifyUserAction();
+    }
+
     @VisibleForTesting
     protected void sendSyntheticKeyPress(int keyCode, int flags) {
         long eventTime = SystemClock.uptimeMillis();
         sendKeyEvent(new KeyEvent(eventTime, eventTime,
                 KeyEvent.ACTION_DOWN, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
                 flags));
         sendKeyEvent(new KeyEvent(SystemClock.uptimeMillis(), eventTime,
                 KeyEvent.ACTION_UP, keyCode, 0, 0,
                 KeyCharacterMap.VIRTUAL_KEYBOARD, 0,
@@ skipping 21 matching lines @@
             nativeSetComposingText(
                     mNativeImeAdapterAndroid, text, text.toString(), newCursorPosition);
         }
 
         nativeSendSyntheticKeyEvent(mNativeImeAdapterAndroid, WebInputEventType.KeyUp,
                 timestampMs, COMPOSITION_KEY_CODE, 0, 0);
         return true;
     }
 
     @VisibleForTesting
-    void finishComposingText() {
-        if (mNativeImeAdapterAndroid == 0) return;
+    boolean finishComposingText() {
+        if (mNativeImeAdapterAndroid == 0) return false;
         nativeFinishComposingText(mNativeImeAdapterAndroid);
+        return true;
     }
 
     boolean sendKeyEvent(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 42 matching lines @@
         nativeSetEditableSelectionOffsets(mNativeImeAdapterAndroid, start, end);
         return true;
     }
 
     /**
      * Send a request to the native counterpart to set composing region to given indices.
      * @param start The start of the composition.
      * @param end The end of the composition.
      * @return Whether the native counterpart of ImeAdapter received the call.
      */
-    boolean setComposingRegion(CharSequence text, int start, int end) {
+    boolean setComposingRegion(int start, int end) {
         if (mNativeImeAdapterAndroid == 0) return false;
         nativeSetComposingRegion(mNativeImeAdapterAndroid, start, end);
         return true;
     }
 
     @CalledByNative
     private void focusedNodeChanged(boolean isEditable) {
         if (DEBUG_LOGS) Log.w(TAG, "focusedNodeChanged: isEditable [%b]", isEditable);
         if (mTextInputType != TextInputType.NONE && mInputConnection != null && isEditable) {
             restartInput();
         }
     }
 
+    /**
+     * Send a request to the native counterpart to give the latest text input state update.
+     */
+    boolean requestTextInputStateUpdate() {
+        if (mNativeImeAdapterAndroid == 0) return false;
+        // You won't get state update anyways.
+        if (mInputConnection == null) return false;
+        return nativeRequestTextInputStateUpdate(mNativeImeAdapterAndroid);
+    }
+
     @CalledByNative
     private void populateUnderlinesFromSpans(CharSequence text, long underlines) {
         if (DEBUG_LOGS) {
             Log.w(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);
@@ skipping 16 matching lines @@
     }
 
     @CalledByNative
     private void detach() {
         if (DEBUG_LOGS) Log.w(TAG, "detach");
         mNativeImeAdapterAndroid = 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 boolean nativeRequestTextInputStateUpdate(long nativeImeAdapterAndroid);
 }