Introduce ViewRoot forwarding input/view events to native

chrome/android/java/src/org/chromium/chrome/browser/tab/Tab.java

 // Copyright 2014 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.tab;
 
 import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.Application;
 import android.content.Context;
@@ skipping 88 matching lines @@
 import org.chromium.content_public.common.BrowserControlsState;
 import org.chromium.content_public.common.BrowserControlsState.BrowserControlsStateEnum;
 import org.chromium.content_public.common.Referrer;
 import org.chromium.content_public.common.ResourceRequestBody;
 import org.chromium.printing.PrintManagerDelegateImpl;
 import org.chromium.printing.PrintingController;
 import org.chromium.printing.PrintingControllerImpl;
 import org.chromium.ui.base.LocalizationUtils;
 import org.chromium.ui.base.PageTransition;
 import org.chromium.ui.base.ViewAndroidDelegate;
+import org.chromium.ui.base.ViewRoot;
 import org.chromium.ui.base.WindowAndroid;
 import org.chromium.ui.mojom.WindowOpenDisposition;
 
 import java.lang.ref.WeakReference;
 import java.nio.ByteBuffer;
 import java.util.List;
 
 /**
  * The basic Java representation of a tab.  Contains and manages a {@link ContentView}.
  * <p>
@@ skipping 39 matching lines @@
 
     /**
      * An Application {@link Context}.  Unlike {@link #mActivity}, this is the only one that is
      * publicly exposed to help prevent leaking the {@link Activity}.
      */
     private final Context mThemedApplicationContext;
 
     /** Gives {@link Tab} a way to interact with the Android window. */
     private WindowAndroid mWindowAndroid;
 
+    /** {@link ViewRoot} used to forward input/view events down to native. */
+    private ViewRoot mViewRoot;
+
     /** Whether or not this {@link Tab} is initialized and should be interacted with. */
     private boolean mIsInitialized;
 
     /** The current native page (e.g. chrome-native://newtab), or {@code null} if there is none. */
     private NativePage mNativePage;
 
     /** InfoBar container to show InfoBars for this tab. */
     private InfoBarContainer mInfoBarContainer;
 
     /** Controls overscroll pull-to-refresh behavior for this tab. */
@@ skipping 338 matching lines @@
     /**
      * Creates an instance of a {@link Tab}.
      *
      * This constructor may be called before the native library has been loaded, so any additions
      * must be vetted for library calls.
      *
      * @param id        The id this tab should be identified with.
      * @param incognito Whether or not this tab is incognito.
      * @param window    An instance of a {@link WindowAndroid}.
      */
