Add always-on-top property to app windows

ui/views/widget/desktop_aura/desktop_root_window_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_root_window_host_x11.h"
 
 #include <X11/extensions/shape.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xatom.h>
 #include <X11/Xregion.h>
@@ skipping 106 matching lines @@
     DesktopNativeWidgetAura* desktop_native_widget_aura,
     const gfx::Rect& initial_bounds)
     : close_widget_factory_(this),
       xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       atom_cache_(xdisplay_, kAtomsToCache),
       window_mapped_(false),
       focus_when_shown_(false),
       is_fullscreen_(false),
+      always_on_top_(false),
       current_cursor_(ui::kCursorNull),
       native_widget_delegate_(native_widget_delegate),
       desktop_native_widget_aura_(desktop_native_widget_aura) {
 }
 
 DesktopRootWindowHostX11::~DesktopRootWindowHostX11() {
   root_window_->ClearProperty(kHostForRootWindow);
   aura::client::SetFocusClient(root_window_, NULL);
   aura::client::SetActivationClient(root_window_, NULL);
 }
@@ skipping 288 matching lines @@
 bool DesktopRootWindowHostX11::IsMinimized() const {
   return HasWMSpecProperty("_NET_WM_STATE_HIDDEN");
 }
 
 
 bool DesktopRootWindowHostX11::HasCapture() const {
   return g_current_capture == this;
 }
 
 void DesktopRootWindowHostX11::SetAlwaysOnTop(bool always_on_top) {
+  always_on_top_ = always_on_top;
   SetWMSpecState(always_on_top,
                  atom_cache_.GetAtom("_NET_WM_STATE_ABOVE"),
                  None);
 }
 
+bool DesktopRootWindowHostX11::IsAlwaysOnTop() const {
+  return always_on_top_;
+}
+
 void DesktopRootWindowHostX11::SetWindowTitle(const string16& title) {
   XStoreName(xdisplay_, xwindow_, UTF16ToUTF8(title).c_str());
 }
 
 void DesktopRootWindowHostX11::ClearNativeFocus() {
   // This method is weird and misnamed. Instead of clearing the native focus,
   // it sets the focus to our |content_window_|, which will trigger a cascade
   // of focus changes into views.
   if (content_window_ && aura::client::GetFocusClient(content_window_) &&
       content_window_->Contains(
@@ skipping 457 matching lines @@
     // mapped. So we manually change the state.
     XChangeProperty (xdisplay_,
                      xwindow_,
                      atom_cache_.GetAtom("_NET_WM_STATE"),
                      XA_ATOM,
                      32,
                      PropModeAppend,
                      reinterpret_cast<unsigned char*>(&atom), 1);
   }
 
+  // If the window should stay on top of other windows, add the
+  // _NET_WM_STATE_ABOVE property.
+  always_on_top_ = params.keep_on_top;
+  if (always_on_top_) {
+    Atom atom = atom_cache_.GetAtom("_NET_WM_STATE_ABOVE");
+    XChangeProperty (xdisplay_,

[Elliot Glaysher, 2013/10/08 18:05:00]

This will clobber the XChangeProperty immediately above. _NET_WM_STATE takes an
array, and you're possibly overwriting the previous one length array. We have a
nice utility function, ui::SetAtomArrayProperty, in x11_util.h which can handle
that.

Documentation:
http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html#id2731936

[tmdiep, 2013/10/09 02:15:04]

Thanks for that. Fixed.

+                     xwindow_,
+                     atom_cache_.GetAtom("_NET_WM_STATE"),
+                     XA_ATOM,
+                     32,
+                     PropModeAppend,
+                     reinterpret_cast<unsigned char*>(&atom), 1);
+  }
+
   if (!params.wm_class_name.empty() || !params.wm_class_class.empty()) {
     ui::SetWindowClassHint(
         xdisplay_, xwindow_, params.wm_class_name, params.wm_class_class);
   }
 }
 
 aura::RootWindow* DesktopRootWindowHostX11::InitRootWindow(
     const Widget::InitParams& params) {
   aura::RootWindow::CreateParams rw_params(bounds_);
   rw_params.host = this;
@@ skipping 422 matching lines @@
         } else if (IsMaximized() && restored_bounds_.IsEmpty()) {
           // The request that we become maximized originated from a different
           // process. |bounds_| already contains our maximized bounds. Do a
           // best effort attempt to get restored bounds by setting it to our
           // previously set bounds (and if we get this wrong, we aren't any
           // worse off since we'd otherwise be returning our maximized bounds).
           restored_bounds_ = previous_bounds_;
         }
 
         is_fullscreen_ = HasWMSpecProperty("_NET_WM_STATE_FULLSCREEN");
+        always_on_top_ = HasWMSpecProperty("_NET_WM_STATE_ABOVE");
 
         // Now that we have different window properties, we may need to
         // relayout the window. (The windows code doesn't need this because
         // their window change is synchronous.)
         //
         // TODO(erg): While this does work, there's a quick flash showing the
         // tabstrip/toolbar/etc. when going into fullscreen mode before hiding
         // those parts of the UI because we receive the sizing event from the
         // window manager before we receive the event that changes the
         // fullscreen state. Unsure what to do about that.
@@ skipping 35 matching lines @@
   if (linux_ui) {
     ui::NativeTheme* native_theme = linux_ui->GetNativeTheme();
     if (native_theme)
       return native_theme;
   }
 
   return ui::NativeTheme::instance();
 }
 
 }  // namespace views