Consolidate/cleanup event cracking code; single out GdkEvents.

ui/base/touchui/touch_factory.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.
 
-#include "views/touchui/touch_factory.h"
+#include "ui/base/touchui/touch_factory.h"
 
 #include <gtk/gtk.h>
 #include <gdk/gdkx.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/XIproto.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "ui/base/x/x11_util.h"
 
 namespace {
 
 // The X cursor is hidden if it is idle for kCursorIdleSeconds seconds.
 int kCursorIdleSeconds = 5;
 
 // Given the TouchParam, return the correspoding XIValuatorClassInfo using
 // the X device information through Atom name matching.
 XIValuatorClassInfo* FindTPValuator(Display* display,
                                     XIDeviceInfo* info,
-                                    views::TouchFactory::TouchParam tp) {
+                                    ui::TouchFactory::TouchParam tp) {
   // Lookup table for mapping TouchParam to Atom string used in X.
   // A full set of Atom strings can be found at xserver-properties.h.
   // For Slot ID, See this chromeos revision: http://git.chromium.org/gitweb/?
   //        p=chromiumos/overlays/chromiumos-overlay.git;
   //        a=commit;h=9164d0a75e48c4867e4ef4ab51f743ae231c059a
   static struct {
-    views::TouchFactory::TouchParam tp;
+    ui::TouchFactory::TouchParam tp;
     const char* atom;
   } kTouchParamAtom[] = {
-    { views::TouchFactory::TP_TOUCH_MAJOR, "Abs MT Touch Major" },
-    { views::TouchFactory::TP_TOUCH_MINOR, "Abs MT Touch Minor" },
-    { views::TouchFactory::TP_ORIENTATION, "Abs MT Orientation" },
-    { views::TouchFactory::TP_PRESSURE,    "Abs MT Pressure" },
-    { views::TouchFactory::TP_SLOT_ID,     "Abs MT Slot ID" },
-    { views::TouchFactory::TP_TRACKING_ID, "Abs MT Tracking ID" },
-    { views::TouchFactory::TP_LAST_ENTRY, NULL },
+    { ui::TouchFactory::TP_TOUCH_MAJOR, "Abs MT Touch Major" },
+    { ui::TouchFactory::TP_TOUCH_MINOR, "Abs MT Touch Minor" },
+    { ui::TouchFactory::TP_ORIENTATION, "Abs MT Orientation" },
+    { ui::TouchFactory::TP_PRESSURE,    "Abs MT Pressure" },
+    { ui::TouchFactory::TP_SLOT_ID,     "Abs MT Slot ID" },
+    { ui::TouchFactory::TP_TRACKING_ID, "Abs MT Tracking ID" },
+    { ui::TouchFactory::TP_LAST_ENTRY, NULL },
   };
 
   const char* atom_tp = NULL;
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTouchParamAtom); i++) {
     if (tp == kTouchParamAtom[i].tp) {
       atom_tp = kTouchParamAtom[i].atom;
       break;
     }
   }
@@ skipping 13 matching lines @@
   }
 
   return NULL;
 }
 
 // Setup XInput2 select for the GtkWidget.
 gboolean GtkWidgetRealizeCallback(GSignalInvocationHint* hint, guint nparams,
                                   const GValue* pvalues, gpointer data) {
   GtkWidget* widget = GTK_WIDGET(g_value_get_object(pvalues));
   GdkWindow* window = widget->window;
-  views::TouchFactory* factory = static_cast<views::TouchFactory*>(data);
+  ui::TouchFactory* factory = static_cast<ui::TouchFactory*>(data);
 
   if (GDK_WINDOW_TYPE(window) != GDK_WINDOW_TOPLEVEL &&
       GDK_WINDOW_TYPE(window) != GDK_WINDOW_CHILD &&
       GDK_WINDOW_TYPE(window) != GDK_WINDOW_DIALOG)
     return true;
 
   factory->SetupXI2ForXWindow(GDK_WINDOW_XID(window));
   return true;
 }
 
 // We need to capture all the GDK windows that get created, and start
 // listening for XInput2 events. So we setup a callback to the 'realize'
 // signal for GTK+ widgets, so that whenever the signal triggers for any
 // GtkWidget, which means the GtkWidget should now have a GdkWindow, we can
 // setup XInput2 events for the GdkWindow.
 guint realize_signal_id = 0;
 guint realize_hook_id = 0;
 
-void SetupGtkWidgetRealizeNotifier(views::TouchFactory* factory) {
+void SetupGtkWidgetRealizeNotifier(ui::TouchFactory* factory) {
   gpointer klass = g_type_class_ref(GTK_TYPE_WIDGET);
 
   g_signal_parse_name("realize", GTK_TYPE_WIDGET,
                       &realize_signal_id, NULL, FALSE);
   realize_hook_id = g_signal_add_emission_hook(realize_signal_id, 0,
       GtkWidgetRealizeCallback, static_cast<gpointer>(factory), NULL);
 
   g_type_class_unref(klass);
 }
 
 void RemoveGtkWidgetRealizeNotifier() {
   if (realize_signal_id != 0)
     g_signal_remove_emission_hook(realize_signal_id, realize_hook_id);
   realize_signal_id = 0;
   realize_hook_id = 0;
 }
 
 }  // namespace
 
-namespace views {
+namespace ui {
 
 // static
 TouchFactory* TouchFactory::GetInstance() {
   return Singleton<TouchFactory>::get();
 }
 
 TouchFactory::TouchFactory()
     : is_cursor_visible_(true),
       keep_mouse_cursor_(false),
       cursor_timer_(),
@@ skipping 307 matching lines @@
                                       float* min,
                                       float* max) {
   if (valuator_lookup_[deviceid][tp] >= 0) {
     *min = touch_param_min_[deviceid][tp];
     *max = touch_param_max_[deviceid][tp];
     return true;
   }
   return false;
 }
 
-}  // namespace views
+}  // namespace ui