📺 Move fullscreen web content to a new Activity.

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;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.Color;
 import android.graphics.Rect;
 import android.net.Uri;
 import android.os.Bundle;
 import android.provider.Browser;
 import android.support.annotation.Nullable;
 import android.support.v4.view.ViewCompat;
 import android.text.TextUtils;
-import android.util.Log;
 import android.view.ContextThemeWrapper;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.view.accessibility.AccessibilityEvent;
 import android.widget.FrameLayout;
 import android.widget.FrameLayout.LayoutParams;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ContextUtils;
+import org.chromium.base.Log;
 import org.chromium.base.ObserverList;
 import org.chromium.base.ObserverList.RewindableIterator;
 import org.chromium.base.TraceEvent;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.metrics.RecordHistogram;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.AppHooks;
 import org.chromium.chrome.browser.ChromeActionModeCallback;
 import org.chromium.chrome.browser.ChromeActivity;
@@ skipping 295 matching lines @@
     private FullscreenManager mFullscreenManager;
     private float mPreviousTopControlsOffsetY = Float.NaN;
     private float mPreviousBottomControlsOffsetY = Float.NaN;
     private float mPreviousContentOffsetY = Float.NaN;
 
     /**
      * Indicates whether this tab has been detached from its activity and the corresponding
      * {@link WindowAndroid} for reparenting to a new activity.
      */
     private boolean mIsDetachedForReparenting;
+    private Boolean mIsPendingFullscreen;
 
     /**
      * 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.
      */
@@ skipping 976 matching lines @@
         } finally {
             if (mTimestampMillis == INVALID_TIMESTAMP) {
                 mTimestampMillis = System.currentTimeMillis();
             }
 
             TraceEvent.end("Tab.initialize");
         }
     }
 
     /**
+     * Begins the tab reparenting process, see
+     * {@link detachAndStartReparenting(Intent, Bundle, Runnable, Boolean).
+     */
+    public boolean detachAndStartReparenting(
+            Intent intent, Bundle startActivityOptions, Runnable finalizeCallback) {
+        return detachAndStartReparenting(
+                intent, startActivityOptions, finalizeCallback, null /* pendingFullscreen */);
+    }
+
+    /**
      * Begins the tab reparenting process. Detaches the tab from its current activity and fires
      * an Intent to reparent the tab into its new host activity.
      *
      * @param intent An optional intent with the desired component, flags, or extras to use when
      *               launching the new host activity. This intent's URI and action will be
      *               overriden. This may be null if no intent customization is needed.
      * @param startActivityOptions Options to pass to {@link Activity#startActivity(Intent, Bundle)}
      * @param finalizeCallback A callback that will be called after the tab is attached to the new
      *                         host activity in {@link #attachAndFinishReparenting}.
+     * @param pendingFullscreen What state fullscreen should be toggled to after finishing
+     *                          reparenting, or null if it should be left untouched.
      * @return Whether reparenting succeeded. If false, the tab was not removed and the intent was
      *         not fired.
      */
     public boolean detachAndStartReparenting(Intent intent, Bundle startActivityOptions,
-            Runnable finalizeCallback) {
+            Runnable finalizeCallback, @Nullable Boolean pendingFullscreen) {
         ChromeActivity activity = getActivity();
         if (activity == null) return false;
 
         if (intent == null) intent = new Intent();
         if (intent.getComponent() == null) {
             intent.setClass(mThemedApplicationContext, ChromeLauncherActivity.class);
         }
         intent.setAction(Intent.ACTION_VIEW);
         if (TextUtils.isEmpty(intent.getDataString())) intent.setData(Uri.parse(getUrl()));
         if (isIncognito()) {
             intent.putExtra(Browser.EXTRA_APPLICATION_ID,
                     ContextUtils.getApplicationContext().getPackageName());
             intent.putExtra(IntentHandler.EXTRA_OPEN_NEW_INCOGNITO_TAB, true);
         }
         IntentHandler.addTrustedIntentExtras(intent);
 
         if (ChromeFeatureList.isEnabled(ChromeFeatureList.TAB_REPARENTING)) {
             TabModelSelector tabModelSelector = getTabModelSelector();
             if (tabModelSelector == null) return false;
             mIsDetachedForReparenting = true;
+            mIsPendingFullscreen = pendingFullscreen;
+
+            if (getFullscreenManager().getTab() == this) {
+                getFullscreenManager().setTab(null);
+            }
 
             // Add the tab to AsyncTabParamsManager before removing it from the current model to
             // 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
@@ skipping 43 matching lines @@
 
         // 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);
         }
+
+        if (mIsPendingFullscreen != null) {

[Yusuf, 2017/04/10 17:08:49]

see the finalizeCallback in detach.. That is a runnable that carries out any
activity to activity specific logic at the end of tab reparenting. If you look
up, the line:

reparentingParams.finalizeTabReparenting();

runs that callback. I think this logic inside the if, is a good candidate for
that. You can just pass it in moveToOtherWindow as a runnable and then we can
keep detach-attach mostly UX flow agnostic.

[PEConn, 2017/04/11 00:54:46]

Done.

+            mFullscreenManager.setTab(mIsPendingFullscreen ? this : null);
+            toggleFullscreenMode(mIsPendingFullscreen);
+        }
+        mIsPendingFullscreen = null;
     }
 
     /**
      * Update and propagate the new WindowAndroid.
      * @param windowAndroid The WindowAndroid to propagate.
      */
     public void updateWindowAndroid(WindowAndroid windowAndroid) {
         // TODO(yusufo): mWindowAndroid can never be null until crbug.com/657007 is fixed.
         assert windowAndroid != null;
         mWindowAndroid = windowAndroid;
@@ skipping 1622 matching lines @@
     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);
     private native void nativeSetWebappManifestScope(long nativeTabAndroid, String scope);
     private native void nativeEnableEmbeddedMediaExperience(long nativeTabAndroid, boolean enabled);
 }