Introduce ThreadedInputConnection behind a switch

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

Index: content/public/android/java/src/org/chromium/content/browser/input/ChromiumInputConnection.java
diff --git a/content/public/android/java/src/org/chromium/content/browser/input/ChromiumInputConnection.java b/content/public/android/java/src/org/chromium/content/browser/input/ChromiumInputConnection.java
new file mode 100644
index 0000000000000000000000000000000000000000..bad967608b16f67febaed3f327fe24a84f61f6bf
--- /dev/null
+++ b/content/public/android/java/src/org/chromium/content/browser/input/ChromiumInputConnection.java
@@ -0,0 +1,735 @@
+// Copyright 2015 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.Bundle;
+import android.os.Handler;
+import android.os.SystemClock;
+import android.text.InputType;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.inputmethod.CompletionInfo;
+import android.view.inputmethod.CorrectionInfo;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.ExtractedText;
+import android.view.inputmethod.ExtractedTextRequest;
+import android.view.inputmethod.InputConnection;
+
+import org.chromium.base.Log;
+import org.chromium.base.ThreadUtils;
+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;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * TODO(changwan): add a description
+ */
+public class ChromiumInputConnection implements ChromiumBaseInputConnection {
+    private static final String TAG = "cr.Ime";
+
+    // Android will raise TimeoutException to IME if bound call takes 2 seconds.
+    private static final long MAX_TIMEOUT = 1900;
+    private static final long MIN_TIMEOUT = 15;
+
+    private final Handler mHandler;
+    private final View mInternalView;
+    private final ImeAdapter mImeAdapter;
+
+    private int mNumNestedBatchEdits = 0;
+
+    // TODO(changwan): this value is used in two threads.
+    private final AtomicBoolean mSingleLine = new AtomicBoolean(true);

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

How about making this one of the TextInputState fields instead of storing it
separately?

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

Good idea! Done.

+    private final BlockingQueue<TextInputState> mQueue = new LinkedBlockingQueue<>();
+    private TextInputState mLastTextInputState;
+
+    @VisibleForTesting
+    ChromiumInputConnection(View view, ImeAdapter imeAdapter) {
+        ImeUtils.assertOnUiThread();
+
+        mHandler = InputConnectionHandlerFactory.getInputConnectionHandler();
+        mInternalView = view;
+        mImeAdapter = imeAdapter;
+        mImeAdapter.setInputConnection(ChromiumInputConnection.this);
+
+        // Make sure the previous composition is finished. There is no proper way to
+        // tell IME about the previous composition by the time this call ends, anyways.
+        // finishComposingText();

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

Can this be deleted?  Was this useful for anything?  (I think we should avoid
calling finishComposingText() on the UI thread, anyway.)

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

Done.

+
+        Log.d(TAG, "%d Constructor called", System.identityHashCode(this));
+    }
+
+    private void updateToInputMethodManager(TextInputState textInputState) {
+        ImeUtils.assertNotOnUiThread();
+        if (mNumNestedBatchEdits != 0) {
+            mLastTextInputState = textInputState;
+            return;
+        }
+        ImeUtils.assertReally(textInputState != null);
+        if (textInputState.equals(mLastTextInputState)) return;
+        Range selection = textInputState.selection();
+        Range composition = textInputState.composition();
+        getInputMethodManagerWrapper().updateSelection(mInternalView, selection.start(),
+                selection.end(), composition.start(), composition.end());
+        mLastTextInputState = textInputState;
+    }
+
+    public void updateEditorInfo(EditorInfo outAttrs, int inputType, int inputFlags) {

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

Please rename this to updateEditorInfoOnUiThread and assertOnUiThread().

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

Done.

+        Log.d(TAG, "updateEditorInfo");
+        mSingleLine.set(true);
+        outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_FULLSCREEN | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
+        outAttrs.inputType =
+                EditorInfo.TYPE_CLASS_TEXT | EditorInfo.TYPE_TEXT_VARIATION_WEB_EDIT_TEXT;
+
+        if ((inputFlags & WebTextInputFlags.AutocompleteOff) != 0) {
+            outAttrs.inputType |= EditorInfo.TYPE_TEXT_FLAG_NO_SUGGESTIONS;
+        }
+
+        if (inputType == TextInputType.TEXT) {

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

Please move most of this logic into a private static method called something
like "computeEditorInfo".

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

Done.

+            // Normal text field
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_GO;
+            if ((inputFlags & WebTextInputFlags.AutocorrectOff) == 0) {
+                outAttrs.inputType |= EditorInfo.TYPE_TEXT_FLAG_AUTO_CORRECT;
+            }
+        } else if (inputType == TextInputType.TEXT_AREA
+                || inputType == TextInputType.CONTENT_EDITABLE) {
+            outAttrs.inputType |= EditorInfo.TYPE_TEXT_FLAG_MULTI_LINE;
+            mSingleLine.set(false);
+            if ((inputFlags & WebTextInputFlags.AutocorrectOff) == 0) {
+                outAttrs.inputType |= EditorInfo.TYPE_TEXT_FLAG_AUTO_CORRECT;
+            }
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_NONE;
+        } else if (inputType == TextInputType.PASSWORD) {
+            // Password
+            outAttrs.inputType =
+                    InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_PASSWORD;
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_GO;
+        } else if (inputType == TextInputType.SEARCH) {
+            // Search
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_SEARCH;
+        } else if (inputType == TextInputType.URL) {
+            // Url
+            outAttrs.inputType = InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_URI;
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_GO;
+        } else if (inputType == TextInputType.EMAIL) {
+            // Email
+            outAttrs.inputType =
+                    InputType.TYPE_CLASS_TEXT | InputType.TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS;
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_GO;
+        } else if (inputType == TextInputType.TELEPHONE) {
+            // Telephone
+            // Number and telephone do not have both a Tab key and an
+            // action in default OSK, so set the action to NEXT
+            outAttrs.inputType = InputType.TYPE_CLASS_PHONE;
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_NEXT;
+        } else if (inputType == TextInputType.NUMBER) {
+            // Number
+            outAttrs.inputType = InputType.TYPE_CLASS_NUMBER
+                    | InputType.TYPE_NUMBER_VARIATION_NORMAL | InputType.TYPE_NUMBER_FLAG_DECIMAL;
+            outAttrs.imeOptions |= EditorInfo.IME_ACTION_NEXT;
+        }
+
+        // Handling of autocapitalize. Blink will send the flag taking into account the element's
+        // type. This is not using AutocapitalizeNone because Android does not autocapitalize by
+        // default and there is no way to express no capitalization.
+        // Autocapitalize is meant as a hint to the virtual keyboard.
+        if ((inputFlags & WebTextInputFlags.AutocapitalizeCharacters) != 0) {
+            outAttrs.inputType |= InputType.TYPE_TEXT_FLAG_CAP_CHARACTERS;
+        } else if ((inputFlags & WebTextInputFlags.AutocapitalizeWords) != 0) {
+            outAttrs.inputType |= InputType.TYPE_TEXT_FLAG_CAP_WORDS;
+        } else if ((inputFlags & WebTextInputFlags.AutocapitalizeSentences) != 0) {
+            outAttrs.inputType |= InputType.TYPE_TEXT_FLAG_CAP_SENTENCES;
+        }
+        // Content editable doesn't use autocapitalize so we need to set it manually.
+        if (inputType == TextInputType.CONTENT_EDITABLE) {
+            outAttrs.inputType |= InputType.TYPE_TEXT_FLAG_CAP_SENTENCES;
+        }
+
+        Range selection = getSelection();
+        outAttrs.initialSelStart = selection.start();
+        outAttrs.initialSelEnd = selection.end();
+    }
+
+    @Override
+    public void updateState(final String text, final int selectionStart, final int selectionEnd,
+            final int compositionStart, final int compositionEnd, final boolean isNonImeChange) {
+        Log.d(TAG, "updateState [%s] [%s %s] [%s %s] [%b]", text, selectionStart, selectionEnd,
+                compositionStart, compositionEnd, isNonImeChange);
+        ImeUtils.assertOnUiThread();
+
+        // TODO(changwan): this should be called at the end of each call, not after it.
+        final TextInputState newState =
+                new TextInputState(text, new Range(selectionStart, selectionEnd),
+                        new Range(compositionStart, compositionEnd));
+
+        if (isNonImeChange) {
+            mHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    updateToInputMethodManager(newState);
+                }
+            });
+        } else {
+            onStateUpdateOriginatingFromIme(newState);
+        }
+        Log.d(TAG, "updateState finished");
+    }
+
+    private TextInputState updateTextInputState() {
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.requestTextInputStateUpdate();
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate();
+    }
+
+    private Range getSelection() {
+        Log.d(TAG, "getSelection");
+        return new Range(0, 0);

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

Looks like this needs to be fixed to work properly with initial selections?

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

Applied the logic from AdapterInputConnection.

BTW, AdapterInputConnection and ChromiumInputConnection may not work correctly
because
it just keeps track of the last selection before restartInput().

+        //        TextInputState textInputState = updateTextInputState();
+        //        if (textInputState == null) return new Range(0, 0);
+        //        return textInputState.selection();
+    }
+
+    private void onStateUpdateOriginatingFromIme(TextInputState textInputState) {
+        ImeUtils.assertOnUiThread();
+        try {
+            mQueue.put(textInputState);
+        } catch (InterruptedException e) {
+            Log.w(TAG, "onStateUpdateOriginatingFromIme interrupted", e);
+        }
+        Log.d(TAG, "%d onStateUpdateOriginatingFromIme finished: %d", System.identityHashCode(this),
+                mQueue.size());
+    }
+
+    /**
+     * TODO(changwan): simplify calls using this.
+     * @param c
+     * @return
+     */
+    private TextInputState runAndGetStateUpdate(final Callable<Boolean> c) {
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear();
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                // TODO(changwan): remove this.
+                Boolean result = null;
+                try {
+                    result = c.call();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                if (result == null || !result.booleanValue()) {
+                    // Now we know that updateState() will never be called.
+                    unblock();
+                }
+            }
+        });
+
+        return blockAndGetStateUpdate();
+    }
+
+    /**
+     * TODO(changwan): simplify calls using this.
+     * @param c
+     * @return
+     */
+    private TextInputState runAndGetStateUpdate2(final Callable<Boolean> c) {

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

This has no callers, can it be deleted?

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

Done.

+        mQueue.clear();
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                Boolean result = null;
+                try {
+                    result = c.call();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+                if (result == null || !result.booleanValue()) {
+                    // Now we know that updateState() will never be called.
+                    unblock();
+                }
+            }
+        });
+        FutureTask<TextInputState> task = new FutureTask<>(new Callable<TextInputState>() {
+            @Override
+            public TextInputState call() throws Exception {
+                TextInputState result = blockAndGetStateUpdate();
+                // if (result != null) updateToInputMethodManager(result);
+                return result;
+            }
+        });
+        mHandler.post(task);
+        if (!ThreadUtils.runningOnUiThread()) {
+            try {
+                return task.get();
+            } catch (InterruptedException | ExecutionException e) {
+                // TODO(changwan): Auto-generated catch block
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Unblock the blockAndGetStateUpdate() function if we found that we will
+     * never get state update.
+     */
+    private void unblock() {
+        ImeUtils.assertOnUiThread();
+        onStateUpdateOriginatingFromIme(new TextInputState.Dummy());
+    }
+
+    private void postConsumeStateUpdate() {
+        mHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                blockAndGetStateUpdate();
+            }
+        });
+    }
+
+    /**
+     * Block until we get the expected state update.
+     * @return TextInputState if we get it successfully. null otherwise.
+     */
+    private TextInputState blockAndGetStateUpdate() {
+        ImeUtils.assertNotOnUiThread();
+        long timeout = MAX_TIMEOUT;
+        try {
+            while (true) {
+                long startTime = System.currentTimeMillis();
+                TextInputState result = mQueue.poll(timeout, TimeUnit.MILLISECONDS);
+
+                if (result != null) {
+                    if (result.isDummy()) {
+                        Log.d(TAG, "blockAndGetStateUpdate: failed, got dummy");
+                        return null;
+                    }
+                    updateToInputMethodManager(result);
+                    return result;
+                }
+
+                long polledTime = System.currentTimeMillis() - startTime;
+                timeout -= polledTime + 10;
+                if (timeout < MIN_TIMEOUT) {

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

This doesn't seem useful, how about simply having an infinite loop here instead?
 If the message doesn't arrive, it's a bug we need to fix elsewhere in the
system: there's no reason to introduce complexity here.

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

Done.

+                    Log.e(TAG, "%d blockAndGetStateUpdate: failed %d",
+                            System.identityHashCode(this), mQueue.size());
+                    ImeUtils.assertReally(false);
+                    return null;
+                }
+            }
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+            Log.d(TAG, "blockAndGetStateUpdate: failed due to interruption");
+            return null;
+        }
+    }
+
+    /**
+     * @see InputConnection#setComposingText(java.lang.CharSequence, int)
+     */
+    @Override
+    public boolean setComposingText(final CharSequence text, final int newCursorPosition) {
+        Log.d(TAG, "setComposingText [%s] [%d]", text, newCursorPosition);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove

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

Can all these be removed yet?

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

Done.

+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.checkCompositionQueueAndCallNative(
+                        text, newCursorPosition, false);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    /**
+     * @see InputConnection#commitText(java.lang.CharSequence, int)
+     */
+    @Override
+    public boolean commitText(final CharSequence text, final int newCursorPosition) {
+        Log.d(TAG, "commitText [%s] [%d]", text, newCursorPosition);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.checkCompositionQueueAndCallNative(
+                        text, newCursorPosition, text.length() > 0);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    @Override
+    public void restartInput() {
+        Log.d(TAG, "restartInput");
+        if (ThreadUtils.runningOnUiThread()) {

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

After this is renamed restartInputOnUiThread, this should be an assert and the
else branch should be deleted.

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

The logic here has been refactored into ImeAdapter.

+            unblock();
+            mHandler.post(new Runnable() {
+                @Override
+                public void run() {
+                    getInputMethodManagerWrapper().restartInput(mInternalView);
+                }
+            });
+        } else {
+            getInputMethodManagerWrapper().restartInput(mInternalView);
+        }
+    }
+
+    /**
+     * @see InputConnection#performEditorAction(int)
+     */
+    @Override
+    public boolean performEditorAction(int actionCode) {
+        Log.d(TAG, "performEditorAction [%d]", actionCode);
+        ImeUtils.assertNotOnUiThread();
+        if (actionCode == EditorInfo.IME_ACTION_NEXT) {
+            restartInput();

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

This is the only IME-thread caller of restartInput.  First of all, I doubt that
this call is truly needed because it seems too early, and the restart should
happen after the tab key propagates to Blink and the focus change events come
back up to the browser.  So I'd suggest trying to delete it and see if anything
breaks.  If it's still needed for some reason, I'd prefer this be a direct call
to "getInputMethodManagerWrapper().restartInput(mInternalView);" to avoid having
a method that can be called on two threads.

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

Thanks for pointing that out. It's already been moved up to ImeAdapter (by you I
remember).

+            mQueue.clear(); // TODO(changwan): remove
+            // Send TAB key event
+            ThreadUtils.postOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    long timeStampMs = SystemClock.uptimeMillis();
+                    boolean result = mImeAdapter.sendSyntheticKeyEvent(
+                            WebInputEventType.RawKeyDown, timeStampMs, KeyEvent.KEYCODE_TAB, 0, 0);
+                    if (!result) unblock();
+                }
+            });
+            return blockAndGetStateUpdate() != null;
+        } else {
+            mQueue.clear(); // TODO(changwan): remove
+            ThreadUtils.postOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    boolean result = mImeAdapter.sendKeyEventWithKeyCode(
+                            KeyEvent.KEYCODE_ENTER, KeyEvent.FLAG_SOFT_KEYBOARD
+                                    | KeyEvent.FLAG_KEEP_TOUCH_MODE | KeyEvent.FLAG_EDITOR_ACTION);
+                    if (!result) unblock();
+                }
+            });
+            return blockAndGetStateUpdate() != null;
+        }
+    }
+
+    /**
+     * @see InputConnection#performContextMenuAction(int)
+     */
+    @Override
+    public boolean performContextMenuAction(final int id) {
+        Log.d(TAG, "performContextMenuAction [%d]", id);
+        ImeUtils.assertNotOnUiThread();
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                mImeAdapter.performContextMenuAction(id);
+            }
+        });
+        // TODO(changwan): return correct value
+        return true;
+    }
+
+    /**
+     * @see InputConnection#getExtractedText(android.view.inputmethod.ExtractedTextRequest,
+     *                                           int)
+     */
+    @Override
+    public ExtractedText getExtractedText(ExtractedTextRequest request, int flags) {
+        Log.d(TAG, "getExtractedText");
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        TextInputState textInputState = updateTextInputState();
+        if (textInputState == null) return null;
+        ExtractedText extractedText = new ExtractedText();
+        extractedText.text = textInputState.text();
+        extractedText.partialEndOffset = textInputState.text().length();
+        extractedText.selectionStart = textInputState.selection().start();
+        extractedText.selectionEnd = textInputState.selection().end();
+        extractedText.flags = mSingleLine.get() ? ExtractedText.FLAG_SINGLE_LINE : 0;
+        return extractedText;
+    }
+
+    /**
+     * @see InputConnection#beginBatchEdit()
+     */
+    @Override
+    public boolean beginBatchEdit() {
+        Log.d(TAG, "beginBatchEdit [%b]", (mNumNestedBatchEdits == 0));
+        ImeUtils.assertNotOnUiThread();
+        mNumNestedBatchEdits++;
+        return true;
+    }
+
+    /**
+     * @see InputConnection#endBatchEdit()
+     */
+    @Override
+    public boolean endBatchEdit() {
+        ImeUtils.assertNotOnUiThread();
+        if (mNumNestedBatchEdits == 0) return false;
+        --mNumNestedBatchEdits;
+        Log.d(TAG, "endBatchEdit [%b]", (mNumNestedBatchEdits == 0));
+        if (mNumNestedBatchEdits == 0 && mLastTextInputState != null) {
+            updateToInputMethodManager(mLastTextInputState);

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

I don't think this works as you intended, this is defeated by the line "if
(textInputState.equals(mLastTextInputState)) return;".  I think you should
introduce a second field "mDelayedBatchEditInputState" instead of using the same
one.

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

You're correct. Now we have mLastUpdatedTextInputState and
mUpdatePendingTextInputState.

+        }
+        return mNumNestedBatchEdits != 0;
+    }
+
+    /**
+     * @see InputConnection#deleteSurroundingText(int, int)
+     */
+    @Override
+    public boolean deleteSurroundingText(final int beforeLength, final int afterLength) {
+        Log.d(TAG, "deleteSurroundingText [%d %d]", beforeLength, afterLength);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.deleteSurroundingText(beforeLength, afterLength);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    /**
+     * @see ChromiumBaseInputConnection#dispatchKeyEvent(KeyEvent)
+     */
+    @Override
+    public boolean dispatchKeyEvent(final KeyEvent event) {
+        // TODO(changwan): check if we need to post to IME handler first.
+        ImeUtils.assertOnUiThread();
+        // This should not happen.
+        if (!mImeAdapter.translateAndSendNativeEvents(event)) return false;
+        postConsumeStateUpdate();
+        return true;
+    }
+
+    /**
+     * @see InputConnection#sendKeyEvent(android.view.KeyEvent)
+     */
+    @Override
+    public boolean sendKeyEvent(final KeyEvent event) {
+        Log.d(TAG, "sendKeyEvent [%d %d]", event.getAction(), event.getKeyCode());
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.translateAndSendNativeEvents(event);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    /**
+     * @see InputConnection#finishComposingText()
+     */
+    @Override
+    public boolean finishComposingText() {
+        Log.d(TAG, "%d finishComposingText", System.identityHashCode(this));
+        mQueue.clear(); // TODO(changwan): remove
+        // This is the only function that may be called on UI thread because
+        // of direct calls from InputMethodManager.
+
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.finishComposingText();
+                if (!result) unblock();
+            }
+        });
+
+        if (ThreadUtils.runningOnUiThread()) {

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

There doesn't appear to be any (non-unit-test) code that calls this on the UI
thread.  Please delete this if() statement and replace it with
ImeUtils.assertNotOnUiThread();

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

Hmm.. How about InputMethodManager#reportFinishInputConnection() and
InputMethodManager#checkFocusNoStartInput()?

I experienced assertion failure sometimes when I added it.

+            postConsumeStateUpdate();
+            return true;
+        } else {
+            return blockAndGetStateUpdate() != null;
+        }
+    }
+
+    /**
+     * @see InputConnection#setSelection(int, int)
+     */
+    @Override
+    public boolean setSelection(final int start, final int end) {
+        Log.d(TAG, "setSelection [%d %d]", start, end);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.setEditableSelectionOffsets(start, end);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    /**
+     * @see InputConnection#setComposingRegion(int, int)
+     */
+    @Override
+    public boolean setComposingRegion(final int start, final int end) {
+        Log.d(TAG, "setComposingRegion [%d %d]", start, end);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        ThreadUtils.postOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                boolean result = mImeAdapter.setComposingRegion("", start, end);
+                if (!result) unblock();
+            }
+        });
+        return blockAndGetStateUpdate() != null;
+    }
+
+    private InputMethodManagerWrapper getInputMethodManagerWrapper() {
+        return mImeAdapter.getInputMethodManagerWrapper();
+    }
+
+    /**
+     * @see InputConnection#getTextBeforeCursor(int, int)
+     */
+    @Override
+    public CharSequence getTextBeforeCursor(int maxChars, int flags) {
+        Log.d(TAG, "getTextBeforeCursor [%d %x]", maxChars, flags);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        TextInputState textInputState = updateTextInputState();
+        if (textInputState == null) return null;
+        return textInputState.getTextBeforeSelection(maxChars);
+    }
+
+    /**
+     * @see InputConnection#getTextAfterCursor(int, int)
+     */
+    @Override
+    public CharSequence getTextAfterCursor(int maxChars, int flags) {
+        Log.d(TAG, "getTextAfterCursor [%d %x]", maxChars, flags);
+        mQueue.clear(); // TODO(changwan): remove
+        ImeUtils.assertNotOnUiThread();
+        TextInputState textInputState = updateTextInputState();
+        if (textInputState == null) return null;
+        return textInputState.getTextAfterSelection(maxChars);
+    }
+
+    /**
+     * @see InputConnection#getSelectedText(int)
+     */
+    @Override
+    public CharSequence getSelectedText(int flags) {
+        Log.d(TAG, "getSelectedText [%x]", flags);
+        ImeUtils.assertNotOnUiThread();
+        mQueue.clear(); // TODO(changwan): remove
+        TextInputState textInputState = updateTextInputState();
+        if (textInputState == null) return null;
+        return textInputState.getSelectedText();
+    }
+
+    /**
+     * @see InputConnection#getCursorCapsMode(int)
+     */
+    @Override
+    public int getCursorCapsMode(int reqModes) {
+        Log.d(TAG, "getCursorCapsMode [%x]", reqModes);
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub

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

Looks like you have several rarely called methods still to fill in here?

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

Since InputConnection is an interface, we still need to fill in these empty
implementations.

+        return 0;
+    }
+
+    /**
+     * @see InputConnection#commitCompletion(android.view.inputmethod.CompletionInfo)
+     */
+    @Override
+    public boolean commitCompletion(CompletionInfo text) {
+        Log.d(TAG, "commitCompletion [%s]", text);
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub
+        return false;
+    }
+
+    /**
+     * @see InputConnection#commitCorrection(android.view.inputmethod.CorrectionInfo)
+     */
+    @Override
+    public boolean commitCorrection(CorrectionInfo correctionInfo) {
+        Log.d(TAG, "commitCorrection [%s]", ImeUtils.dumpCorrectionInfo(correctionInfo));
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub
+        return false;
+    }
+
+    /**
+     * @see InputConnection#clearMetaKeyStates(int)
+     */
+    @Override
+    public boolean clearMetaKeyStates(int states) {
+        Log.d(TAG, "clearMetaKeyStates [%x]", states);
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub
+        return false;
+    }
+
+    /**
+     * @see InputConnection#reportFullscreenMode(boolean)
+     */
+    @Override
+    public boolean reportFullscreenMode(boolean enabled) {
+        Log.d(TAG, "reportFullscreenMode [%b]", enabled);
+        ImeUtils.assertNotOnUiThread();
+        // We ignore fullscreen mode for now. That's why we set
+        // EditorInfo.IME_FLAG_NO_FULLSCREEN in constructor.
+        return false;
+    }
+
+    /**
+     * @see InputConnection#performPrivateCommand(java.lang.String, android.os.Bundle)
+     */
+    @Override
+    public boolean performPrivateCommand(String action, Bundle data) {
+        Log.d(TAG, "performPrivateCommand [%s]", action);
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub
+        return false;
+    }
+
+    /**
+     * @see InputConnection#requestCursorUpdates(int)
+     */
+    @Override
+    public boolean requestCursorUpdates(int cursorUpdateMode) {
+        Log.d(TAG, "requestCursorUpdates [%x]", cursorUpdateMode);
+        ImeUtils.assertNotOnUiThread();
+        // TODO(changwan): Auto-generated method stub
+        return false;
+    }
+
+    /**
+     * TODO(changwan): add description
+     */
+    public void reset() {
+        ImeUtils.assertOnUiThread();
+        finishComposingText();
+    }
+}