Restoring a session should restore window minimization state on Windows

chrome/browser/ui/views/chrome_views_delegate.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/chrome_views_delegate.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 47 matching lines @@
   return g_browser_process->clipboard();
 }
 
 views::View* ChromeViewsDelegate::GetDefaultParentView() {
   return default_parent_view;
 }
 
 void ChromeViewsDelegate::SaveWindowPlacement(const views::Widget* window,
                                               const std::wstring& window_name,
                                               const gfx::Rect& bounds,
-                                              bool maximized) {
+                                              ui::WindowShowState show_state) {
   bool using_local_state = false;
   PrefService* prefs = GetPrefsForWindow(window, &using_local_state);
   if (!prefs)
     return;
 
   CHECK(prefs->FindPreference(WideToUTF8(window_name).c_str())) << " " <<
       browser_shutdown::GetShutdownType() << " " << using_local_state << " " <<
       window->destroy_state();
   DictionaryPrefUpdate update(prefs, WideToUTF8(window_name).c_str());
   DictionaryValue* window_preferences = update.Get();
   window_preferences->SetInteger("left", bounds.x());
   window_preferences->SetInteger("top", bounds.y());
   window_preferences->SetInteger("right", bounds.right());
   window_preferences->SetInteger("bottom", bounds.bottom());
-  window_preferences->SetBoolean("maximized", maximized);
+  window_preferences->SetBoolean("maximized",
+                                 show_state == ui::SHOW_STATE_MAXIMIZED);
 
   scoped_ptr<WindowSizer::MonitorInfoProvider> monitor_info_provider(
       WindowSizer::CreateDefaultMonitorInfoProvider());
   gfx::Rect work_area(
       monitor_info_provider->GetMonitorWorkAreaMatching(bounds));
   window_preferences->SetInteger("work_area_left", work_area.x());
   window_preferences->SetInteger("work_area_top", work_area.y());
   window_preferences->SetInteger("work_area_right", work_area.right());
   window_preferences->SetInteger("work_area_bottom", work_area.bottom());
 }
@@ skipping 11 matching lines @@
   if (!dictionary || !dictionary->GetInteger("left", &left) ||
       !dictionary->GetInteger("top", &top) ||
       !dictionary->GetInteger("right", &right) ||
       !dictionary->GetInteger("bottom", &bottom))
     return false;
 
   bounds->SetRect(left, top, right - left, bottom - top);
   return true;
 }
 
-bool ChromeViewsDelegate::GetSavedMaximizedState(
+bool ChromeViewsDelegate::GetSavedWindowShowState(
     const std::wstring& window_name,
-    bool* maximized) const {
+    ui::WindowShowState* show_state) const {
   PrefService* prefs = g_browser_process->local_state();
   if (!prefs)
     return false;
 
   DCHECK(prefs->FindPreference(WideToUTF8(window_name).c_str()));
   const DictionaryValue* dictionary =
       prefs->GetDictionary(WideToUTF8(window_name).c_str());
 
-  return dictionary && dictionary->GetBoolean("maximized", maximized) &&
-      maximized;
+  bool maximized = false;
+  return dictionary && dictionary->GetBoolean("maximized", &maximized);
+  *show_state = maximized ? ui::SHOW_STATE_MAXIMIZED : ui::SHOW_STATE_NORMAL;
+  return maximized;
 }
 
 void ChromeViewsDelegate::NotifyAccessibilityEvent(
     views::View* view, ui::AccessibilityTypes::Event event_type) {
   AccessibilityEventRouterViews::GetInstance()->HandleAccessibilityEvent(
       view, event_type);
 }
 
 void ChromeViewsDelegate::NotifyMenuItemFocused(
       const std::wstring& menu_name,
@@ skipping 15 matching lines @@
   g_browser_process->AddRefModule();
 }
 
 void ChromeViewsDelegate::ReleaseRef() {
   g_browser_process->ReleaseModule();
 }
 
 int ChromeViewsDelegate::GetDispositionForEvent(int event_flags) {
   return event_utils::DispositionFromEventFlags(event_flags);
 }