[Android] Composited selection handle rendering

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

 // Copyright 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.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.SearchManager;
+import android.content.ClipboardManager;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.database.ContentObserver;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Rect;
@@ skipping 34 matching lines @@
 import org.chromium.base.JNINamespace;
 import org.chromium.base.ObserverList;
 import org.chromium.base.ObserverList.RewindableIterator;
 import org.chromium.base.TraceEvent;
 import org.chromium.content.R;
 import org.chromium.content.browser.ScreenOrientationListener.ScreenOrientationObserver;
 import org.chromium.content.browser.accessibility.AccessibilityInjector;
 import org.chromium.content.browser.accessibility.BrowserAccessibilityManager;
 import org.chromium.content.browser.input.AdapterInputConnection;
 import org.chromium.content.browser.input.GamepadList;
-import org.chromium.content.browser.input.HandleView;
 import org.chromium.content.browser.input.ImeAdapter;
 import org.chromium.content.browser.input.ImeAdapter.AdapterInputConnectionFactory;
 import org.chromium.content.browser.input.InputMethodManagerWrapper;
-import org.chromium.content.browser.input.InsertionHandleController;
+import org.chromium.content.browser.input.PastePopupMenu;
+import org.chromium.content.browser.input.PastePopupMenu.PastePopupMenuDelegate;
+import org.chromium.content.browser.input.PopupTouchHandleDrawable;
+import org.chromium.content.browser.input.PopupTouchHandleDrawable.PopupTouchHandleDrawableDelegate;
 import org.chromium.content.browser.input.SelectPopup;
 import org.chromium.content.browser.input.SelectPopupDialog;
 import org.chromium.content.browser.input.SelectPopupDropdown;
 import org.chromium.content.browser.input.SelectPopupItem;
-import org.chromium.content.browser.input.SelectionHandleController;
+import org.chromium.content.browser.input.SelectionEventType;
 import org.chromium.content.common.ContentSwitches;
 import org.chromium.content_public.browser.GestureStateListener;
 import org.chromium.content_public.browser.WebContents;
 import org.chromium.ui.base.DeviceFormFactor;
 import org.chromium.ui.base.ViewAndroid;
 import org.chromium.ui.base.ViewAndroidDelegate;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.gfx.DeviceDisplayInfo;
 
 import java.lang.annotation.Annotation;
@@ skipping 16 matching lines @@
     private static final String TAG = "ContentViewCore";
 
     // Used to avoid enabling zooming in / out if resulting zooming will
     // produce little visible difference.
     private static final float ZOOM_CONTROLS_EPSILON = 0.007f;
 
     // Used to represent gestures for long press and long tap.
     private static final int IS_LONG_PRESS = 1;
     private static final int IS_LONG_TAP = 2;
 
-    // Length of the delay (in ms) before fading in handles after the last page movement.
-    private static final int TEXT_HANDLE_FADE_IN_DELAY = 300;
-
     // If the embedder adds a JavaScript interface object that contains an indirect reference to
     // the ContentViewCore, then storing a strong ref to the interface object on the native
     // side would prevent garbage collection of the ContentViewCore (as that strong ref would
     // create a new GC root).
     // For that reason, we store only a weak reference to the interface object on the
     // native side. However we still need a strong reference on the Java side to
     // prevent garbage collection if the embedder doesn't maintain their own ref to the
     // interface object - the Java side ref won't create a new GC root.
     // This map stores those refernces. We put into the map on addJavaScriptInterface()
     // and remove from it in removeJavaScriptInterface().
@@ skipping 129 matching lines @@
     private SelectPopup mSelectPopup;
 
     private Runnable mFakeMouseMoveRunnable = null;
 
     // Only valid when focused on a text / password field.
     private ImeAdapter mImeAdapter;
     private ImeAdapter.AdapterInputConnectionFactory mAdapterInputConnectionFactory;
     private AdapterInputConnection mInputConnection;
     private InputMethodManagerWrapper mInputMethodManagerWrapper;
 
-    private SelectionHandleController mSelectionHandleController;
-    private InsertionHandleController mInsertionHandleController;
+    // Lazily created paste popup menu, triggered either via long press in an
+    // editable region or from tapping the insertion handle.
+    private PastePopupMenu mPastePopupMenu;
+    private boolean mAllowAutomaticPastePopupShowing;
 
-    private Runnable mDeferredHandleFadeInRunnable;
+    private PopupTouchHandleDrawableDelegate mTouchHandleDelegate;
 
     private PositionObserver mPositionObserver;
-    private PositionObserver.Listener mPositionListener;
 
     // Size of the viewport in physical pixels as set from onSizeChanged.
     private int mViewportWidthPix;
     private int mViewportHeightPix;
     private int mPhysicalBackingWidthPix;
     private int mPhysicalBackingHeightPix;
     private int mOverdrawBottomHeightPix;
     private int mViewportSizeOffsetWidthPix;
     private int mViewportSizeOffsetHeightPix;
 
     // Cached copy of all positions and scales as reported by the renderer.
     private final RenderCoordinates mRenderCoordinates;
 
