Some dead-code removal from message_pump_x and touch_factory.

ui/base/touch/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 "ui/base/touch/touch_factory.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"
 
-#if defined(TOOLKIT_USES_GTK)
-// TODO(sad) Remove all TOOLKIT_USES_GTK uses once we move to aura only.
-#include <gtk/gtk.h>
-#include <gdk/gdkx.h>
-#endif
-
 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,
                                     ui::TouchFactory::TouchParam tp) {
@@ skipping 36 matching lines @@
         reinterpret_cast<XIValuatorClassInfo*>(info->classes[i]);
 
     const char* atom = XGetAtomName(display, v->label);
     if (atom && strcmp(atom, atom_tp) == 0)
       return v;
   }
 
   return NULL;
 }
 
-#if defined(TOOLKIT_USES_GTK)
-// 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;
-  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(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;
-}
-#endif
-
 }  // namespace
 
 namespace ui {
 
 // static
 TouchFactory* TouchFactory::GetInstance() {
   return Singleton<TouchFactory>::get();
 }
 
 TouchFactory::TouchFactory()
@@ skipping 17 matching lines @@
   Display* display = ui::GetXDisplay();
   Pixmap blank = XCreateBitmapFromData(display, ui::GetX11RootWindow(),
                                        nodata, 8, 8);
   invisible_cursor_ = XCreatePixmapCursor(display, blank, blank,
                                           &black, &black, 0, 0);
   arrow_cursor_ = XCreateFontCursor(display, XC_arrow);
 
   SetCursorVisible(false, false);
   UpdateDeviceList(display);
 
-#if defined(TOOLKIT_USES_GTK)
-  // TODO(sad): Here, we only setup so that the X windows created by GTK+ are
-  // setup for XInput2 events. We need a way to listen for XInput2 events for X
-  // windows created by other means (e.g. for context menus).
-  SetupGtkWidgetRealizeNotifier(this);
-#endif
   // Make sure the list of devices is kept up-to-date by listening for
   // XI_HierarchyChanged event on the root window.
   unsigned char mask[XIMaskLen(XI_LASTEVENT)];
   memset(mask, 0, sizeof(mask));
 
   XISetMask(mask, XI_HierarchyChanged);
 
   XIEventMask evmask;
   evmask.deviceid = XIAllDevices;
   evmask.mask_len = sizeof(mask);
   evmask.mask = mask;
   XISelectEvents(display, ui::GetX11RootWindow(), &evmask, 1);
 }
 
 TouchFactory::~TouchFactory() {
 #if defined(TOUCH_UI)
   if (!base::MessagePumpForUI::HasXInput2())
     return;
 #endif
 
   SetCursorVisible(true, false);
   Display* display = ui::GetXDisplay();
   XFreeCursor(display, invisible_cursor_);
   XFreeCursor(display, arrow_cursor_);
-
-#if defined(TOOLKIT_USES_GTK)
-  RemoveGtkWidgetRealizeNotifier();
-#endif
 }
 
 void TouchFactory::UpdateDeviceList(Display* display) {
   // Detect touch devices.
   // NOTE: The new API for retrieving the list of devices (XIQueryDevice) does
   // not provide enough information to detect a touch device. As a result, the
   // old version of query function (XListInputDevices) is used instead.
   // If XInput2 is not supported, this will return null (with count of -1) so
   // we assume there cannot be any touch devices.
   int count = 0;
@@ skipping 333 matching lines @@
                                       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 ui