Move message_pump to base/message_loop.

base/message_loop/message_pump_aurax11.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 "base/message_pump_aurax11.h"
+#include "base/message_loop/message_pump_aurax11.h"
 
 #include <glib.h>
 #include <X11/X.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/XKBlib.h>
 
 #include "base/basictypes.h"
 #include "base/message_loop.h"
 
+namespace base {
+
 namespace {
 
 gboolean XSourcePrepare(GSource* source, gint* timeout_ms) {
-  if (XPending(base::MessagePumpAuraX11::GetDefaultXDisplay()))
+  if (XPending(MessagePumpAuraX11::GetDefaultXDisplay()))
     *timeout_ms = 0;
   else
     *timeout_ms = -1;
   return FALSE;
 }
 
 gboolean XSourceCheck(GSource* source) {
-  return XPending(base::MessagePumpAuraX11::GetDefaultXDisplay());
+  return XPending(MessagePumpAuraX11::GetDefaultXDisplay());
 }
 
 gboolean XSourceDispatch(GSource* source,
                          GSourceFunc unused_func,
                          gpointer data) {
-  base::MessagePumpAuraX11* pump = static_cast<base::MessagePumpAuraX11*>(data);
+  MessagePumpAuraX11* pump = static_cast<MessagePumpAuraX11*>(data);
   return pump->DispatchXEvents();
 }
 
 GSourceFuncs XSourceFuncs = {
   XSourcePrepare,
   XSourceCheck,
   XSourceDispatch,
   NULL
 };
 
 // The connection is essentially a global that's accessed through a static
 // method and destroyed whenever ~MessagePumpAuraX11() is called. We do this
 // for historical reasons so user code can call
 // MessagePumpForUI::GetDefaultXDisplay() where MessagePumpForUI is a typedef
 // to whatever type in the current build.
 //
 // TODO(erg): This can be changed to something more sane like
 // MessagePumpAuraX11::Current()->display() once MessagePumpGtk goes away.
 Display* g_xdisplay = NULL;
 int g_xinput_opcode = -1;
 
 bool InitializeXInput2Internal() {
-  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  Display* display = MessagePumpAuraX11::GetDefaultXDisplay();
   if (!display)
     return false;
 
   int event, err;
 
   int xiopcode;
   if (!XQueryExtension(display, "XInputExtension", &xiopcode, &event, &err)) {
     DVLOG(1) << "X Input extension not available.";
     return false;
   }
@@ skipping 13 matching lines @@
   if (major < 2 || (major == 2 && minor < USE_XI2_MT)) {
     DVLOG(1) << "XI version on server is " << major << "." << minor << ". "
             << "But 2." << USE_XI2_MT << " is required.";
     return false;
   }
 #endif
 
   return true;
 }
 
-Window FindEventTarget(const base::NativeEvent& xev) {
+Window FindEventTarget(const NativeEvent& xev) {
   Window target = xev->xany.window;
   if (xev->type == GenericEvent &&
       static_cast<XIEvent*>(xev->xcookie.data)->extension == g_xinput_opcode) {
     target = static_cast<XIDeviceEvent*>(xev->xcookie.data)->event;
   }
   return target;
 }
 
 bool InitializeXInput2() {
   static bool xinput2_supported = InitializeXInput2Internal();
   return xinput2_supported;
 }
 
 bool InitializeXkb() {
-  Display* display = base::MessagePumpAuraX11::GetDefaultXDisplay();
+  Display* display = MessagePumpAuraX11::GetDefaultXDisplay();
   if (!display)
     return false;
 
   int opcode, event, error;
   int major = XkbMajorVersion;
   int minor = XkbMinorVersion;
   if (!XkbQueryExtension(display, &opcode, &event, &error, &major, &minor)) {
     DVLOG(1) << "Xkb extension not available.";
     return false;
   }
 
   // Ask the server not to send KeyRelease event when the user holds down a key.
   // crbug.com/138092
   Bool supported_return;
   if (!XkbSetDetectableAutoRepeat(display, True, &supported_return)) {
     DVLOG(1) << "XKB not supported in the server.";
     return false;
   }
 
   return true;
 }
 
 }  // namespace
 
-namespace base {
-
 MessagePumpAuraX11::MessagePumpAuraX11() : MessagePumpGlib(),
     x_source_(NULL) {
   InitializeXInput2();
   InitializeXkb();
   InitXSource();
 
   // Can't put this in the initializer list because g_xdisplay may not exist
   // until after InitXSource().
   x_root_window_ = DefaultRootWindow(g_xdisplay);
 }
@@ skipping 129 matching lines @@
       return true;
   }
   return false;
 }
 
 void MessagePumpAuraX11::DidProcessXEvent(XEvent* xevent) {
   FOR_EACH_OBSERVER(MessagePumpObserver, observers(), DidProcessEvent(xevent));
 }
 
 MessagePumpDispatcher* MessagePumpAuraX11::GetDispatcherForXEvent(
-    const base::NativeEvent& xev) const {
+    const NativeEvent& xev) const {
   ::Window x_window = FindEventTarget(xev);
   DispatchersMap::const_iterator it = dispatchers_.find(x_window);
   return it != dispatchers_.end() ? it->second : NULL;
 }
 
-bool MessagePumpAuraX11::Dispatch(const base::NativeEvent& xev) {
+bool MessagePumpAuraX11::Dispatch(const NativeEvent& xev) {
   // MappingNotify events (meaning that the keyboard or pointer buttons have
   // been remapped) aren't associated with a window; send them to all
   // dispatchers.
   if (xev->type == MappingNotify) {
     for (DispatchersMap::const_iterator it = dispatchers_.begin();
          it != dispatchers_.end(); ++it) {
       it->second->Dispatch(xev);
     }
     return true;
   }
 
   if (FindEventTarget(xev) == x_root_window_) {
     FOR_EACH_OBSERVER(MessagePumpDispatcher, root_window_dispatchers_,
                       Dispatch(xev));
     return true;
   }
   MessagePumpDispatcher* dispatcher = GetDispatcherForXEvent(xev);
   return dispatcher ? dispatcher->Dispatch(xev) : true;
 }
 
 }  // namespace base