Show the image header for the Context Menu

chrome/android/java/src/org/chromium/chrome/browser/contextmenu/ContextMenuHelper.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.chrome.browser.contextmenu;
 
 import android.app.Activity;
 import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
 import android.util.Pair;
 import android.view.ContextMenu;
 import android.view.ContextMenu.ContextMenuInfo;
 import android.view.View;
 import android.view.View.OnCreateContextMenuListener;
 
 import org.chromium.base.Callback;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.metrics.RecordHistogram;
@@ skipping 11 matching lines @@
  */
 public class ContextMenuHelper implements OnCreateContextMenuListener {
     private long mNativeContextMenuHelper;
 
     private ContextMenuPopulator mPopulator;
     private ContextMenuParams mCurrentContextMenuParams;
     private Context mContext;
     private Callback<Integer> mCallback;
     private Runnable mOnMenuShown;
     private Runnable mOnMenuClosed;
+    private OnThumbnailReceivedListener mOnThumbnailReceivedListener;
+
+    /**
+     * This waits for a thumbnail to be retrieved by the native code.
+     */
+    interface OnThumbnailReceivedListener {
+        /**
+         * When the thumbnail is received it will send the thumbnail via this method. This is
+         * activated after calling {@link #getThumbnail()}.
+         * @param bitmap The bitmap that is retrieved from native code.
+         */
+        void onThumbnailReceived(Bitmap bitmap);
+    }
+
+    @VisibleForTesting
+    ContextMenuHelper() {}
 
     private ContextMenuHelper(long nativeContextMenuHelper) {
         mNativeContextMenuHelper = nativeContextMenuHelper;
     }
 
     @CalledByNative
     private static ContextMenuHelper create(long nativeContextMenuHelper) {
         return new ContextMenuHelper(nativeContextMenuHelper);
     }
 
@@ skipping 51 matching lines @@
             public void run() {
                 if (mNativeContextMenuHelper == 0) return;
                 nativeOnContextMenuClosed(mNativeContextMenuHelper);
             }
         };
 
         if (ChromeFeatureList.isEnabled(ChromeFeatureList.CUSTOM_CONTEXT_MENU)) {
             List<Pair<Integer, List<ContextMenuItem>>> items =
                     mPopulator.buildContextMenu(null, mContext, mCurrentContextMenuParams);
 
-            ContextMenuUi menuUi = new TabularContextMenuUi();
+            ContextMenuUi menuUi = new TabularContextMenuUi(this);
             menuUi.displayMenu(mContext, mCurrentContextMenuParams, items, mCallback, mOnMenuShown,
                     mOnMenuClosed);
             return;
         }
 
         // The Platform Context Menu requires the listener within this hepler since this helper and
         // provides context menu for us to show.
         view.setOnCreateContextMenuListener(this);
         if (view.showContextMenu()) {
             mOnMenuShown.run();
@@ skipping 35 matching lines @@
 
     @CalledByNative
     private void onShareImageReceived(
             WindowAndroid windowAndroid, byte[] jpegImageData) {
         Activity activity = windowAndroid.getActivity().get();
         if (activity == null) return;
 
         ShareHelper.shareImage(activity, jpegImageData);
     }
 
+    /**
+     * Gets the thumbnail of the current image that triggered the context menu.
+     */
+    public void getThumbnail() {

[David Trainor- moved to gerrit, 2017/03/30 05:03:14]

I actually think this (and maybe shareImage() with some rework) could probably
be done with Callbacks.

In this particular case, it looks like you're doing:
setOnThumbnailReceivedListener(listener)
getThumbnail()

Could you just make it getThumbnail(Callback<byte[]> callback)?  Maybe something
like the following:

getThumbnail(new Callback<byte[]>() { void onResult(byte[] thumbnail) {...}});?

Native can trigger the callback directly too.  The method signature would be
better if you could return a Bitmap, so maybe that's preferable if you can make
that work.

Finally... if you don't like this, just pass OnThumbnailReceivedListener into
getThumbnail()...

[JJ, 2017/03/30 16:00:25]

You make an interesting point on that native can call the callback directly. For
now I'll change it to just passing the onThumbnailReceivedListener into
getThumbnail. I'll keep looking into the other method and some examples I've
found later on to see if I can go that route cause it sounds interesting.

[JJ, 2017/03/30 17:09:00]

Checked it out! It's not impossible, but there are some clear roadblocks. Right
now that means adding a param "RequestThumbnailForContextMenu" which means we'd
need to change share. This is however a good spot for improving as the code is
extremely similar and we can aaaaaaaaaalmost change it but it needs some
refactoring to do it.

[David Trainor- moved to gerrit, 2017/03/30 23:45:14]

You could probably just do it all with finals.  For this function I think the
below would be good:

public void getThumbnail(final OnThumbnailReceivedListener listener) {
  Callback<byte[]> callback = new Callback<byte[]>() {
    @Override
    public void onResult(byte[] result) {
      listener.onThumbnailReceived(BitmapFactory.decodeByteArray(result, 0,
result.length);
    }
  }
}

[JJ, 2017/03/31 02:28:45]

It's not the Java side that's the problem. That part is actually easy. It's the
C++ side. Right now it calls a RequestTumbnailForContextNode which only accepts
specifics arguments. The problem is that I can't pass a callback into there as
sadly this affects shared methods. So I'd have to change it for Share Image as
well and for any other potential images as well. So while I think it is an
awesome idea that should be explored in the future. I don't think it's one I can
do at this moment, especially while keeping the cl short.

+        if (mNativeContextMenuHelper == 0) return;
+        nativeRetrieveHeaderThumbnail(mNativeContextMenuHelper);
+    }
+
+    @CalledByNative
+    private void onHeaderThumbnailReceived(WindowAndroid windowAndroid, byte[] jpegImageData) {
+        Bitmap bitmap = BitmapFactory.decodeByteArray(jpegImageData, 0, jpegImageData.length);
+        if (mOnThumbnailReceivedListener != null) {
+            mOnThumbnailReceivedListener.onThumbnailReceived(bitmap);
+        }
+    }
+
     @Override
     public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
         List<Pair<Integer, List<ContextMenuItem>>> items =
                 mPopulator.buildContextMenu(menu, v.getContext(), mCurrentContextMenuParams);
         ContextMenuUi menuUi = new PlatformContextMenuUi(menu);
         menuUi.displayMenu(
                 mContext, mCurrentContextMenuParams, items, mCallback, mOnMenuShown, mOnMenuClosed);
     }
 
     /**
+     * Sets the listener for retrieving a thumbnail when calling {@link #getThumbnail()}.
+     * @param listener The listener that will be called once a thumbnail is retrieved.
+     */
+    public void setOnThumbnailReceivedListener(OnThumbnailReceivedListener listener) {
+        mOnThumbnailReceivedListener = listener;
+    }
+
+    /**
      * @return The {@link ContextMenuPopulator} responsible for populating the context menu.
      */
     @VisibleForTesting
     public ContextMenuPopulator getPopulator() {
         return mPopulator;
     }
 
     private native void nativeOnStartDownload(
             long nativeContextMenuHelper, boolean isLink, boolean isDataReductionProxyEnabled);
     private native void nativeSearchForImage(long nativeContextMenuHelper);
     private native void nativeShareImage(long nativeContextMenuHelper);
     private native void nativeOnContextMenuClosed(long nativeContextMenuHelper);
+    private native void nativeRetrieveHeaderThumbnail(long nativeContextMenuHelper);
 }