linux_aura: Implement the fallback path in IsX11WindowFullScreen.

ui/base/x/x11_util.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.
 
 // 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"
 
@@ skipping 1291 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 = GetAtom("_NET_WM_STATE_FULLSCREEN");
+  // If _NET_WM_STATE_FULLSCREEN is in _NET_SUPPORTED, use the presence or
+  // absence of _NET_WM_STATE_FULLSCREEN in _NET_WM_STATE to determine
+  // whether we're fullscreen.
+  std::vector<Atom> supported_atoms;
+  if (GetAtomArrayProperty(GetX11RootWindow(),
+                           "_NET_SUPPORTED",
+                           &supported_atoms)) {
+    Atom atom = GetAtom("_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;
+    if (std::find(supported_atoms.begin(), supported_atoms.end(), atom)
+        != supported_atoms.end()) {
+      std::vector<Atom> atom_properties;
+      if (GetAtomArrayProperty(window,
+                               "_NET_WM_STATE",
+                               &atom_properties)) {
+        return std::find(atom_properties.begin(), atom_properties.end(), atom)
+            != atom_properties.end();
+      }
+    }
+  }
+
+  gfx::Rect window_rect;
+  if (!ui::GetWindowRect(window, &window_rect))
+    return false;
 
 #if defined(TOOLKIT_GTK)
   // 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();
 #else
-  NOTIMPLEMENTED();
-  return false;
+  // We can't use gfx::Screen here because we don't have an aura::Window. So
+  // instead just look at the size of the default display.
+  //
+  // TODO(erg): Actually doing this correctly would require pulling out xrandr,
+  // which we don't even do in the desktop screen yet.
+  ::Display* display = ui::GetXDisplay();
+  ::Screen* screen = DefaultScreenOfDisplay(display);
+  int width = WidthOfScreen(screen);
+  int height = HeightOfScreen(screen);
+  return window_rect.size() == gfx::Size(width, height);
 #endif
 }
 
 bool IsMotionEvent(XEvent* event) {
   int type = event->type;
   if (type == GenericEvent)
     type = event->xgeneric.evtype;
   return type == MotionNotify;
 }
 
@@ skipping 190 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui