Do not show notifications when in fullscreen or screensaver mode....

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <gtk/gtk.h>
 
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
 #include <list>
-#include <set>
+#include <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "gfx/rect.h"
 #include "gfx/size.h"
 #include "ui/base/x/x11_util_internal.h"
 
@@ skipping 29 matching lines @@
   LOG(ERROR) << GetErrorEventDescription(d, e);
   return 0;
 }
 
 int DefaultX11IOErrorHandler(Display* d) {
   // If there's an IO error it likely means the X server has gone away
   LOG(ERROR) << "X IO Error detected";
   _exit(1);
 }
 
+// Note: The caller should free the resulting value data.
+bool GetProperty(XID window, const std::string& property_name, long max_length,
+                 Atom* type, int* format, unsigned long* num_items,
+                 unsigned char** property) {
+  Atom property_atom = gdk_x11_get_xatom_by_name_for_display(
+      gdk_display_get_default(), property_name.c_str());
+
+  unsigned long remaining_bytes = 0;
+  return XGetWindowProperty(GetXDisplay(),
+                            window,
+                            property_atom,
+                            0,          // offset into property data to read
+                            max_length, // max length to get
+                            False,      // deleted
+                            AnyPropertyType,
+                            type,
+                            format,
+                            num_items,
+                            &remaining_bytes,
+                            property);
+}
+
 }  // namespace
 
 bool XDisplayExists() {
   return (gdk_display_get_default() != NULL);
 }
 
 Display* GetXDisplay() {
   static Display* display = NULL;
 
   if (!display)
@@ skipping 135 matching lines @@
     return false;
 
   if (!XTranslateCoordinates(GetSecondaryDisplay(), window, root,
                              0, 0, &x, &y, &child))
     return false;
 
   *rect = gfx::Rect(x, y, width, height);
   return true;
 }
 
