Completing refactor of startup_browser_creator_impl

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 172 matching lines @@
 
 void UrlsToTabs(const std::vector<GURL>& urls, StartupTabs* tabs) {
   for (size_t i = 0; i < urls.size(); ++i) {
     StartupTab tab;
     tab.is_pinned = false;
     tab.url = urls[i];
     tabs->push_back(tab);
   }
 }
 
+std::vector<GURL> TabsToUrls(const StartupTabs& tabs) {
+  std::vector<GURL> urls(tabs.size());

[grt (UTC plus 2), 2016/10/28 18:49:16]

micro-optimization: you could default construct the vector,
urls.reserve(tabs.size()) to get the memory allocated, then use
std::back_inserter(urls) below. this avoids constructing a bunch of URLs on this
line only to overwrite them during the transform.

+  std::transform(tabs.begin(), tabs.end(), urls.begin(),
+                 [](StartupTab tab) { return tab.url; });

[grt (UTC plus 2), 2016/10/28 18:49:15]

const StartupTab& tab

+  return urls;
+}
+
 // Return true if the command line option --app-id is used.  Set
 // |out_extension| to the app to open, and |out_launch_container|
 // to the type of window into which the app should be open.
 bool GetAppLaunchContainer(
     Profile* profile,
     const std::string& app_id,
     const Extension** out_extension,
     extensions::LaunchContainer* out_launch_container) {
 
   const Extension* extension = extensions::ExtensionRegistry::Get(
@@ skipping 58 matching lines @@
           extension_id, extensions::ExtensionRegistry::EVERYTHING);
   return extension && extension->is_platform_app() ? extension : NULL;
 }
 
 // Appends the contents of |from| to the end of |to|.
 void AppendTabs(const StartupTabs& from, StartupTabs* to) {
   if (!from.empty())
     to->insert(to->end(), from.begin(), from.end());
 }
 
+// Determines whether the Consolidated startup flow should be used, based on
+// OS, OS version, and the kUseConsolidatedStartupFlow Feature.
+bool UseConsolidatedFlow() {
+#if defined(OS_WIN)
+  if (base::win::GetVersion() >= base::win::VERSION_WIN10)
+    return false;
+#endif  // defined(OS_WIN)
+  return base::FeatureList::IsEnabled(features::kUseConsolidatedStartupFlow);
+}
+
 }  // namespace
 
 namespace internals {
 
 GURL GetTriggeredResetSettingsURL() {
   return GURL(
       chrome::GetSettingsUrl(chrome::kTriggeredResetProfileSettingsSubPage));
 }
 
 GURL GetWelcomePageURL() {
@@ skipping 66 matching lines @@
   // URLs in that case. The user should see the window as an app,
   // not as chrome.
   // Special case is when app switches are passed but we do want to restore
   // session. In that case open app window + focus it after session is restored.
   if (OpenApplicationWindow(profile)) {
     RecordLaunchModeHistogram(LM_AS_WEBAPP);
   } else {
     RecordLaunchModeHistogram(urls_to_open.empty() ?
                               LM_TO_BE_DECIDED : LM_WITH_URLS);
 
-    if (base::FeatureList::IsEnabled(features::kUseConsolidatedStartupFlow))
+    if (UseConsolidatedFlow())
       ProcessLaunchUrlsUsingConsolidatedFlow(process_startup, urls_to_open);
     else
       ProcessLaunchURLs(process_startup, urls_to_open);
 
     if (command_line_.HasSwitch(switches::kInstallChromeApp)) {
       install_chrome_app::InstallChromeApp(
           command_line_.GetSwitchValueASCII(switches::kInstallChromeApp));
     }
 
     // If this is an app launch, but we didn't open an app window, it may
@@ skipping 221 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_incognito = IncognitoModePrefs::ShouldLaunchIncognito(
-      command_line_, profile_->GetPrefs());
+  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_incognito, is_post_crash_launch);
+                           is_incognito_or_guest, is_post_crash_launch);
 
-  // TODO(tmartino): If this is not process startup, attempt to restore
-  // asynchronously and return here. This logic is self-contained in
-  // SessionService and therefore can't be combined with the other Browser
-  // creation logic.
+  // If an async restore is necessary and is successfully kicked off, the
+  // remainder of the process is self-contained, so return.
+  if (MaybeAsyncRestore(tabs, process_startup, is_post_crash_launch))
+    return;
 
-  // TODO(tmartino): Function which determines what behavior of session
-  // restore, if any, is necessary, and passes the result to a new function
-  // which opens tabs in a restored or newly-created Browser accordingly.
-  // Incorporates code from ProcessStartupUrls.
+  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());
 
