[WIP] Add support for Android SuggestionSpans when editing text

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

 // Copyright 2016 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.annotation.TargetApi;
 import android.graphics.Matrix;
 import android.os.Build;
 import android.view.View;
 import android.view.inputmethod.CursorAnchorInfo;
 
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.content.browser.RenderCoordinates;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 /**
  * A state machine interface which receives Chromium internal events to determines when to call
  * {@link InputMethodManager#updateCursorAnchorInfo(View, CursorAnchorInfo)}. This interface is
  * also used in unit tests to mock out {@link CursorAnchorInfo}, which is available only in
  * Android 5.0 (Lollipop) and later.
  */
@@ skipping 10 matching lines @@
      * An interface to mock out composing text retrieval from ImeAdapter.
      */
     public interface ComposingTextDelegate {
         CharSequence getText();
         int getSelectionStart();
         int getSelectionEnd();
         int getComposingTextStart();
         int getComposingTextEnd();
     }
 
+    /**
+     * An interface implemented by classes that want to listener to
+     * CursorAnchorInfo updates.
+     */
+    public interface Listener { void onCursorAnchorInfoUpdate(CursorAnchorInfo info); }
+
     // Current focus and monitoring states.
     private boolean mIsEditable;
     private boolean mHasPendingImmediateRequest;
     private boolean mMonitorModeEnabled;
 
     // Parmeter for CursorAnchorInfo, updated by setCompositionCharacterBounds.
     @Nullable
     private float[] mCompositionCharacterBounds;
     // Paremeters for CursorAnchorInfo, updated by onUpdateFrameInfo.
     private boolean mHasCoordinateInfo;
@@ skipping 17 matching lines @@
     private final CursorAnchorInfo.Builder mCursorAnchorInfoBuilder =
             new CursorAnchorInfo.Builder();
 
     @Nullable
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
     @Nullable
     private final ComposingTextDelegate mComposingTextDelegate;
     @Nonnull
     private final ViewDelegate mViewDelegate;
 
