Remove HostDesktopType from Browser::CreateParams

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 67 matching lines @@
 
 // SessionRestoreImpl ---------------------------------------------------------
 
 // SessionRestoreImpl is responsible for fetching the set of tabs to create
 // from SessionService. SessionRestoreImpl deletes itself when done.
 
 class SessionRestoreImpl : public content::NotificationObserver {
  public:
   SessionRestoreImpl(Profile* profile,
                      Browser* browser,
-                     chrome::HostDesktopType host_desktop_type,
                      bool synchronous,
                      bool clobber_existing_tab,
                      bool always_create_tabbed_browser,
                      const std::vector<GURL>& urls_to_open,
                      SessionRestore::CallbackList* callbacks)
       : profile_(profile),
         browser_(browser),
-        host_desktop_type_(host_desktop_type),
         synchronous_(synchronous),
         clobber_existing_tab_(clobber_existing_tab),
         always_create_tabbed_browser_(always_create_tabbed_browser),
         urls_to_open_(urls_to_open),
         active_window_id_(0),
         restore_started_(base::TimeTicks::Now()),
         on_session_restored_callbacks_(callbacks) {
-    // For sanity's sake, if |browser| is non-null: force |host_desktop_type| to
-    // be the same as |browser|'s desktop type.
-    DCHECK(!browser || browser->host_desktop_type() == host_desktop_type);
-
     if (active_session_restorers == nullptr)
       active_session_restorers = new std::set<SessionRestoreImpl*>();
 
     // Only one SessionRestoreImpl should be operating on the profile at the
     // same time.
     std::set<SessionRestoreImpl*>::const_iterator it;
     for (it = active_session_restorers->begin();
          it != active_session_restorers->end(); ++it) {
       if ((*it)->profile_ == profile)
         break;
@@ skipping 83 matching lines @@
     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 == NEW_WINDOW;
 
     Browser* browser =
         use_new_window
-            ? new Browser(Browser::CreateParams(profile_, host_desktop_type_))
+            ? new Browser(Browser::CreateParams(profile_))
             : browser_;
 
     RecordAppLaunchForTab(browser, tab, selected_index);
 
     WebContents* web_contents;
     if (disposition == 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 61 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_, host_desktop_type_));
+      browser = new Browser(Browser::CreateParams(profile_));
       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 318 matching lines @@
     // focused tab will be loaded by Browser, and TabLoader will load the rest.
     DCHECK(web_contents->GetController().NeedsReload());
 
     return web_contents;
   }
 
   Browser* CreateRestoredBrowser(Browser::Type type,
                                  gfx::Rect bounds,
                                  ui::WindowShowState show_state,
                                  const std::string& app_name) {
-    Browser::CreateParams params(type, profile_, host_desktop_type_);
+    Browser::CreateParams params(type, profile_);
     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_, host_desktop_type_);
+      params = Browser::CreateParams::CreateForApp(app_name, trusted_source,
+                                                   bounds, profile_);
     } else {
       params.initial_bounds = bounds;
     }
     params.initial_show_state = show_state;
     params.is_session_restore = true;
     return new Browser(params);
   }
 
   void ShowBrowser(Browser* browser, int selected_tab_index) {
     DCHECK(browser);
@@ skipping 37 matching lines @@
       session_service->TabRestored(tab_strip->GetWebContentsAt(i),
                                    tab_strip->IsTabPinned(i));
   }
 
   // The profile to create the sessions for.
   Profile* profile_;
 
   // The first browser to restore to, may be null.
   Browser* browser_;
 
-  // The desktop on which all new browsers should be created (browser_, if it is
-  // not NULL, must be of this desktop type as well).
-  chrome::HostDesktopType host_desktop_type_;
-
   // Whether or not restore is synchronous.
   const bool synchronous_;
 
   // The quit-closure to terminate the nested message-loop started for
   // synchronous session-restore.
   base::Closure quit_closure_for_sync_restore_;
 
   // See description of CLOBBER_CURRENT_TAB.
   const bool clobber_existing_tab_;
 
@@ skipping 30 matching lines @@
 };
 
 }  // namespace
 
 // SessionRestore -------------------------------------------------------------
 
 // static
 Browser* SessionRestore::RestoreSession(
     Profile* profile,
     Browser* browser,
-    chrome::HostDesktopType host_desktop_type,
     uint32_t behavior,
     const std::vector<GURL>& urls_to_open) {
 #if defined(OS_CHROMEOS)
   chromeos::BootTimesRecorder::Get()->AddLoginTimeMarker(
       "SessionRestore-Start", false);
 #endif
   DCHECK(profile);
   // Always restore from the original profile (incognito profiles have no
   // session service).
   profile = profile->GetOriginalProfile();
   if (!SessionServiceFactory::GetForProfile(profile)) {
     NOTREACHED();
     return nullptr;
   }
   profile->set_restored_last_session(true);
   // SessionRestoreImpl takes care of deleting itself when done.
   SessionRestoreImpl* restorer = new SessionRestoreImpl(
-      profile, browser, host_desktop_type, (behavior & SYNCHRONOUS) != 0,
+      profile, browser, (behavior & SYNCHRONOUS) != 0,
       (behavior & CLOBBER_CURRENT_TAB) != 0,
-      (behavior & ALWAYS_CREATE_TABBED_BROWSER) != 0,
-      urls_to_open,
+      (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() == GURL(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;
     }
   }
-  SessionRestore::RestoreSession(browser->profile(), browser,
-                                 browser->host_desktop_type(), behavior,
+  SessionRestore::RestoreSession(browser->profile(), browser, behavior,
                                  std::vector<GURL>());
 }
 
 // static
 std::vector<Browser*> SessionRestore::RestoreForeignSessionWindows(
     Profile* profile,
-    chrome::HostDesktopType host_desktop_type,
     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),
-                              host_desktop_type, true, false, true, gurls,
+  SessionRestoreImpl restorer(profile, static_cast<Browser*>(nullptr), true,
+                              false, true, gurls,
                               on_session_restored_callbacks());
   return restorer.RestoreForeignSession(begin, end);
 }
 
 // static
 WebContents* SessionRestore::RestoreForeignSessionTab(
     content::WebContents* source_web_contents,
     const sessions::SessionTab& tab,
     WindowOpenDisposition disposition) {
   Browser* browser = chrome::FindBrowserWithWebContents(source_web_contents);
   Profile* profile = browser->profile();
   std::vector<GURL> gurls;
-  SessionRestoreImpl restorer(profile, browser, browser->host_desktop_type(),
-                              true, false, false, gurls,
+  SessionRestoreImpl restorer(profile, browser, true, false, false, gurls,
                               on_session_restored_callbacks());
   return restorer.RestoreForeignTab(tab, disposition);
 }
 
 // static
 bool SessionRestore::IsRestoring(const Profile* profile) {
   if (active_session_restorers == nullptr)
     return false;
   for (std::set<SessionRestoreImpl*>::const_iterator it =
            active_session_restorers->begin();
@@ skipping 20 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;