Make AsyncTabParamsManager a singleton

Pass it as a parameter into constructors where possible.

This is a step to modularize TabWindowManager. Next step is to split
AsyncTabParamsManager into interface/impl and modularize it.

Bug: 1112920
Change-Id: I3461a539177daba5b42e1f1ec422350a84dca8c2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2347381
Reviewed-by: David Trainor <dtrainor@chromium.org>
Commit-Queue: Henrique Nakashima <hnakashima@chromium.org>
Cr-Commit-Position: refs/heads/master@{#797891}

chrome/android/java/src/org/chromium/chrome/browser/ChromeActivity.java

@@ -1109,7 +1109,8 @@ protected void recordIntentToCreationTime(long timeMs) {
     @Override
     public void onStart() {
         // Sometimes mCompositorViewHolder is null, see crbug.com/1057613.
-        if (AsyncTabParamsManager.hasParamsWithTabToReparent() && mCompositorViewHolder != null) {
+        if (AsyncTabParamsManager.getInstance().hasParamsWithTabToReparent()
+                && mCompositorViewHolder != null) {
             mCompositorViewHolder.prepareForTabReparenting();
         }
         super.onStart();
@@ -1371,7 +1372,8 @@ public void finishNativeInitialization() {
         if (ChromeFeatureList.isEnabled(ChromeFeatureList.ANDROID_NIGHT_MODE_TAB_REPARENTING)) {
             mNightModeReparentingController = new NightModeReparentingController(
                     ReparentingDelegateFactory.createNightModeReparentingControllerDelegate(
-                            getActivityTabProvider(), getTabModelSelector()));
+                            getActivityTabProvider(), getTabModelSelector()),
+                    AsyncTabParamsManager.getInstance());
         }
     }
 

chrome/android/java/src/org/chromium/chrome/browser/ChromeTabbedActivity.java

@@ -389,7 +389,8 @@ public ChromeTabbedActivity() {
         // path to reparenting to ensure the launching logic isn't disrupted.
         // TODO(crbug.com/1065491): Unlock this codepath for all incoming intents once it's
         // confirmed working and stable.
-        if (savedInstanceState != null && AsyncTabParamsManager.hasParamsWithTabToReparent()) {
+        if (savedInstanceState != null
+                && AsyncTabParamsManager.getInstance().hasParamsWithTabToReparent()) {
             return LaunchIntentDispatcher.Action.CONTINUE;
         }
 
@@ -1124,7 +1125,8 @@ public void initializeState() {
             // are coming from night mode tab reparenting. In this case, reparenting happens
             // synchronously along with tab restoration so there are no tabs waiting for
             // reparenting like there are for other tab reparenting operations.
-            boolean hasTabWaitingForReparenting = AsyncTabParamsManager.hasParamsWithTabToReparent()
+            boolean hasTabWaitingForReparenting =
+                    AsyncTabParamsManager.getInstance().hasParamsWithTabToReparent()
                     && getSavedInstanceState() == null;
             mCreatedTabOnStartup = getCurrentTabModel().getCount() > 0
                     || mTabModelSelectorImpl.getRestoredTabCount() > 0 || mIntentWithEffect
@@ -1638,9 +1640,11 @@ public boolean handleCreateNTPIfNeeded(boolean isNTP, boolean incognito) {
             };
         }
         return Pair.create(new ChromeTabCreator(this, getWindowAndroid(), getStartupTabPreloader(),
-                                   tabDelegateFactorySupplier, false, overviewNTPCreator),
+                                   tabDelegateFactorySupplier, false, overviewNTPCreator,
+                                   AsyncTabParamsManager.getInstance()),
                 new ChromeTabCreator(this, getWindowAndroid(), getStartupTabPreloader(),
-                        tabDelegateFactorySupplier, true, overviewNTPCreator));
+                        tabDelegateFactorySupplier, true, overviewNTPCreator,
+                        AsyncTabParamsManager.getInstance()));
     }
 
     @Override

chrome/android/java/src/org/chromium/chrome/browser/app/tab_activity_glue/ReparentingTask.java

