Prevent a window from being put into fullscreen upon startup on desktop Linux

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 12 matching lines @@
 #include "ui/aura/window_property.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/platform/platform_event_source.h"
 #include "ui/events/platform/x11/x11_event_source.h"
 #include "ui/events/x/device_data_manager_x11.h"
 #include "ui/events/x/device_list_cache_x.h"
 #include "ui/events/x/touch_factory_x11.h"
+#include "ui/gfx/display.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/insets.h"
 #include "ui/gfx/path.h"
 #include "ui/gfx/path_x11.h"
 #include "ui/gfx/screen.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/corewm/tooltip_aura.h"
 #include "ui/views/ime/input_method.h"
 #include "ui/views/linux_ui/linux_ui.h"
@@ skipping 335 matching lines @@
     const gfx::Rect& restored_bounds) {
   ShowWindowWithState(ui::SHOW_STATE_MAXIMIZED);
   // Enforce |restored_bounds_| since calling Maximize() could have reset it.
   restored_bounds_ = restored_bounds;
 }
 
 bool DesktopWindowTreeHostX11::IsVisible() const {
   return window_mapped_;
 }
 
-void DesktopWindowTreeHostX11::SetSize(const gfx::Size& size) {
+void DesktopWindowTreeHostX11::SetSize(const gfx::Size& requested_size) {
+  gfx::Size size = AdjustSize(requested_size);
   bool size_changed = bounds_.size() != size;
   XResizeWindow(xdisplay_, xwindow_, size.width(), size.height());
   bounds_.set_size(size);
   if (size_changed) {
     OnHostResized(size);
     ResetWindowRegion();
   }
 }
 
 void DesktopWindowTreeHostX11::StackAtTop() {
@@ skipping 114 matching lines @@
 
   ReleaseCapture();
   X11DesktopHandler::get()->DeactivateWindow(xwindow_);
 }
 
 bool DesktopWindowTreeHostX11::IsActive() const {
   return X11DesktopHandler::get()->IsActiveWindow(xwindow_);
 }
 
 void DesktopWindowTreeHostX11::Maximize() {
+  if (HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN")) {
+    // Unfullscreen the window if it is fullscreen.
+    SetWMSpecState(false,
+                   atom_cache_.GetAtom("_NET_WM_STATE_FULLSCREEN"),
+                   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);
+  }
+
   // 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);
@@ skipping 310 matching lines @@
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
   native_widget_delegate_->OnNativeWidgetVisibilityChanged(false);
 }
 
 gfx::Rect DesktopWindowTreeHostX11::GetBounds() const {
   return bounds_;
 }
 
-void DesktopWindowTreeHostX11::SetBounds(const gfx::Rect& bounds) {
+void DesktopWindowTreeHostX11::SetBounds(const gfx::Rect& requested_bounds) {
+  gfx::Rect bounds(requested_bounds.origin(),
+                   AdjustSize(requested_bounds.size()));
   bool origin_changed = bounds_.origin() != bounds.origin();
   bool size_changed = bounds_.size() != bounds.size();
   XWindowChanges changes = {0};
   unsigned value_mask = 0;
 
   if (size_changed) {
     // X11 will send an XError at our process if have a 0 sized window.
     DCHECK_GT(bounds.width(), 0);
     DCHECK_GT(bounds.height(), 0);
 
@@ skipping 167 matching lines @@
 
       // x.org will BadMatch if we don't set a border when the depth isn't the
       // same as the parent depth.
       attribute_mask |= CWBorderPixel;
       swa.border_pixel = 0;
 
       use_argb_visual_ = true;
     }
   }
 
-  bounds_ = params.bounds;
+  bounds_ = gfx::Rect(params.bounds.origin(),
+                      AdjustSize(params.bounds.size()));
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds_.x(), bounds_.y(),
       bounds_.width(), bounds_.height(),
       0,               // border width
       depth,
       InputOutput,
       visual,
       attribute_mask,
       &swa);
@@ skipping 112 matching lines @@
   // If we have a delegate which is providing a default window icon, use that
   // icon.
   gfx::ImageSkia* window_icon = ViewsDelegate::views_delegate ?
       ViewsDelegate::views_delegate->GetDefaultWindowIcon() : NULL;
   if (window_icon) {
     SetWindowIcons(gfx::ImageSkia(), *window_icon);
   }
   CreateCompositor(GetAcceleratedWidget());
 }
 
+gfx::Size DesktopWindowTreeHostX11::AdjustSize(
+    const gfx::Size& requested_size) {
+  std::vector<gfx::Display> displays =
+      gfx::Screen::GetScreenByType(gfx::SCREEN_TYPE_NATIVE)->GetAllDisplays();
+  // Compare against all monitor sizes. The window manager can move the window
+  // to whichever monitor it wants.
+  for (size_t i = 0; i < displays.size(); ++i) {
+    if (requested_size == displays[i].size()) {
+      return gfx::Size(requested_size.width() - 1,
+                       requested_size.height() - 1);
+    }
+  }
+  return requested_size;
+}
+
 void DesktopWindowTreeHostX11::OnWMStateUpdated() {
   std::vector< ::Atom> atom_list;
   if (!ui::GetAtomArrayProperty(xwindow_, "_NET_WM_STATE", &atom_list))
     return;
 
   bool was_minimized = IsMinimized();
 
   window_properties_.clear();
   std::copy(atom_list.begin(), atom_list.end(),
             inserter(window_properties_, window_properties_.begin()));
@@ skipping 676 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