Introduce ThreadedInputConnection behind a switch

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

 // Copyright 2013 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.SystemClock;
 import android.text.Editable;
 import android.text.InputType;
 import android.text.Selection;
@@ skipping 11 matching lines @@
 import org.chromium.base.VisibleForTesting;
 import org.chromium.blink_public.web.WebInputEventType;
 import org.chromium.blink_public.web.WebTextInputFlags;
 import org.chromium.ui.base.ime.TextInputType;
 
 /**
  * InputConnection is created by ContentView.onCreateInputConnection.
  * It then adapts android's IME to chrome's RenderWidgetHostView using the
  * native ImeAdapterAndroid via the class ImeAdapter.
  */
-public class AdapterInputConnection extends BaseInputConnection {
+public class AdapterInputConnection
+        extends BaseInputConnection implements ChromiumBaseInputConnection {
     private static final String TAG = "cr.Ime";
     /**
      * Selection value should be -1 if not known. See EditorInfo.java for details.
      */
     public static final int INVALID_SELECTION = -1;
     public static final int INVALID_COMPOSITION = -1;
 
     private final View mInternalView;
     private final ImeAdapter mImeAdapter;
     private final Editable mEditable;
@@ skipping 105 matching lines @@
         updateSelectionIfRequired();
     }
 
     private String dumpEditorInfo(EditorInfo editorInfo) {
         StringBuilder builder = new StringBuilder();
         StringBuilderPrinter printer = new StringBuilderPrinter(builder);
         editorInfo.dump(printer, "");
         return builder.toString();
     }
 
-    /**
-     * Updates the AdapterInputConnection's internal representation of the text being edited and
-     * its selection and composition properties. The resulting Editable is accessible through the
-     * getEditable() method. If the text has not changed, this also calls updateSelection on the
-     * InputMethodManager.
-     *
-     * @param text The String contents of the field being edited.
-     * @param selectionStart The character offset of the selection start, or the caret position if
-     *                       there is no selection.
-     * @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).
-     */
-    @VisibleForTesting
+    @Override
     public void updateState(String text, int selectionStart, int selectionEnd, int compositionStart,
             int compositionEnd, boolean isNonImeChange) {
         Log.d(TAG, "updateState [%s] [%s %s] [%s %s] [%b]", text, selectionStart,
                 selectionEnd, compositionStart, compositionEnd, isNonImeChange);
         // If this update is from the IME, no further state modification is necessary because the
         // state should have been updated already by the IM framework directly.
         if (!isNonImeChange) return;
 
         // Non-breaking spaces can cause the IME to get confused. Replace with normal spaces.
         text = text.replace('\u00A0', ' ');
@@ skipping 84 matching lines @@
                 text.length() > 0);
     }
 
     /**
      * @see BaseInputConnection#performEditorAction(int)
      */
     @Override
     public boolean performEditorAction(int actionCode) {
         Log.d(TAG, "performEditorAction [%d]", actionCode);
         if (actionCode == EditorInfo.IME_ACTION_NEXT) {
-            restartInput();
+            getInputMethodManagerWrapper().restartInput(mInternalView);
             // Send TAB key event
             long timeStampMs = SystemClock.uptimeMillis();
             mImeAdapter.sendSyntheticKeyEvent(
                     WebInputEventType.RawKeyDown, timeStampMs, KeyEvent.KEYCODE_TAB, 0, 0);
         } else {
             mImeAdapter.sendKeyEventWithKeyCode(KeyEvent.KEYCODE_ENTER,
                     KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE
                     | KeyEvent.FLAG_EDITOR_ACTION);
         }
         return true;
@@ skipping 119 matching lines @@
             result &= mImeAdapter.sendSyntheticKeyEvent(
                     WebInputEventType.KeyUp, SystemClock.uptimeMillis(), keyCode, 0, 0);
         } else {
             mImeAdapter.sendKeyEventWithKeyCode(
                     keyCode, KeyEvent.FLAG_SOFT_KEYBOARD | KeyEvent.FLAG_KEEP_TOUCH_MODE);
         }
         return result;
     }
 
     /**
+     * @see ChromiumBaseInputConnection#dispatchKeyEvent(KeyEvent)
+     */
+    @Override
+    public boolean dispatchKeyEvent(KeyEvent event) {
+        return sendKeyEvent(event);
+    }
+
+    /**
      * @see BaseInputConnection#sendKeyEvent(android.view.KeyEvent)
      */
     @Override
     public boolean sendKeyEvent(KeyEvent event) {
         Log.d(TAG, "sendKeyEvent [%d] [%d] [%d]", event.getAction(), event.getKeyCode(),
                 event.getUnicodeChar());
 
         int action = event.getAction();
         int keycode = event.getKeyCode();
         int unicodeChar = event.getUnicodeChar();
@@ skipping 90 matching lines @@
         if (start < 0 || end < 0 || start > textLength || end > textLength) return true;
         super.setSelection(start, end);
         updateSelectionIfRequired();
         return mImeAdapter.setEditableSelectionOffsets(start, end);
     }
 
     /**
      * Informs the InputMethodManager and InputMethodSession (i.e. the IME) that the text
      * state is no longer what the IME has and that it needs to be updated.
      */
-    void restartInput() {
+    @Override
+    public void restartInput() {
         Log.d(TAG, "restartInput");
         getInputMethodManagerWrapper().restartInput(mInternalView);
         mNumNestedBatchEdits = 0;
         mPendingAccent = 0;
     }
 
     /**
      * @see BaseInputConnection#setComposingRegion(int, int)
      */
     @Override
@@ skipping 86 matching lines @@
     @VisibleForTesting
     ImeState getImeStateForTesting() {
         String text = mEditable.toString();
         int selectionStart = Selection.getSelectionStart(mEditable);
         int selectionEnd = Selection.getSelectionEnd(mEditable);
         int compositionStart = getComposingSpanStart(mEditable);
         int compositionEnd = getComposingSpanEnd(mEditable);
         return new ImeState(text, selectionStart, selectionEnd, compositionStart, compositionEnd);
     }
 }