Add pathway to auto-migrate users when Chrome launches

chrome/android/java/src/org/chromium/chrome/browser/tabmodel/DocumentModeAssassin.java

 // Copyright 2016 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.tabmodel;
 
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.os.AsyncTask;
 import android.os.Build;
 import android.util.Pair;
 
 import org.chromium.base.ApplicationStatus;
+import org.chromium.base.CommandLine;
 import org.chromium.base.FileUtils;
 import org.chromium.base.Log;
 import org.chromium.base.ObserverList;
 import org.chromium.base.StreamUtil;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.chrome.browser.ChromeApplication;
+import org.chromium.chrome.browser.ChromeSwitches;
 import org.chromium.chrome.browser.TabState;
 import org.chromium.chrome.browser.document.DocumentActivity;
 import org.chromium.chrome.browser.document.DocumentUtils;
 import org.chromium.chrome.browser.document.IncognitoDocumentActivity;
 import org.chromium.chrome.browser.preferences.DocumentModeManager;
 import org.chromium.chrome.browser.tab.Tab;
 import org.chromium.chrome.browser.tabmodel.TabPersistentStore.TabModelMetadata;
 import org.chromium.chrome.browser.tabmodel.document.ActivityDelegate;
 import org.chromium.chrome.browser.tabmodel.document.ActivityDelegateImpl;
 import org.chromium.chrome.browser.tabmodel.document.DocumentTabModel;
 import org.chromium.chrome.browser.tabmodel.document.DocumentTabModelImpl;
 import org.chromium.chrome.browser.tabmodel.document.DocumentTabModelSelector;
 import org.chromium.chrome.browser.tabmodel.document.StorageDelegate;
 import org.chromium.chrome.browser.util.FeatureUtilities;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.channels.FileChannel;
 import java.util.HashSet;
 import java.util.Set;
 
