Force guest profiles to return default startup prefs.

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 68 matching lines @@
 
 bool HasSingleNewTabPage(Browser* browser) {
   if (browser->tab_strip_model()->count() != 1)
     return false;
   const content::WebContents* active_tab =
       browser->tab_strip_model()->GetWebContentsAt(0);
   return active_tab->GetURL() == chrome::kChromeUINewTabURL ||
          search::IsInstantNTP(active_tab);
 }
 
+Profile* SafeProfileForNewWindows(Profile* profile) {
+  // Guest sessions must always be OffTheRecord when opening windows.
+  return profile->IsGuestSession() ? profile->GetOffTheRecordProfile()

[sky, 2017/06/07 19:21:40]

I'm a little confused by this, and forgive me because I couldn't readily find
docs for guest mode. It's my understanding that when you exit guest mode we
throw everything away. If that's the case, why and how are we triggering session
restore of a guest session? Shouldn't all the data be temporary? If it's because
of a crash and parts of the guest session were left around, shouldn't we clean
them up and not attempt a restore?

[shrike, 2017/06/07 20:19:05]

Gosh, I wish could even start to comment. I know nothing about all this stuff,
but was mirroring a similar change I made in
https://codereview.chromium.org/2899313005 to fix a different set of crashers.

The following crash seems to show that somehow the condition I'm trying to guard
against can happen (which it sounds like you're saying should not happen):

https://crash.corp.google.com/browse?q=product.name%3D%27Chrome_Mac%27%20AND%...

+                                   : profile;
+}
+
 class SessionRestoreImpl;
 
 // Pointers to SessionRestoreImpls which are currently restoring the session.
 std::set<SessionRestoreImpl*>* active_session_restorers = nullptr;
 
 // SessionRestoreImpl ---------------------------------------------------------
 
 // SessionRestoreImpl is responsible for fetching the set of tabs to create
 // from SessionService. SessionRestoreImpl deletes itself when done.
 
@@ skipping 108 matching lines @@
                                  WindowOpenDisposition disposition) {
     DCHECK(!tab.navigations.empty());
     int selected_index = tab.current_navigation_index;
     selected_index = std::max(
         0,
         std::min(selected_index, static_cast<int>(tab.navigations.size() - 1)));
 
     bool use_new_window = disposition == WindowOpenDisposition::NEW_WINDOW;
 
     Browser* browser = use_new_window
-                           ? new Browser(Browser::CreateParams(profile_, true))
+                           ? new Browser(Browser::CreateParams(
+                                 SafeProfileForNewWindows(profile_), true))
                            : browser_;
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     WebContents* web_contents;
     if (disposition == WindowOpenDisposition::CURRENT_TAB) {
       DCHECK(!use_new_window);
       web_contents = chrome::ReplaceRestoredTab(
           browser, tab.navigations, selected_index, true, tab.extension_app_id,
           nullptr, tab.user_agent_override);
@@ skipping 57 matching lines @@
   //
   // If successful, this begins loading tabs and deletes itself when all tabs
   // have been loaded.
   //
   // Returns the Browser that was created, if any.
   Browser* FinishedTabCreation(bool succeeded,
                                bool created_tabbed_browser,
                                std::vector<RestoredTab>* contents_created) {
     Browser* browser = nullptr;
     if (!created_tabbed_browser && always_create_tabbed_browser_) {
-      browser = new Browser(Browser::CreateParams(profile_, false));
+      browser = new Browser(
+          Browser::CreateParams(SafeProfileForNewWindows(profile_), false));
       if (urls_to_open_.empty()) {
         // No tab browsers were created and no URLs were supplied on the command
         // line. Open the new tab page.
         urls_to_open_.push_back(GURL(chrome::kChromeUINewTabURL));
       }
       AppendURLsToBrowser(browser, urls_to_open_);
       browser->window()->Show();
     }
 
     if (succeeded) {
@@ skipping 316 matching lines @@
     DCHECK(web_contents->GetController().NeedsReload());
 
     return web_contents;
   }
 
   Browser* CreateRestoredBrowser(Browser::Type type,
                                  gfx::Rect bounds,
                                  const std::string& workspace,
                                  ui::WindowShowState show_state,
                                  const std::string& app_name) {
-    Browser::CreateParams params(type, profile_, false);
+    Profile* profile = SafeProfileForNewWindows(profile_);
+    Browser::CreateParams params(type, profile, false);
     if (!app_name.empty()) {
       const bool trusted_source = true;  // We only store trusted app windows.
       params = Browser::CreateParams::CreateForApp(app_name, trusted_source,
-                                                   bounds, profile_, false);
+                                                   bounds, profile, false);
     } else {
       params.initial_bounds = bounds;
     }
     params.initial_show_state = show_state;
     params.initial_workspace = workspace;
     params.is_session_restore = true;
     return new Browser(params);
   }
 
   void ShowBrowser(Browser* browser, int selected_tab_index) {
@@ skipping 197 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;