Restoring a session should restore window minimization state

chrome/browser/ui/gtk/browser_window_gtk.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/gtk/browser_window_gtk.h"
 
 #include <gdk/gdkkeysyms.h>
 
 #include <dlfcn.h>
 #include <string>
@@ skipping 306 matching lines @@
        render_area_vbox_(NULL),
        render_area_floating_container_(NULL),
        render_area_event_box_(NULL),
        toolbar_border_(NULL),
        browser_(browser),
        state_(GDK_WINDOW_STATE_WITHDRAWN),
        contents_split_(NULL),
        frame_cursor_(NULL),
        is_active_(!ui::ActiveWindowWatcherX::WMSupportsActivation()),
        last_click_time_(0),
-       maximize_after_show_(false),
+       show_state_after_show_(ui::SHOW_STATE_DEFAULT),
        suppress_window_raise_(false),
        accel_group_(NULL),
        debounce_timer_disabled_(false) {
 }
 
 BrowserWindowGtk::~BrowserWindowGtk() {
   ui::ActiveWindowWatcherX::RemoveObserver(this);
 
   browser_->tabstrip_model()->RemoveObserver(this);
 }
@@ skipping 300 matching lines @@
 void BrowserWindowGtk::Show() {
   // The Browser associated with this browser window must become the active
   // browser at the time Show() is called. This is the natural behaviour under
   // Windows, but gtk_widget_show won't show the widget (and therefore won't
   // call OnFocusIn()) until we return to the runloop. Therefore any calls to
   // BrowserList::GetLastActive() (for example, in bookmark_util), will return
   // the previous browser instead if we don't explicitly set it here.
   BrowserList::SetLastActive(browser());
 
   gtk_window_present(window_);
-  if (maximize_after_show_) {
+  if (show_state_after_show_ == ui::SHOW_STATE_MAXIMIZED) {
     gtk_window_maximize(window_);
-    maximize_after_show_ = false;
+    show_state_after_show_ = ui::SHOW_STATE_NORMAL;
+  } else if (show_state_after_show_ == ui::SHOW_STATE_MINIMIZED) {
+    gtk_window_iconify(window_);
+    show_state_after_show_ = ui::SHOW_STATE_NORMAL;
   }
 
   // If we have sized the window by setting a size request for the render
   // area, then undo it so that the render view can later adjust its own
   // size.
   gtk_widget_set_size_request(contents_container_->widget(), -1, -1);
 }
 
 void BrowserWindowGtk::ShowInactive() {
   gtk_window_set_focus_on_map(window_, false);
@@ skipping 168 matching lines @@
 }
 
 gfx::Rect BrowserWindowGtk::GetBounds() const {
   return bounds_;
 }
 
 bool BrowserWindowGtk::IsMaximized() const {
   return (state_ & GDK_WINDOW_STATE_MAXIMIZED);
 }
 
+bool BrowserWindowGtk::IsMinimized() const {
+  return (state_ & GDK_WINDOW_STATE_ICONIFIED);
+}
+
 bool BrowserWindowGtk::ShouldDrawContentDropShadow() {
   return !IsMaximized() && UseCustomFrame();
 }
 
 void BrowserWindowGtk::SetFullscreen(bool fullscreen) {
   // gtk_window_(un)fullscreen asks the window manager to toggle the EWMH
   // for fullscreen windows.  Not all window managers support this.
   if (fullscreen) {
     gtk_window_fullscreen(window_);
   } else {
@@ skipping 745 matching lines @@
 
 void BrowserWindowGtk::QueueToolbarRedraw() {
   gtk_widget_queue_draw(toolbar_->widget());
 }
 
 void BrowserWindowGtk::SetGeometryHints() {
   // If we call gtk_window_maximize followed by gtk_window_present, compiz gets
   // confused and maximizes the window, but doesn't set the
   // GDK_WINDOW_STATE_MAXIMIZED bit.  So instead, we keep track of whether to
   // maximize and call it after gtk_window_present.
-  maximize_after_show_ = browser_->GetSavedMaximizedState();
+  show_state_after_show_ = browser_->GetSavedWindowShowState();
 
   gfx::Rect bounds = browser_->GetSavedWindowBounds();
   // We don't blindly call SetBounds here: that sets a forced position
   // on the window and we intentionally *don't* do that for normal
   // windows.  Most programs do not restore their window position on
   // Linux, instead letting the window manager choose a position.
   //
   // However, in cases like dropping a tab where the bounds are
   // specifically set, we do want to position explicitly.  We also
   // force the position as part of session restore, as applications
@@ skipping 268 matching lines @@
 }
 
 void BrowserWindowGtk::UpdateCustomFrame() {
   gtk_window_set_decorated(window_, !UseCustomFrame());
   titlebar_->UpdateCustomFrame(UseCustomFrame() && !IsFullscreen());
   UpdateWindowShape(bounds_.width(), bounds_.height());
 }
 
 void BrowserWindowGtk::SaveWindowPosition() {
   // Browser::SaveWindowPlacement is used for session restore.
+  ui::WindowShowState show_state = ui::SHOW_STATE_NORMAL;
+  if (IsMaximized())
+    show_state = ui::SHOW_STATE_MAXIMIZED;
+  else if (IsMinimized())
+    show_state = ui::SHOW_STATE_MINIMIZED;
+
   if (browser_->ShouldSaveWindowPlacement())
-    browser_->SaveWindowPlacement(restored_bounds_, IsMaximized());
+    browser_->SaveWindowPlacement(restored_bounds_, show_state);
 
   // We also need to save the placement for startup.
   // This is a web of calls between views and delegates on Windows, but the
   // crux of the logic follows.  See also cocoa/browser_window_controller.mm.
   if (!browser_->profile()->GetPrefs())
     return;
 
   std::string window_name = browser_->GetWindowPlacementKey();
   DictionaryPrefUpdate update(browser_->profile()->GetPrefs(),
                               window_name.c_str());
@@ skipping 468 matching lines @@
   // are taken from the WMs' source code.
   return (wm_name == "Blackbox" ||
           wm_name == "compiz" ||
           wm_name == "Compiz" ||
           wm_name == "e16" ||  // Enlightenment DR16
           wm_name == "Metacity" ||
           wm_name == "Mutter" ||
           wm_name == "Openbox" ||
           wm_name == "Xfwm4");
 }