-    private final RenderCoordinates.NormalizedPoint mStartHandlePoint;
-    private final RenderCoordinates.NormalizedPoint mEndHandlePoint;
-    private final RenderCoordinates.NormalizedPoint mInsertionHandlePoint;
-
     // Tracks whether a selection is currently active.  When applied to selected text, indicates
     // whether the last selected text is still highlighted.
     private boolean mHasSelection;
+    private boolean mHasInsertion;
     private String mLastSelectedText;
     private boolean mSelectionEditable;
     private ActionMode mActionMode;
     private boolean mUnselectAllOnActionModeDismiss;
 
     // Delegate that will handle GET downloads, and be notified of completion of POST downloads.
     private ContentViewDownloadDelegate mDownloadDelegate;
 
     // The AccessibilityInjector that handles loading Accessibility scripts into the web page.
     private AccessibilityInjector mAccessibilityInjector;
@@ skipping 73 matching lines @@
         mInputMethodManagerWrapper = new InputMethodManagerWrapper(mContext);
 
         mRenderCoordinates = new RenderCoordinates();
         float deviceScaleFactor = getContext().getResources().getDisplayMetrics().density;
         String forceScaleFactor = CommandLine.getInstance().getSwitchValue(
                 ContentSwitches.FORCE_DEVICE_SCALE_FACTOR);
         if (forceScaleFactor != null) {
             deviceScaleFactor = Float.valueOf(forceScaleFactor);
         }
         mRenderCoordinates.setDeviceScaleFactor(deviceScaleFactor);
