Restoring a session should restore window minimization state on Windows

views/widget/widget.cc

Index: views/widget/widget.cc
diff --git a/views/widget/widget.cc b/views/widget/widget.cc
index 80ca73d7413fc1f87f386ceede1ed83330e3accb..8ed6c8d724acab94f1a18a45af72dbd9cdc51554 100644
--- a/views/widget/widget.cc
+++ b/views/widget/widget.cc
@@ -109,7 +109,7 @@ Widget::InitParams::InitParams()
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
-      maximize(false),
+      show_state(ui::SHOW_STATE_DEFAULT),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
@@ -129,7 +129,7 @@ Widget::InitParams::InitParams(Type type)
       ownership(NATIVE_WIDGET_OWNS_WIDGET),
       mirror_origin_in_rtl(false),
       has_dropshadow(false),
-      maximize(false),
+      show_state(ui::SHOW_STATE_DEFAULT),
       double_buffer(false),
       parent(NULL),
       parent_widget(NULL),
@@ -158,10 +158,11 @@ Widget::Widget()
       frame_type_(FRAME_TYPE_DEFAULT),
       disable_inactive_rendering_(false),
       widget_closed_(false),
-      saved_maximized_state_(false),
+      saved_show_state_(ui::SHOW_STATE_DEFAULT),
       minimum_size_(100, 100),
       focus_on_creation_(true),