+    @Nonnull
+    private final HashMap<View, ArrayList<Listener>> mListeners =
+            new HashMap<View, ArrayList<Listener>>();
+
     private CursorAnchorInfoController(InputMethodManagerWrapper inputMethodManagerWrapper,
             ComposingTextDelegate composingTextDelegate, ViewDelegate viewDelegate) {
         mInputMethodManagerWrapper = inputMethodManagerWrapper;
         mComposingTextDelegate = composingTextDelegate;
         mViewDelegate = viewDelegate;
     }
 
     public static CursorAnchorInfoController create(
             InputMethodManagerWrapper inputMethodManagerWrapper,
             ComposingTextDelegate composingTextDelegate) {
-        return new CursorAnchorInfoController(inputMethodManagerWrapper,
-                composingTextDelegate, new ViewDelegate() {
+        return new CursorAnchorInfoController(
+                inputMethodManagerWrapper, composingTextDelegate, new ViewDelegate() {
                     @Override
                     public void getLocationOnScreen(View view, int[] location) {
                         view.getLocationOnScreen(location);
                     }
                 });
     }
 
     @VisibleForTesting
     public void setInputMethodManagerWrapperForTest(
             InputMethodManagerWrapper inputMethodManagerWrapper) {
         mInputMethodManagerWrapper = inputMethodManagerWrapper;
     }
 
     @VisibleForTesting
     public static CursorAnchorInfoController createForTest(
             InputMethodManagerWrapper inputMethodManagerWrapper,
-            ComposingTextDelegate composingTextDelegate,
-            ViewDelegate viewDelegate) {
-        return new CursorAnchorInfoController(inputMethodManagerWrapper, composingTextDelegate,
-                viewDelegate);
+            ComposingTextDelegate composingTextDelegate, ViewDelegate viewDelegate) {
+        return new CursorAnchorInfoController(
+                inputMethodManagerWrapper, composingTextDelegate, viewDelegate);
     }
 
     /**
      * Called by ImeAdapter when a IME related web content state is changed.
      */
     public void invalidateLastCursorAnchorInfo() {
         if (!mIsEditable) return;
 
         mLastCursorAnchorInfo = null;
     }
@@ skipping 59 matching lines @@
             mScale = scale;
             mTranslationX = translationX;
             mTranslationY = translationY;
             mHasInsertionMarker = hasInsertionMarker;
             mIsInsertionMarkerVisible = isInsertionMarkerVisible;
             mInsertionMarkerHorizontal = insertionMarkerHorizontal;
             mInsertionMarkerTop = insertionMarkerTop;
             mInsertionMarkerBottom = insertionMarkerBottom;
         }
 
-        // Notify to IME if there is a pending request, or if it is in monitor mode and we have
-        // some change in the state.
+        // Notify to IME if there is a pending request, or if we're monitoring
+        // for the view and we have some change in the state.
         if (mHasPendingImmediateRequest
-                || (mMonitorModeEnabled && mLastCursorAnchorInfo == null)) {
+                || (monitoringForView(view) && mLastCursorAnchorInfo == null)) {
             updateCursorAnchorInfo(view);
         }
     }
 
     public void focusedNodeChanged(boolean isEditable) {
         mIsEditable = isEditable;
         mCompositionCharacterBounds = null;
         mHasCoordinateInfo = false;
         mLastCursorAnchorInfo = null;
     }
 
     public boolean onRequestCursorUpdates(boolean immediateRequest, boolean monitorRequest,
             View view) {
         if (!mIsEditable) return false;
 
-        if (mMonitorModeEnabled && !monitorRequest) {
-            // Invalidate saved cursor anchor info if monitor request is cancelled since no longer
-            // new values will be arrived from renderer and immediate request may return too old
-            // position.
-            invalidateLastCursorAnchorInfo();
+        if (!monitorRequest && monitoringForView(view)) {
+            // Invalidate saved cursor anchor info if we're no longer going to
+            // be monitoring for this view to prevent returning stale values for
+            // immediate requests.
+            if (!mListeners.containsKey(view) || mListeners.get(view).isEmpty()) {
+                invalidateLastCursorAnchorInfo();
+            }
         }
+
         mMonitorModeEnabled = monitorRequest;
         if (immediateRequest) {
             mHasPendingImmediateRequest = true;
             updateCursorAnchorInfo(view);
         }
         return true;
     }
 
+    public void addListener(Listener listener, View view) {
+        if (!mListeners.containsKey(view)) {
+            mListeners.put(view, new ArrayList<Listener>());
+        }
+        mListeners.get(view).add(listener);
+
+        mHasPendingImmediateRequest = true;
+    }
+
+    public void removeListener(Listener listener, View view) {
+        mListeners.get(view).remove(listener);
+    }
+
+    private boolean monitoringForView(View view) {
+        if (mMonitorModeEnabled) {
+            return true;
+        }
+
+        return mListeners.containsKey(view) && !mListeners.get(view).isEmpty();
+    }
+
     /**
      * Computes the CursorAnchorInfo instance and notify to InputMethodManager if needed.
      */
     private void updateCursorAnchorInfo(View view) {
         if (!mHasCoordinateInfo) return;
 
         if (mLastCursorAnchorInfo == null) {
             // Reuse the builder object.
             mCursorAnchorInfoBuilder.reset();
 
@@ skipping 31 matching lines @@
                         mInsertionMarkerBottom,
                         mIsInsertionMarkerVisible ? CursorAnchorInfo.FLAG_HAS_VISIBLE_REGION :
                                 CursorAnchorInfo.FLAG_HAS_INVISIBLE_REGION);
             }
             mLastCursorAnchorInfo = mCursorAnchorInfoBuilder.build();
         }
 
         if (mInputMethodManagerWrapper != null) {
             mInputMethodManagerWrapper.updateCursorAnchorInfo(view, mLastCursorAnchorInfo);
         }
+
+        if (mListeners.containsKey(view)) {
+            for (Listener listener : mListeners.get(view)) {
+                listener.onCursorAnchorInfoUpdate(mLastCursorAnchorInfo);
+            }
+        }
         mHasPendingImmediateRequest = false;
     }
 }