-  Browser* browser = OpenTabsInBrowser(nullptr, process_startup, tabs);
+  uint32_t 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_incognito,
+    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_incognito || 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 15 matching lines @@
   // including OS and whether or not this is First Run.
   StartupTabs onboarding_tabs = provider.GetOnboardingTabs();
   AppendTabs(onboarding_tabs, &tabs);
 
   // If the user has set the preference indicating URLs to show on opening,
   // read and add those.
   StartupTabs prefs_tabs = provider.GetPreferencesTabs(command_line_, profile_);
   AppendTabs(prefs_tabs, &tabs);
 
   // Potentially add the New Tab Page. Onboarding content is designed to
-  // replace (and eventually funnel the user to) the NTP. Likewise, URLs read
+  // replace (and eventually funnel the user to) the NTP. Likewise, URLs
   // from preferences are explicitly meant to override showing the NTP.
   if (onboarding_tabs.empty() && prefs_tabs.empty())
-    tabs.emplace_back(GURL(chrome::kChromeUINewTabURL), false);
+    AppendTabs(provider.GetNewTabPageTabs(command_line_, profile_), &tabs);
 
-  // Add any tabs which the user has previously pinned.
-  AppendTabs(provider.GetPinnedTabs(profile_), &tabs);
+  // Maybe add any tabs which the user has previously pinned.
+  AppendTabs(provider.GetPinnedTabs(command_line_, profile_), &tabs);
 
   return tabs;
 }
 
+bool StartupBrowserCreatorImpl::MaybeAsyncRestore(const StartupTabs& tabs,
+                                                  bool process_startup,
+                                                  bool is_post_crash_launch) {
+  // Restore is performed synchronously on startup, and is never performed when
+  // launching after crashing.
+  if (process_startup || is_post_crash_launch)
+    return false;
+
+  SessionService* service =
+      SessionServiceFactory::GetForProfileForSessionRestore(profile_);
+
+  // Service will be null in incognito and guest mode.
+  return (service && service->RestoreIfNecessary(TabsToUrls(tabs)));
+}
+
+Browser* StartupBrowserCreatorImpl::RestoreOrCreateBrowser(
+    const StartupTabs& tabs,
+    BrowserOpenBehavior behavior,
+    uint32_t 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);
+  }
+
+  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.
+  browser = OpenTabsInBrowser(
+      browser, process_startup,
+      (tabs.empty()
+           ? StartupTabs({StartupTab(GURL(chrome::kChromeUINewTabURL), false)})
+           : tabs));
+
+  StartupBrowserCreator::in_synchronous_profile_launch_ = false;
+
+  // 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_)
+        ->GetDOMStorageContext()
+        ->StartScavengingUnusedSessionStorage();
+  }
+
+  return browser;
+}
+
+// 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) {
+    // 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
+    // switch.
+    return (has_cmd_line_tabs && !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.
+    if (!is_post_crash_launch || has_restore_switch)
+      return BrowserOpenBehavior::SYNCHRONOUS_RESTORE;
+  }
+
+  return BrowserOpenBehavior::NEW;
+}
+
+// static
+uint32_t StartupBrowserCreatorImpl::DetermineSynchronousRestoreOptions(
+    bool has_create_browser_default,
+    bool has_create_browser_switch,
+    bool was_mac_login_or_resume) {
+  uint32_t options = SessionRestore::SYNCHRONOUS;
+
+  // 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 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;
+}
+
 void StartupBrowserCreatorImpl::AddUniqueURLs(const std::vector<GURL>& urls,
                                               StartupTabs* tabs) {
   size_t num_existing_tabs = tabs->size();
   for (size_t i = 0; i < urls.size(); ++i) {
     bool in_tabs = false;
     for (size_t j = 0; j < num_existing_tabs; ++j) {
       if (urls[i] == (*tabs)[j].url) {
         in_tabs = true;
         break;
       }
@@ skipping 393 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;
 }