Add Browser Actions tab model selector and open a tab through it if ChromeTabbedActivity is not ava…

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 334 matching lines @@
     private float mPreviousBottomControlsOffsetY = Float.NaN;
     private float mPreviousContentOffsetY = Float.NaN;
 
     /**
      * Indicates whether this tab is detached from any activity and its corresponding
      * {@link WindowAndroid}.
      */
     private boolean mIsDetached;
 
     /**
+     * Indicates whether the history of this tab should be separated from Chrome history.
+     * This is true only for startSpeculation in CCT.
+     */
+    private boolean mIsHistoryDetached;
+
+    /**
      * The UMA object used to report stats for this tab. Note that this may be null under certain
      * conditions, such as incognito mode.
      */
     private TabUma mTabUma;
 
     /**
      * Reference to the current sadTabView if one is defined.
      */
     private View mSadTabView;
 
@@ skipping 120 matching lines @@
     public Tab(int id, int parentId, boolean incognito, Context context,
             WindowAndroid window, 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;
         mLaunchType = type;
-        if (mLaunchType == TabLaunchType.FROM_DETACHED) mIsDetached = true;
+        if (mLaunchType == TabLaunchType.FROM_DETACHED_SPECULATE
+                || mLaunchType == TabLaunchType.FROM_DETACHED_USER_ACTION) {
+            mIsDetached = true;
+        }
+        if (mLaunchType == TabLaunchType.FROM_DETACHED_SPECULATE) mIsHistoryDetached = true;
         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;
             mDefaultThemeColor = 0;
@@ skipping 781 matching lines @@
                 }
             }
 
             ContentViewCore contentViewCore = ContentViewCore.fromWebContents(webContents);
 
             if (contentViewCore == null) {
                 initContentViewCore(webContents);
             } else {
                 setContentViewCore(contentViewCore);
             }
-
             mContentViewCore.addImeEventObserver(new ImeEventObserver() {
                 @Override
                 public void onImeEvent() {
                     // Some text was set in the page. Don't reuse it if a tab is
                     // open from the same external application, we might lose some
                     // user data.
                     mAppAssociatedWith = null;
                 }
 
                 @Override
                 public void onNodeAttributeUpdated(boolean editable, boolean password) {
                     if (getFullscreenManager() == null) return;
                     updateFullscreenEnabledState();
                 }
             });
 
             if (!creatingWebContents && webContents.isLoadingToDifferentDocument()) {
                 didStartPageLoad(webContents.getUrl(), false);
             }
-
             getAppBannerManager().setIsEnabledForTab(mDelegateFactory.canShowAppBanners(this));
         } finally {
             if (mTimestampMillis == INVALID_TIMESTAMP) {
                 mTimestampMillis = System.currentTimeMillis();
             }
 
             TraceEvent.end("Tab.initialize");
         }
     }
 
@@ skipping 92 matching lines @@
         mWebContentsDelegate = mDelegateFactory.createWebContentsDelegate(this);
         nativeUpdateDelegates(mNativeTabAndroid,
                 mWebContentsDelegate, mDelegateFactory.createContextMenuPopulator(this));
         mBrowserControlsVisibilityDelegate =
                 mDelegateFactory.createBrowserControlsVisibilityDelegate(this);
         setInterceptNavigationDelegate(mDelegateFactory.createInterceptNavigationDelegate(this));
         getAppBannerManager().setIsEnabledForTab(mDelegateFactory.canShowAppBanners(this));
 
         reparentingParams.finalizeTabReparenting();
         mIsDetached = false;
