Fix problem with accents caused by race condition.

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 373 matching lines @@
     public boolean sendKeyEvent(KeyEvent event) {
         if (DEBUG) {
             Log.w(TAG, "sendKeyEvent [" + event.getAction() + "] [" + event.getKeyCode() + "]");
         }
 
         // Short-cut modifier keys so they're not affected by accents.
         if (KeyEvent.isModifierKey(event.getKeyCode())) {
             return mImeAdapter.translateAndSendNativeEvents(event, NO_ACCENT);
         }
 
+        // Some keys we just want to pass events straight through.  This allows
+        // proper "repeating key" behavior with physical keyboards.
+        int eventKeyCode = event.getKeyCode();
+        if (eventKeyCode == KeyEvent.KEYCODE_DEL || eventKeyCode == KeyEvent.KEYCODE_FORWARD_DEL) {
+            mPendingAccent = 0;
+            return mImeAdapter.translateAndSendNativeEvents(event, NO_ACCENT);
+        }
+
         int unicodeChar = event.getUnicodeChar();
 
         // If this is a key-up, and 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).
         if (event.getAction() == KeyEvent.ACTION_UP) {
             if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                 deleteSurroundingText(1, 0);
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
@@ skipping 18 matching lines @@
                 finishComposingText();
                 mImeAdapter.translateAndSendNativeEvents(event, 0);
                 endBatchEdit();
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_DEL) {
                 return true;
             } else if (event.getKeyCode() == KeyEvent.KEYCODE_FORWARD_DEL) {
                 return true;
             }
         }
-        mImeAdapter.translateAndSendNativeEvents(event, mPendingAccent);
 
         // Physical keyboards also have their events come through here though not
         // by BaseInputConnection.  In order to support "accent" key sequences
         // such as "~n" or "^o" we have to record that one has been pressed
         // and, if an accentable letter follows, delete the accent glyph and
         // insert the composed character.
 
         // Copy class variable to local because class version may get indirectly
         // cleared by the deleteSurroundingText() call below.
         int pendingAccent = mPendingAccent;
+        int nextAccent = mPendingAccent;
 
         if ((unicodeChar & KeyCharacterMap.COMBINING_ACCENT) != 0) {
-            pendingAccent = unicodeChar & KeyCharacterMap.COMBINING_ACCENT_MASK;
+            pendingAccent = NO_ACCENT;
+            nextAccent = unicodeChar & KeyCharacterMap.COMBINING_ACCENT_MASK;
         } else if (pendingAccent != NO_ACCENT) {
             if (event.getAction() == KeyEvent.ACTION_DOWN) {
                 int combined = KeyEvent.getDeadChar(pendingAccent, unicodeChar);
                 if (combined != 0) {
                     // Previous accent combines with new character to create
                     // a new accented character.  First delete the displayed
                     // accent so it appears overwritten by the composition.
                     super.deleteSurroundingText(1, 0);
                     mImeAdapter.deleteSurroundingText(1, 0);
                 } else {
                     // Previous accent doesn't combine with this character
                     // so assume both are completely independent.
                     pendingAccent = NO_ACCENT;
+                    nextAccent = NO_ACCENT;
                 }
             }
 
             if (event.getAction() == KeyEvent.ACTION_UP) {
                 // Forget accent after release of key being accented.
-                pendingAccent = NO_ACCENT;
+                nextAccent = NO_ACCENT;
             }
         }
 
-        mPendingAccent = pendingAccent;
+        mImeAdapter.translateAndSendNativeEvents(event, pendingAccent);
+        mPendingAccent = nextAccent;
         return true;
     }
 
     /**
      * @see BaseInputConnection#finishComposingText()
      */
     @Override
     public boolean finishComposingText() {
         if (DEBUG) Log.w(TAG, "finishComposingText");
         if (getComposingSpanStart(mEditable) == getComposingSpanEnd(mEditable)) {
@@ skipping 115 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);
     }
 }