Restoring a session should restore window minimization state

chrome/browser/ui/browser.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/ui/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 229 matching lines @@
     : type_(type),
       profile_(profile),
       window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_handler_(TabHandler::CreateTabHandler(this))),
       command_updater_(this),
       toolbar_model_(this),
       chrome_updater_factory_(this),
       is_attempting_to_close_browser_(false),
       cancel_download_confirmation_state_(NOT_PROMPTED),
-      maximized_state_(MAXIMIZED_STATE_DEFAULT),
+      show_state_(ui::SHOW_STATE_DEFAULT),
       method_factory_(this),
       block_command_execution_(false),
       last_blocked_command_id_(-1),
       last_blocked_command_disposition_(CURRENT_TAB),
       pending_web_app_action_(NONE),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           tab_restore_service_delegate_(
               new BrowserTabRestoreServiceDelegate(this))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           synced_window_delegate_(
@@ skipping 583 matching lines @@
       // or the window belongs to DevTools.
       return browser_defaults::kRestorePopups || is_devtools();
     case TYPE_PANEL:
       // Do not save the window placement of panels.
       return false;
     default:
       return false;
   }
 }
 
-void Browser::SaveWindowPlacement(const gfx::Rect& bounds, bool maximized) {
+void Browser::SaveWindowPlacement(const gfx::Rect& bounds,
+                                  ui::WindowShowState show_state) {
   // Save to the session storage service, used when reloading a past session.
   // Note that we don't want to be the ones who cause lazy initialization of
   // the session service. This function gets called during initial window
   // showing, and we don't want to bring in the session service this early.
   SessionService* session_service =
       SessionServiceFactory::GetForProfileIfExisting(profile());
   if (session_service)
-    session_service->SetWindowBounds(session_id_, bounds, maximized);
+    session_service->SetWindowBounds(session_id_, bounds, show_state);
 }
 
 gfx::Rect Browser::GetSavedWindowBounds() const {
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   bool record_mode = parsed_command_line.HasSwitch(switches::kRecordMode);
   bool playback_mode = parsed_command_line.HasSwitch(switches::kPlaybackMode);
   if (record_mode || playback_mode) {
     // In playback/record mode we always fix the size of the browser and
     // move it to (0,0).  The reason for this is two reasons:  First we want
     // resize/moves in the playback to still work, and Second we want
     // playbacks to work (as much as possible) on machines w/ different
     // screen sizes.
     return gfx::Rect(0, 0, 800, 600);
   }
 
   gfx::Rect restored_bounds = override_bounds_;
   bool maximized;
   WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, this,
                                       &restored_bounds, &maximized);
   return restored_bounds;
 }
 
 // TODO(beng): obtain maximized state some other way so we don't need to go
 //             through all this hassle.
-bool Browser::GetSavedMaximizedState() const {
+ui::WindowShowState Browser::GetSavedWindowShowState() const {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kStartMaximized))
-    return true;
+    return ui::SHOW_STATE_MAXIMIZED;
 
-  if (maximized_state_ == MAXIMIZED_STATE_MAXIMIZED)
-    return true;
-  if (maximized_state_ == MAXIMIZED_STATE_UNMAXIMIZED)
-    return false;
+  if (show_state_ != ui::SHOW_STATE_DEFAULT)
+    return show_state_;
 
   // An explicit maximized state was not set. Query the window sizer.
   gfx::Rect restored_bounds;
   bool maximized = false;
   WindowSizer::GetBrowserWindowBounds(app_name_, restored_bounds, this,
                                       &restored_bounds, &maximized);
-  return maximized;
+  return maximized ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL;
 }
 
 SkBitmap Browser::GetCurrentPageIcon() const {
   TabContentsWrapper* contents = GetSelectedTabContentsWrapper();
   // |contents| can be NULL since GetCurrentPageIcon() is called by the window
   // during the window's creation (before tabs have been added).
   return contents ? contents->favicon_tab_helper()->GetFavicon() : SkBitmap();
 }
 
 string16 Browser::GetWindowTitleForCurrentTab() const {
@@ skipping 1799 matching lines @@
     bool maximize) {
   DCHECK(CanSupportWindowFeature(FEATURE_TABSTRIP));
 
   gfx::Rect new_window_bounds = window_bounds;
   if (dock_info.GetNewWindowBounds(&new_window_bounds, &maximize))
     dock_info.AdjustOtherWindowBounds();
 
   // Create an empty new browser window the same size as the old one.
   Browser* browser = new Browser(TYPE_TABBED, profile_);
   browser->set_override_bounds(new_window_bounds);
-  browser->set_maximized_state(
-      maximize ? MAXIMIZED_STATE_MAXIMIZED : MAXIMIZED_STATE_UNMAXIMIZED);
+  browser->set_show_state(
+      maximize ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL);
   browser->InitBrowserWindow();
   browser->tabstrip_model()->AppendTabContents(detached_contents, true);
   // Make sure the loading state is updated correctly, otherwise the throbber
   // won't start if the page is loading.
   browser->LoadingStateChanged(detached_contents->tab_contents());
   return browser;
 }
 
 int Browser::GetDragActions() const {
   return TabStripModelDelegate::TAB_TEAROFF_ACTION | (tab_count() > 1 ?
@@ skipping 2142 matching lines @@
 }
 
 void Browser::ShowSyncSetup() {
   ProfileSyncService* service =
       profile()->GetOriginalProfile()->GetProfileSyncService();
   if (service->HasSyncSetupCompleted())
     ShowOptionsTab(chrome::kSyncSetupSubPage);
   else
     service->ShowLoginDialog();
 }