-    public Tab(int id, boolean incognito, WindowAndroid window) {
-        this(id, INVALID_TAB_ID, incognito, null, window, null, null, null);
+    public Tab(int id, boolean incognito, ViewRoot viewRoot) {
+        this(id, INVALID_TAB_ID, incognito, null, viewRoot, null, null, null);
     }
 
     /**
      * Creates an instance of a {@link Tab}.
      *
      * This constructor can be called before the native library has been loaded, so any additions
      * must be vetted for library calls.
      *
      * @param id          The id this tab should be identified with.
      * @param parentId    The id id of the tab that caused this tab to be opened.
      * @param incognito   Whether or not this tab is incognito.
      * @param context     An instance of a {@link Context}.
      * @param window      An instance of a {@link WindowAndroid}.
      * @param creationState State in which the tab is created, needed to initialize TabUma
      *                      accounting. When null, TabUma will not be initialized.
      * @param frozenState State containing information about this Tab, if it was persisted.
      */
     @SuppressLint("HandlerLeak")
     public Tab(int id, int parentId, boolean incognito, Context context,
-            WindowAndroid window, TabLaunchType type, TabCreationState creationState,
+            ViewRoot viewRoot, TabLaunchType type, TabCreationState creationState,
             TabState frozenState) {
         mId = TabIdManager.getInstance().generateValidId(id);
         mParentId = parentId;
         mIncognito = incognito;
         mThemedApplicationContext = context != null ? new ContextThemeWrapper(
                 context.getApplicationContext(), ChromeActivity.getThemeId()) : null;
-        mWindowAndroid = window;
+        mViewRoot = viewRoot;
+        mWindowAndroid = viewRoot != null ? viewRoot.getWindowAndroid() : null;
         mLaunchType = type;
         if (mThemedApplicationContext != null) {
             Resources resources = mThemedApplicationContext.getResources();
             mIdealFaviconSize = resources.getDimensionPixelSize(R.dimen.default_favicon_size);
             mDefaultThemeColor = mIncognito
                     ? ApiCompatibilityUtils.getColor(resources, R.color.incognito_primary_color)
                     : ApiCompatibilityUtils.getColor(resources, R.color.default_primary_color);
             mThemeColor = calculateThemeColor(false);
         } else {
             mIdealFaviconSize = 16;
@@ skipping 876 matching lines @@
             // ensure the global count of tabs is correct. See crbug.com/611806.
             intent.putExtra(IntentHandler.EXTRA_TAB_ID, mId);
             AsyncTabParamsManager.add(mId,
                     new TabReparentingParams(this, intent, finalizeCallback));
 
             tabModelSelector.getModel(mIncognito).removeTab(this);
 
             // TODO(yusufo): We can't call updateWindowAndroid here and set mWindowAndroid to null
             // because many code paths (including navigation) expect the tab to always be associated
             // with an activity, and will crash. crbug.com/657007
-            if (mContentViewCore != null) mContentViewCore.updateWindowAndroid(null);
+            if (mContentViewCore != null) mContentViewCore.updateViewRoot(null);
             attachTabContentManager(null);
         }
 
         activity.startActivity(intent, startActivityOptions);
         return true;
     }
 
     /**
      * Finishes the tab reparenting process. Attaches the tab to the new activity, and updates the
      * tab and related objects to reference the new activity. This updates many delegates inside the
      * tab and {@link ContentViewCore} both on java and native sides.
      *
      * @param activity The new activity this tab should be associated with.
      * @param tabDelegateFactory The new delegate factory this tab should be using.
      * @Param reparentingParams The TabReparentingParams associated with this reparenting process.
      */
     public void attachAndFinishReparenting(ChromeActivity activity,
             TabDelegateFactory tabDelegateFactory, TabReparentingParams reparentingParams) {
         // TODO(yusufo): Share these calls with the construction related calls.
         // crbug.com/590281
 
-        updateWindowAndroid(activity.getWindowAndroid());
+        updateViewRoot(activity.getViewRoot());
 
         // Update for the controllers that need the Compositor from the new Activity.
         attachTabContentManager(activity.getTabContentManager());
         mFullscreenManager = activity.getFullscreenManager();
         activity.getCompositorViewHolder().prepareForTabReparenting();
 
         // Update the delegate factory, then recreate and propagate all delegates.
         mDelegateFactory = tabDelegateFactory;
         mWebContentsDelegate = mDelegateFactory.createWebContentsDelegate(this);
         nativeUpdateDelegates(mNativeTabAndroid,
@@ skipping 11 matching lines @@
         maybeShowNativePage(getUrl(), true);
 
         mIsTabStateDirty = true;
 
         for (TabObserver observer : mObservers) {
             observer.onReparentingFinished(this);
         }
     }
 
     /**
-     * Update and propagate the new WindowAndroid.
-     * @param windowAndroid The WindowAndroid to propagate.
+     * Update and propagate the new ViewRoot and its WindowAndroid
+     * @param viewRoot New ViewRoot to update.
      */
-    public void updateWindowAndroid(WindowAndroid windowAndroid) {
+    public void updateViewRoot(ViewRoot viewRoot) {
+        assert viewRoot != null;
+        mViewRoot = viewRoot;
+        mWindowAndroid = viewRoot.getWindowAndroid();
         // TODO(yusufo): mWindowAndroid can never be null until crbug.com/657007 is fixed.
-        assert windowAndroid != null;
-        mWindowAndroid = windowAndroid;
-        if (mContentViewCore != null) mContentViewCore.updateWindowAndroid(mWindowAndroid);
+        if (mContentViewCore != null) mContentViewCore.updateViewRoot(viewRoot);
     }
 
     /**
      * @return Whether the tab is detached from its Activity and {@link WindowAndroid} for
      * reparenting. Certain functionalities will not work until it is attached to a new activity
      * with {@link Tab#attachAndFinishReparenting(
      * ChromeActivity, TabDelegateFactory, TabReparentingParams)}.
      */
     public boolean isDetachedForReparenting() {
         return mIsDetachedForReparenting;
@@ skipping 18 matching lines @@
     public View getContentView() {
         if (!isNativePage()) {
             return getView();
         } else if (mContentViewCore != null) {
             return mContentViewCore.getContainerView();
         }
         return null;
     }
 
     /**
+     * @return {@link ViewRoot} instance used to forward view/input events.
+     */
+    public ViewRoot getViewRoot() {
+        return mViewRoot;
+    }
+
+    /**
      * Called when a navigation begins and no navigation was in progress
      * @param toDifferentDocument Whether this navigation will transition between
      * documents (i.e., not a fragment navigation or JS History API call).
      */
     protected void onLoadStarted(boolean toDifferentDocument) {
         if (toDifferentDocument) mIsLoading = true;
         for (TabObserver observer : mObservers) observer.onLoadStarted(this, toDifferentDocument);
     }
 
     /**
@@ skipping 74 matching lines @@
      */
     protected void initContentViewCore(WebContents webContents) {
         setContentViewCore(createContentViewCore(webContents));
     }
 
     private ContentViewCore createContentViewCore(WebContents webContents) {
         ContentViewCore cvc = new ContentViewCore(mThemedApplicationContext, PRODUCT_VERSION);
         ContentView cv = ContentView.createContentView(mThemedApplicationContext, cvc);
         cv.setContentDescription(mThemedApplicationContext.getResources().getString(
                 R.string.accessibility_content_view));
-        cvc.initialize(ViewAndroidDelegate.createBasicDelegate(cv), cv, webContents,
-                getWindowAndroid());
+        cvc.initialize(ViewAndroidDelegate.createBasicDelegate(cv), cv, webContents, mViewRoot);
         ChromeActionModeCallback actionModeCallback = new ChromeActionModeCallback(
                 mThemedApplicationContext, this, cvc.getActionModeCallbackHelper());
         cvc.setActionModeCallback(actionModeCallback);
         return cvc;
     }
 
     /**
      * Completes the {@link ContentViewCore} specific initialization around a native WebContents
      * pointer. {@link #getNativePage()} will still return the {@link NativePage} if there is one.
      * All initialization that needs to reoccur after a web contents swap should be added here.
@@ skipping 1234 matching lines @@
         return mParentIntent;
     }
 
     /**
      * Creates a new, "frozen" tab from a saved state. This can be used for background tabs restored
      * on cold start that should be loaded when switched to. initialize() needs to be called
      * afterwards to complete the second level initialization.
      */
     public static Tab createFrozenTabFromState(
             int id, ChromeActivity activity, boolean incognito,
-            WindowAndroid nativeWindow, int parentId, TabState state) {
+            ViewRoot viewRoot, int parentId, TabState state) {
         assert state != null;
-        return new Tab(id, parentId, incognito, activity, nativeWindow,
+        return new Tab(id, parentId, incognito, activity, viewRoot,
                 TabLaunchType.FROM_RESTORE, TabCreationState.FROZEN_ON_RESTORE, state);
     }
 
     /**
      * Update whether or not the current native tab and/or web contents are
      * currently visible (from an accessibility perspective), or whether
      * they're obscured by another view.
      */
     public void updateAccessibilityVisibility() {
         View view = getView();
@@ skipping 20 matching lines @@
         ChromeActivity activity = getActivity();
         return activity != null && activity.isViewObscuringAllTabs();
     }
 
     /**
      * Creates a new tab to be loaded lazily. This can be used for tabs opened in the background
      * that should be loaded when switched to. initialize() needs to be called afterwards to
      * complete the second level initialization.
      */
     public static Tab createTabForLazyLoad(ChromeActivity activity, boolean incognito,
-            WindowAndroid nativeWindow, TabLaunchType type, int parentId,
+            ViewRoot viewRoot, TabLaunchType type, int parentId,
             LoadUrlParams loadUrlParams) {
         Tab tab = new Tab(
-                INVALID_TAB_ID, parentId, incognito, activity, nativeWindow, type,
+                INVALID_TAB_ID, parentId, incognito, activity, viewRoot, type,
                 TabCreationState.FROZEN_FOR_LAZY_LOAD, null);
         tab.setPendingLoadParams(loadUrlParams);
         return tab;
     }
 
     /**
      * Creates a fresh tab. initialize() needs to be called afterwards to complete the second level
      * initialization.
      * @param initiallyHidden true iff the tab being created is initially in background
      */
     public static Tab createLiveTab(int id, ChromeActivity activity, boolean incognito,
-            WindowAndroid nativeWindow, TabLaunchType type, int parentId, boolean initiallyHidden) {
-        return new Tab(id, parentId, incognito, activity, nativeWindow, type, initiallyHidden
+            ViewRoot viewRoot, TabLaunchType type, int parentId, boolean initiallyHidden) {
+        return new Tab(id, parentId, incognito, activity, viewRoot, type, initiallyHidden
                 ? TabCreationState.LIVE_IN_BACKGROUND
                 : TabCreationState.LIVE_IN_FOREGROUND, null);
     }
 
     /**
      * @return Whether the theme color for this tab is the default color.
      */
     public boolean isDefaultThemeColor() {
         return isNativePage() || mDefaultThemeColor == getThemeColor();
     }
@@ skipping 130 matching lines @@
     private native void nativeLoadOriginalImage(long nativeTabAndroid);
     private native long nativeGetBookmarkId(long nativeTabAndroid, boolean onlyEditable);
     private native boolean nativeIsOfflinePage(long nativeTabAndroid);
     private native OfflinePageItem nativeGetOfflinePage(long nativeTabAndroid);
     private native void nativeSetInterceptNavigationDelegate(long nativeTabAndroid,
             InterceptNavigationDelegate delegate);
     private native void nativeAttachToTabContentManager(long nativeTabAndroid,
             TabContentManager tabContentManager);
     private native boolean nativeHasPrerenderedUrl(long nativeTabAndroid, String url);
 }