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.

[no sievers, 2016/02/24 20:08:24]

So how is this triggered for the less obvious cases like navigation and renderer
crash?
Is there a test for it (I only see one that manually calls unblockOnUiThread()
in the test)?

Also, if the renderer is malicious I guess it can just hang all of input by not
replying?

[Changwan Ryu, 2016/02/24 23:03:24]

hideSoftInput or restartInput with null text input type will unblock the wait if
any.

As for navigation testing, although not very obvious, 
ImeTest#testKeyboardDismissedAfterClickingGo and
ImeTest#testPhysicalKeyboard_AttachDetach covers that
1) navigation does not block the test
2) navigation hides the keyboard

I could not fully emulate renderer crash case,
so testDoesNotHang_rendererCrashes() simply
calls renderProcessGone().

As long as renderer does the state update when OnRequestTextInputState()
is called, then browser should not hang.
Also if it does hang, we can break the hang on the next focus loss / navigation.
(as argued in comment #44).

+            // 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);
 }