📺 Move fullscreen web content to a new Activity.

chrome/android/java/src/org/chromium/chrome/browser/multiwindow/MultiWindowUtils.java

 // Copyright 2015 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.multiwindow;
 
 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.ActivityManager;
 import android.app.ActivityManager.AppTask;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Build;
 import android.provider.Browser;
 import android.text.TextUtils;
 
 import org.chromium.base.ActivityState;
 import org.chromium.base.ApplicationStatus;
 import org.chromium.base.ApplicationStatus.ActivityStateListener;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.AppHooks;
+import org.chromium.chrome.browser.ChromeActivity;
 import org.chromium.chrome.browser.ChromeTabbedActivity;
 import org.chromium.chrome.browser.ChromeTabbedActivity2;
 import org.chromium.chrome.browser.IntentHandler;
 import org.chromium.chrome.browser.document.ChromeLauncherActivity;
+import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.util.IntentUtils;
 
+import java.io.Serializable;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
 import javax.annotation.Nullable;
 
 /**
  * Utilities for detecting multi-window/multi-instance support.
  *
  * Thread-safe: This class may be accessed from any thread.
  */
 public class MultiWindowUtils implements ActivityStateListener {
 
     // TODO(twellington): replace this with Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT once we're building
     //                    against N.
     public static final int FLAG_ACTIVITY_LAUNCH_ADJACENT = 0x00001000;
+    public static final String EXTRA_FROM_ACTIVITY_INTENT =
+            "org.chromium.chrome.browser.multiwindow.FromActivity";

[Theresa, 2017/04/12 22:29:11]

Rather than introducing a new intent flag, I think you can reuse
IntentHandler#EXTRA_PARENT_COMPONENT. That's what we use for history, bookmarks,
and downloads to make sure we open items in the correct parent activity.

[PEConn, 2017/04/26 17:24:37]

Done.

 
-    private static AtomicReference<MultiWindowUtils> sInstance =
-            new AtomicReference<MultiWindowUtils>();
+    private static AtomicReference<MultiWindowUtils> sInstance = new AtomicReference<>();
 
     // Used to keep track of whether ChromeTabbedActivity2 is running. A tri-state Boolean is
     // used in case both activities die in the background and MultiWindowUtils is recreated.
     private Boolean mTabbedActivity2TaskRunning;
     private WeakReference<ChromeTabbedActivity> mLastResumedTabbedActivity;
     private boolean mIsInMultiWindowModeForTesting;
 
     /**
      * Returns the singleton instance of MultiWindowUtils, creating it if needed.
      */
@@ skipping 81 matching lines @@
 
         // Let Chrome know that this intent is from Chrome, so that it does not close the app when
         // the user presses 'back' button.
         intent.putExtra(Browser.EXTRA_APPLICATION_ID, activity.getPackageName());
         intent.putExtra(Browser.EXTRA_CREATE_NEW_TAB, true);
     }
 
     @Override
     public void onActivityStateChange(Activity activity, int newState) {
         if (newState == ActivityState.RESUMED && activity instanceof ChromeTabbedActivity) {
-            mLastResumedTabbedActivity =
-                    new WeakReference<ChromeTabbedActivity>((ChromeTabbedActivity) activity);
+            mLastResumedTabbedActivity = new WeakReference<>((ChromeTabbedActivity) activity);
         }
     }
 
     /**
      * Determines the correct ChromeTabbedActivity class to use for an incoming intent.
      * @param intent The incoming intent that is starting ChromeTabbedActivity.
      * @param context The current Context, used to retrieve the ActivityManager system service.
      * @return The ChromeTabbedActivity to use for the incoming intent.
      */
     public Class<? extends ChromeTabbedActivity> getTabbedActivityForIntent(
@@ skipping 106 matching lines @@
      */
     public static boolean isActivityVisible(Activity activity) {
         if (activity == null) return false;
         int activityState = ApplicationStatus.getStateForActivity(activity);
         // In Android N multi-window mode, only one activity is resumed at a time. The other
         // activity visible on the screen will be in the paused state. Activities not visible on
         // the screen will be stopped or destroyed.
         return activityState == ActivityState.RESUMED || activityState == ActivityState.PAUSED;
     }
 
+    /**
+     * Moves a Tab to the other MultiWindow window.
+     * @param activity An {@link Activity} to use for context.
+     * @param tab The {@link Tab} to move.
+     */
+    public static void moveTabToOtherWindow(Activity activity, Tab tab) {
+        moveTabToActivity(
+                activity, tab, getInstance().getOpenInOtherWindowActivity(activity), null);
+    }
+
+    /**
+     * Moves a Tab to a specific Activity.
+     * @param activity An {@link Activity} for context.
+     * @param tab The {@link Tab} to move.
+     * @param targetActivity The class of the Activity to move the Tab to.
+     * @param finalizeCallback A callback that will be called after the tab is attached to the new
+     *                         host activity}.
+     */
+    public static void moveTabToActivity(Activity activity, Tab tab,
+            Class<? extends Activity> targetActivity, @Nullable Runnable finalizeCallback) {
+        if (targetActivity == null) return;
+
+        Intent intent = new Intent(activity, targetActivity);
+        intent.putExtra(EXTRA_FROM_ACTIVITY_INTENT, tab.getActivity().getClass());
+
+        MultiWindowUtils.setOpenInOtherWindowIntentExtras(intent, activity, targetActivity);
+        MultiWindowUtils.onMultiInstanceModeStarted();

[Theresa, 2017/04/12 22:29:11]

"Multi-instance" mode has historically referred to two ChromeTabbedActivity
instances. ChromeTabbedActivity#onMultiInstanceModeStarted() relies on this
definition for its tab model merging behavior (when exiting multi-window mode,
we kill one of the ChromeTabbedActivity instances and merge its tabs into the
other instance).

It seems that the definition of "multi-instance" is changing and that the tab
may be moving to a non-ChromeTabbedActivity? If so, calling this method here
probably causes issues with tab model merging and possibly reintroduces
crbug.com/657418.

Maybe it's a simple fix, and we can just conditionally call
onMultiInstanceModeStarted():

if (activity instanceof ChromeTabbedActivity) 
MultiWindowUtils.onMultiInstanceModeStarted()


It'd also be great to update the JavaDoc for onMultiInstanceModeStarted to be
specific about what multi-instance is now that we may be moving tabs to other
types of activities.

[PEConn, 2017/04/26 17:24:37]

Acknowledged.

+        tab.detachAndStartReparenting(intent, null, finalizeCallback);
+    }
+
+    /**
+     * Extracts the class of the {@link Activity} that sent a {@link Tab} to the given Activity.
+     * May be null.
+     */
+    @SuppressWarnings("unchecked")
+    public static Class<? extends ChromeActivity> getSenderActivity(Activity activity) {

[Theresa, 2017/04/12 22:29:11]

Typically we use IntentUtils#safeGet*() to extract extras from intents.

[PEConn, 2017/04/26 17:24:37]

Done.

+        Serializable extra = activity.getIntent().getSerializableExtra(EXTRA_FROM_ACTIVITY_INTENT);
+        if (extra == null) return null;
+
+        assert extra instanceof Class;
+        Class<?> clazz = (Class<?>) extra;
+
+        assert ChromeActivity.class.isAssignableFrom(clazz);
+        return (Class<? extends ChromeActivity>) clazz;
+    }
+
     @VisibleForTesting
     public Boolean getTabbedActivity2TaskRunning() {
         return mTabbedActivity2TaskRunning;
     }
 
     /**
      * @param activity The {@link Activity} to check.
      * @return Whether or not {@code activity} is currently in pre-N Samsung multi-window mode.
      */
     public boolean isLegacyMultiWindow(Activity activity) {
@@ skipping 20 matching lines @@
         if (isLegacyMultiWindow(activity)) {
             if (TextUtils.equals(ChromeTabbedActivity.class.getName(),
                     intent.getComponent().getClassName())) {
                 intent.setClassName(activity, MultiInstanceChromeTabbedActivity.class.getName());
             }
             intent.setFlags(intent.getFlags()
                     & ~(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_NEW_DOCUMENT));
         }
     }
 }