+import javax.annotation.Nullable;
+
 /**
  * Divorces Chrome's tabs from Android's Overview menu.  Assumes native libraries are unavailable.
  *
  * Migration from document mode to tabbed mode occurs in two main phases:
  *
  * 1) NON-DESTRUCTIVE MIGRATION:
  *    TabState files for the normal DocumentTabModel are copied from the document mode directories
  *    into the tabbed mode directory.  Incognito tabs are silently dropped, as with the previous
  *    migration pathway.
  *
- *    TODO(dfalcantara): Check what happens if a user last viewed an Incognito tab.
  *    TODO(dfalcantara): Check what happens on other launchers.
  *
  *    Once all TabState files are copied, a TabModel metadata file is written out for the tabbed
  *    mode {@link TabModelImpl} to read out.  Because the native library is not available, the file
  *    will be incomplete but usable; it will be corrected by the TabModelImpl when it loads it and
  *    all of the TabState files up.  See {@link #writeTabModelMetadata} for details.
  *
  * 2) CLEANUP OF ALL DOCUMENT-RELATED THINGS:
  *    DocumentActivity tasks in Android's Recents are removed, TabState files in the document mode
  *    directory are deleted, and document mode preferences are cleared.
  *
- *    TODO(dfalcantara): Clean up the incognito notification, if possible.
  *    TODO(dfalcantara): Add histograms for tracking migration progress.
  *
  * TODO(dfalcantara): Potential pitfalls that need to be accounted for:
  *   - Consistently crashing during migration means you can never open Chrome until you clear data.
  *   - Successfully migrating, but crashing while deleting things and closing off tasks.
  *   - Failing to copy all the TabState files over during migration because of a lack of space.
  */
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
 public class DocumentModeAssassin {
     /** Alerted about progress along the migration pipeline. */
@@ skipping 20 matching lines @@
     /** Stages of the pipeline.  Each stage is blocked off by a STARTED and DONE pair. */
     static final int STAGE_UNINITIALIZED = 0;
     static final int STAGE_INITIALIZED = 1;
     static final int STAGE_COPY_TAB_STATES_STARTED = 2;
     static final int STAGE_COPY_TAB_STATES_DONE = 3;
     static final int STAGE_WRITE_TABMODEL_METADATA_STARTED = 4;
     static final int STAGE_WRITE_TABMODEL_METADATA_DONE = 5;
     static final int STAGE_CHANGE_SETTINGS_STARTED = 6;
     static final int STAGE_CHANGE_SETTINGS_DONE = 7;
     static final int STAGE_DELETION_STARTED = 8;
-    static final int STAGE_DONE = 9;
+    public static final int STAGE_DONE = 9;
 
     private static final String TAG = "DocumentModeAssassin";
 
     /** Which TabModelSelectorImpl to copy files into during migration. */
     private static final int TAB_MODEL_INDEX = 0;
 
     /** Creates and holds the Singleton. */
     private static class LazyHolder {
         private static final DocumentModeAssassin INSTANCE = new DocumentModeAssassin();
     }
@@ skipping 11 matching lines @@
             new ObserverList<DocumentModeAssassinObserver>();
 
     /** Current stage of the migration. */
     private int mStage = STAGE_UNINITIALIZED;
 
     /** Whether or not startStage is allowed to progress along the migration pipeline. */
     private boolean mIsPipelineActive;
 
     /** Returns whether or not a migration to tabbed mode from document mode is necessary. */
     public static boolean isMigrationNecessary() {
-        return FeatureUtilities.isDocumentMode(ApplicationStatus.getApplicationContext());
+        return CommandLine.getInstance().hasSwitch(ChromeSwitches.ENABLE_FORCED_MIGRATION)
+                && FeatureUtilities.isDocumentMode(ApplicationStatus.getApplicationContext());
     }
 
     /** Migrates the user from document mode to tabbed mode if necessary. */
     @VisibleForTesting
     public void migrateFromDocumentToTabbedMode() {
         ThreadUtils.assertOnUiThread();
 
         if (!isMigrationNecessary()) {
             // Don't kick off anything if we don't need to.
             setStage(STAGE_UNINITIALIZED, STAGE_DONE);
             return;
         } else if (mStage != STAGE_UNINITIALIZED) {
             // Migration is already underway.
             return;
         }
 
         // TODO(dfalcantara): Add a pathway to catch repeated migration failures.
 
         setStage(STAGE_UNINITIALIZED, STAGE_INITIALIZED);
     }
 
     /**
      * Makes copies of {@link TabState} files in the document mode directory and places them in the
      * tabbed mode directory.  Only non-Incognito tabs are transferred.
      *
      * TODO(dfalcantara): Prevent migrating chrome:// pages?
      *
-     * @param selectedTabId     ID of the last viewed non-Incognito tab.
-     * @param documentDirectory File pointing at the DocumentTabModel TabState file directory.
-     * @param tabbedDirectory   File pointing at tabbed mode TabState file directory.
+     * @param selectedTabId             ID of the last viewed non-Incognito tab.
+     * @param context                   Context to use when accessing directories.
+     * @param documentDirectoryOverride Overrides the default location for where document mode's
+     *                                  TabState files are expected to be.
+     * @param tabbedDirectoryOverride   Overrides the default location for where tabbed mode's
+     *                                  TabState files are expected to be.
      */
-    void copyTabStateFiles(
-            final int selectedTabId, final File documentDirectory, final File tabbedDirectory) {
+    void copyTabStateFiles(final int selectedTabId, final Context context,
+            @Nullable final File documentDirectoryOverride,
+            @Nullable final File tabbedDirectoryOverride) {
         ThreadUtils.assertOnUiThread();
         if (!setStage(STAGE_INITIALIZED, STAGE_COPY_TAB_STATES_STARTED)) return;
 
         new AsyncTask<Void, Void, Void>() {
+            private DocumentTabModelImpl mNormalTabModel;
+
+            @Override
+            protected void onPreExecute() {
+                if (documentDirectoryOverride == null) {
+                    mNormalTabModel = (DocumentTabModelImpl)
+                            ChromeApplication.getDocumentTabModelSelector().getModel(false);
+                }
+            }
+
             @Override
             protected Void doInBackground(Void... params) {
+                File documentDirectory = documentDirectoryOverride == null
+                        ? mNormalTabModel.getStorageDelegate().getStateDirectory()
+                        : documentDirectoryOverride;
+                File tabbedDirectory = tabbedDirectoryOverride == null
+                        ? TabPersistentStore.getStateDirectory(context, TAB_MODEL_INDEX)
+                        : tabbedDirectoryOverride;
+
                 Log.d(TAG, "Copying TabState files from document to tabbed mode directory.");
                 assert mMigratedTabIds.size() == 0;
 
                 File[] allTabStates = documentDirectory.listFiles();
                 if (allTabStates != null) {
                     // If we know what tab the user was last viewing, copy just that TabState file
                     // before all the other ones to mitigate storage issues for devices with limited
                     // available storage.
                     if (selectedTabId != Tab.INVALID_TAB_ID) {
-                        copyTabStateFilesInternal(allTabStates, selectedTabId, true);
+                        copyTabStateFilesInternal(
+                                allTabStates, tabbedDirectory, selectedTabId, true);
                     }
 
                     // Copy over everything else.
-                    copyTabStateFilesInternal(allTabStates, selectedTabId, false);
+                    copyTabStateFilesInternal(allTabStates, tabbedDirectory, selectedTabId, false);
                 }
                 return null;
             }
 
             @Override
             protected void onPostExecute(Void result) {
                 Log.d(TAG, "Finished copying files.");
                 setStage(STAGE_COPY_TAB_STATES_STARTED, STAGE_COPY_TAB_STATES_DONE);
             }
 
             /**
              * Copies the files from the document mode directory to the tabbed mode directory.
              *
              * @param allTabStates        Listing of all files in the document mode directory.
+             * @param tabbedDirectory     Directory for the tabbed mode files.
              * @param selectedTabId       ID of the non-Incognito tab the user last viewed.  May be
              *                            {@link Tab#INVALID_TAB_ID} if the ID is unknown.
              * @param copyOnlySelectedTab Copy only the TabState file for the selectedTabId.
              */
-            private void copyTabStateFilesInternal(
-                    File[] allTabStates, int selectedTabId, boolean copyOnlySelectedTab) {
+            private void copyTabStateFilesInternal(File[] allTabStates, File tabbedDirectory,
+                    int selectedTabId, boolean copyOnlySelectedTab) {
                 assert !ThreadUtils.runningOnUiThread();
                 for (int i = 0; i < allTabStates.length; i++) {
                     // Trawl the directory for non-Incognito TabState files.
                     String fileName = allTabStates[i].getName();
                     Pair<Integer, Boolean> tabInfo = TabState.parseInfoFromFilename(fileName);
                     if (tabInfo == null || tabInfo.second) continue;
 
                     // Ignore any files that are not relevant for the current pass.
                     int tabId = tabInfo.first;
                     if (selectedTabId != Tab.INVALID_TAB_ID) {
@@ skipping 50 matching lines @@
      *
      * 1) {@link TabPersistentStore} uses the URL to allow reusing already open tabs for Home screen
      *    Intents.  If a Tab doesn't match the Intent's URL, a new Tab is created.  This is already
      *    the case when a cold start launches into document mode because the data is unavailable at
      *    startup.
      *
      * 2) {@link TabModelImpl} uses the URL when it fails to load a Tab's persisted TabState.  This
      *    means that the user loses some navigation history, but it's not a case document mode would
      *    have been able to recover from anyway because the TabState stores the URL data.
      *
-     * @param tabbedDirectory Directory containing all of the main TabModel's files.
-     * @param normalTabModel  DocumentTabModel containing information about non-Incognito tabs.
-     * @param migratedTabIds  IDs of Tabs whose TabState files were copied successfully.
+     * @param normalTabModel            DocumentTabModel containing info about non-Incognito tabs.
+     * @param migratedTabIds            IDs of Tabs whose TabState files were copied successfully.
+     * @param context                   Context to access Files from.
+     * @param tabbedDirectoryOverride   Overrides the default location for where tabbed mode's
+     *                                  TabState files are expected to be.
      */
-    void writeTabModelMetadata(final File tabbedDirectory, final DocumentTabModel normalTabModel,
-            final Set<Integer> migratedTabIds) {
+    void writeTabModelMetadata(final DocumentTabModel normalTabModel,
+            final Set<Integer> migratedTabIds, final Context context,
+            @Nullable final File tabbedDirectoryOverride) {
         ThreadUtils.assertOnUiThread();
         if (!setStage(STAGE_COPY_TAB_STATES_DONE, STAGE_WRITE_TABMODEL_METADATA_STARTED)) return;
 
         new AsyncTask<Void, Void, Boolean>() {
             private byte[] mSerializedMetadata;
 
             @Override
             protected void onPreExecute() {
                 Log.d(TAG, "Beginning to write tabbed mode metadata files.");
 
@@ skipping 22 matching lines @@
                             normalMetadata, incognitoMetadata, null);
                 } catch (IOException e) {
                     Log.e(TAG, "Failed to serialize the TabModel.", e);
                     mSerializedMetadata = null;
                 }
             }
 
             @Override
             protected Boolean doInBackground(Void... params) {
                 if (mSerializedMetadata != null) {
+                    File tabbedDirectory = tabbedDirectoryOverride == null
+                            ? TabPersistentStore.getStateDirectory(context, TAB_MODEL_INDEX)
+                            : tabbedDirectoryOverride;
                     TabPersistentStore.saveListToFile(tabbedDirectory, mSerializedMetadata);
                     return true;
                 } else {
                     return false;
                 }
             }
 
             @Override
             protected void onPostExecute(Boolean result) {
                 // TODO(dfalcantara): What do we do if the metadata file failed to be written out?
@@ skipping 91 matching lines @@
      *    shortcut the first time they start Chrome after migration.  This was already
      *    broken for document mode during cold starts, anyway.
      */
     private void startStage(int newStage) {
         ThreadUtils.assertOnUiThread();
         if (!mIsPipelineActive) return;
 
         Context context = ApplicationStatus.getApplicationContext();
         if (newStage == STAGE_INITIALIZED) {
             Log.d(TAG, "Migrating user into tabbed mode.");
-            DocumentTabModelSelector selector = ChromeApplication.getDocumentTabModelSelector();
-            DocumentTabModelImpl normalTabModel =
-                    (DocumentTabModelImpl) selector.getModel(false);
             int selectedTabId = DocumentUtils.getLastShownTabIdFromPrefs(context, false);
-
-            File documentDirectory = normalTabModel.getStorageDelegate().getStateDirectory();
-            File tabbedDirectory = TabPersistentStore.getStateDirectory(context, TAB_MODEL_INDEX);
-            copyTabStateFiles(selectedTabId, documentDirectory, tabbedDirectory);
+            copyTabStateFiles(selectedTabId, context, null, null);
         } else if (newStage == STAGE_COPY_TAB_STATES_DONE) {
             Log.d(TAG, "Writing tabbed mode metadata file.");
             DocumentTabModelSelector selector = ChromeApplication.getDocumentTabModelSelector();
             DocumentTabModelImpl normalTabModel =
                     (DocumentTabModelImpl) selector.getModel(false);
-            File tabbedDirectory =
-                    TabPersistentStore.getStateDirectory(context, TAB_MODEL_INDEX);
-            writeTabModelMetadata(tabbedDirectory, normalTabModel, mMigratedTabIds);
+            writeTabModelMetadata(normalTabModel, mMigratedTabIds, context, null);
         } else if (newStage == STAGE_WRITE_TABMODEL_METADATA_DONE) {
             Log.d(TAG, "Changing user preference.");
             changePreferences(context);
         } else if (newStage == STAGE_CHANGE_SETTINGS_DONE) {
             Log.d(TAG, "Cleaning up document mode data.");
             deleteDocumentModeData(context);
         }
     }
 
 
     /**
      * Returns the current stage of the pipeline.
      */
     @VisibleForTesting
     public int getStage() {
+        ThreadUtils.assertOnUiThread();
         return mStage;
     }
 
 
     /**
      * Adds a observer that is alerted as migration progresses.
      *
      * @param observer Observer to add.
      */
     @VisibleForTesting
@@ skipping 27 matching lines @@
 
     private DocumentModeAssassin() {
         this(isMigrationNecessary() ? STAGE_UNINITIALIZED : STAGE_DONE, true);
     }
 
     private DocumentModeAssassin(int stage, boolean isPipelineActive) {
         mStage = stage;
         mIsPipelineActive = isPipelineActive;
     }
 }