Restoring a session should restore window minimization state

chrome/browser/ui/views/frame/browser_view.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/views/frame/browser_view.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 765 matching lines @@
 }
 
 gfx::Rect BrowserView::GetBounds() const {
   return frame_->GetWindowScreenBounds();
 }
 
 bool BrowserView::IsMaximized() const {
   return frame_->IsMaximized();
 }
 
+bool BrowserView::IsMinimized() const {
+  // TODO(dhollowa): Add support for session restore of minimized state.
+  // http://crbug.com/43274
+  return false;
+}
+
 void BrowserView::SetFullscreen(bool fullscreen) {
   if (IsFullscreen() == fullscreen)
     return;  // Nothing to do.
 
 #if defined(OS_WIN)
   ProcessFullscreen(fullscreen);
 #else
   // On Linux changing fullscreen is async. Ask the window to change it's
   // fullscreen state, and when done invoke ProcessFullscreen.
   frame_->SetFullscreen(fullscreen);
@@ skipping 820 matching lines @@
 
   return browser_->ExecuteCommandIfEnabled(command_id);
 }
 
 std::wstring BrowserView::GetWindowName() const {
   return UTF8ToWide(browser_->GetWindowPlacementKey());
 }
 
 void BrowserView::SaveWindowPlacement(const gfx::Rect& bounds,
                                       bool maximized) {
+  // TODO(dhollowa): Add support for session restore of minimized state.
+  // http://crbug.com/43274
+
   // If IsFullscreen() is true, we've just changed into fullscreen mode, and
   // we're catching the going-into-fullscreen sizing and positioning calls,
   // which we want to ignore.
   if (!IsFullscreen() && browser_->ShouldSaveWindowPlacement()) {
     WidgetDelegate::SaveWindowPlacement(bounds, maximized);
-    browser_->SaveWindowPlacement(bounds, maximized);
+    browser_->SaveWindowPlacement(bounds,
+                                  maximized ? ui::SHOW_STATE_MAXIMIZED :
+                                              ui::SHOW_STATE_NORMAL);
   }
 }
 
 bool BrowserView::GetSavedWindowBounds(gfx::Rect* bounds) const {
   *bounds = browser_->GetSavedWindowBounds();
   if (browser_->is_type_popup() || browser_->is_type_panel()) {
     // We are a popup window. The value passed in |bounds| represents two
     // pieces of information:
     // - the position of the window, in screen coordinates (outer position).
     // - the size of the content area (inner size).
@@ skipping 23 matching lines @@
   }
 
   // We return true because we can _always_ locate reasonable bounds using the
   // WindowSizer, and we don't want to trigger the Window's built-in "size to
   // default" handling because the browser window has no default preferred
   // size.
   return true;
 }
 
 bool BrowserView::GetSavedMaximizedState(bool* maximized) const {
-  *maximized = browser_->GetSavedMaximizedState();
+  // TODO(dhollowa): Add support for session restore of minimized state.
+  // http://crbug.com/43274
+  *maximized = browser_->GetSavedWindowShowState() == ui::SHOW_STATE_MAXIMIZED;
   return true;
 }
 
 views::View* BrowserView::GetContentsView() {
   return contents_container_;
 }
 
 views::ClientView* BrowserView::CreateClientView(views::Widget* widget) {
   return this;
 }
@@ skipping 978 matching lines @@
 BrowserWindow* BrowserWindow::CreateBrowserWindow(Browser* browser) {
   // Create the view and the frame. The frame will attach itself via the view
   // so we don't need to do anything with the pointer.
   BrowserView* view = new BrowserView(browser);
   (new BrowserFrame(view))->InitBrowserFrame();
   view->GetWidget()->non_client_view()->SetAccessibleName(
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
   return view;
 }
 #endif