gtk: Allow building both the X11 and Gtk message-pumps for gtk.

ui/aura/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/aura/root_window_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/Xatom.h>
 #include <X11/Xcursor/Xcursor.h>
 #include <X11/Xlib.h>
 
 #include <algorithm>
 #include <limits>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
-#include "base/message_loop/message_pump_aurax11.h"
+#include "base/message_loop/message_pump_x11.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/user_action_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
@@ skipping 322 matching lines @@
   size_t insert_index_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseMoveFilter);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowHostX11
 
 RootWindowHostX11::RootWindowHostX11(const gfx::Rect& bounds)
     : delegate_(NULL),
-      xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
+      xdisplay_(base::MessagePumpX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       window_mapped_(false),
       bounds_(bounds),
       is_internal_display_(false),
       focus_when_shown_(false),
       touch_calibrate_(new internal::TouchEventCalibrate),
       mouse_move_filter_(new MouseMoveFilter),
       atom_cache_(xdisplay_, kAtomsToCache),
       bezel_tracking_ids_(0) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.override_redirect = default_override_redirect;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
       InputOutput,
       CopyFromParent,  // visual
       CWBackPixmap | CWOverrideRedirect,
       &swa);
-  base::MessagePumpAuraX11::Current()->AddDispatcherForWindow(this, xwindow_);
-  base::MessagePumpAuraX11::Current()->AddDispatcherForRootWindow(this);
+  base::MessagePumpX11::Current()->AddDispatcherForWindow(this, xwindow_);
+  base::MessagePumpX11::Current()->AddDispatcherForRootWindow(this);
 
   long event_mask = ButtonPressMask | ButtonReleaseMask | FocusChangeMask |
                     KeyPressMask | KeyReleaseMask |
                     EnterWindowMask | LeaveWindowMask |
                     ExposureMask | VisibilityChangeMask |
                     StructureNotifyMask | PropertyChangeMask |
                     PointerMotionMask;
   XSelectInput(xdisplay_, xwindow_, event_mask);
   XFlush(xdisplay_);
 
@@ skipping 30 matching lines @@
                   PropModeReplace,
                   reinterpret_cast<unsigned char*>(&pid), 1);
 
   XRRSelectInput(xdisplay_, x_root_window_,
                  RRScreenChangeNotifyMask | RROutputChangeNotifyMask);
   Env::GetInstance()->AddObserver(this);
 }
 
 RootWindowHostX11::~RootWindowHostX11() {
   Env::GetInstance()->RemoveObserver(this);
-  base::MessagePumpAuraX11::Current()->RemoveDispatcherForRootWindow(this);
-  base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
+  base::MessagePumpX11::Current()->RemoveDispatcherForRootWindow(this);
+  base::MessagePumpX11::Current()->RemoveDispatcherForWindow(xwindow_);
 
   UnConfineCursor();
 
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
 bool RootWindowHostX11::Dispatch(const base::NativeEvent& event) {
   XEvent* xev = event;
 
   if (FindEventTarget(event) == x_root_window_)
@@ skipping 168 matching lines @@
     // Set StaticGravity so that the window position is not affected by the
     // frame width when running with window manager.
     size_hints.win_gravity = StaticGravity;
     XSetWMNormalHints(xdisplay_, xwindow_, &size_hints);
 
     XMapWindow(xdisplay_, xwindow_);
 
     // We now block until our window is mapped. Some X11 APIs will crash and
     // burn if passed |xwindow_| before the window is mapped, and XMapWindow is
     // asynchronous.
-    base::MessagePumpAuraX11::Current()->BlockUntilWindowMapped(xwindow_);
+    base::MessagePumpX11::Current()->BlockUntilWindowMapped(xwindow_);
     window_mapped_ = true;
   }
 }
 
 void RootWindowHostX11::Hide() {
   if (window_mapped_) {
     XWithdrawWindow(xdisplay_, xwindow_, 0);
     window_mapped_ = false;
   }
 }
@@ skipping 203 matching lines @@
       break;
   }
   XSendEvent(xdisplay_, xwindow_, False, 0, &xevent);
 }
 
 void RootWindowHostX11::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
 }
 
 void RootWindowHostX11::PrepareForShutdown() {
-  base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
+  base::MessagePumpX11::Current()->RemoveDispatcherForWindow(xwindow_);
 }
 
 void RootWindowHostX11::OnWindowInitialized(Window* window) {
 }
 
 void RootWindowHostX11::OnRootWindowInitialized(RootWindow* root_window) {
   // UpdateIsInternalDisplay relies on:
   // 1. delegate_ pointing to RootWindow - available after SetDelegate.
   // 2. RootWindow's kDisplayIdKey property set - available by the time
   //    RootWindow::Init is called.
@@ skipping 215 matching lines @@
 #endif
 }
 
 // static
 RootWindowHost* RootWindowHost::Create(const gfx::Rect& bounds) {
   return new RootWindowHostX11(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
-  ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  ::Display* xdisplay = base::MessagePumpX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura