Implement SmartText selection.

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

 // Copyright 2015 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.TargetApi;
 import android.app.Activity;
 import android.app.SearchManager;
 import android.content.ClipboardManager;
@@ skipping 36 matching lines @@
  * A class that handles input-related web content selection UI like action mode
  * and paste popup view. It wraps an {@link ActionMode} created by the associated view,
  * providing modified interaction with it.
  *
  * Embedders can use {@link ActionModeCallbackHelper} implemented by this class
  * to create {@link ActionMode.Callback} instance and configure the selection action
  * mode tasks to their requirements.
  */
 @TargetApi(Build.VERSION_CODES.M)
 public class SelectionPopupController extends ActionModeCallbackHelper {
-    private static final String TAG = "cr.SelectionPopCtlr";  // 20 char limit
+    private static final String TAG = "SelectionPopupCtlr"; // 20 char limit
 
     /**
      * Android Intent size limitations prevent sending over a megabyte of data. Limit
      * query lengths to 100kB because other things may be added to the Intent.
      */
     private static final int MAX_SHARE_QUERY_LENGTH = 100000;
 
     // Default delay for reshowing the {@link ActionMode} after it has been
     // hidden. This avoids flickering issues if there are trailing rect
     // invalidations after the ActionMode is shown. For example, after the user
@@ skipping 40 matching lines @@
     private boolean mHasSelection;
 
     // 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 mWasPastePopupShowingOnInsertionDragStart;
 
     // The client that processes textual selection, or null if none exists.
     private SelectionClient mSelectionClient;
 
+    // The classificaton result of the selected text if the selection exists and
+    // ContextSelectionProvider was able to classify it, otherwise null.
+    private ContextSelectionProvider.Result mClassificationResult;
+
+    // The resource ID for Assist menu item.
+    private int mAssistMenuItemId;
+
+    // This variable is set to true when the classification request is in progress.
+    private boolean mPendingClassificationRequest;
+
     /**
      * Create {@link SelectionPopupController} instance.
      * @param context Context for action mode.
      * @param window WindowAndroid instance.
      * @param webContents WebContents instance.
      * @param view Container view.
      * @param renderCoordinates Coordinates info used to position elements.
      * @param imeAdapter ImeAdapter instance to handle cursor position.
      */
     public SelectionPopupController(Context context, WindowAndroid window, WebContents webContents,
@@ skipping 10 matching lines @@
         mRepeatingHideRunnable = new Runnable() {
             @Override
             public void run() {
                 assert mHidden;
                 final long hideDuration = getDefaultHideDuration();
                 // Ensure the next hide call occurs before the ActionMode reappears.
                 mView.postDelayed(mRepeatingHideRunnable, hideDuration - 1);
                 hideActionModeTemporarily(hideDuration);
             }
         };
+
+        mSelectionClient =
+                ContextSelectionClient.create(new ContextSelectionCallback(), window, webContents);
+
+        // TODO(timav): Use android.R.id.textAssist for the Assist item id once we switch to
+        // Android O SDK and remove |mAssistMenuItemId|.
+        mAssistMenuItemId = mContext.getResources().getIdentifier("textAssist", "id", "android");
     }
 
     /**
      * Update the container view.
      */
     void setContainerView(View view) {
         assert view != null;
 
         // Cleans up action mode before switching to a new container view.
         if (isActionModeValid()) finishActionMode();
@@ skipping 24 matching lines @@
     @Override
     public void setAllowedMenuItems(int allowedMenuItems) {
         mAllowedMenuItems = allowedMenuItems;
     }
 
     /**
      * Show (activate) android action mode by starting it.
      *
      * <p>Action mode in floating mode is tried first, and then falls back to
      * a normal one.
-     * @return {@code true} if the action mode started successfully or is already on.
+     * <p> If the action mode cannot be created the selection is cleared.
      */
-    public boolean showActionMode() {
-        if (isEmpty()) return false;
+    public void showActionModeOrClearOnFailure() {
+        if (isEmpty()) return;

[amaralp, 2017/03/25 00:52:27]

Wouldn't you also want to clear the selection here?

[Tima Vaisburd, 2017/03/25 02:57:16]

I assumed no real action happens before setCallback(), but maybe this is not
true?

[boliu, 2017/03/25 21:19:10]

It is true. Should rename isEmpty to something like "supportsActionMode"

[Tima Vaisburd, 2017/03/27 06:33:04]

Does isReady() sound good?

[boliu, 2017/03/27 17:25:07]

Not really. isReady implies it might not be ready. The reality is it's set as
part of initialization. But embedder may not implement a callback in which case
action mode is just not supported

[Tima Vaisburd, 2017/03/27 18:19:45]

I renamed to isActionModeSupported(), if you like supportsActionMode() better I
will rename again.

 
         destroyActionModeAndKeepSelection();
 
         if (mView.getParent() != null) {
-             // On ICS, startActionMode throws an NPE when getParent() is null.
+            // On ICS, startActionMode throws an NPE when getParent() is null.
             assert mWebContents != null;
             ActionMode actionMode = supportsFloatingActionMode()
                     ? startFloatingActionMode()
                     : mView.startActionMode(mCallback);
             if (actionMode != null) {
                 // This is to work around an LGE email issue. See crbug.com/651706 for more details.
                 LGEmailActionModeWorkaround.runIfNecessary(mContext, actionMode);
             }
             mActionMode = actionMode;
         }
         mUnselectAllOnDismiss = true;
-        return isActionModeValid();
+        if (!isActionModeValid()) clearSelection();
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     private ActionMode startFloatingActionMode() {
         ActionMode actionMode = mView.startActionMode(
                 new FloatingActionModeCallback(this, mCallback), ActionMode.TYPE_FLOATING);
         return actionMode;
     }
 
     void createAndShowPastePopup(int x, int y) {
@@ skipping 54 matching lines @@
         return mPastePopupMenu != null;
     }
 
     // Composition methods for android.view.ActionMode
 
     /**
      * @see ActionMode#finish()
      */
     @Override
     public void finishActionMode() {
+        mPendingClassificationRequest = false;
+        mHidden = false;

[amaralp, 2017/03/25 00:52:27]

My CL crrev.com/2777663002 should make this and the next line unnecessary

[Tima Vaisburd, 2017/03/27 06:33:04]

I kept all the checks since I thought invalidate() will stay for a while.

+        mView.removeCallbacks(mRepeatingHideRunnable);
+
         if (isActionModeValid()) {
             mActionMode.finish();
 
             // Should be nulled out in case #onDestroyActionMode() is not invoked in response.
             mActionMode = null;
         }
     }
 
     /**
      * @see ActionMode#invalidateContentRect()
      */
-    public void invalidateContentRect() {
+    private void invalidateContentRect() {
         if (supportsFloatingActionMode()) {
             if (mHidden) {
                 mPendingInvalidateContentRect = true;
             } else {
                 mPendingInvalidateContentRect = false;
                 if (isActionModeValid()) mActionMode.invalidateContentRect();
             }
         }
     }
 
@@ skipping 13 matching lines @@
      */
     void hideActionMode(boolean hide) {
         if (!canHideActionMode()) return;
         if (mHidden == hide) return;
         mHidden = hide;
         if (mHidden) {
             mRepeatingHideRunnable.run();
         } else {
             mHidden = false;
             mView.removeCallbacks(mRepeatingHideRunnable);
+            // To show the action mode that is being hidden call hide() again with a short delay.
             hideActionModeTemporarily(SHOW_DELAY_MS);
             if (mPendingInvalidateContentRect) {
                 mPendingInvalidateContentRect = false;
                 invalidateContentRect();
             }
         }
     }
 
     /**
      * @see ActionMode#hide(long)
@@ skipping 49 matching lines @@
             // caused a resource loading failure to be logged. WebView
             // resource access needs to be improved so that this
             // logspam can be avoided.
             new MenuInflater(context).inflate(R.menu.select_action_menu, menu);
         }
     }
 
     private void createActionMenu(ActionMode mode, Menu menu) {
         mNeedsPrepare = false;
         initializeMenu(mContext, mode, menu);
+        updateAssistMenuItem(menu);
 
         if (!isSelectionEditable() || !canPaste()) {
             menu.removeItem(R.id.select_action_menu_paste);
         }
 
         if (isInsertion()) {
             menu.removeItem(R.id.select_action_menu_select_all);
             menu.removeItem(R.id.select_action_menu_cut);
             menu.removeItem(R.id.select_action_menu_copy);
             menu.removeItem(R.id.select_action_menu_share);
@@ skipping 22 matching lines @@
 
         initializeTextProcessingMenu(menu);
     }
 
     private boolean canPaste() {
         ClipboardManager clipMgr = (ClipboardManager)
                 mContext.getSystemService(Context.CLIPBOARD_SERVICE);
         return clipMgr.hasPrimaryClip();
     }
 
+    private void updateAssistMenuItem(Menu menu) {
+        // The assist menu item ID has to be equal to android.R.id.textAssist. Until we compile
+        // with Android O SDK where this ID is defined we replace the corresponding inflated
+        // item with an item with the proper ID.
+        // TODO(timav): Use android.R.id.textAssist for the Assist item id once we switch to
+        // Android O SDK and remove |mAssistMenuItemId|.
+        menu.removeItem(R.id.select_action_menu_assist);
+        if (mAssistMenuItemId == 0) return;
+
+        if (mClassificationResult != null && mClassificationResult.hasNamedAction()) {
+            menu.add(mAssistMenuItemId, mAssistMenuItemId, 1, mClassificationResult.label)
+                    .setIcon(mClassificationResult.icon);
+        }
+    }
+
     /**
      * Intialize the menu items for processing text, if there is any.
      */
     private void initializeTextProcessingMenu(Menu menu) {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M
                 || !isSelectActionModeAllowed(MENU_ITEM_PROCESS_TEXT)) {
             return;
         }
 
         PackageManager packageManager = mContext.getPackageManager();
         List<ResolveInfo> supportedActivities =
                 packageManager.queryIntentActivities(createProcessTextIntent(), 0);
+        final int order = menu.size();
         for (int i = 0; i < supportedActivities.size(); i++) {
             ResolveInfo resolveInfo = supportedActivities.get(i);
             CharSequence label = resolveInfo.loadLabel(mContext.getPackageManager());
-            menu.add(R.id.select_action_menu_text_processing_menus, Menu.NONE, i, label)
+            menu.add(R.id.select_action_menu_text_processing_menus, Menu.NONE, order, label)
                     .setIntent(createProcessTextIntentForResolveInfo(resolveInfo))
                     .setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
         }
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     private static Intent createProcessTextIntent() {
         return new Intent().setAction(Intent.ACTION_PROCESS_TEXT).setType("text/plain");
     }
 
     @TargetApi(Build.VERSION_CODES.M)
     private Intent createProcessTextIntentForResolveInfo(ResolveInfo info) {
         boolean isReadOnly = !isSelectionEditable();
         return createProcessTextIntent()
                 .putExtra(Intent.EXTRA_PROCESS_TEXT_READONLY, isReadOnly)
                 .setClassName(info.activityInfo.packageName, info.activityInfo.name);
     }
 
     @Override
     public boolean onActionItemClicked(ActionMode mode, MenuItem item) {
         if (!isActionModeValid()) return true;
 
         int id = item.getItemId();
         int groupId = item.getGroupId();
 
-        if (id == R.id.select_action_menu_select_all) {
+        if (id == mAssistMenuItemId) {
+            doAssistAction();
+            mode.finish();
+        } else if (id == R.id.select_action_menu_select_all) {
             selectAll();
         } else if (id == R.id.select_action_menu_cut) {
             cut();
             mode.finish();
         } else if (id == R.id.select_action_menu_copy) {
             copy();
             mode.finish();
         } else if (id == R.id.select_action_menu_paste) {
             paste();
             mode.finish();
@@ skipping 38 matching lines @@
                 (int) (mSelectionRect.top * deviceScale),
                 (int) (mSelectionRect.right * deviceScale),
                 (int) (mSelectionRect.bottom * deviceScale));
 
         // The selection coordinates are relative to the content viewport, but we need
         // coordinates relative to the containing View.
         outRect.offset(0, (int) mRenderCoordinates.getContentOffsetYPix());
     }
 
     /**
+     * Perform an action that depends on the semantics of the selected text.
+     */
+    @VisibleForTesting
+    void doAssistAction() {
+        if (mClassificationResult == null || !mClassificationResult.hasNamedAction()) return;
+
+        assert mClassificationResult.onClickListener != null
+                || mClassificationResult.intent != null;
+
+        if (mClassificationResult.onClickListener != null) {
+            mClassificationResult.onClickListener.onClick(mView);
+            return;
+        }
+
+        if (mClassificationResult.intent != null) {
+            Context context = mWindowAndroid.getContext().get();
+            if (context == null) return;
+
+            context.startActivity(mClassificationResult.intent);
+            return;
+        }
+    }
+
+    /**
      * Perform a select all action.
      */
     @VisibleForTesting
     void selectAll() {
         mWebContents.selectAll();
         // Even though the above statement logged a SelectAll user action, we want to
         // track whether the focus was in an editable field, so log that too.
         if (isSelectionEditable()) {
             RecordUserAction.record("MobileActionMode.SelectAllWasEditable");
         } else {
@@ skipping 157 matching lines @@
         CharSequence result = data.getCharSequenceExtra(Intent.EXTRA_PROCESS_TEXT);
         if (result != null) {
             // TODO(hush): Use a variant of replace that re-selects the replaced text.
             // crbug.com/546710
             mWebContents.replace(result.toString());
         }
     }
 
     void restoreSelectionPopupsIfNecessary() {
         if (mHasSelection && !isActionModeValid()) {
-            if (!showActionMode()) clearSelection();
+            showActionModeOrClearOnFailure();
         }
     }
 
     // All coordinates are in DIP.
     void onSelectionEvent(int eventType, int xAnchor, int yAnchor,
             int left, int top, int right, int bottom, boolean isScrollInProgress,
             boolean touchScrollInProgress) {
         // Ensure the provided selection coordinates form a non-empty rect, as required by
         // the selection action mode.
         if (left == right) ++right;
         if (top == bottom) ++bottom;
         switch (eventType) {
             case SelectionEventType.SELECTION_HANDLES_SHOWN:
                 mSelectionRect.set(left, top, right, bottom);
                 mHasSelection = true;
                 mUnselectAllOnDismiss = true;
-                if (!showActionMode()) clearSelection();
+                if (mSelectionClient != null && mSelectionClient.sendsSelectionPopupUpdates()) {
+                    // Rely on |mSelectionClient| sending a classification request and the request
+                    // always calling onClassified() callback.
+                    mPendingClassificationRequest = true;
+                } else {
+                    showActionModeOrClearOnFailure();
+                }
                 break;
 
             case SelectionEventType.SELECTION_HANDLES_MOVED:
                 mSelectionRect.set(left, top, right, bottom);
                 invalidateContentRect();
                 break;
 
             case SelectionEventType.SELECTION_HANDLES_CLEARED:
                 mHasSelection = false;
                 mUnselectAllOnDismiss = false;
                 mSelectionRect.setEmpty();
                 finishActionMode();
                 break;
 
             case SelectionEventType.SELECTION_HANDLE_DRAG_STARTED:
                 hideActionMode(true);
                 break;
 
             case SelectionEventType.SELECTION_HANDLE_DRAG_STOPPED:
-                hideActionMode(false);
+                if (mSelectionClient != null && mSelectionClient.sendsSelectionPopupUpdates()) {
+                    // Rely on |mSelectionClient| sending a classification request and the request
+                    // always calling onClassified() callback.
+                    mPendingClassificationRequest = true;
+                } else {
+                    hideActionMode(false);
+                }
                 break;
 
             case SelectionEventType.INSERTION_HANDLE_SHOWN:
                 mSelectionRect.set(left, top, right, bottom);
                 setIsInsertion(true);
                 break;
 
             case SelectionEventType.INSERTION_HANDLE_MOVED:
                 mSelectionRect.set(left, top, right, bottom);
                 if (!isScrollInProgress && isPastePopupShowing()) {
@@ skipping 42 matching lines @@
         }
     }
 
     /**
      * Clears the current text selection. Note that we will try to move cursor to selection
      * end if applicable.
      */
     void clearSelection() {
         if (mWebContents == null || isEmpty()) return;
         mWebContents.collapseSelection();
+        mClassificationResult = null;
     }
 
     void onSelectionChanged(String text) {
         mLastSelectedText = text;
         if (mSelectionClient != null) {
             mSelectionClient.onSelectionChanged(text);
         }
     }
 
     // The client that implements selection augmenting functionality, or null if none exists.
     void setSelectionClient(SelectionClient selectionClient) {
         mSelectionClient = selectionClient;
+
+        mClassificationResult = null;
+
+        assert !mPendingClassificationRequest;
+        assert !mHidden;
     }
 
     void onShowUnhandledTapUIIfNeeded(int x, int y) {
         if (mSelectionClient != null) {
             mSelectionClient.showUnhandledTapUIIfNeeded(x, y);
         }
     }
 
     void destroyActionModeAndUnselect() {
         mUnselectAllOnDismiss = true;
@@ skipping 34 matching lines @@
         if (isActionModeValid() && mIsInsertion != insertion) mNeedsPrepare = true;
         mIsInsertion = insertion;
     }
 
     private boolean isShareAvailable() {
         Intent intent = new Intent(Intent.ACTION_SEND);
         intent.setType("text/plain");
         return mContext.getPackageManager().queryIntentActivities(intent,
                 PackageManager.MATCH_DEFAULT_ONLY).size() > 0;
     }
+
+    // The callback class that delivers result from a ContextSelectionClient.
+    private class ContextSelectionCallback implements ContextSelectionProvider.ResultCallback {
+        @Override
+        public void onClassified(ContextSelectionProvider.Result result) {
+            boolean pendingClassificationRequest = mPendingClassificationRequest;
+            mPendingClassificationRequest = false;
+
+            // If the selection does not exist any more, discard |result|.
+            if (!mHasSelection) {
+                assert !mHidden;
+                assert mClassificationResult == null;
+                return;
+            }
+
+            mClassificationResult = result;
+
+            // The request might be cancelled by finishActionMode(). Keep the result and quit.

[amaralp, 2017/03/25 00:52:27]

Why do you want to keep the result if the request was canceled?

[Tima Vaisburd, 2017/03/25 02:57:16]

This onClassified() may come after finish and recreate, in this case we need to
keep the classification result. But I missed that it can also come even later,
after onCreateActionMode.

[Tima Vaisburd, 2017/03/27 06:33:04]

Updated.

+            if (!pendingClassificationRequest) {
+                assert !mHidden;
+                return;
+            }
+
+            // Update the selection range if needed.
+            if (!(result.startAdjust == 0 && result.endAdjust == 0)) {
+                // This call causes SELECTION_HANDLES_MOVED event
+                mWebContents.adjustSelectionByCharacterOffset(result.startAdjust, result.endAdjust);
+            }
+
+            // Rely on this method to clear mHidden and unhide the action mode.
+            showActionModeOrClearOnFailure();
+        }
+    };
 }