Restoring a session should restore window minimization state on Windows

views/widget/widget.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 "views/widget/widget.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "ui/base/l10n/l10n_font_util.h"
@@ skipping 83 matching lines @@
       delegate(NULL),
       child(false),
       transient(false),
       transparent(false),
       accept_events(true),
       can_activate(true),
       keep_on_top(false),
       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),
       native_widget(NULL),
       top_level(false) {
 }
 
 Widget::InitParams::InitParams(Type type)
     : type(type),
       delegate(NULL),
       child(type == TYPE_CONTROL),
       transient(type == TYPE_POPUP || type == TYPE_MENU),
       transparent(false),
       accept_events(true),
       can_activate(type != TYPE_POPUP && type != TYPE_MENU),
       keep_on_top(type == TYPE_MENU),
       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),
       native_widget(NULL),
       top_level(false) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, public:
 
 // static
 Widget::InitParams Widget::WindowInitParams() {
   return InitParams(InitParams::TYPE_WINDOW);
 }
 
 Widget::Widget()
     : is_mouse_button_pressed_(false),
       last_mouse_event_was_move_(false),
       native_widget_(NULL),
       widget_delegate_(NULL),
       non_client_view_(NULL),
       dragged_view_(NULL),
       event_stack_(),
       ownership_(InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       is_secondary_widget_(true),
       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),
-      destroy_state_(DESTROY_STATE_NONE) {
+      destroy_state_(DESTROY_STATE_NONE),
+      native_widget_created_(false) {
 }
 
 Widget::~Widget() {
   destroy_state_ = DESTROY_STATE_DELETED;
 
   while (!event_stack_.empty()) {
     event_stack_.top()->reset();
     event_stack_.pop();
   }
 
@@ skipping 131 matching lines @@
   }
   native_widget_->InitNativeWidget(params);
   if (params.type == InitParams::TYPE_WINDOW) {
     non_client_view_ = new NonClientView;
     non_client_view_->SetFrameView(CreateNonClientFrameView());
     // Create the ClientView, add it to the NonClientView and add the
     // NonClientView to the RootView. This will cause everything to be parented.
     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();
   }
 }
 
 // Unconverted methods (see header) --------------------------------------------
 
 gfx::NativeView Widget::GetNativeView() const {
    return native_widget_->GetNativeView();
 }
 
@@ skipping 113 matching lines @@
     // It appears we can hit this code path if you close a modal dialog then
     // close the last browser before the destructor is hit, which triggers
     // invoking Close again.
     return;
   }
 
   bool can_close = true;
   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
     // |FormManager::ViewRemoved()| calls are fouled.  We clear focus here
     // to avoid these redundant steps and to avoid accessing deleted views
     // that may have been in focus.
     if (is_top_level() && focus_manager_.get())
       focus_manager_->SetFocusedView(NULL);
 
     native_widget_->Close();
     widget_closed_ = true;
   }
 }
 
 void Widget::CloseNow() {
   native_widget_->CloseNow();
 }
 
 void Widget::EnableClose(bool enable) {
   if (non_client_view_)
     non_client_view_->EnableClose(enable);
   native_widget_->EnableClose(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();
   }
 }
 
 void Widget::Hide() {
   native_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() {
   native_widget_->Activate();
 }
 
 void Widget::Deactivate() {
   native_widget_->Deactivate();
 }
 
@@ skipping 303 matching lines @@
 }
 
 void Widget::EnableInactiveRendering() {
   disable_inactive_rendering_ = false;
   if (non_client_view_)
     non_client_view_->DisableInactiveRendering(false);
 }
 
 void Widget::OnNativeWidgetActivationChanged(bool active) {
   if (!active) {
-    SaveWindowPosition();
+    SaveWindowPlacement();
 
     // Close any open menus.
     MenuController* menu_controller = MenuController::GetActiveInstance();
     if (menu_controller)
       menu_controller->OnWidgetActivationChanged();
   }
 
   FOR_EACH_OBSERVER(Observer, observers_,
                     OnWidgetActivationChanged(this, active));
 }
@@ skipping 20 matching lines @@
   if (is_top_level())
     focus_manager_.reset(FocusManagerFactory::Create(this));
 
   native_widget_->SetAccessibleRole(
       widget_delegate_->GetAccessibleWindowRole());
   native_widget_->SetAccessibleState(
       widget_delegate_->GetAccessibleWindowState());
 
   if (widget_delegate_->IsModal())
     native_widget_->BecomeModal();
+
+  native_widget_created_ = true;
 }
 
 void Widget::OnNativeWidgetDestroying() {
   FOR_EACH_OBSERVER(Observer, observers_, OnWidgetClosing(this));
   if (destroy_state_ == DESTROY_STATE_NONE)
     destroy_state_ = DESTROY_STATE_IN_DESTROYING;
   if (non_client_view_)
     non_client_view_->WindowClosing();
   widget_delegate_->WindowClosing();
 }
 
 void Widget::OnNativeWidgetDestroyed() {
   if (destroy_state_ == DESTROY_STATE_IN_DESTROYING ||
       destroy_state_ == DESTROY_STATE_NONE)
     destroy_state_ = DESTROY_STATE_DESTROYED;
   widget_delegate_->DeleteDelegate();
   widget_delegate_ = NULL;
 }
 
 gfx::Size Widget::GetMinimumSize() {
   return non_client_view_ ? non_client_view_->GetMinimumSize() : gfx::Size();
 }
 
 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_created_)
+    SaveWindowPlacement();
 }
 
 void Widget::OnNativeWidgetBeginUserBoundsChange() {
   widget_delegate_->OnWindowBeginUserBoundsChange();
 }
 
 void Widget::OnNativeWidgetEndUserBoundsChange() {
   widget_delegate_->OnWindowEndUserBoundsChange();
 }
 
@@ skipping 149 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, private:
 
 // static
 ui::Compositor*(*Widget::compositor_factory_)() = NULL;
 
 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
   // bail.
   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) {
   if (!non_client_view_)
     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;
     } else {
       SetBounds(saved_bounds);
     }
   } else {
     if (bounds.IsEmpty()) {
       // No initial bounds supplied, so size the window to its content and
       // center over its parent.
       native_widget_->CenterWindow(non_client_view_->GetPreferredSize());
     } else {
       // Use the supplied initial bounds.
       SetBoundsConstrained(bounds, NULL);
     }
   }
 }
 
-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 {
       // Make sure the bounds are at least the minimum size.
       if (bounds->width() < minimum_size_.width())
         bounds->set_width(minimum_size_.width());
 
       if (bounds->height() < minimum_size_.height())
         bounds->set_height(minimum_size_.height());
     }
@@ skipping 16 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // internal::NativeWidgetPrivate, NativeWidget implementation:
 
 internal::NativeWidgetPrivate* NativeWidgetPrivate::AsNativeWidgetPrivate() {
   return this;
 }
 
 }  // namespace internal
 }  // namespace views