-      is_top_level_(false) {
+      is_top_level_(false),
+      native_widget_initialized_(false) {
 }
 
 Widget::~Widget() {
@@ -311,10 +312,13 @@ void Widget::Init(const InitParams& params) {
     non_client_view_->set_client_view(widget_delegate_->CreateClientView(this));
     SetContentsView(non_client_view_);
     SetInitialBounds(params.bounds);
-    if (params.maximize)
+    if (params.show_state == ui::SHOW_STATE_MAXIMIZED)
       Maximize();
+    else if (params.show_state == ui::SHOW_STATE_MINIMIZED)
+      Minimize();
     UpdateWindowTitle();
   }
+  native_widget_initialized_ = true;
 }
 
 // Unconverted methods (see header) --------------------------------------------
@@ -446,7 +450,7 @@ void Widget::Close() {
   if (non_client_view_)
     can_close = non_client_view_->CanClose();
   if (can_close) {
-    SaveWindowPosition();
+    SaveWindowPlacement();
 
     // During tear-down the top-level focus manager becomes unavailable to
     // GTK tabbed panes and their children, so normal deregistration via
@@ -473,17 +477,16 @@ void Widget::EnableClose(bool enable) {
 
 void Widget::Show() {
   if (non_client_view_) {
-    if (saved_maximized_state_ && !initial_restored_bounds_.IsEmpty()) {
+    if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED &&
+        !initial_restored_bounds_.IsEmpty()) {
       native_widget_->ShowMaximizedWithBounds(initial_restored_bounds_);
     } else {
-      native_widget_->ShowWithState(saved_maximized_state_ ?
-          internal::NativeWidgetPrivate::SHOW_MAXIMIZED :
-          internal::NativeWidgetPrivate::SHOW_RESTORED);
+      native_widget_->ShowWithWindowState(saved_show_state_);
     }
-    // |saved_maximized_state_| only applies the first time the window is shown.
-    // If we don't reset the value the window will be shown maximized every time
+    // |saved_show_state_| only applies the first time the window is shown.
+    // If we don't reset the value the window may be shown maximized every time
     // it is subsequently shown after being hidden.
-    saved_maximized_state_ = false;
+    saved_show_state_ = ui::SHOW_STATE_NORMAL;
   } else {
     native_widget_->Show();
   }
@@ -494,14 +497,16 @@ void Widget::Hide() {
 }
 
 void Widget::ShowInactive() {
-  // If this gets called with saved_maximized_state_ == true, call SetBounds()
-  // with the restored bounds to set the correct size. This normally should
-  // not happen, but if it does we should avoid showing unsized windows.
-  if (saved_maximized_state_ && !initial_restored_bounds_.IsEmpty()) {
+  // If this gets called with saved_show_state_ == ui::SHOW_STATE_MAXIMIZED,
+  // call SetBounds()with the restored bounds to set the correct size. This
+  // normally should not happen, but if it does we should avoid showing unsized
+  // windows.
+  if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED &&
+      !initial_restored_bounds_.IsEmpty()) {
     SetBounds(initial_restored_bounds_);
-    saved_maximized_state_ = false;
+    saved_show_state_ = ui::SHOW_STATE_NORMAL;
   }
-  native_widget_->ShowWithState(internal::NativeWidgetPrivate::SHOW_INACTIVE);
+  native_widget_->ShowWithWindowState(ui::SHOW_STATE_INACTIVE);
 }
 
 void Widget::Activate() {
@@ -825,7 +830,7 @@ void Widget::EnableInactiveRendering() {
 
 void Widget::OnNativeWidgetActivationChanged(bool active) {
   if (!active) {
-    SaveWindowPosition();
+    SaveWindowPlacement();
 
     // Close any open menus.
     MenuController* menu_controller = MenuController::GetActiveInstance();
@@ -886,6 +891,12 @@ gfx::Size Widget::GetMinimumSize() {
 
 void Widget::OnNativeWidgetSizeChanged(const gfx::Size& new_size) {
   root_view_->SetSize(new_size);
+
+  // Size changed notifications can fire prior to full initialization
+  // i.e. during session restore.  Avoid saving session state during these
+  // startup procedures.
+  if (native_widget_initialized_)
+    SaveWindowPlacement();
 }
 
 void Widget::OnNativeWidgetBeginUserBoundsChange() {
@@ -1055,7 +1066,7 @@ bool Widget::ShouldReleaseCaptureOnMouseReleased() const {
   return true;
 }
 
-void Widget::SaveWindowPosition() {
+void Widget::SaveWindowPlacement() {
   // The window delegate does the actual saving for us. It seems like (judging
   // by go/crash) that in some circumstances we can end up here after
   // WM_DESTROY, at which point the window delegate is likely gone. So just
@@ -1063,10 +1074,10 @@ void Widget::SaveWindowPosition() {
   if (!widget_delegate_)
     return;
 
-  bool maximized = false;
+  ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
   gfx::Rect bounds;
-  native_widget_->GetWindowBoundsAndMaximizedState(&bounds, &maximized);
-  widget_delegate_->SaveWindowPlacement(bounds, maximized);
+  native_widget_->GetWindowPlacement(&bounds, &show_state);
+  widget_delegate_->SaveWindowPlacement(bounds, show_state);
 }
 
 void Widget::SetInitialBounds(const gfx::Rect& bounds) {
@@ -1074,8 +1085,8 @@ void Widget::SetInitialBounds(const gfx::Rect& bounds) {
     return;
 
   gfx::Rect saved_bounds;
-  if (GetSavedBounds(&saved_bounds, &saved_maximized_state_)) {
-    if (saved_maximized_state_) {
+  if (GetSavedWindowPlacement(&saved_bounds, &saved_show_state_)) {
+    if (saved_show_state_ == ui::SHOW_STATE_MAXIMIZED) {
       // If we're going to maximize, wait until Show is invoked to set the
       // bounds. That way we avoid a noticable resize.
       initial_restored_bounds_ = saved_bounds;
@@ -1094,17 +1105,17 @@ void Widget::SetInitialBounds(const gfx::Rect& bounds) {
   }
 }
 
-bool Widget::GetSavedBounds(gfx::Rect* bounds, bool* maximize) {
+bool Widget::GetSavedWindowPlacement(gfx::Rect* bounds,
+                                     ui::WindowShowState* show_state) {
   // First we obtain the window's saved show-style and store it. We need to do
   // this here, rather than in Show() because by the time Show() is called,
   // the window's size will have been reset (below) and the saved maximized
   // state will have been lost. Sadly there's no way to tell on Windows when
   // a window is restored from maximized state, so we can't more accurately
   // track maximized state independently of sizing information.
-  widget_delegate_->GetSavedMaximizedState(maximize);
 
   // Restore the window's placement from the controller.
-  if (widget_delegate_->GetSavedWindowBounds(bounds)) {
+  if (widget_delegate_->GetSavedWindowPlacement(bounds, show_state)) {
     if (!widget_delegate_->ShouldRestoreWindowSize()) {
       bounds->set_size(non_client_view_->GetPreferredSize());
     } else {