Delete best-effort keycode guessing.

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;
 import android.text.TextUtils;
 import android.util.StringBuilderPrinter;
 import android.view.KeyCharacterMap;
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.inputmethod.BaseInputConnection;
 import android.view.inputmethod.EditorInfo;
 import android.view.inputmethod.ExtractedText;
 import android.view.inputmethod.ExtractedTextRequest;
 
 import org.chromium.base.Log;
 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 {
     private static final String TAG = "cr.Ime";
@@ skipping 212 matching lines @@
     /**
      * @see BaseInputConnection#setComposingText(java.lang.CharSequence, int)
      */
     @Override
     public boolean setComposingText(CharSequence text, int newCursorPosition) {
         Log.d(TAG, "setComposingText [%s] [%d]", text, newCursorPosition);
         if (maybePerformEmptyCompositionWorkaround(text)) return true;
         mPendingAccent = 0;
         super.setComposingText(text, newCursorPosition);
         updateSelectionIfRequired();
-        return mImeAdapter.checkCompositionQueueAndCallNative(text, newCursorPosition, false);
+        return mImeAdapter.sendCompositionToNative(text, newCursorPosition, false);
     }
 
     /**
      * @see BaseInputConnection#commitText(java.lang.CharSequence, int)
      */
     @Override
     public boolean commitText(CharSequence text, int newCursorPosition) {
         Log.d(TAG, "commitText [%s] [%d]", text, newCursorPosition);
         if (maybePerformEmptyCompositionWorkaround(text)) return true;
         mPendingAccent = 0;
         super.commitText(text, newCursorPosition);
         updateSelectionIfRequired();
-        return mImeAdapter.checkCompositionQueueAndCallNative(text, newCursorPosition,
-                text.length() > 0);
+        return mImeAdapter.sendCompositionToNative(text, newCursorPosition, 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();
-            // 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;
+        return mImeAdapter.performEditorAction(actionCode);
     }
 
     /**
      * @see BaseInputConnection#performContextMenuAction(int)
      */
     @Override
     public boolean performContextMenuAction(int id) {
         Log.d(TAG, "performContextMenuAction [%d]", id);
         return mImeAdapter.performContextMenuAction(id);
     }
@@ skipping 84 matching lines @@
 
         super.deleteSurroundingText(beforeLength, afterLength);
         updateSelectionIfRequired();
 
         // If this was called due to a physical key, no need to generate a key event here as
         // the caller will take care of forwarding the original.
         if (fromPhysicalKey) {
             return true;
         }
 
-        // For single-char deletion calls |ImeAdapter.sendKeyEventWithKeyCode| with the real key
-        // code. For multi-character deletion, executes deletion by calling
-        // |ImeAdapter.deleteSurroundingText| and sends synthetic key events with a dummy key code.
-        int keyCode = KeyEvent.KEYCODE_UNKNOWN;
-        if (originalBeforeLength == 1 && originalAfterLength == 0) {
-            keyCode = KeyEvent.KEYCODE_DEL;
-        } else if (originalBeforeLength == 0 && originalAfterLength == 1) {
-            keyCode = KeyEvent.KEYCODE_FORWARD_DEL;
-        }
-
-        boolean result = true;
-        if (keyCode == KeyEvent.KEYCODE_UNKNOWN) {
-            result = mImeAdapter.sendSyntheticKeyEvent(
-                    WebInputEventType.RawKeyDown, SystemClock.uptimeMillis(), keyCode, 0, 0);
-            result &= mImeAdapter.deleteSurroundingText(beforeLength, afterLength);
-            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;
+        return mImeAdapter.deleteSurroundingText(beforeLength, afterLength);
     }
 
     /**
      * @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();
 
         // If this isn't a KeyDown event, no need to update composition state; just pass the key
         // event through and return. But note that some keys, such as enter, may actually be
         // handled on ACTION_UP in Blink.
         if (action != KeyEvent.ACTION_DOWN) {
-            mImeAdapter.translateAndSendNativeEvents(event);
+            mImeAdapter.sendKeyEvent(event);
             return true;
         }
 
         // If this is backspace/del or if the key has a character representation,
         // need to update the underlying Editable (i.e. the local representation of the text
         // being edited).  Some IMEs like Jellybean stock IME and Samsung IME mix in delete
         // KeyPress events instead of calling deleteSurroundingText.
         if (keycode == KeyEvent.KEYCODE_DEL) {
             deleteSurroundingTextImpl(1, 0, true);
         } else if (keycode == KeyEvent.KEYCODE_FORWARD_DEL) {
@@ skipping 16 matching lines @@
                 StringBuilder builder = new StringBuilder();
                 builder.appendCodePoint(combined);
                 commitText(builder.toString(), 1);
                 return true;
             }
             // Noncombinable character; commit the accent character and fall through to sending
             // the key event for the character afterwards.
             finishComposingText();
         }
         replaceSelectionWithUnicodeChar(unicodeChar);
-        mImeAdapter.translateAndSendNativeEvents(event);
+        mImeAdapter.sendKeyEvent(event);
         return true;
     }
 
     /**
      * Update the mEditable state to reflect what Blink will do in response to the KeyDown
      * for a unicode-mapped key event.
      * @param unicodeChar The Unicode character to update selection with.
      */
     private void replaceSelectionWithUnicodeChar(int unicodeChar) {
         if (unicodeChar == 0) return;
@@ skipping 135 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);
     }
 }