Fix maximize on some window managers

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.cc

 // Copyright (c) 2012 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 "ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 120 matching lines @@
     DesktopNativeWidgetAura* desktop_native_widget_aura)
     : close_widget_factory_(this),
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false),
       is_fullscreen_(false),
       is_always_on_top_(false),
       use_native_frame_(false),
+      should_maximize_after_map_(false),
       use_argb_visual_(false),
       drag_drop_client_(NULL),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura),
       content_window_(NULL),
       window_parent_(NULL),
       window_shape_(NULL),
       custom_window_shape_(false),
       urgency_hint_set_(false) {
 }
@@ skipping 208 matching lines @@
   return this;
 }
 
 void DesktopWindowTreeHostX11::ShowWindowWithState(
     ui::WindowShowState show_state) {
   if (!window_mapped_)
     MapWindow(show_state);
 
   if (show_state == ui::SHOW_STATE_NORMAL ||
       show_state == ui::SHOW_STATE_MAXIMIZED) {
-    // Note: XFCE ignores a maximize hint given before mapping the window.
-    if (show_state == ui::SHOW_STATE_MAXIMIZED)
-      Maximize();
     Activate();
   }
 
   native_widget_delegate_->AsWidget()->SetInitialFocus(show_state);
 }
 
 void DesktopWindowTreeHostX11::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
   // Enforce |restored_bounds_| since calling Maximize() could have reset it.
@@ skipping 152 matching lines @@
                    None);
 
     // Resize the window so that it does not have the same size as a monitor.
     // (Otherwise, some window managers immediately put the window back in
     // fullscreen mode).
     gfx::Rect adjusted_bounds(bounds_.origin(), AdjustSize(bounds_.size()));
     if (adjusted_bounds != bounds_)
       SetBounds(adjusted_bounds);
   }
 
+  // Some WMs do not respect maximization hints on unmapped windows, so we
+  // save this one for later too.
+  should_maximize_after_map_ = !window_mapped_;
+
   // When we are in the process of requesting to maximize a window, we can
   // accurately keep track of our restored bounds instead of relying on the
   // heuristics that are in the PropertyNotify and ConfigureNotify handlers.
   restored_bounds_ = bounds_;
 
   SetWMSpecState(true,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 void DesktopWindowTreeHostX11::Minimize() {
   ReleaseCapture();
   XIconifyWindow(xdisplay_, xwindow_, 0);
 }
 
 void DesktopWindowTreeHostX11::Restore() {
+  should_maximize_after_map_ = false;

[Elliot Glaysher, 2014/09/04 17:37:04]

This seems fragile.

Could you please test in the case of Maximizing through code before the window
is mapped, restoring through the window manager controls (not chrome's buttons),
and then doing something that would unmap and then remap the window?

And if that's broken, you'll also have to add more should_maximize_after_map_ =
false statements to the _net_wm_state property notify.

[Arjan van Leeuwen, 2014/09/05 11:23:26]

You can't restore the window through the window manager before the window is
mapped. And when the window is mapped (via DesktopWindowTreeHostX11::MapWindow),
we always reset should_maximize_after_map. Is there another way for the window
to get mapped besides using that function?

   SetWMSpecState(false,
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_VERT"),
                  atom_cache_.GetAtom("_NET_WM_STATE_MAXIMIZED_HORZ"));
   if (IsMinimized())
     ShowWindowWithState(ui::SHOW_STATE_NORMAL);
 }
 
 bool DesktopWindowTreeHostX11::IsMaximized() const {
   return (HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_VERT") &&
           HasWMSpecProperty("_NET_WM_STATE_MAXIMIZED_HORZ"));
@@ skipping 1004 matching lines @@
   }
 
   XMapWindow(xdisplay_, xwindow_);
 
   // We now block until our window is mapped. Some X11 APIs will crash and
   // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
   // asynchronous.
   if (ui::X11EventSource::GetInstance())
     ui::X11EventSource::GetInstance()->BlockUntilWindowMapped(xwindow_);
   window_mapped_ = true;
+
+  // Some WMs only respect maximize hints after the window has been mapped.
+  // Check whether we need to re-do a maximization.
+  if (should_maximize_after_map_) {
+    Maximize();
+    should_maximize_after_map_ = false;
+  }
 }
 
 void DesktopWindowTreeHostX11::SetWindowTransparency() {
   compositor()->SetHostHasTransparentBackground(use_argb_visual_);
   window()->SetTransparent(use_argb_visual_);
   content_window_->SetTransparent(use_argb_visual_);
 }
 
 void DesktopWindowTreeHostX11::Relayout() {
   Widget* widget = native_widget_delegate_->AsWidget();
@@ skipping 318 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme(window);
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views