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 1298 matching lines @@
 }
 
 bool IsX11WindowFullScreen(XID window) {
   // First check if _NET_WM_STATE property contains _NET_WM_STATE_FULLSCREEN.
   static 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)

[Daniel Erat, 2013/06/01 03:05:59]

i don't think that this is correct. see
http://standards.freedesktop.org/wm-spec/wm-spec-latest.html#idp3331912. i think
that you should check _NET_SUPPORTED to see if the window manager supports
_NET_WM_STATE_FULLSCREEN. if it does, return true if _NET_WM_STATE contains the
fullscreen property and false if it doesn't. this should prevent the later code
from being executed as long as a decent window manager is being used.

           != atom_properties.end())
     return true;
 
+  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.
+  ::Display* display = ui::GetXDisplay();

[Daniel Erat, 2013/06/01 03:05:59]

this will probably break in the multi-monitor case -- presumably you'd need to
use xrandr or xinerama to get the bounds of the monitor where the window is
being displayed. at least, i'm assuming that most window managers won't
fullscreen windows across multiple monitors. if you implement the above
suggestion, this is probably enough of a corner case that i wouldn't worry about
it (e.g. i don't think that ion3 sets the fullscreen property, but it also
doesn't do per-monitor fullscreening, so whatever).

+  ::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