[Android] Switch to Gin Java Bridge implementation

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.ContentResolver;
@@ skipping 11 matching lines @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.ResultReceiver;
 import android.os.SystemClock;
 import android.provider.Browser;
 import android.provider.Settings;
 import android.text.Editable;
 import android.text.Selection;
 import android.text.TextUtils;
 import android.util.Log;
+import android.util.Pair;
 import android.view.ActionMode;
 import android.view.HapticFeedbackConstants;
 import android.view.InputDevice;
 import android.view.KeyEvent;
 import android.view.MotionEvent;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.accessibility.AccessibilityEvent;
 import android.view.accessibility.AccessibilityManager;
 import android.view.accessibility.AccessibilityManager.AccessibilityStateChangeListener;
@@ skipping 69 matching lines @@
     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().
-    private final Map<String, Object> mJavaScriptInterfaces = new HashMap<String, Object>();
+    // This map stores those references. We put into the map on addJavaScriptInterface()
+    // and remove from it in removeJavaScriptInterface(). The annotation class is stored for
+    // the purpose of migrating injected objects from one instance of CVC to another, which
+    // is used by Android WebView to support WebChromeClient.onCreateWindow scenario.
+    private final Map<String, Pair<Object, Class>> mJavaScriptInterfaces =
+            new HashMap<String, Pair<Object, Class>>();
 
     // Additionally, we keep track of all Java bound JS objects that are in use on the
     // current page to ensure that they are not garbage collected until the page is
     // navigated. This includes interface objects that have been removed
     // via the removeJavaScriptInterface API and transient objects returned from methods
     // on the interface object. Note we use HashSet rather than Set as the native side
     // expects HashSet (no bindings for interfaces).
     private final HashSet<Object> mRetainedJavaScriptObjects = new HashSet<Object>();
 
     /**
@@ skipping 2536 matching lines @@
      * when debugging hybrid Android apps, but can't be enabled for legacy applications due
      * to compatibility risks.
      *
      * @param allow Whether to allow JavaScript objects inspection.
      */
     public void setAllowJavascriptInterfacesInspection(boolean allow) {
         nativeSetAllowJavascriptInterfacesInspection(mNativeContentViewCore, allow);
     }
 
     /**
+     * Returns JavaScript interface objects previously injected via
+     * {@link #addJavascriptInterface(Object, String)}.
+     *
+     * @return the mapping of names to interface objects and corresponding annotation classes
+     */
+    public Map<String, Pair<Object, Class>> getJavascriptInterfaces() {
+        return mJavaScriptInterfaces;
+    }
+
+    /**
      * This will mimic {@link #addPossiblyUnsafeJavascriptInterface(Object, String, Class)}
      * and automatically pass in {@link JavascriptInterface} as the required annotation.
      *
      * @param object The Java object to inject into the ContentViewCore's JavaScript context.  Null
      *               values are ignored.
      * @param name   The name used to expose the instance in JavaScript.
      */
     public void addJavascriptInterface(Object object, String name) {
         addPossiblyUnsafeJavascriptInterface(object, name, JavascriptInterface.class);
     }
@@ skipping 36 matching lines @@
      * @param name               The name used to expose the instance in
      *                           JavaScript.
      * @param requiredAnnotation Restrict exposed methods to ones with this
      *                           annotation.  If {@code null} all methods are
      *                           exposed.
      *
      */
     public void addPossiblyUnsafeJavascriptInterface(Object object, String name,
             Class<? extends Annotation> requiredAnnotation) {
         if (mNativeContentViewCore != 0 && object != null) {
-            mJavaScriptInterfaces.put(name, object);
+            mJavaScriptInterfaces.put(name, new Pair<Object, Class>(object, requiredAnnotation));
             nativeAddJavascriptInterface(mNativeContentViewCore, object, name, requiredAnnotation);
         }
     }
 
     /**
      * Removes a previously added JavaScript interface with the given name.
      *
      * @param name The name of the interface to remove.
      */
     public void removeJavascriptInterface(String name) {
@@ skipping 580 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);
 }