Tech Debt Repayment for StartupBrowserCreatorImpl Refactor

chrome/browser/ui/startup/startup_browser_creator_impl.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 31 matching lines @@
 #include "chrome/browser/extensions/launch_util.h"
 #include "chrome/browser/extensions/pack_extension_job.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profile_resetter/triggered_profile_resetter.h"
 #include "chrome/browser/profile_resetter/triggered_profile_resetter_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
-#include "chrome/browser/sessions/session_restore.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_navigator_params.h"
@@ skipping 554 matching lines @@
 void StartupBrowserCreatorImpl::ProcessLaunchUrlsUsingConsolidatedFlow(
     bool process_startup,
     const std::vector<GURL>& cmd_line_urls) {
   // Don't open any browser windows if starting up in "background mode".
   if (process_startup && command_line_.HasSwitch(switches::kNoStartupWindow))
     return;
 
   StartupTabs cmd_line_tabs;
   UrlsToTabs(cmd_line_urls, &cmd_line_tabs);
 
-  bool is_ephemeral_profile =
+  bool is_incognito_or_guest =
       profile_->GetProfileType() != Profile::ProfileType::REGULAR_PROFILE;
   bool is_post_crash_launch = HasPendingUncleanExit(profile_);
   StartupTabs tabs =
       DetermineStartupTabs(StartupTabProviderImpl(), cmd_line_tabs,
-                           is_ephemeral_profile, is_post_crash_launch);
+                           is_incognito_or_guest, is_post_crash_launch);
 
   // Return immediately if we start an async restore, since the remainder of
   // that process is self-contained.
   if (MaybeAsyncRestore(tabs, process_startup, is_post_crash_launch))
     return;
 
+  BrowserOpenBehaviorOptions behavior_options = 0;
+  if (process_startup)
+    behavior_options |= PROCESS_STARTUP;
+  if (is_post_crash_launch)
+    behavior_options |= IS_POST_CRASH_LAUNCH;
+  if (command_line_.HasSwitch(switches::kRestoreLastSession))
+    behavior_options |= HAS_RESTORE_SWITCH;
+  if (command_line_.HasSwitch(switches::kOpenInNewWindow))
+    behavior_options |= HAS_NEW_WINDOW_SWITCH;
+  if (!cmd_line_tabs.empty())
+    behavior_options |= HAS_CMD_LINE_TABS;
+
   BrowserOpenBehavior behavior = DetermineBrowserOpenBehavior(
       StartupBrowserCreator::GetSessionStartupPref(command_line_, profile_),
-      process_startup, is_post_crash_launch,
-      command_line_.HasSwitch(switches::kRestoreLastSession),
-      command_line_.HasSwitch(switches::kOpenInNewWindow),
-      !cmd_line_tabs.empty());
+      behavior_options);
 