@@ -118,7 +118,7 @@ public boolean begin(Context context, Intent intent, Bundle startActivityOptions
             // Add the tab to AsyncTabParamsManager before removing it from the current model to
             // ensure the global count of tabs is correct. See https://crbug.com/611806.
             intent.putExtra(IntentHandler.EXTRA_TAB_ID, mTab.getId());
-            AsyncTabParamsManager.add(
+            AsyncTabParamsManager.getInstance().add(
                     mTab.getId(), new TabReparentingParams(mTab, finalizeCallback));
 
             detach();

chrome/android/java/src/org/chromium/chrome/browser/customtabs/content/CustomTabActivityTabController.java

@@ -107,6 +107,7 @@ public class CustomTabActivityTabController implements InflationObserver {
     private final ReparentingTaskProvider mReparentingTaskProvider;
     private final Lazy<CustomTabIncognitoManager> mCustomTabIncognitoManager;
     private final ProfileProvider mProfileProvider;
+    private final Lazy<AsyncTabParamsManager> mAsyncTabParamsManager;
 
     @Nullable
     private final CustomTabsSessionToken mSession;
@@ -133,7 +134,7 @@ public CustomTabActivityTabController(ChromeActivity<?> activity,
             CustomTabActivityTabProvider tabProvider, StartupTabPreloader startupTabPreloader,
             ReparentingTaskProvider reparentingTaskProvider,
             Lazy<CustomTabIncognitoManager> customTabIncognitoManager,
-            ProfileProvider profileProvider) {
+            ProfileProvider profileProvider, Lazy<AsyncTabParamsManager> asyncTabParamsManager) {
         mCustomTabDelegateFactory = customTabDelegateFactory;
         mActivity = activity;
         mConnection = connection;
@@ -152,6 +153,7 @@ public CustomTabActivityTabController(ChromeActivity<?> activity,
         mReparentingTaskProvider = reparentingTaskProvider;
         mCustomTabIncognitoManager = customTabIncognitoManager;
         mProfileProvider = profileProvider;
+        mAsyncTabParamsManager = asyncTabParamsManager;
 
         mSession = mIntentDataProvider.getSession();
         mIntent = mIntentDataProvider.getIntent();
@@ -343,7 +345,7 @@ private void finalizeCreatingTab(TabModelSelectorImpl tabModelSelector, TabModel
         // when we have compositor related controllers.
         if (mode == TabCreationMode.HIDDEN) {
             TabReparentingParams params =
-                    (TabReparentingParams) AsyncTabParamsManager.remove(tab.getId());
+                    (TabReparentingParams) mAsyncTabParamsManager.get().remove(tab.getId());
             mReparentingTaskProvider.get(tab).finish(
                     ReparentingDelegateFactory.createReparentingTaskDelegate(
                             mActivity.getCompositorViewHolder(), mActivity.getWindowAndroid(),
@@ -457,7 +459,7 @@ private WebContents takeWebContents() {
     private WebContents takeAsyncWebContents() {
         int assignedTabId = IntentUtils.safeGetIntExtra(
                 mIntent, IntentHandler.EXTRA_TAB_ID, Tab.INVALID_TAB_ID);
-        AsyncTabParams asyncParams = AsyncTabParamsManager.remove(assignedTabId);
+        AsyncTabParams asyncParams = mAsyncTabParamsManager.get().remove(assignedTabId);
         if (asyncParams == null) return null;
         return asyncParams.getWebContents();
     }

chrome/android/java/src/org/chromium/chrome/browser/customtabs/content/CustomTabActivityTabFactory.java

@@ -23,6 +23,7 @@
 import org.chromium.chrome.browser.tab.TabBuilder;
 import org.chromium.chrome.browser.tab.TabDelegateFactory;
 import org.chromium.chrome.browser.tab.TabLaunchType;
+import org.chromium.chrome.browser.tabmodel.AsyncTabParamsManager;
 import org.chromium.chrome.browser.tabmodel.ChromeTabCreator;
 import org.chromium.chrome.browser.tabmodel.NextTabPolicy;
 import org.chromium.chrome.browser.tabmodel.TabModelFilterFactory;
@@ -51,6 +52,8 @@ public class CustomTabActivityTabFactory {
     @Nullable
     private final StartupTabPreloader mStartupTabPreloader;
 
+    private final Lazy<AsyncTabParamsManager> mAsyncTabParamsManager;
+
     @Nullable
     private TabModelSelectorImpl mTabModelSelector;
 
@@ -61,20 +64,23 @@ public CustomTabActivityTabFactory(ChromeActivity<?> activity,
             Lazy<ActivityWindowAndroid> activityWindowAndroid,
             Lazy<CustomTabDelegateFactory> customTabDelegateFactory,
             BrowserServicesIntentDataProvider intentDataProvider,
-            @Nullable StartupTabPreloader startupTabPreloader) {
+            @Nullable StartupTabPreloader startupTabPreloader,
+            Lazy<AsyncTabParamsManager> asyncTabParamsManager) {
         mActivity = activity;
         mPersistencePolicy = persistencePolicy;
         mTabModelFilterFactory = tabModelFilterFactory;
         mActivityWindowAndroid = activityWindowAndroid;
         mCustomTabDelegateFactory = customTabDelegateFactory;
         mIntentDataProvider = intentDataProvider;
         mStartupTabPreloader = startupTabPreloader;
+        mAsyncTabParamsManager = asyncTabParamsManager;
     }
 
     /** Creates a {@link TabModelSelector} for the custom tab. */
     public TabModelSelectorImpl createTabModelSelector() {
         mTabModelSelector = new TabModelSelectorImpl(mActivity, mActivity, mPersistencePolicy,
-                mTabModelFilterFactory, () -> NextTabPolicy.LOCATIONAL, false, false, false);
+                mTabModelFilterFactory,
+                () -> NextTabPolicy.LOCATIONAL, mAsyncTabParamsManager.get(), false, false, false);
         return mTabModelSelector;
     }
 
@@ -94,7 +100,8 @@ public Pair<ChromeTabCreator, ChromeTabCreator> createTabCreators() {
 
     private ChromeTabCreator createTabCreator(boolean incognito) {
         return new ChromeTabCreator(mActivity, mActivityWindowAndroid.get(), mStartupTabPreloader,
-                mCustomTabDelegateFactory::get, incognito, null);
+                mCustomTabDelegateFactory::get, incognito, null,
+                AsyncTabParamsManager.getInstance());
     }
 
     /** Creates a new tab for a Custom Tab activity */

chrome/android/java/src/org/chromium/chrome/browser/dependency_injection/ChromeAppModule.java

@@ -19,6 +19,7 @@
 import org.chromium.chrome.browser.notifications.channels.SiteChannelsManager;
 import org.chromium.chrome.browser.preferences.SharedPreferencesManager;
 import org.chromium.chrome.browser.profiles.Profile;
+import org.chromium.chrome.browser.tabmodel.AsyncTabParamsManager;
 import org.chromium.chrome.browser.webapps.WebappRegistry;
 
 import javax.inject.Named;
@@ -86,4 +87,9 @@ public TrustedWebActivityServiceConnectionPool providesTwaServiceConnectionManag
     public SystemNightModeMonitor provideSystemNightModeMonitor() {
         return SystemNightModeMonitor.getInstance();
     }
+
+    @Provides
+    public AsyncTabParamsManager provideAsyncTabParamsManager() {
+        return AsyncTabParamsManager.getInstance();
+    }
 }

chrome/android/java/src/org/chromium/chrome/browser/night_mode/NightModeReparentingController.java

@@ -32,11 +32,14 @@ public interface Delegate {
         boolean isNTPUrl(String url);
     }
 
-    private Delegate mDelegate;
+    private final Delegate mDelegate;
+    private final AsyncTabParamsManager mAsyncTabParamsManager;
 
     /** Constructs a {@link NightModeReparentingController} with the given delegate. */
-    public NightModeReparentingController(@NonNull Delegate delegate) {
+    public NightModeReparentingController(
+            @NonNull Delegate delegate, AsyncTabParamsManager asyncTabParamsManager) {
         mDelegate = delegate;
+        mAsyncTabParamsManager = asyncTabParamsManager;
     }
 
     @Override
@@ -60,13 +63,13 @@ public void onNightModeStateChanged() {
 
             // The current tab has already been detached/stored and is waiting for andorid to
             // recreate the activity.
-            if (AsyncTabParamsManager.hasParamsForTabId(tab.getId())) continue;
+            if (mAsyncTabParamsManager.hasParamsForTabId(tab.getId())) continue;
             // Intentionally skip new tab pages and allow them to reload and restore scroll
             // state themselves.
             if (mDelegate.isNTPUrl(tab.getUrlString())) continue;
 
             TabReparentingParams params = new TabReparentingParams(tab, null);
-            AsyncTabParamsManager.add(tab.getId(), params);
+            mAsyncTabParamsManager.add(tab.getId(), params);
             ReparentingTask.from(tab).detach();
         }
     }

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

@@ -11,47 +11,52 @@
 /**
  * Data that will be used later when a tab is opened via an intent. Often only the necessary
  * subset of the data will be set. All data is removed once the tab finishes initializing.
- *
- * TODO(pshmakov): convert to a singleton.
  */
 public class AsyncTabParamsManager {
+    /** Singleton instance. */
+    private static final AsyncTabParamsManager INSTANCE = new AsyncTabParamsManager();
 
     /** A map of tab IDs to AsyncTabParams consumed by Activities started asynchronously. */
-    private static final SparseArray<AsyncTabParams> sAsyncTabParams = new SparseArray<>();
+    private final SparseArray<AsyncTabParams> mAsyncTabParams = new SparseArray<>();
 
-    private static boolean sAddedToIncognitoTabHostRegistry;
+    private boolean mAddedToIncognitoTabHostRegistry;
+
+    /** Get the singleton instance of {@link AsyncTabParamsManager}. */
+    public static AsyncTabParamsManager getInstance() {
+        return INSTANCE;
+    }
 
     /**
      * Stores AsyncTabParams used when the tab with the given ID is launched via intent.
      * @param tabId The ID of the tab that will be launched via intent.
      * @param params The AsyncTabParams to use when creating the Tab.
      */
-    public static void add(int tabId, AsyncTabParams params) {
-        sAsyncTabParams.put(tabId, params);
+    public void add(int tabId, AsyncTabParams params) {
+        mAsyncTabParams.put(tabId, params);
 
-        if (!sAddedToIncognitoTabHostRegistry) {
+        if (!mAddedToIncognitoTabHostRegistry) {
             // Make sure async incognito tabs are taken into account when, for example,
             // checking if any incognito tabs exist.
-            IncognitoTabHostRegistry.getInstance().register(new AsyncTabsIncognitoTabHost());
-            sAddedToIncognitoTabHostRegistry = true;
+            IncognitoTabHostRegistry.getInstance().register(new AsyncTabsIncognitoTabHost(this));
+            mAddedToIncognitoTabHostRegistry = true;
         }
     }
 
     /**
      * @return Whether there is already an {@link AsyncTabParams} added for the given ID.
      */
-    public static boolean hasParamsForTabId(int tabId) {
-        return sAsyncTabParams.get(tabId) != null;
+    public boolean hasParamsForTabId(int tabId) {
+        return mAsyncTabParams.get(tabId) != null;
     }
 
     /**
      * @return Whether there are any saved {@link AsyncTabParams} with a tab to reparent. All
      *         implementations of this are keyed off of a user gesture so the likelihood of having
      *         more than one is zero.
      */
-    public static boolean hasParamsWithTabToReparent() {
-        for (int i = 0; i < sAsyncTabParams.size(); i++) {
-            if (sAsyncTabParams.get(sAsyncTabParams.keyAt(i)).getTabToReparent() == null) continue;
+    public boolean hasParamsWithTabToReparent() {
+        for (int i = 0; i < mAsyncTabParams.size(); i++) {
+            if (mAsyncTabParams.get(mAsyncTabParams.keyAt(i)).getTabToReparent() == null) continue;
             return true;
         }
         return false;
@@ -61,26 +66,31 @@ public static boolean hasParamsWithTabToReparent() {
      * @return A map of tab IDs to AsyncTabParams containing data that will be used later when a tab
      *         is opened via an intent.
      */
-    public static SparseArray<AsyncTabParams> getAsyncTabParams() {
-        return sAsyncTabParams;
+    public SparseArray<AsyncTabParams> getAsyncTabParams() {
+        return mAsyncTabParams;
     }
 
     /**
      * @return Retrieves and removes AsyncTabCreationParams for a particular tab id.
      */
-    public static AsyncTabParams remove(int tabId) {
-        AsyncTabParams data = sAsyncTabParams.get(tabId);
-        sAsyncTabParams.remove(tabId);
+    public AsyncTabParams remove(int tabId) {
+        AsyncTabParams data = mAsyncTabParams.get(tabId);
+        mAsyncTabParams.remove(tabId);
         return data;
     }
 
-    private AsyncTabParamsManager() {
-    }
+    private AsyncTabParamsManager() {}
 
     private static class AsyncTabsIncognitoTabHost implements IncognitoTabHost {
+        private final AsyncTabParamsManager mAsyncTabParamsManager;
+
+        private AsyncTabsIncognitoTabHost(AsyncTabParamsManager asyncTabParamsManager) {
+            mAsyncTabParamsManager = asyncTabParamsManager;
+        }
+
         @Override
         public boolean hasIncognitoTabs() {
-            SparseArray<AsyncTabParams> asyncTabParams = AsyncTabParamsManager.getAsyncTabParams();
+            SparseArray<AsyncTabParams> asyncTabParams = mAsyncTabParamsManager.getAsyncTabParams();
             for (int i = 0; i < asyncTabParams.size(); i++) {
                 Tab tab = asyncTabParams.valueAt(i).getTabToReparent();
                 if (tab != null && tab.isIncognito()) {
@@ -92,11 +102,11 @@ public boolean hasIncognitoTabs() {
 
         @Override
         public void closeAllIncognitoTabs() {
-            SparseArray<AsyncTabParams> asyncTabParams = AsyncTabParamsManager.getAsyncTabParams();
+            SparseArray<AsyncTabParams> asyncTabParams = mAsyncTabParamsManager.getAsyncTabParams();
             for (int i = 0; i < asyncTabParams.size(); i++) {
                 Tab tab = asyncTabParams.valueAt(i).getTabToReparent();
                 if (tab != null && tab.isIncognito()) {
-                    AsyncTabParamsManager.remove(tab.getId());
+                    mAsyncTabParamsManager.remove(tab.getId());
                 }
             }
         }

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

@@ -65,18 +65,20 @@ public interface OverviewNTPCreator {
     private TabModelOrderController mOrderController;
     private Supplier<TabDelegateFactory> mTabDelegateFactorySupplier;
     @Nullable
-    private OverviewNTPCreator mOverviewNTPCreator;
+    private final OverviewNTPCreator mOverviewNTPCreator;
+    private final AsyncTabParamsManager mAsyncTabParamsManager;
 
     public ChromeTabCreator(ChromeActivity activity, WindowAndroid nativeWindow,
             StartupTabPreloader startupTabPreloader,
             Supplier<TabDelegateFactory> tabDelegateFactory, boolean incognito,
-            OverviewNTPCreator overviewNTPCreator) {
+            OverviewNTPCreator overviewNTPCreator, AsyncTabParamsManager asyncTabParamsManager) {
         mActivity = activity;
         mStartupTabPreloader = startupTabPreloader;
         mNativeWindow = nativeWindow;
         mTabDelegateFactorySupplier = tabDelegateFactory;
         mIncognito = incognito;
         mOverviewNTPCreator = overviewNTPCreator;
+        mAsyncTabParamsManager = asyncTabParamsManager;
     }
 
     @Override
@@ -143,8 +145,7 @@ private Tab createNewTab(LoadUrlParams loadUrlParams, @TabLaunchType int type, T
             // Check if the tab is being created asynchronously.
             int assignedTabId = intent == null ? Tab.INVALID_TAB_ID : IntentUtils.safeGetIntExtra(
                     intent, IntentHandler.EXTRA_TAB_ID, Tab.INVALID_TAB_ID);
-            AsyncTabParams asyncParams =
-                    AsyncTabParamsManager.remove(assignedTabId);
+            AsyncTabParams asyncParams = mAsyncTabParamsManager.remove(assignedTabId);
 
             boolean openInForeground = mOrderController.willOpenInForeground(type, mIncognito);
             TabDelegateFactory delegateFactory =
@@ -375,7 +376,7 @@ public Tab createFrozenTab(TabState state, int id, int index) {
         Tab parent = selector != null ? selector.getTabById(state.parentId) : null;
         boolean selectTab = mOrderController.willOpenInForeground(
                 TabLaunchType.FROM_RESTORE, state.isIncognito());
-        AsyncTabParams asyncParams = AsyncTabParamsManager.remove(id);
+        AsyncTabParams asyncParams = mAsyncTabParamsManager.remove(id);
         Tab tab = null;
         @TabLaunchType
         int launchType = TabLaunchType.FROM_RESTORE;