+        mIsHistoryDetached = false;
         nativeAttachDetachedTab(mNativeTabAndroid);
 
         // Reload the NativePage (if any), since the old NativePage has a reference to the old
         // activity.
         maybeShowNativePage(getUrl(), true);
 
         mIsTabStateDirty = true;
 
         for (TabObserver observer : mObservers) {
             observer.onReparentingFinished(this);
@@ skipping 223 matching lines @@
             cvc.getContainerView().setOnSystemUiVisibilityChangeListener(this);
 
             mContentView = cvc.getContainerView();
             mWebContentsDelegate = mDelegateFactory.createWebContentsDelegate(this);
             mWebContentsObserver =
                     new TabWebContentsObserver(mContentViewCore.getWebContents(), this);
 
             mDownloadDelegate = new ChromeDownloadDelegate(mThemedApplicationContext, this);
 
             assert mNativeTabAndroid != 0;
-            nativeInitWebContents(mNativeTabAndroid, mIncognito, mIsDetached,
+            nativeInitWebContents(mNativeTabAndroid, mIncognito, mIsHistoryDetached,

[Yusuf, 2017/07/18 22:59:47]

This param is for isBackgroundTab, right? Is that only related with history? I
guess I don't see how detached tab in speculation mode is different from a
detached browser actions tab. Both are first navigations, so should not have
history. The only difference is one is user initiated like you mention in launch
type, but I guess I dont see how that relates to the isBackgroundTab param.

And I guess we need another name for this new boolean (if it is necessary) that
makes it clear how these are all linked to the isBackgroundTab check in
tab_android.cc

[ltian, 2017/08/07 23:24:12]

New design will open all tabs in lazy load mode so this change is not needed.

                     mContentViewCore.getWebContents(), mWebContentsDelegate,
                     new TabContextMenuPopulator(
                             mDelegateFactory.createContextMenuPopulator(this), this));
 
             // In the case where restoring a Tab or showing a prerendered one we already have a
             // valid infobar container, no need to recreate one.
             if (mInfoBarContainer == null) {
                 WindowAndroid windowAndroid = getWindowAndroid();
                 Activity activity =
                         windowAndroid == null ? null : windowAndroid.getActivity().get();
@@ skipping 1263 matching lines @@
     }
 
     /**
      * Creates an instance of a {@link Tab} that is fully detached from any activity.
      * Also performs general tab initialization as well as detached specifics.
      *
      * The current application context must allow the creation of a WindowAndroid.
      *
      * @return The newly created and initialized tab.
      */
-    public static Tab createDetached(TabDelegateFactory delegateFactory) {
+    public static Tab createDetached(TabDelegateFactory delegateFactory, boolean byUserAction) {
         Context context = ContextUtils.getApplicationContext();
         WindowAndroid windowAndroid = new WindowAndroid(context);
-        Tab tab = new Tab(INVALID_TAB_ID, INVALID_TAB_ID, false, context, windowAndroid,
-                TabLaunchType.FROM_DETACHED, null, null);
+        TabLaunchType launchType = byUserAction ? TabLaunchType.FROM_DETACHED_USER_ACTION
+                                                : TabLaunchType.FROM_DETACHED_SPECULATE;
+        Tab tab = new Tab(INVALID_TAB_ID, INVALID_TAB_ID, false, context, windowAndroid, launchType,
+                null, null);
         tab.initialize(null, null, delegateFactory, true, false);
 
         // Resize the webContent to avoid expensive post load resize when attaching the tab.
         Rect bounds = ExternalPrerenderHandler.estimateContentSize((Application) context, false);
         int width = bounds.right - bounds.left;
         int height = bounds.bottom - bounds.top;
         tab.getContentViewCore().onSizeChanged(width, height, 0, 0);
 
         tab.detach(null, null);
         return tab;
@@ skipping 158 matching lines @@
     private native long nativeGetBookmarkId(long nativeTabAndroid, boolean onlyEditable);
     private native void nativeSetInterceptNavigationDelegate(long nativeTabAndroid,
             InterceptNavigationDelegate delegate);
     private native void nativeAttachToTabContentManager(long nativeTabAndroid,
             TabContentManager tabContentManager);
     private native boolean nativeHasPrerenderedUrl(long nativeTabAndroid, String url);
     private native void nativeSetWebappManifestScope(long nativeTabAndroid, String scope);
     private native void nativeEnableEmbeddedMediaExperience(long nativeTabAndroid, boolean enabled);
     private native void nativeAttachDetachedTab(long nativeTabAndroid);
 }