-  uint32_t restore_options = 0;
+  SessionRestore::Behavior restore_options = 0;
   if (behavior == BrowserOpenBehavior::SYNCHRONOUS_RESTORE) {
 #if defined(OS_MACOSX)
     bool was_mac_login_or_resume = base::mac::WasLaunchedAsLoginOrResumeItem();
 #else
     bool was_mac_login_or_resume = false;
 #endif
     restore_options = DetermineSynchronousRestoreOptions(
         browser_defaults::kAlwaysCreateTabbedBrowserOnSessionRestore,
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kCreateBrowserOnStartupForTests),
         was_mac_login_or_resume);
   }
 
   Browser* browser = RestoreOrCreateBrowser(
       tabs, behavior, restore_options, process_startup, is_post_crash_launch);
 
   // Finally, add info bars.
   AddInfoBarsIfNecessary(
       browser, process_startup ? chrome::startup::IS_PROCESS_STARTUP
                                : chrome::startup::IS_NOT_PROCESS_STARTUP);
 }
 
 StartupTabs StartupBrowserCreatorImpl::DetermineStartupTabs(
     const StartupTabProvider& provider,
     const StartupTabs& cmd_line_tabs,
-    bool is_ephemeral_profile,
+    bool is_incognito_or_guest,
     bool is_post_crash_launch) {
   // Only the New Tab Page or command line URLs may be shown in incognito mode.
   // A similar policy exists for crash recovery launches, to prevent getting the
   // user stuck in a crash loop.
-  if (is_ephemeral_profile || is_post_crash_launch) {
+  if (is_incognito_or_guest || is_post_crash_launch) {
     if (cmd_line_tabs.empty())
       return StartupTabs({StartupTab(GURL(chrome::kChromeUINewTabURL), false)});
     return cmd_line_tabs;
   }
 
   // A trigger on a profile may indicate that we should show a tab which
   // offers to reset the user's settings.  When this appears, it is first, and
   // may be shown alongside command-line tabs.
   StartupTabs tabs = provider.GetResetTriggerTabs(profile_);
 
@@ skipping 44 matching lines @@
   // Note: there's no session service in incognito or guest mode.
   SessionService* service =
       SessionServiceFactory::GetForProfileForSessionRestore(profile_);
 
   return service && service->RestoreIfNecessary(TabsToUrls(tabs));
 }
 
 Browser* StartupBrowserCreatorImpl::RestoreOrCreateBrowser(
     const StartupTabs& tabs,
     BrowserOpenBehavior behavior,
-    uint32_t restore_options,
+    SessionRestore::Behavior restore_options,
     bool process_startup,
     bool is_post_crash_launch) {
   Browser* browser = nullptr;
   if (behavior == BrowserOpenBehavior::SYNCHRONOUS_RESTORE) {
     browser = SessionRestore::RestoreSession(profile_, nullptr, restore_options,
                                              TabsToUrls(tabs));
     if (browser)
       return browser;
   } else if (behavior == BrowserOpenBehavior::USE_EXISTING) {
     browser = chrome::FindTabbedBrowser(profile_, process_startup);
   }
 
   base::AutoReset<bool> synchronous_launch_resetter(
       &StartupBrowserCreator::in_synchronous_profile_launch_, true);
 
   // OpenTabsInBrowser requires at least one tab be passed. As a fallback to
-  // prevent a crash, use the NTP if |tabs| is empty.
+  // prevent a crash, use the NTP if |tabs| is empty. This could happen if
+  // we expected a session restore to happen but it did not occur/succeed.
   browser = OpenTabsInBrowser(
       browser, process_startup,
       (tabs.empty()
            ? StartupTabs({StartupTab(GURL(chrome::kChromeUINewTabURL), false)})
            : tabs));
 
   // Now that a restore is no longer possible, it is safe to clear DOM storage,
   // unless this is a crash recovery.
   if (!is_post_crash_launch) {
     content::BrowserContext::GetDefaultStoragePartition(profile_)
@@ skipping 68 matching lines @@
   for (const GURL& url : urls_to_open) {
     rappor::SampleDomainAndRegistryFromGURL(g_browser_process->rappor_service(),
                                             "Startup.BrowserLaunchURL", url);
   }
 }
 
 // static
 StartupBrowserCreatorImpl::BrowserOpenBehavior
 StartupBrowserCreatorImpl::DetermineBrowserOpenBehavior(
     const SessionStartupPref& pref,
-    bool process_startup,
-    bool is_post_crash_launch,
-    bool has_restore_switch,
-    bool has_new_window_switch,
-    bool has_cmd_line_tabs) {
-  if (!process_startup) {
+    BrowserOpenBehaviorOptions options) {
+  if (!(options & PROCESS_STARTUP)) {
     // For existing processes, restore would have happened before invoking this
     // function. If Chrome was launched with passed URLs, assume these should
     // be appended to an existing window if possible, unless overridden by a
     // switch.
-    return (has_cmd_line_tabs && !has_new_window_switch)
+    return ((options & HAS_CMD_LINE_TABS) && !(options & HAS_NEW_WINDOW_SWITCH))
                ? BrowserOpenBehavior::USE_EXISTING
                : BrowserOpenBehavior::NEW;
   }
 
   if (pref.type == SessionStartupPref::LAST) {
     // Don't perform a session restore on a post-crash launch, as this could
     // cause a crash loop. These checks can be overridden by a switch.
-    // TODO(crbug.com/647851): Group this check with the logic in
-    // GetSessionStartupPref.

[tmartino, 2017/02/03 23:44:12]

Note: Removing this TODO because I've closed the bug after deciding that such an
organization doesn't actually make sense.

-    if (!is_post_crash_launch || has_restore_switch)
+    if (!(options & IS_POST_CRASH_LAUNCH) || (options & HAS_RESTORE_SWITCH))
       return BrowserOpenBehavior::SYNCHRONOUS_RESTORE;
   }
 
   return BrowserOpenBehavior::NEW;
 }
 
 // static
-uint32_t StartupBrowserCreatorImpl::DetermineSynchronousRestoreOptions(
+SessionRestore::Behavior
+StartupBrowserCreatorImpl::DetermineSynchronousRestoreOptions(
     bool has_create_browser_default,
     bool has_create_browser_switch,
     bool was_mac_login_or_resume) {
-  uint32_t options = SessionRestore::SYNCHRONOUS;
+  SessionRestore::Behavior options = SessionRestore::SYNCHRONOUS;
 
   // Suppress the creation of a new window on Mac when restoring with no windows
   // if launching Chrome via a login item or the resume feature in OS 10.7+.
   if (!was_mac_login_or_resume &&
       (has_create_browser_default || has_create_browser_switch))
     options |= SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
 
   return options;
 }
 
@@ skipping 84 matching lines @@
     if (profile_->GetLastSessionExitType() == Profile::EXIT_CRASHED &&
         !command_line_.HasSwitch(switches::kRestoreLastSession)) {
       // The last session crashed. It's possible automatically loading the
       // page will trigger another crash, locking the user out of chrome.
       // To avoid this, don't restore on startup but instead show the crashed
       // infobar.
       VLOG(1) << "Unclean exit; not processing";
       return false;
     }
 
-    uint32_t restore_behavior = SessionRestore::SYNCHRONOUS;
+    SessionRestore::Behavior restore_behavior = SessionRestore::SYNCHRONOUS;
     if (browser_defaults::kAlwaysCreateTabbedBrowserOnSessionRestore ||
         base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kCreateBrowserOnStartupForTests)) {
       restore_behavior |= SessionRestore::ALWAYS_CREATE_TABBED_BROWSER;
     }
 
 #if defined(OS_MACOSX)
     // On Mac, when restoring a session with no windows, suppress the creation
     // of a new window in the case where the system is launching Chrome via a
     // login item or Lion's resume feature.
@@ skipping 233 matching lines @@
 #if defined(OS_WIN)
   TriggeredProfileResetter* triggered_profile_resetter =
       TriggeredProfileResetterFactory::GetForBrowserContext(profile_);
   // TriggeredProfileResetter instance will be nullptr for incognito profiles.
   if (triggered_profile_resetter) {
     has_reset_trigger = triggered_profile_resetter->HasResetTrigger();
   }
 #endif  // defined(OS_WIN)
   return has_reset_trigger;
 }