Offer to open the startup pages after a crash.

chrome/browser/sessions/session_restore.cc

 // Copyright 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/sessions/session_restore.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 13 matching lines @@
 #include "base/metrics/histogram_macros.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/lifetime/keep_alive_types.h"
 #include "chrome/browser/lifetime/scoped_keep_alive.h"
+#include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/sessions/session_restore_delegate.h"
 #include "chrome/browser/sessions/session_service.h"
 #include "chrome/browser/sessions/session_service_factory.h"
 #include "chrome/browser/sessions/session_service_utils.h"
 #include "chrome/browser/sessions/tab_loader.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_navigator.h"
@@ skipping 216 matching lines @@
         return;
 
       default:
         NOTREACHED();
         break;
     }
   }
 
   Profile* profile() { return profile_; }
 
+  // Appends the urls in |urls| to |browser|.
+  static void AppendURLsToBrowser(Browser* browser,

[Georges Khalil, 2017/01/24 17:18:29]

nit: I would simply move this outside of the class instead of making it static.

[MAD, 2017/01/24 18:24:18]

Done.

+                                  const std::vector<GURL>& urls) {
+    for (size_t i = 0; i < urls.size(); ++i) {
+      int add_types = TabStripModel::ADD_FORCE_INDEX;
+      if (i == 0)
+        add_types |= TabStripModel::ADD_ACTIVE;
+      chrome::NavigateParams params(browser, urls[i],
+                                    ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
+      params.disposition = i == 0 ? WindowOpenDisposition::NEW_FOREGROUND_TAB
+                                  : WindowOpenDisposition::NEW_BACKGROUND_TAB;
+      params.tabstrip_add_types = add_types;
+      chrome::Navigate(&params);
+    }
+  }
+
  private:
   // Invoked when done with creating all the tabs/browsers.
   //
   // |created_tabbed_browser| indicates whether a tabbed browser was created,
   // or we used an existing tabbed browser.
   //
   // If successful, this begins loading tabs and deletes itself when all tabs
   // have been loaded.
   //
   // Returns the Browser that was created, if any.
@@ skipping 362 matching lines @@
       return;
 
     browser->window()->Show();
     browser->set_is_session_restore(false);
 
     // TODO(jcampan): http://crbug.com/8123 we should not need to set the
     //                initial focus explicitly.
     browser->tab_strip_model()->GetActiveWebContents()->SetInitialFocus();
   }
 
-  // Appends the urls in |urls| to |browser|.
-  void AppendURLsToBrowser(Browser* browser, const std::vector<GURL>& urls) {
-    for (size_t i = 0; i < urls.size(); ++i) {
-      int add_types = TabStripModel::ADD_FORCE_INDEX;
-      if (i == 0)
-        add_types |= TabStripModel::ADD_ACTIVE;
-      chrome::NavigateParams params(browser, urls[i],
-                                    ui::PAGE_TRANSITION_AUTO_TOPLEVEL);
-      params.disposition = i == 0 ? WindowOpenDisposition::NEW_FOREGROUND_TAB
-                                  : WindowOpenDisposition::NEW_BACKGROUND_TAB;
-      params.tabstrip_add_types = add_types;
-      chrome::Navigate(&params);
-    }
-  }
-
   // Invokes TabRestored on the SessionService for all tabs in browser after
   // initial_count.
   void NotifySessionServiceOfRestoredTabs(Browser* browser, int initial_count) {
     SessionService* session_service =
         SessionServiceFactory::GetForProfile(profile_);
     if (!session_service)
       return;
     TabStripModel* tab_strip = browser->tab_strip_model();
     for (int i = initial_count; i < tab_strip->count(); ++i)
       session_service->TabRestored(tab_strip->GetWebContentsAt(i),
@@ skipping 46 matching lines @@
 
   // The time we started the restore.
   base::TimeTicks restore_started_;
 
   // List of callbacks for session restore notification.
   SessionRestore::CallbackList* on_session_restored_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(SessionRestoreImpl);
 };
 
+bool HasSingleNewTabPage(Browser* browser) {
+  if (browser->tab_strip_model()->count() == 1) {

[Georges Khalil, 2017/01/24 17:18:29]

nit: I would invert logic to make this slightly clearer (fail-fast).

[MAD, 2017/01/24 18:24:18]

Done.

+    const content::WebContents* active_tab =
+        browser->tab_strip_model()->GetWebContentsAt(0);
+    return active_tab->GetURL() == chrome::kChromeUINewTabURL ||
+           search::IsInstantNTP(active_tab);
+  }
+  return false;
+}
+
 }  // namespace
 
 // SessionRestore -------------------------------------------------------------
 
 // static
 Browser* SessionRestore::RestoreSession(
     Profile* profile,
     Browser* browser,
     uint32_t behavior,
     const std::vector<GURL>& urls_to_open) {
@@ skipping 14 matching lines @@
   SessionRestoreImpl* restorer = new SessionRestoreImpl(
       profile, browser, (behavior & SYNCHRONOUS) != 0,
       (behavior & CLOBBER_CURRENT_TAB) != 0,
       (behavior & ALWAYS_CREATE_TABBED_BROWSER) != 0, urls_to_open,
       SessionRestore::on_session_restored_callbacks());
   return restorer->Restore();
 }
 
 // static
 void SessionRestore::RestoreSessionAfterCrash(Browser* browser) {
-  uint32_t behavior = 0;
-  if (browser->tab_strip_model()->count() == 1) {
-    const content::WebContents* active_tab =
-        browser->tab_strip_model()->GetWebContentsAt(0);
-    if (active_tab->GetURL() == chrome::kChromeUINewTabURL ||
-        search::IsInstantNTP(active_tab)) {
-      // There is only one tab and its the new tab page, make session restore
-      // clobber it.
-      behavior = SessionRestore::CLOBBER_CURRENT_TAB;
-    }
-  }
+  uint32_t behavior =
+      HasSingleNewTabPage(browser) ? SessionRestore::CLOBBER_CURRENT_TAB : 0;
   SessionRestore::RestoreSession(browser->profile(), browser, behavior,
                                  std::vector<GURL>());
 }
 
 // static
+void SessionRestore::OpenStartupPagesAfterCrash(Browser* browser) {
+  WebContents* tab_to_clobber = nullptr;
+  if (HasSingleNewTabPage(browser))
+    tab_to_clobber = browser->tab_strip_model()->GetActiveWebContents();
+
+  SessionRestoreImpl::AppendURLsToBrowser(
+      browser, SessionStartupPref::GetStartupPref(browser->profile()).urls);
+  if (tab_to_clobber)
+    chrome::CloseWebContents(browser, tab_to_clobber, true);
+}
+
+// static
 std::vector<Browser*> SessionRestore::RestoreForeignSessionWindows(
     Profile* profile,
     std::vector<const sessions::SessionWindow*>::const_iterator begin,
     std::vector<const sessions::SessionWindow*>::const_iterator end) {
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile, static_cast<Browser*>(nullptr), true,
                               false, true, gurls,
                               on_session_restored_callbacks());
   return restorer.RestoreForeignSession(begin, end);
 }
@@ skipping 40 matching lines @@
 // static
 SessionRestore::CallbackSubscription
     SessionRestore::RegisterOnSessionRestoredCallback(
         const base::Callback<void(int)>& callback) {
   return on_session_restored_callbacks()->Add(callback);
 }
 
 // static
 base::CallbackList<void(int)>*
     SessionRestore::on_session_restored_callbacks_ = nullptr;