[Android] Suppress unnecessary selection updates.

content/public/android/java/src/org/chromium/content/browser/ImeAdapter.java

 // Copyright (c) 2012 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;
 
 import android.content.Context;
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.text.Editable;
@@ skipping 477 matching lines @@
     public static class AdapterInputConnection extends BaseInputConnection {
         private static final String TAG =
                 "org.chromium.content.browser.ImeAdapter$AdapterInputConnection";
         private static final boolean DEBUG = false;
         private final View mInternalView;
         private final ImeAdapter mImeAdapter;
 
         private boolean mSingleLine;
         private int mNumNestedBatchEdits = 0;
         private boolean mIgnoreTextInputStateUpdates = false;
+        private boolean mPendingUpdate = false;
 
         private int mLastUpdateSelectionStart = INVALID_SELECTION;
         private int mLastUpdateSelectionEnd = INVALID_SELECTION;
         private int mLastUpdateCompositionStart = INVALID_COMPOSITION;
         private int mLastUpdateCompositionEnd = INVALID_COMPOSITION;
 
         /**
          * 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.
@@ skipping 33 matching lines @@
                 editable.replace(0, editable.length(), text);
             }
 
             if (prevSelectionStart == selectionStart && prevSelectionEnd == selectionEnd
                     && prevCompositionStart == compositionStart
                     && prevCompositionEnd == compositionEnd) {
                 // Nothing has changed; don't need to do anything
                 return;
             }
 
-            Selection.setSelection(editable, selectionStart, selectionEnd);
-
-            if (compositionStart == compositionEnd) {
-                removeComposingSpans(getEditable());
-            } else {
-                super.setComposingRegion(compositionStart, compositionEnd);
+            if (prevSelectionStart != selectionStart || prevSelectionEnd != selectionEnd) {
+                Selection.setSelection(editable, selectionStart, selectionEnd);
             }
 
-            if (mIgnoreTextInputStateUpdates) return;
+            if (prevCompositionStart != compositionStart || prevCompositionEnd != compositionEnd) {
+                if (compositionStart == compositionEnd) {
+                    removeComposingSpans(getEditable());
+                } else {
+                    super.setComposingRegion(compositionStart, compositionEnd);
+                }
+            }
+
+            if (mIgnoreTextInputStateUpdates) {
+                mPendingUpdate = true;
+                return;
+            }
             updateSelection(selectionStart, selectionEnd, compositionStart, compositionEnd);
         }
 
         @VisibleForTesting
         protected void updateSelection(
                 int selectionStart, int selectionEnd,
                 int compositionStart, int compositionEnd) {
+            mPendingUpdate = false;
             // Avoid sending update if we sent an exact update already previously.
             if (mLastUpdateSelectionStart == selectionStart &&

[aurimas (slooooooooow), 2013/04/10 14:35:46]

Can you explain why this if check for the last update would allow sending an
update though if we did not receive any setEditableText()? 

[Fredrik Öhrn, 2013/04/10 15:27:36]

When setIgnoreTextInputStateUpdates(false) calls this function the test will not
match if the on screen keyboard changed the selection or composition ranges
during the batch edit.

[aurimas (slooooooooow), 2013/04/10 15:49:12]

If the keyboard did change the selection or composition ranges, then why
wouldn't we want to send an update?

                     mLastUpdateSelectionEnd == selectionEnd &&
                     mLastUpdateCompositionStart == compositionStart &&
                     mLastUpdateCompositionEnd == compositionEnd) {
                 return;
             }
             if (DEBUG) {
                 Log.w(TAG, "updateSelection [" + selectionStart + " " + selectionEnd + "] ["
                         + compositionStart + " " + compositionEnd + "]");
             }
             // updateSelection should be called every time the selection or composition changes
@@ skipping 153 matching lines @@
         }
 
         /**
          * 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() {
             if (DEBUG) Log.w(TAG, "restartInput");
             getInputMethodManagerWrapper().restartInput(mInternalView);
             mIgnoreTextInputStateUpdates = false;
+            mPendingUpdate = false;
             mNumNestedBatchEdits = 0;
         }
 
         @Override
         public boolean setComposingRegion(int start, int end) {
             if (DEBUG) Log.w(TAG, "setComposingRegion [" + start + " " + end + "]");
             int a = Math.min(start, end);
             int b = Math.max(start, end);
             if (a == b) {
                 removeComposingSpans(getEditable());
             } else {
                 super.setComposingRegion(a, b);
             }
             return mImeAdapter.setComposingRegion(a, b);
         }
 
         boolean isActive() {
             return getInputMethodManagerWrapper().isActive(mInternalView);
         }
 
         void setIgnoreTextInputStateUpdates(boolean shouldIgnore) {
             mIgnoreTextInputStateUpdates = shouldIgnore;
-            if (shouldIgnore) return;
+            if (shouldIgnore || !mPendingUpdate) return;
 
             Editable editable = getEditable();
             updateSelection(Selection.getSelectionStart(editable),
                     Selection.getSelectionEnd(editable),
                     getComposingSpanStart(editable),
                     getComposingSpanEnd(editable));
         }
 
         @VisibleForTesting
         protected boolean isIgnoringTextInputStateUpdates() {
@@ skipping 83 matching lines @@
             int before, int after);
 
     private native void nativeImeBatchStateChanged(int nativeImeAdapterAndroid, boolean isBegin);
 
     private native void nativeUnselect(int nativeImeAdapterAndroid);
     private native void nativeSelectAll(int nativeImeAdapterAndroid);
     private native void nativeCut(int nativeImeAdapterAndroid);
     private native void nativeCopy(int nativeImeAdapterAndroid);
     private native void nativePaste(int nativeImeAdapterAndroid);
 }