Restoring a session should restore window minimization state on Windows

views/widget/native_widget_win.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/native_widget_win.h"
 
 #include <dwmapi.h>
 #include <shellapi.h>
 
 #include "base/string_util.h"
@@ skipping 619 matching lines @@
   return NULL;
 }
 
 void NativeWidgetWin::CenterWindow(const gfx::Size& size) {
   HWND parent = GetParent();
   if (!IsWindow())
     parent = ::GetWindow(GetNativeView(), GW_OWNER);
   ui::CenterAndSizeWindow(parent, GetNativeView(), size, false);
 }
 
-void NativeWidgetWin::GetWindowBoundsAndMaximizedState(gfx::Rect* bounds,
-                                                       bool* maximized) const {
+void NativeWidgetWin::GetWindowBoundsAndShowState(
+    gfx::Rect* bounds,
+    ui::WindowShowState* show_state) const {
   WINDOWPLACEMENT wp;
   wp.length = sizeof(wp);
   const bool succeeded = !!GetWindowPlacement(GetNativeView(), &wp);
   DCHECK(succeeded);
 
   if (bounds != NULL) {
     MONITORINFO mi;
     mi.cbSize = sizeof(mi);
     const bool succeeded = !!GetMonitorInfo(
         MonitorFromWindow(GetNativeView(), MONITOR_DEFAULTTONEAREST), &mi);
     DCHECK(succeeded);
     *bounds = gfx::Rect(wp.rcNormalPosition);
     // Convert normal position from workarea coordinates to screen coordinates.
     bounds->Offset(mi.rcWork.left - mi.rcMonitor.left,
                    mi.rcWork.top - mi.rcMonitor.top);
   }
 
-  if (maximized != NULL)
-    *maximized = (wp.showCmd == SW_SHOWMAXIMIZED);
+  if (show_state != NULL) {
+    *show_state = ui::SHOW_STATE_NORMAL;

[sky, 2011/08/26 16:26:20]

nit: put this as the last 'else' branch of the if.

[dhollowa, 2011/08/26 22:13:50]

Done.

+    if (wp.showCmd == SW_SHOWMAXIMIZED)
+      *show_state = ui::SHOW_STATE_MAXIMIZED;
+    else if (wp.showCmd == SW_SHOWMINIMIZED)
+      *show_state = ui::SHOW_STATE_MINIMIZED;
+  }
 }
 
 void NativeWidgetWin::SetWindowTitle(const std::wstring& title) {
   SetWindowText(GetNativeView(), title.c_str());
   SetAccessibleName(title);
 }
 
 void NativeWidgetWin::SetWindowIcons(const SkBitmap& window_icon,
                                      const SkBitmap& app_icon) {
   if (!window_icon.isNull()) {
@@ skipping 83 matching lines @@
   return gfx::Rect(point.x, point.y, r.right - r.left, r.bottom - r.top);
 }
 
 gfx::Rect NativeWidgetWin::GetRestoredBounds() const {
   // If we're in fullscreen mode, we've changed the normal bounds to the monitor
   // rect, so return the saved bounds instead.
   if (IsFullscreen())
     return gfx::Rect(saved_window_info_.window_rect);
 
   gfx::Rect bounds;
-  GetWindowBoundsAndMaximizedState(&bounds, NULL);
+  GetWindowBoundsAndShowState(&bounds, NULL);
   return bounds;
 }
 
 void NativeWidgetWin::SetBounds(const gfx::Rect& bounds) {
   LONG style = GetWindowLong(GWL_STYLE);
   if (style & WS_MAXIMIZE)
     SetWindowLong(GWL_STYLE, style & ~WS_MAXIMIZE);
   SetWindowPos(NULL, bounds.x(), bounds.y(), bounds.width(), bounds.height(),
                SWP_NOACTIVATE | SWP_NOZORDER);
 }
@@ skipping 86 matching lines @@
     // NOTE: Be careful not to activate any windows here (for example, calling
     // ShowWindow(SW_HIDE) will automatically activate another window).  This
     // code can be called while a window is being deactivated, and activating
     // another window will screw up the activation that is already in progress.
     SetWindowPos(NULL, 0, 0, 0, 0,
                  SWP_HIDEWINDOW | SWP_NOACTIVATE | SWP_NOMOVE |
                  SWP_NOREPOSITION | SWP_NOSIZE | SWP_NOZORDER);
   }
 }
 
 void NativeWidgetWin::ShowMaximizedWithBounds(

[sky, 2011/08/26 16:26:20]

Are you sure we don't need something similar for minimized?

[dhollowa, 2011/08/26 22:13:50]

Yes, my understanding is that with maximize the |SetBounds| call separate from
|Show| causes a visual jump from normal to maximized.  But with minimize the
discontinuity does not show up because the window is hidden.  This seems to be
the case when I test it too.

On 2011/08/26 16:26:20, sky wrote:

     const gfx::Rect& restored_bounds) {
   WINDOWPLACEMENT placement = { 0 };
   placement.length = sizeof(WINDOWPLACEMENT);
   placement.showCmd = SW_SHOWMAXIMIZED;
   placement.rcNormalPosition = restored_bounds.ToRECT();
   SetWindowPlacement(hwnd(), &placement);
 }
 
-void NativeWidgetWin::ShowWithState(ShowState state) {
+void NativeWidgetWin::ShowWithWindowState(ui::WindowShowState show_state) {
   DWORD native_show_state;
-  switch (state) {
-    case SHOW_INACTIVE:
+  switch (show_state) {
+    case ui::SHOW_STATE_INACTIVE:
       native_show_state = SW_SHOWNOACTIVATE;
       break;
-    case SHOW_MAXIMIZED:
+    case ui::SHOW_STATE_MAXIMIZED:
       native_show_state = SW_SHOWMAXIMIZED;
       break;
+    case ui::SHOW_STATE_MINIMIZED:
+      native_show_state = SW_SHOWMINIMIZED;
+      break;
     default:
       native_show_state = GetShowState();
       break;
   }
   Show(native_show_state);
 }
 
 bool NativeWidgetWin::IsVisible() const {
   return !!::IsWindowVisible(hwnd());
 }
@@ skipping 1267 matching lines @@
   // Set non-style attributes.
   ownership_ = params.ownership;
 
   DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
   DWORD ex_style = 0;
   DWORD class_style = CS_DBLCLKS;
 
   // Set type-independent style attributes.
   if (params.child)
     style |= WS_CHILD | WS_VISIBLE;
-  if (params.maximize)
+  if (params.show_state == ui::SHOW_STATE_MAXIMIZED)
     style |= WS_MAXIMIZE;
+  if (params.show_state == ui::SHOW_STATE_MINIMIZED)
+    style |= WS_MINIMIZE;
   if (!params.accept_events)
     ex_style |= WS_EX_TRANSPARENT;
   if (!params.can_activate)
     ex_style |= WS_EX_NOACTIVATE;
   if (params.keep_on_top)
     ex_style |= WS_EX_TOPMOST;
   if (params.mirror_origin_in_rtl)
     ex_style |= l10n_util::GetExtendedTooltipStyles();
   if (params.transparent)
     ex_style |= WS_EX_LAYERED;
@@ skipping 342 matching lines @@
   return (GetKeyState(VK_LBUTTON) & 0x80) ||
     (GetKeyState(VK_RBUTTON) & 0x80) ||
     (GetKeyState(VK_MBUTTON) & 0x80) ||
     (GetKeyState(VK_XBUTTON1) & 0x80) ||
     (GetKeyState(VK_XBUTTON2) & 0x80);
 }
 
 }  // namespace internal
 
 }  // namespace views