am e193c525: Revert Ida230ca42 and I6adf7d08f.

* commit 'e193c5255d96d3971ee207b459a8a1e91c0d176c':
  Revert  Ida230ca42 and I6adf7d08f.

java/src/com/android/inputmethod/latin/LatinIME.java

@@ -1667,8 +1667,15 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         return didAutoCorrect;
     }
 
-    // Called from the end of onTextInput
+    // Called from PointerTracker through the KeyboardActionListener interface
-    private void completeOnTextInput(final String rawText) {
+    @Override
+    public void onTextInput(final String rawText) {
+        mConnection.beginBatchEdit();
+        if (mWordComposer.isComposingWord()) {
+            commitCurrentAutoCorrection(rawText);
+        } else {
+            resetComposingState(true /* alsoResetLastComposedWord */);
+        }
         mHandler.postUpdateSuggestionStrip();
         if (ProductionFlag.USES_DEVELOPMENT_ONLY_DIAGNOSTICS
                 && ResearchLogger.RESEARCH_KEY_OUTPUT_TEXT.equals(rawText)) {
@@ -1691,44 +1698,12 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         mEnteredText = text;
     }
 
-    // Called from PointerTracker through the KeyboardActionListener interface
-    @Override
-    public void onTextInput(final String rawText) {
-        mConnection.beginBatchEdit();
-        boolean isReturningAsynchronously = false;
-        if (mWordComposer.isComposingWord()) {
-            commitCurrentAutoCorrection(rawText, new Runnable() {
-                @Override
-                public void run() {
-                    completeOnTextInput(rawText);
-                }
-            });
-            isReturningAsynchronously = true;
-        } else {
-            resetComposingState(true /* alsoResetLastComposedWord */);
-        }
-        if (!isReturningAsynchronously) {
-            completeOnTextInput(rawText);
-        }
-    }
-
-    private void completeOnStartBatchInput(final SettingsValues settingsValues) {
-        final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
-        if (Character.isLetterOrDigit(codePointBeforeCursor)
-                || settingsValues.isUsuallyFollowedBySpace(codePointBeforeCursor)) {
-            mSpaceState = SPACE_STATE_PHANTOM;
-        }
-        mConnection.endBatchEdit();
-        mWordComposer.setCapitalizedModeAtStartComposingTime(getActualCapsMode());
-    }
-
     @Override
     public void onStartBatchInput() {
         mInputUpdater.onStartBatchInput();
         mHandler.cancelUpdateSuggestionStrip();
         mConnection.beginBatchEdit();
         final SettingsValues settingsValues = mSettings.getCurrent();
-        boolean isReturningAsynchronously = false;
         if (mWordComposer.isComposingWord()) {
             if (settingsValues.mIsInternal) {
                 if (mWordComposer.isBatchMode()) {
@@ -1750,21 +1725,19 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
                 // tapping probably is that the word you intend to type is not in the dictionary,
                 // so we do not attempt to correct, on the assumption that if that was a dictionary
                 // word, the user would probably have gestured instead.
-                commitCurrentAutoCorrection(LastComposedWord.NOT_A_SEPARATOR, new Runnable() {
+                commitCurrentAutoCorrection(LastComposedWord.NOT_A_SEPARATOR);
-                    @Override
-                    public void run() {
-                        completeOnStartBatchInput(settingsValues);
-                    }
-                });
-                isReturningAsynchronously = true;
             } else {
                 commitTyped(LastComposedWord.NOT_A_SEPARATOR);
             }
             mExpectingUpdateSelection = true;
         }
-        if (!isReturningAsynchronously) {
+        final int codePointBeforeCursor = mConnection.getCodePointBeforeCursor();
-            completeOnStartBatchInput(settingsValues);
+        if (Character.isLetterOrDigit(codePointBeforeCursor)
+                || settingsValues.isUsuallyFollowedBySpace(codePointBeforeCursor)) {
+            mSpaceState = SPACE_STATE_PHANTOM;
         }
+        mConnection.endBatchEdit();
+        mWordComposer.setCapitalizedModeAtStartComposingTime(getActualCapsMode());
     }
 
     private static final class InputUpdater implements Handler.Callback {
@@ -2244,9 +2217,30 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         mKeyboardSwitcher.updateShiftState();
     }
 
-    private void completeHandleSeparator(final int primaryCode, final int x, final int y,
+    // Returns true if we do an autocorrection, false otherwise.
-            final int spaceState, final SettingsValues currentSettings,
+    private boolean handleSeparator(final int primaryCode, final int x, final int y,
-            final boolean shouldAvoidSendingCode) {
+            final int spaceState) {
+        boolean didAutoCorrect = false;
+        final SettingsValues currentSettings = mSettings.getCurrent();
+        // We avoid sending spaces in languages without spaces if we were composing.
+        final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == primaryCode
+                && !currentSettings.mCurrentLanguageHasSpaces && mWordComposer.isComposingWord();
+        if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
+            // If we are in the middle of a recorrection, we need to commit the recorrection
+            // first so that we can insert the separator at the current cursor position.
+            resetEntireInputState(mLastSelectionStart);
+        }
+        if (mWordComposer.isComposingWord()) { // May have changed since we stored wasComposing
+            if (currentSettings.mCorrectionEnabled) {
+                final String separator = shouldAvoidSendingCode ? LastComposedWord.NOT_A_SEPARATOR
+                        : new String(new int[] { primaryCode }, 0, 1);
+                commitCurrentAutoCorrection(separator);
+                didAutoCorrect = true;
+            } else {
+                commitTyped(new String(new int[]{primaryCode}, 0, 1));
+            }
+        }
+
         final boolean swapWeakSpace = maybeStripSpace(primaryCode, spaceState,
                 Constants.SUGGESTION_STRIP_COORDINATE == x);
 
@@ -2301,44 +2295,7 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         }
 
         mKeyboardSwitcher.updateShiftState();
-    }
+        return didAutoCorrect;
-
-    // Returns true if we do an autocorrection, false otherwise.
-    private boolean handleSeparator(final int primaryCode, final int x, final int y,
-            final int spaceState) {
-        boolean doesAutoCorrect = false;
-        final SettingsValues currentSettings = mSettings.getCurrent();
-        // We avoid sending spaces in languages without spaces if we were composing.
-        final boolean shouldAvoidSendingCode = Constants.CODE_SPACE == primaryCode
-                && !currentSettings.mCurrentLanguageHasSpaces && mWordComposer.isComposingWord();
-        if (mWordComposer.isCursorFrontOrMiddleOfComposingWord()) {
-            // If we are in the middle of a recorrection, we need to commit the recorrection
-            // first so that we can insert the separator at the current cursor position.
-            resetEntireInputState(mLastSelectionStart);
-        }
-        boolean isReturningAsynchronously = false;
-        if (mWordComposer.isComposingWord()) { // May have changed since we stored wasComposing
-            if (currentSettings.mCorrectionEnabled) {
-                final String separator = shouldAvoidSendingCode ? LastComposedWord.NOT_A_SEPARATOR
-                        : new String(new int[] { primaryCode }, 0, 1);
-                commitCurrentAutoCorrection(separator, new Runnable() {
-                    @Override
-                    public void run() {
-                        completeHandleSeparator(primaryCode, x, y, spaceState, currentSettings,
-                               shouldAvoidSendingCode);
-                    }
-                });
-                doesAutoCorrect = true;
-                isReturningAsynchronously = true;
-            } else {
-                commitTyped(new String(new int[]{primaryCode}, 0, 1));
-            }
-        }
-        if (!isReturningAsynchronously) {
-            completeHandleSeparator(primaryCode, x, y, spaceState, currentSettings,
-                    shouldAvoidSendingCode);
-        }
-        return doesAutoCorrect;
     }
 
     private CharSequence getTextWithUnderline(final String text) {
@@ -2543,7 +2500,11 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         setSuggestionStripShown(isSuggestionsStripVisible());
     }
 
-    private void completeCommitCurrentAutoCorrection(final String separator) {
+    private void commitCurrentAutoCorrection(final String separator) {
+        // Complete any pending suggestions query first
+        if (mHandler.hasPendingUpdateSuggestions()) {
+            updateSuggestionStrip();
+        }
         final String typedAutoCorrection = mWordComposer.getAutoCorrectionOrNull();
         final String typedWord = mWordComposer.getTypedWord();
         final String autoCorrection = (typedAutoCorrection != null)
@@ -2579,22 +2540,6 @@ public class LatinIME extends InputMethodService implements KeyboardActionListen
         }
     }
 
-    private void commitCurrentAutoCorrection(final String separator, final Runnable callback) {
-        getSuggestedWordsOrOlderSuggestionsAsync(Suggest.SESSION_TYPING,
-                new OnGetSuggestedWordsCallback() {
-                    @Override
-                    public void onGetSuggestedWords(final SuggestedWords suggestedWords) {
-                        if (suggestedWords != null) {
-                            setAutoCorrection(suggestedWords);
-                        }
-                        completeCommitCurrentAutoCorrection(separator);
-                        if (callback != null) {
-                            callback.run();
-                        }
-                    }
-                });
-    }
-
     // Called from {@link SuggestionStripView} through the {@link SuggestionStripView#Listener}
     // interface
     @Override

tests/src/com/android/inputmethod/latin/InputTestsBase.java

@@ -48,8 +48,6 @@ public class InputTestsBase extends ServiceTestCase<LatinIMEForTests> {
     protected static final int DELAY_TO_WAIT_FOR_UNDERLINE = 200;
     // The message that sets predictions is posted with a 200 ms delay
     protected static final int DELAY_TO_WAIT_FOR_PREDICTIONS = 200;
-    // The message that sets auto-corrections is posted within a 100 ms delay.
-    protected static final int DELAY_TO_WAIT_FOR_AUTOCORRECTION = 100;
 
     protected LatinIME mLatinIME;
     protected Keyboard mKeyboard;
@@ -223,7 +221,6 @@ public class InputTestsBase extends ServiceTestCase<LatinIMEForTests> {
     protected void type(final String stringToType) {
         for (int i = 0; i < stringToType.length(); i = stringToType.offsetByCodePoints(i, 1)) {
             type(stringToType.codePointAt(i));
-            sleep(DELAY_TO_WAIT_FOR_AUTOCORRECTION);
         }
     }