Restoring a session should restore window minimization state

chrome/browser/sessions/session_restore.cc

 // Copyright (c) 2011 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 <algorithm>
 #include <list>
 #include <set>
 #include <vector>
@@ skipping 448 matching lines @@
   void RestoreForeignSession(
       std::vector<SessionWindow*>::const_iterator begin,
       std::vector<SessionWindow*>::const_iterator end) {
     StartTabCreation();
     // Create a browser instance to put the restored tabs in.
     for (std::vector<SessionWindow*>::const_iterator i = begin;
         i != end; ++i) {
       Browser* browser = CreateRestoredBrowser(
           static_cast<Browser::Type>((*i)->type),
           (*i)->bounds,
-          (*i)->is_maximized);
+          (*i)->show_state);
 
       // Restore and show the browser.
       const int initial_tab_count = browser->tab_count();
       int selected_tab_index = (*i)->selected_tab_index;
       RestoreTabsToBrowser(*(*i), browser, selected_tab_index);
       ShowBrowser(browser, initial_tab_count, selected_tab_index);
       tab_loader_->TabIsLoading(
           &browser->GetSelectedTabContents()->controller());
       NotifySessionServiceOfRestoredTabs(browser, initial_tab_count);
     }
@@ skipping 129 matching lines @@
         // The first set of tabs is added to the existing browser.
         browser = current_browser;
       } else {
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-CreateRestoredBrowser-Start", false);
 #endif
         browser = CreateRestoredBrowser(
             static_cast<Browser::Type>((*i)->type),
             (*i)->bounds,
-            (*i)->is_maximized);
+            (*i)->show_state);
 #if defined(OS_CHROMEOS)
     chromeos::BootTimesLoader::Get()->AddLoginTimeMarker(
         "SessionRestore-CreateRestoredBrowser-End", false);
 #endif
       }
       if ((*i)->type == Browser::TYPE_TABBED)
         last_browser = browser;
       TabContents* active_tab = browser->GetSelectedTabContents();
       int initial_tab_count = browser->tab_count();
       int selected_tab_index = (*i)->selected_tab_index;
@@ skipping 73 matching lines @@
                                 false,
                                 tab.pinned,
                                 true,
                                 NULL);
     if (schedule_load)
       tab_loader_->ScheduleLoad(&tab_contents->controller());
   }
 
   Browser* CreateRestoredBrowser(Browser::Type type,
                                  gfx::Rect bounds,
-                                 bool is_maximized) {
+                                 ui::WindowShowState show_state) {
     Browser* browser = new Browser(type, profile_);
     browser->set_override_bounds(bounds);
-    browser->set_maximized_state(is_maximized ?
-        Browser::MAXIMIZED_STATE_MAXIMIZED :
-        Browser::MAXIMIZED_STATE_UNMAXIMIZED);
+    browser->set_show_state(show_state);
     browser->InitBrowserWindow();
     return browser;
   }
 
   void ShowBrowser(Browser* browser,
                    int initial_tab_count,
                    int selected_session_index) {
     DCHECK(browser);
     DCHECK(browser->tab_count());
     browser->ActivateTabAt(
@@ skipping 125 matching lines @@
   std::vector<GURL> gurls;
   SessionRestoreImpl restorer(profile,
       static_cast<Browser*>(NULL), true, false, true, gurls);
   restorer.RestoreForeignTab(tab);
 }
 
 // static
 bool SessionRestore::IsRestoring() {
   return restoring;
 }