-bool GetIntProperty(XID window, const std::string& property_name, int* value) {
-  Atom property_atom = gdk_x11_get_xatom_by_name_for_display(
-      gdk_display_get_default(), property_name.c_str());
-
+bool PropertyExists(XID window, const std::string& property_name) {
   Atom type = None;
   int format = 0;  // size in bits of each item in 'property'
-  long unsigned int num_items = 0, remaining_bytes = 0;
+  long unsigned int num_items = 0;
   unsigned char* property = NULL;
 
-  int result = XGetWindowProperty(GetXDisplay(),
-                                  window,
-                                  property_atom,
-                                  0,      // offset into property data to read
-                                  1,      // max length to get
-                                  False,  // deleted
-                                  AnyPropertyType,
-                                  &type,
-                                  &format,
-                                  &num_items,
-                                  &remaining_bytes,
-                                  &property);
+  int result = GetProperty(window, property_name, 1,
+                           &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
+  XFree(property);
+  return num_items > 0;
+}
+
+bool GetIntProperty(XID window, const std::string& property_name, int* value) {
+  Atom type = None;
+  int format = 0;  // size in bits of each item in 'property'
+  long unsigned int num_items = 0;
+  unsigned char* property = NULL;
+
+  int result = GetProperty(window, property_name, 1,
+                           &type, &format, &num_items, &property);
+  if (result != Success)
+    return false;
+
   if (format != 32 || num_items != 1) {
     XFree(property);
     return false;
   }
 
   *value = *(reinterpret_cast<int*>(property));
   XFree(property);
   return true;
 }
 
 bool GetIntArrayProperty(XID window,
                          const std::string& property_name,
                          std::vector<int>* value) {
-  Atom property_atom = gdk_x11_get_xatom_by_name_for_display(
-      gdk_display_get_default(), property_name.c_str());
-
   Atom type = None;
   int format = 0;  // size in bits of each item in 'property'
-  long unsigned int num_items = 0, remaining_bytes = 0;
+  long unsigned int num_items = 0;
   unsigned char* properties = NULL;
 
-  int result = XGetWindowProperty(GetXDisplay(),
-                                  window,
-                                  property_atom,
-                                  0,      // offset into property data to read
-                                  (~0L),  // max length to get (all of them)
-                                  False,  // deleted
-                                  AnyPropertyType,
-                                  &type,
-                                  &format,
-                                  &num_items,
-                                  &remaining_bytes,
-                                  &properties);
+  int result = GetProperty(window, property_name,
+                           (~0L), // (all of them)
+                           &type, &format, &num_items, &properties);
   if (result != Success)
     return false;
 
   if (format != 32) {
     XFree(properties);
     return false;
   }
 
   int* int_properties = reinterpret_cast<int*>(properties);
   value->clear();
   value->insert(value->begin(), int_properties, int_properties + num_items);
   XFree(properties);
   return true;
 }
 
+bool GetAtomArrayProperty(XID window,
+                          const std::string& property_name,
+                          std::vector<Atom>* value) {
+  Atom type = None;
+  int format = 0;  // size in bits of each item in 'property'
+  long unsigned int num_items = 0;
+  unsigned char* properties = NULL;
+
+  int result = GetProperty(window, property_name,
+                           (~0L), // (all of them)
+                           &type, &format, &num_items, &properties);
+  if (result != Success)
+    return false;
+
+  if (type != XA_ATOM) {
+    XFree(properties);
+    return false;
+  }
+
+  Atom* atom_properties = reinterpret_cast<Atom*>(properties);
+  value->clear();
+  value->insert(value->begin(), atom_properties, atom_properties + num_items);
+  XFree(properties);
+  return true;
+}
+
 bool GetStringProperty(
     XID window, const std::string& property_name, std::string* value) {
-  Atom property_atom = gdk_x11_get_xatom_by_name_for_display(
-      gdk_display_get_default(), property_name.c_str());
-
   Atom type = None;
   int format = 0;  // size in bits of each item in 'property'
-  long unsigned int num_items = 0, remaining_bytes = 0;
+  long unsigned int num_items = 0;
   unsigned char* property = NULL;
 
-  int result = XGetWindowProperty(GetXDisplay(),
-                                  window,
-                                  property_atom,
-                                  0,      // offset into property data to read
-                                  1024,   // max length to get
-                                  False,  // deleted
-                                  AnyPropertyType,
-                                  &type,
-                                  &format,
-                                  &num_items,
-                                  &remaining_bytes,
-                                  &property);
+  int result = GetProperty(window, property_name, 1024,
+                           &type, &format, &num_items, &property);
   if (result != Success)
     return false;
 
   if (format != 8) {
     XFree(property);
     return false;
   }
 
   value->assign(reinterpret_cast<char*>(property), num_items);
   XFree(property);
@@ skipping 41 matching lines @@
   if (depth > max_depth)
     return false;
 
   XID root, parent, *children;
   unsigned int num_children;
   int status = XQueryTree(GetXDisplay(), window, &root, &parent, &children,
                           &num_children);
   if (status == 0)
     return false;
 
-  std::set<XID> windows;
-  for (unsigned int i = 0; i < num_children; i++)
-    windows.insert(children[i]);
+  std::vector<XID> windows;
+  for (int i = static_cast<int>(num_children) - 1; i >= 0; i--)
+    windows.push_back(children[i]);
 
   XFree(children);
 
   // XQueryTree returns the children of |window| in bottom-to-top order, so
   // reverse-iterate the list to check the windows from top-to-bottom.
-  std::set<XID>::reverse_iterator iter;
-  for (iter = windows.rbegin(); iter != windows.rend(); iter++) {
+  std::vector<XID>::iterator iter;
+  for (iter = windows.begin(); iter != windows.end(); iter++) {
     if (IsWindowNamed(*iter) && delegate->ShouldStopIterating(*iter))
       return true;
   }
 
   // If we're at this point, we didn't find the window we're looking for at the
   // current level, so we need to recurse to the next level.  We use a second
   // loop because the recursion and call to XQueryTree are expensive and is only
   // needed for a small number of cases.
   if (++depth <= max_depth) {
-    for (iter = windows.rbegin(); iter != windows.rend(); iter++) {
+    for (iter = windows.begin(); iter != windows.end(); iter++) {
       if (EnumerateChildren(delegate, *iter, max_depth, depth))
         return true;
     }
   }
 
   return false;
 }
 
 bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate, int max_depth) {
   XID root = GetX11RootWindow();
   return EnumerateChildren(delegate, root, max_depth, 0);
 }
 
-bool GetXWindowStack(std::vector<XID>* windows) {
+bool GetXWindowStack(Window window, std::vector<XID>* windows) {
   windows->clear();
 
-  static Atom atom = XInternAtom(GetXDisplay(),
-                                 "_NET_CLIENT_LIST_STACKING", False);
-
   Atom type;
   int format;
   unsigned long count;
-  unsigned long bytes_after;
   unsigned char *data = NULL;
-  if (XGetWindowProperty(GetXDisplay(),
-                         GetX11RootWindow(),
-                         atom,
-                         0,                // offset
-                         ~0L,              // length
-                         False,            // delete
-                         AnyPropertyType,  // requested type
-                         &type,
-                         &format,
-                         &count,
-                         &bytes_after,
-                         &data) != Success) {
+  if (!GetProperty(window,
+                   "_NET_CLIENT_LIST_STACKING",
+                   ~0L,
+                   &type,
+                   &format,
+                   &count,
+                   &data)) {
     return false;
   }
 
   bool result = false;
   if (type == XA_WINDOW && format == 32 && data && count > 0) {
     result = true;
     XID* stack = reinterpret_cast<XID*>(data);
-    for (unsigned long i = 0; i < count; i++)
-      windows->insert(windows->begin(), stack[i]);
+    for (long i = static_cast<long>(count) - 1; i >= 0; i--)
+      windows->push_back(stack[i]);
   }
 
   if (data)
     XFree(data);
 
   return result;
 }
 
 void RestackWindow(XID window, XID sibling, bool above) {
   XWindowChanges changes;
@@ skipping 291 matching lines @@
 
   int result = XSendEvent(GetXDisplay(), GetX11RootWindow(), False,
                           SubstructureNotifyMask, &event);
   return result == Success;
 }
 
 void SetDefaultX11ErrorHandlers() {
   SetX11ErrorHandlers(NULL, NULL);
 }
 
+bool IsX11WindowFullScreen(XID window) {
+  // First check if _NET_WM_STATE property contains _NET_WM_STATE_FULLSCREEN.
+  static Atom atom = gdk_x11_get_xatom_by_name_for_display(
+      gdk_display_get_default(), "_NET_WM_STATE_FULLSCREEN");
+
+  std::vector<Atom> atom_properties;
+  if (GetAtomArrayProperty(window,
+                           "_NET_WM_STATE",
+                           &atom_properties) &&
+      std::find(atom_properties.begin(), atom_properties.end(), atom)
+          != atom_properties.end())
+    return true;
+
+  // As the last resort, check if the window size is as large as the main
+  // screen.
+  GdkRectangle monitor_rect;
+  gdk_screen_get_monitor_geometry(gdk_screen_get_default(), 0, &monitor_rect);
+
+  gfx::Rect window_rect;
+  if (!ui::GetWindowRect(window, &window_rect))
+    return false;
+
+  return monitor_rect.x == window_rect.x() &&
+         monitor_rect.y == window_rect.y() &&
+         monitor_rect.width == window_rect.width() &&
+         monitor_rect.height == window_rect.height();
+}
+
 // ----------------------------------------------------------------------------
 // These functions are declared in x11_util_internal.h because they require
 // XLib.h to be included, and it conflicts with many other headers.
 XRenderPictFormat* GetRenderARGB32Format(Display* dpy) {
   static XRenderPictFormat* pictformat = NULL;
   if (pictformat)
     return pictformat;
 
   // First look for a 32-bit format which ignores the alpha value
   XRenderPictFormat templ;
@@ skipping 106 matching lines @@
       "X Error detected: serial %lu, error_code %u (%s), "
       "request_code %u minor_code %u (%s)",
       error_event->serial, error_event->error_code, error_str,
       error_event->request_code, error_event->minor_code, request_str);
 }
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui