Revert of Revert of 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;
   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