aura: Have aura and aura_demo build and run without gtk on linux.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/thread.h"
 #include "ui/base/x/x11_util_internal.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
+#if defined(TOOLKIT_USES_GTK)
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+#include <gtk/gtk.h>
+#else
+#define gdk_error_trap_push()

[Daniel Erat, 2011/09/21 20:27:08]

stubbing these means that we're not trapping X errors, no?  if we're already
installing our own custom Xlib error handler, can the calls to these functions
just be removed?

[Daniel Erat, 2011/09/21 20:31:47]

http://codereview.chromium.org/7889040/ may be related

[sadrul, 2011/09/21 21:56:18]

Thanks for the link. I think that change can be useful here. I have left a
comment in that CL.

+#define gdk_error_trap_pop() false
+#define gdk_flush()
+#endif
+
 namespace ui {
 
 namespace {
 
 // Used to cache the XRenderPictFormat for a visual/display pair.
 struct CachedPictFormat {
   bool equals(Display* display, Visual* visual) const {
     return display == this->display && visual == this->visual;
   }
 
@@ skipping 20 matching lines @@
        FROM_HERE, NewRunnableFunction(LogErrorEventDescription, 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);
 }
 
+Atom GetAtom(const char* name) {
+#if defined(TOOLKIT_USES_GTK)
+  return gdk_x11_get_xatom_by_name_for_display(
+      gdk_display_get_default(), name);
+#else
+  return XInternAtom(GetXDisplay(), name, false);
+#endif
+}
+
 // 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());
-
+  Atom property_atom = GetAtom(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);
+  return (GetXDisplay() != NULL);
 }
 
 Display* GetXDisplay() {
   return base::MessagePumpForUI::GetDefaultXDisplay();
 }
 
 static SharedMemorySupport DoQuerySharedMemorySupport(Display* dpy) {
   int dummy;
   Bool pixmaps_supported;
   // Query the server's support for XSHM.
@@ skipping 52 matching lines @@
   render_supported_cached = true;
 
   return render_supported;
 }
 
 int GetDefaultScreen(Display* display) {
   return XDefaultScreen(display);
 }
 
 XID GetX11RootWindow() {
-  return GDK_WINDOW_XID(gdk_get_default_root_window());
+  return DefaultRootWindow(GetXDisplay());
 }
 
 bool GetCurrentDesktop(int* desktop) {
   return GetIntProperty(GetX11RootWindow(), "_NET_CURRENT_DESKTOP", desktop);
 }
 
+#if defined(TOOLKIT_USES_GTK)
 XID GetX11WindowFromGtkWidget(GtkWidget* widget) {
   return GDK_WINDOW_XID(widget->window);
 }
 
 XID GetX11WindowFromGdkWindow(GdkWindow* window) {
   return GDK_WINDOW_XID(window);
 }
 
 GtkWindow* GetGtkWindowFromX11Window(XID xid) {
   GdkWindow* gdk_window =
       gdk_window_lookup_for_display(gdk_display_get_default(), xid);
   if (!gdk_window)
     return NULL;
   GtkWindow* gtk_window = NULL;
   gdk_window_get_user_data(gdk_window,
                            reinterpret_cast<gpointer*>(&gtk_window));
   if (!gtk_window)
     return NULL;
   return gtk_window;
 }
 
 void* GetVisualFromGtkWidget(GtkWidget* widget) {
   return GDK_VISUAL_XVISUAL(gtk_widget_get_visual(widget));
 }
+#endif  // defined(TOOLKIT_USES_GTK)
 
 int BitsPerPixelForPixmapDepth(Display* dpy, int depth) {
   int count;
   XPixmapFormatValues* formats = XListPixmapFormats(dpy, &count);
   if (!formats)
     return -1;
 
   int bits_per_pixel = -1;
   for (int i = 0; i < count; ++i) {
     if (formats[i].depth == depth) {
@@ skipping 450 matching lines @@
     return false;
 
   // If |window| is sticky, use the current desktop.
   if (desktop == kAllDesktops &&
       !GetCurrentDesktop(&desktop))
     return false;
 
   XEvent event;
   event.xclient.type = ClientMessage;
   event.xclient.window = window;
-  event.xclient.message_type = gdk_x11_get_xatom_by_name_for_display(
-      gdk_display_get_default(), "_NET_WM_DESKTOP");
+  event.xclient.message_type = GetAtom("_NET_WM_DESKTOP");
   event.xclient.format = 32;
   event.xclient.data.l[0] = desktop;
   event.xclient.data.l[1] = 1;  // source indication
 
   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");
+  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)
           != atom_properties.end())
     return true;
 
+#if defined(TOOLKIT_USES_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;
+#endif
 }
 
 // ----------------------------------------------------------------------------
 // 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;
 
@@ skipping 112 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