-        mStartHandlePoint = mRenderCoordinates.createNormalizedPoint();
-        mEndHandlePoint = mRenderCoordinates.createNormalizedPoint();
-        mInsertionHandlePoint = mRenderCoordinates.createNormalizedPoint();
         mAccessibilityManager = (AccessibilityManager)
                 getContext().getSystemService(Context.ACCESSIBILITY_SERVICE);
         mGestureStateListeners = new ObserverList<GestureStateListener>();
         mGestureStateListenersIterator = mGestureStateListeners.rewindableIterator();
 
         mEditable = Editable.Factory.getInstance().newEditable("");
         Selection.setSelection(mEditable, 0);
     }
 
     /**
@@ skipping 137 matching lines @@
         return mInputConnection;
     }
 
     private ImeAdapter createImeAdapter(Context context) {
         return new ImeAdapter(mInputMethodManagerWrapper,
                 new ImeAdapter.ImeAdapterDelegate() {
                     @Override
                     public void onImeEvent(boolean isFinish) {
                         getContentViewClient().onImeEvent();
                         if (!isFinish) {
-                            hideHandles();
+                            hideTextHandles();
                         }
                     }
 
                     @Override
                     public void onDismissInput() {
                         getContentViewClient().onImeStateChangeRequested(false);
                     }
 
                     @Override
                     public View getAttachedView() {
@@ skipping 42 matching lines @@
     // is a vital component of the ContentViewCore, so embedders must exercise caution in what
     // they do with the ContentViewCore before calling initialize().
     // We supply the nativeWebContents pointer here rather than in the constructor to allow us
     // to set the private browsing mode at a later point for the WebView implementation.
     // Note that the caller remains the owner of the nativeWebContents and is responsible for
     // deleting it after destroying the ContentViewCore.
     public void initialize(ViewGroup containerView, InternalAccessDelegate internalDispatcher,
             long nativeWebContents, WindowAndroid windowAndroid) {
         setContainerView(containerView);
 
-        mPositionListener = new PositionObserver.Listener() {
-            @Override
-            public void onPositionChanged(int x, int y) {
-                if (isSelectionHandleShowing() || isInsertionHandleShowing()) {
-                    temporarilyHideTextHandles();
-                }
-            }
-        };
-
         long windowNativePointer = windowAndroid != null ? windowAndroid.getNativePointer() : 0;
 
         long viewAndroidNativePointer = 0;
         if (windowNativePointer != 0) {
             mViewAndroid = new ViewAndroid(windowAndroid, getViewAndroidDelegate());
             viewAndroidNativePointer = mViewAndroid.getNativePointer();
         }
 
         mZoomControlsDelegate = new ZoomControlsDelegate() {
             @Override
@@ skipping 51 matching lines @@
      *     <li>Disconnecting the old container view from this ContentViewCore</li>
      *     <li>Updating the InternalAccessDelegate</li>
      *     <li>Reconciling the state of this ContentViewCore with the new container view</li>
      *     <li>Tearing down and recreating the native GL rendering where appropriate</li>
      *     <li>etc.</li>
      * </ul>
      */
     public void setContainerView(ViewGroup containerView) {
         TraceEvent.begin();
         if (mContainerView != null) {
-            mPositionObserver.removeListener(mPositionListener);
-            mSelectionHandleController = null;
-            mInsertionHandleController = null;
+            mPastePopupMenu = null;
             mInputConnection = null;
         }
 
         mContainerView = containerView;
         mPositionObserver = new ViewPositionObserver(mContainerView);
         String contentDescription = "Web View";
         if (R.string.accessibility_content_view == 0) {
             Log.w(TAG, "Setting contentDescription to 'Web View' as no value was specified.");
         } else {
             contentDescription = mContext.getResources().getString(
@@ skipping 420 matching lines @@
 
     /**
      * @see View#onTouchEvent(MotionEvent)
      */
     public boolean onTouchEvent(MotionEvent event) {
         TraceEvent.begin("onTouchEvent");
         try {
             cancelRequestToScrollFocusedEditableNodeIntoView();
 
             final int eventAction = event.getActionMasked();
-
-            // Only these actions have any effect on gesture detection.  Other
-            // actions have no corresponding WebTouchEvent type and may confuse the
-            // touch pipline, so we ignore them entirely.
-            if (eventAction != MotionEvent.ACTION_DOWN
-                    && eventAction != MotionEvent.ACTION_UP
-                    && eventAction != MotionEvent.ACTION_CANCEL
-                    && eventAction != MotionEvent.ACTION_MOVE
-                    && eventAction != MotionEvent.ACTION_POINTER_DOWN
-                    && eventAction != MotionEvent.ACTION_POINTER_UP) {
-                return false;
-            }
+            if (!isValidTouchEventActionForNative(eventAction)) return false;
 
             if (mNativeContentViewCore == 0) return false;
 
             // A zero offset is quite common, in which case the unnecessary copy should be avoided.
             MotionEvent offset = null;
             if (mCurrentTouchOffsetX != 0 || mCurrentTouchOffsetY != 0) {
                 offset = createOffsetMotionEvent(event);
                 event = offset;
             }
 
@@ skipping 11 matching lines @@
                     pointerCount > 1 ? event.getToolType(1) : MotionEvent.TOOL_TYPE_UNKNOWN,
                     event.getButtonState());
 
             if (offset != null) offset.recycle();
             return consumed;
         } finally {
             TraceEvent.end("onTouchEvent");
         }
     }
 
+    private static boolean isValidTouchEventActionForNative(int eventAction) {
+        // Only these actions have any effect on gesture detection.  Other
+        // actions have no corresponding WebTouchEvent type and may confuse the
+        // touch pipline, so we ignore them entirely.
+        return eventAction == MotionEvent.ACTION_DOWN
+                || eventAction == MotionEvent.ACTION_UP
+                || eventAction == MotionEvent.ACTION_CANCEL
+                || eventAction == MotionEvent.ACTION_MOVE
+                || eventAction == MotionEvent.ACTION_POINTER_DOWN
+                || eventAction == MotionEvent.ACTION_POINTER_UP;
+    }
+
     public void setIgnoreRemainingTouchEvents() {
         resetGestureDetection();
     }
 
     public boolean isScrollInProgress() {
         return mTouchScrollInProgress || mPotentiallyActiveFlingCount > 0;
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onFlingStartEventConsumed(int vx, int vy) {
         mTouchScrollInProgress = false;
         mPotentiallyActiveFlingCount++;
-        temporarilyHideTextHandles();
         for (mGestureStateListenersIterator.rewind();
                     mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onFlingStartGesture(
                     vx, vy, computeVerticalScrollOffset(), computeVerticalScrollExtent());
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onFlingStartEventHadNoConsumer(int vx, int vy) {
         mTouchScrollInProgress = false;
         for (mGestureStateListenersIterator.rewind();
                     mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onUnhandledFlingStartEvent(vx, vy);
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onFlingCancelEventAck() {
         updateGestureStateListener(GestureEventType.FLING_CANCEL);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onScrollBeginEventAck() {
+        hidePastePopup();
         mTouchScrollInProgress = true;
-        temporarilyHideTextHandles();
         mZoomControlsDelegate.invokeZoomPicker();
         updateGestureStateListener(GestureEventType.SCROLL_START);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onScrollUpdateGestureConsumed() {
         mZoomControlsDelegate.invokeZoomPicker();
         for (mGestureStateListenersIterator.rewind();
                 mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onScrollUpdateGestureConsumed();
         }
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onScrollEndEventAck() {
         if (!mTouchScrollInProgress) return;
         mTouchScrollInProgress = false;
         updateGestureStateListener(GestureEventType.SCROLL_END);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onPinchBeginEventAck() {
-        temporarilyHideTextHandles();
         updateGestureStateListener(GestureEventType.PINCH_BEGIN);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onPinchEndEventAck() {
         updateGestureStateListener(GestureEventType.PINCH_END);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onSingleTapEventAck(boolean consumed, int x, int y) {
         for (mGestureStateListenersIterator.rewind();
                 mGestureStateListenersIterator.hasNext();) {
             mGestureStateListenersIterator.next().onSingleTap(consumed, x, y);
         }
     }
 
-    @SuppressWarnings("unused")
-    @CalledByNative
-    private void onDoubleTapEventAck() {
-        temporarilyHideTextHandles();
-    }
-
     /**
      * Called just prior to a tap or press gesture being forwarded to the renderer.
      */
     @SuppressWarnings("unused")
     @CalledByNative
     private boolean filterTapOrPressEvent(int type, int x, int y) {
         if (type == GestureEventType.LONG_PRESS && offerLongPressToEmbedder()) {
             return true;
         }
         updateForTapOrPress(type, x, y);
@@ skipping 145 matching lines @@
      * Return the ContentSettings object used to retrieve the settings for this
      * ContentViewCore. For modifications, ChromeNativePreferences is to be used.
      * @return A ContentSettings object that can be used to retrieve this
      *         ContentViewCore's settings.
      */
     public ContentSettings getContentSettings() {
         return mContentSettings;
     }
 
     private void hidePopups() {
+        mUnselectAllOnActionModeDismiss = true;
+        hideSelectActionBar();
+        hidePastePopup();
         hideSelectPopup();
-        hideHandles();
-        hideSelectActionBar();
+        hideTextHandles();
     }
 
     public void hideSelectActionBar() {
         if (mActionMode != null) {
             mActionMode.finish();
             mActionMode = null;
         }
     }
 
     public boolean isSelectActionBarShowing() {
@@ skipping 434 matching lines @@
         if (mContainerView.isFocusable() && mContainerView.isFocusableInTouchMode()
                 && !mContainerView.isFocused())  {
             mContainerView.requestFocus();
         }
 
         if (!mPopupZoomer.isShowing()) mPopupZoomer.setLastTouch(xPix, yPix);
 
         mLastTapX = (int) xPix;
         mLastTapY = (int) yPix;
 
-        if (type == GestureEventType.LONG_PRESS
-                || type == GestureEventType.LONG_TAP) {
-            getInsertionHandleController().allowAutomaticShowing();
-            getSelectionHandleController().allowAutomaticShowing();
-        } else {
-            if (mSelectionEditable) getInsertionHandleController().allowAutomaticShowing();
-        }
+        if (type == GestureEventType.LONG_PRESS) mAllowAutomaticPastePopupShowing = true;
     }
 
     /**
      * @return The x coordinate for the last point that a tap or press gesture was initiated from.
      */
     public int getLastTapX()  {
         return mLastTapX;
     }
 
     /**
@@ skipping 42 matching lines @@
      */
     public void setDownloadDelegate(ContentViewDownloadDelegate delegate) {
         mDownloadDelegate = delegate;
     }
 
     // Called by DownloadController.
     ContentViewDownloadDelegate getDownloadDelegate() {
         return mDownloadDelegate;
     }
 
-    private SelectionHandleController getSelectionHandleController() {
-        if (mSelectionHandleController == null) {
-            mSelectionHandleController = new SelectionHandleController(
-                    getContainerView(), mPositionObserver) {
-                @Override
-                public void selectBetweenCoordinates(int x1, int y1, int x2, int y2) {
-                    if (mNativeContentViewCore != 0 && !(x1 == x2 && y1 == y2)) {
-                        nativeSelectBetweenCoordinates(mNativeContentViewCore,
-                                x1, y1 - mRenderCoordinates.getContentOffsetYPix(),
-                                x2, y2 - mRenderCoordinates.getContentOffsetYPix());
-                    }
-                }
-
-                @Override
-                public void showHandles(int startDir, int endDir) {
-                    final boolean wasShowing = isShowing();
-                    super.showHandles(startDir, endDir);
-                    if (!wasShowing || mActionMode == null) showSelectActionBar();
-                }
-
-            };
-
-            mSelectionHandleController.hideAndDisallowAutomaticShowing();
-        }
-
-        return mSelectionHandleController;
-    }
-
-    private InsertionHandleController getInsertionHandleController() {
-        if (mInsertionHandleController == null) {
-            mInsertionHandleController = new InsertionHandleController(
-                    getContainerView(), mPositionObserver) {
-                private static final int AVERAGE_LINE_HEIGHT = 14;
-
-                @Override
-                public void setCursorPosition(int x, int y) {
-                    if (mNativeContentViewCore != 0) {
-                        nativeMoveCaret(mNativeContentViewCore,
-                                x, y - mRenderCoordinates.getContentOffsetYPix());
-                    }
-                }
-
-                @Override
-                public void paste() {
-                    mImeAdapter.paste();
-                    hideHandles();
-                }
-
-                @Override
-                public int getLineHeight() {
-                    return (int) Math.ceil(
-                            mRenderCoordinates.fromLocalCssToPix(AVERAGE_LINE_HEIGHT));
-                }
-            };
-
-            mInsertionHandleController.hideAndDisallowAutomaticShowing();
-        }
-
-        return mInsertionHandleController;
-    }
-
-    @VisibleForTesting
-    public InsertionHandleController getInsertionHandleControllerForTest() {
-        return mInsertionHandleController;
-    }
-
-    @VisibleForTesting
-    public SelectionHandleController getSelectionHandleControllerForTest() {
-        return mSelectionHandleController;
-    }
-
-    private void updateHandleScreenPositions() {
-        if (isSelectionHandleShowing()) {
-            mSelectionHandleController.setStartHandlePosition(
-                    mStartHandlePoint.getXPix(), mStartHandlePoint.getYPix());
-            mSelectionHandleController.setEndHandlePosition(
-                    mEndHandlePoint.getXPix(), mEndHandlePoint.getYPix());
-        }
-
-        if (isInsertionHandleShowing()) {
-            mInsertionHandleController.setHandlePosition(
-                    mInsertionHandlePoint.getXPix(), mInsertionHandlePoint.getYPix());
-        }
-    }
-
-    private void hideHandles() {
-        if (mSelectionHandleController != null) {
-            mSelectionHandleController.hideAndDisallowAutomaticShowing();
-        }
-        if (mInsertionHandleController != null) {
-            mInsertionHandleController.hideAndDisallowAutomaticShowing();
-        }
-        mPositionObserver.removeListener(mPositionListener);
-    }
-
     private void showSelectActionBar() {
         if (mActionMode != null) {
             mActionMode.invalidate();
             return;
         }
 
         // Start a new action mode with a SelectActionModeCallback.
         SelectActionModeCallback.ActionHandler actionHandler =
                 new SelectActionModeCallback.ActionHandler() {
             @Override
@@ skipping 109 matching lines @@
         }
         mUnselectAllOnActionModeDismiss = true;
         if (mActionMode == null) {
             // There is no ActionMode, so remove the selection.
             mImeAdapter.unselect();
         } else {
             getContentViewClient().onContextualActionBarShown();
         }
     }
 
+    private void hidePastePopup() {
+        mAllowAutomaticPastePopupShowing = false;
+        if (mPastePopupMenu == null) return;
+        mPastePopupMenu.hide();
+    }
+
+    @CalledByNative
+    private void onSelectionEvent(int eventType, float posXDip, float posYDip) {
+        boolean shouldShowPastePopup = false;
+        switch (eventType) {
+            case SelectionEventType.SELECTION_SHOWN:
+                mHasSelection = true;
+                // TODO(cjhopman): Remove this when there is a better signal that long press caused
+                // a selection. See http://crbug.com/150151.
+                mContainerView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+                showSelectActionBar();
+                break;
+
+            case SelectionEventType.SELECTION_CLEARED:
+                mHasSelection = false;
+                mUnselectAllOnActionModeDismiss = false;
+                hideSelectActionBar();
+                break;
+
+            case SelectionEventType.INSERTION_SHOWN:
+                mHasInsertion = true;
+                shouldShowPastePopup = mAllowAutomaticPastePopupShowing;
+                break;
+
+            case SelectionEventType.INSERTION_MOVED:
+                // TODO(jdduke): Handle case where movement triggered by focus.
+                hidePastePopup();
+                break;
+
+            case SelectionEventType.INSERTION_TAPPED:
+                if (getPastePopup().isShowing())
+                    mPastePopupMenu.hide();
+                else
+                    shouldShowPastePopup = true;
+                break;
+
+            case SelectionEventType.INSERTION_CLEARED:
+                mHasInsertion = false;
+                hidePastePopup();
+                break;
+
+            default:
+                assert false : "Invalid selection event type.";
+        }
+        if (shouldShowPastePopup) {
+            final float contentOffsetYPix = mRenderCoordinates.getContentOffsetYPix();
+            getPastePopup().showAt(
+                (int) mRenderCoordinates.fromDipToPix(posXDip),
+                (int) (mRenderCoordinates.fromDipToPix(posYDip) + contentOffsetYPix));
+        }
+    }
+
     public boolean getUseDesktopUserAgent() {
         if (mNativeContentViewCore != 0) {
             return nativeGetUseDesktopUserAgent(mNativeContentViewCore);
         }
         return false;
     }
 
     /**
      * Set whether or not we're using a desktop user agent for the currently loaded page.
      * @param override If true, use a desktop user agent.  Use a mobile one otherwise.
      * @param reloadOnChange Reload the page if the UA has changed.
      */
     public void setUseDesktopUserAgent(boolean override, boolean reloadOnChange) {
         if (mNativeContentViewCore != 0) {
             nativeSetUseDesktopUserAgent(mNativeContentViewCore, override, reloadOnChange);
         }
     }
 
     public void clearSslPreferences() {
         if (mNativeContentViewCore != 0) nativeClearSslPreferences(mNativeContentViewCore);
     }
 
-    private boolean isSelectionHandleShowing() {
-        return mSelectionHandleController != null && mSelectionHandleController.isShowing();
-    }
-
-    private boolean isInsertionHandleShowing() {
-        return mInsertionHandleController != null && mInsertionHandleController.isShowing();
-    }
-
-    // Makes the insertion/selection handles invisible. They will fade back in shortly after the
-    // last call to scheduleTextHandleFadeIn (or temporarilyHideTextHandles).
-    private void temporarilyHideTextHandles() {
-        if (isSelectionHandleShowing() && !mSelectionHandleController.isDragging()) {
-            mSelectionHandleController.setHandleVisibility(HandleView.INVISIBLE);
-        }
-        if (isInsertionHandleShowing() && !mInsertionHandleController.isDragging()) {
-            mInsertionHandleController.setHandleVisibility(HandleView.INVISIBLE);
-        }
-        scheduleTextHandleFadeIn();
-    }
-
-    private boolean allowTextHandleFadeIn() {
-        if (mTouchScrollInProgress) return false;
-
-        if (mPopupZoomer.isShowing()) return false;
-
-        return true;
-    }
-
-    // Cancels any pending fade in and schedules a new one.
-    private void scheduleTextHandleFadeIn() {
-        if (!isInsertionHandleShowing() && !isSelectionHandleShowing()) return;
-
-        if (mDeferredHandleFadeInRunnable == null) {
-            mDeferredHandleFadeInRunnable = new Runnable() {
-                @Override
-                public void run() {
-                    if (!allowTextHandleFadeIn()) {
-                        // Delay fade in until it is allowed.
-                        scheduleTextHandleFadeIn();
-                    } else {
-                        if (isSelectionHandleShowing()) {
-                            mSelectionHandleController.beginHandleFadeIn();
-                        }
-                        if (isInsertionHandleShowing()) {
-                            mInsertionHandleController.beginHandleFadeIn();
-                        }
-                    }
-                }
-            };
-        }
-
-        mContainerView.removeCallbacks(mDeferredHandleFadeInRunnable);
-        mContainerView.postDelayed(mDeferredHandleFadeInRunnable, TEXT_HANDLE_FADE_IN_DELAY);
+    private void hideTextHandles() {
+        mHasSelection = false;
+        mHasInsertion = false;
+        if (mNativeContentViewCore != 0) nativeHideTextHandles(mNativeContentViewCore);
     }
 
     /**
      * Shows the IME if the focused widget could accept text input.
      */
     public void showImeIfNeeded() {
         if (mNativeContentViewCore != 0) nativeShowImeIfNeeded(mNativeContentViewCore);
     }
 
     /**
@@ skipping 43 matching lines @@
                 pageScaleFactor != mRenderCoordinates.getPageScaleFactor();
         final boolean scrollChanged =
                 pageScaleChanged
                 || scrollOffsetX != mRenderCoordinates.getScrollX()
                 || scrollOffsetY != mRenderCoordinates.getScrollY();
         final boolean contentOffsetChanged =
                 contentOffsetYPix != mRenderCoordinates.getContentOffsetYPix();
 
         final boolean needHidePopupZoomer = contentSizeChanged || scrollChanged;
         final boolean needUpdateZoomControls = scaleLimitsChanged || scrollChanged;
-        final boolean needTemporarilyHideHandles = scrollChanged;
 
         if (needHidePopupZoomer) mPopupZoomer.hide(true);
 
         if (scrollChanged) {
             mContainerViewInternals.onScrollChanged(
                     (int) mRenderCoordinates.fromLocalCssToPix(scrollOffsetX),
                     (int) mRenderCoordinates.fromLocalCssToPix(scrollOffsetY),
                     (int) mRenderCoordinates.getScrollXPix(),
                     (int) mRenderCoordinates.getScrollYPix());
         }
 
         mRenderCoordinates.updateFrameInfo(
                 scrollOffsetX, scrollOffsetY,
                 contentWidth, contentHeight,
                 viewportWidth, viewportHeight,
                 pageScaleFactor, minPageScaleFactor, maxPageScaleFactor,
                 contentOffsetYPix);
 
         if (scrollChanged || contentOffsetChanged) {
             for (mGestureStateListenersIterator.rewind();
                     mGestureStateListenersIterator.hasNext();) {
                 mGestureStateListenersIterator.next().onScrollOffsetOrExtentChanged(
                         computeVerticalScrollOffset(),
                         computeVerticalScrollExtent());
             }
         }
 
-        if (needTemporarilyHideHandles) temporarilyHideTextHandles();
         if (needUpdateZoomControls) mZoomControlsDelegate.updateZoomControls();
-        if (contentOffsetChanged) updateHandleScreenPositions();
 
         // Update offsets for fullscreen.
         final float controlsOffsetPix = controlsOffsetYCss * deviceScale;
         final float overdrawBottomHeightPix = overdrawBottomHeightCss * deviceScale;
         getContentViewClient().onOffsetsForFullscreenChanged(
                 controlsOffsetPix, contentOffsetYPix, overdrawBottomHeightPix);
 
         if (mBrowserAccessibilityManager != null) {
             mBrowserAccessibilityManager.notifyFrameInfoInitialized();
         }
     }
 
     @CalledByNative
     private void updateImeAdapter(long nativeImeAdapterAndroid, int textInputType,
             String text, int selectionStart, int selectionEnd,
             int compositionStart, int compositionEnd, boolean showImeIfNeeded,
             boolean isNonImeChange) {
         TraceEvent.begin();
         mSelectionEditable = (textInputType != ImeAdapter.getTextInputTypeNone());
+        if (!mSelectionEditable) hidePastePopup();
 
         mImeAdapter.updateKeyboardVisibility(
                 nativeImeAdapterAndroid, textInputType, showImeIfNeeded);
 
         if (mInputConnection != null) {
             mInputConnection.updateState(text, selectionStart, selectionEnd, compositionStart,
                     compositionEnd, isNonImeChange);
         }
 
         if (mActionMode != null) mActionMode.invalidate();
@@ skipping 49 matching lines @@
      */
     public SelectPopup getSelectPopupForTest() {
         return mSelectPopup;
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void showDisambiguationPopup(Rect targetRect, Bitmap zoomedBitmap) {
         mPopupZoomer.setBitmap(zoomedBitmap);
         mPopupZoomer.show(targetRect);
-        temporarilyHideTextHandles();
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private TouchEventSynthesizer createTouchEventSynthesizer() {
         return new TouchEventSynthesizer(this);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
+    private PopupTouchHandleDrawable createPopupTouchHandleDrawable() {
+        if (mTouchHandleDelegate == null) {
+            mTouchHandleDelegate = new PopupTouchHandleDrawableDelegate() {
+                public boolean onTouchHandleEvent(MotionEvent event) {
+                    if (mNativeContentViewCore == 0) return false;
+                    if (!isValidTouchEventActionForNative(event.getActionMasked())) return false;
+                    return nativeOnTouchHandleEvent(mNativeContentViewCore, event);
+                }
+            };
+        }
+        return new PopupTouchHandleDrawable(
+                mTouchHandleDelegate, getContainerView(), mPositionObserver);
+    }
+
+    @SuppressWarnings("unused")
+    @CalledByNative
     private void onSelectionChanged(String text) {
         mLastSelectedText = text;
         getContentViewClient().onSelectionChanged(text);
     }
 
     @SuppressWarnings("unused")
-    @CalledByNative
-    private void showSelectionHandlesAutomatically() {
-        getSelectionHandleController().allowAutomaticShowing();
-    }
-
-    @SuppressWarnings("unused")
-    @CalledByNative
-    private void onSelectionBoundsChanged(
-            float anchorXDip, float anchorYDip, float focusXDip, float focusYDip,
-            int anchorDir, int focusDir,
-            boolean isAnchorVisible, boolean isFocusVisible) {
-        // TODO(jdduke): Use |is{Anchor,Focus}Visible|, as well as the action
-        // bar height, to set handle visibility, see crbug.com/164819.
-        if (focusXDip != anchorXDip || focusYDip != anchorYDip ||
-                (mSelectionHandleController != null && mSelectionHandleController.isDragging())) {
-            if (mInsertionHandleController != null) {
-                mInsertionHandleController.hide();
-            }
-            mStartHandlePoint.setLocalDip(anchorXDip, anchorYDip);
-            mEndHandlePoint.setLocalDip(focusXDip, focusYDip);
-
-            boolean wereSelectionHandlesShowing = getSelectionHandleController().isShowing();
-
-            getSelectionHandleController().onSelectionChanged(anchorDir, focusDir);
-            updateHandleScreenPositions();
-            mHasSelection = true;
-
-            if (!wereSelectionHandlesShowing && getSelectionHandleController().isShowing()) {
-                // TODO(cjhopman): Remove this when there is a better signal that long press caused
-                // a selection. See http://crbug.com/150151.
-                mContainerView.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
-            }
-
-        } else {
-            mUnselectAllOnActionModeDismiss = false;
-            hideSelectActionBar();
-            if (anchorXDip != 0 && anchorYDip != 0 && mSelectionEditable) {
-                // Selection is a caret, and a text field is focused.
-                if (mSelectionHandleController != null) {
-                    mSelectionHandleController.hide();
-                }
-                mInsertionHandlePoint.setLocalDip(anchorXDip, anchorYDip);
-
-                getInsertionHandleController().onCursorPositionChanged();
-                updateHandleScreenPositions();
-                if (mInputMethodManagerWrapper.isWatchingCursor(mContainerView)) {
-                    final int xPix = (int) mInsertionHandlePoint.getXPix();
-                    final int yPix = (int) mInsertionHandlePoint.getYPix();
-                    mInputMethodManagerWrapper.updateCursor(
-                            mContainerView, xPix, yPix, xPix, yPix);
-                }
-            } else {
-                // Deselection
-                hideHandles();
-            }
-            mHasSelection = false;
-        }
-        if (isSelectionHandleShowing() || isInsertionHandleShowing()) {
-            mPositionObserver.addListener(mPositionListener);
-        }
-    }
-
-    @SuppressWarnings("unused")
     @CalledByNative
     private static void onEvaluateJavaScriptResult(
             String jsonResult, JavaScriptCallback callback) {
         callback.handleJavaScriptResult(jsonResult);
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void showPastePopup(int xDip, int yDip) {

[cjhopman, 2014/07/09 22:29:12]

Is this called by native? Should it show the paste popup?

[jdduke (slow), 2014/07/10 02:08:39]

Yeah, I was debating what to do here.  I'd like to rip it out eventually, as I'm
not sure we need it and it forces every shell to implement the wiring
(content/chrome/clank/webview).  I'll hook it up for now.

-        mInsertionHandlePoint.setLocalDip(xDip, yDip);
-        getInsertionHandleController().showHandle();
-        updateHandleScreenPositions();
-        getInsertionHandleController().showHandleWithPastePopup();
+        /*
+        if (mPastePopupMenu == null) {
+            mPastePopupMenu = new PastePopupMenu(getContainerView(),
+                new PastePopupMenuDelegate() {
+                    public void paste() {
+                        mImeAdapter.paste();
+                    }
+                });
+        }
+        final float contentOffsetYPix = mRenderCoordinates.getContentOffsetYPix();
+        mPastePopupMenu.showAt((int) mRenderCoordinates.fromDipToPix(xDip),
+                               (int) (mRenderCoordinates.fromDipToPix(yDip) + contentOffsetYPix));
+        */
+    }
+
+    private PastePopupMenu getPastePopup() {
+        if (mPastePopupMenu == null) {
+            mPastePopupMenu = new PastePopupMenu(getContainerView(),
+                new PastePopupMenuDelegate() {
+                    public void paste() {
+                        mImeAdapter.paste();
+                    }
+                    public boolean canPaste() {
+                        if (!mSelectionEditable) return false;
+                        return ((ClipboardManager) mContext.getSystemService(
+                                Context.CLIPBOARD_SERVICE)).hasPrimaryClip();
+                    }
+                });
+        }
+        return mPastePopupMenu;
     }
 
     @SuppressWarnings("unused")
     @CalledByNative
     private void onRenderProcessChange() {
         attachImeAdapter();
     }
 
     /**
      * Attaches the native ImeAdapter object to the java ImeAdapter to allow communication via JNI.
@@ skipping 660 matching lines @@
     // All touch events (including flings, scrolls etc) accept coordinates in physical pixels.
     private native boolean nativeOnTouchEvent(
             long nativeContentViewCoreImpl, MotionEvent event,
             long timeMs, int action, int pointerCount, int historySize, int actionIndex,
             float x0, float y0, float x1, float y1,
             int pointerId0, int pointerId1,
             float touchMajor0, float touchMajor1,
             float rawX, float rawY,
             int androidToolType0, int androidToolType1, int androidButtonState);
 
+    private native boolean nativeOnTouchHandleEvent(
+            long nativeContentViewCoreImpl, MotionEvent event);
+
     private native int nativeSendMouseMoveEvent(
             long nativeContentViewCoreImpl, long timeMs, float x, float y);
 
     private native int nativeSendMouseWheelEvent(
             long nativeContentViewCoreImpl, long timeMs, float x, float y, float verticalAxis);
 
     private native void nativeScrollBegin(
             long nativeContentViewCoreImpl, long timeMs, float x, float y, float hintX,
             float hintY);
 
@@ skipping 23 matching lines @@
     private native void nativePinchEnd(long nativeContentViewCoreImpl, long timeMs);
 
     private native void nativePinchBy(long nativeContentViewCoreImpl, long timeMs,
             float anchorX, float anchorY, float deltaScale);
 
     private native void nativeSelectBetweenCoordinates(
             long nativeContentViewCoreImpl, float x1, float y1, float x2, float y2);
 
     private native void nativeMoveCaret(long nativeContentViewCoreImpl, float x, float y);
 
+    private native void nativeHideTextHandles(long nativeContentViewCoreImpl);
+
     private native void nativeResetGestureDetection(long nativeContentViewCoreImpl);
     private native void nativeSetDoubleTapSupportEnabled(
             long nativeContentViewCoreImpl, boolean enabled);
     private native void nativeSetMultiTouchZoomSupportEnabled(
             long nativeContentViewCoreImpl, boolean enabled);
 
     private native void nativeLoadIfNecessary(long nativeContentViewCoreImpl);
     private native void nativeRequestRestoreLoad(long nativeContentViewCoreImpl);
 
     private native void nativeReload(long nativeContentViewCoreImpl, boolean checkForRepost);
@@ skipping 63 matching lines @@
 
     private native void nativeExtractSmartClipData(long nativeContentViewCoreImpl,
             int x, int y, int w, int h);
     private native void nativeSetBackgroundOpaque(long nativeContentViewCoreImpl, boolean opaque);
 
     private native void nativeResumeResponseDeferredAtStart(
             long nativeContentViewCoreImpl);
     private native void nativeSetHasPendingNavigationTransitionForTesting(
             long nativeContentViewCoreImpl);
 }