Consolidate/cleanup event cracking code; single out GdkEvents.

views/widget/native_widget_gtk.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/widget/native_widget_gtk.h"
 
 #include <gdk/gdk.h>
 #include <gdk/gdkx.h>
 #include <X11/extensions/shape.h>
 #include <X11/Xatom.h>
@@ skipping 24 matching lines @@
 #include "views/views_delegate.h"
 #include "views/widget/drop_target_gtk.h"
 #include "views/widget/gtk_views_fixed.h"
 #include "views/widget/gtk_views_window.h"
 #include "views/widget/native_widget_views.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/hit_test.h"
 
 #if defined(TOUCH_UI)
+#include "ui/base/touch/touch_factory.h"
 #include "views/widget/tooltip_manager_views.h"
-#include "views/touchui/touch_factory.h"
 #else
 #include "views/widget/tooltip_manager_gtk.h"
 #endif
 
 #if defined(HAVE_IBUS)
 #include "views/ime/input_method_ibus.h"
 #endif
 
 using ui::OSExchangeData;
 using ui::OSExchangeDataProviderGtk;
@@ skipping 316 matching lines @@
       should_handle_menu_key_release_(false),
       dragged_view_(NULL),
       painted_(false),
       has_pointer_grab_(false),
       has_keyboard_grab_(false),
       grab_notify_signal_id_(0),
       is_menu_(false) {
 #if defined(TOUCH_UI)
   // Make sure the touch factory is initialized so that it can setup XInput2 for
   // the widget.
-  TouchFactory::GetInstance();
+  ui::TouchFactory::GetInstance();
 #endif
   static bool installed_message_loop_observer = false;
   if (!installed_message_loop_observer) {
     installed_message_loop_observer = true;
     MessageLoopForUI* loop = MessageLoopForUI::current();
     if (loop)
       loop->AddObserver(DropObserver::GetInstance());
   }
 }
 
@@ skipping 525 matching lines @@
                          NULL, NULL, GDK_CURRENT_TIME);
     // NOTE: technically grab may fail. We may want to try and continue on in
     // that case.
     DCHECK_EQ(GDK_GRAB_SUCCESS, pointer_grab_status);
     has_pointer_grab_ = pointer_grab_status == GDK_GRAB_SUCCESS;
 
 #if defined(TOUCH_UI)
     ::Window window = GDK_WINDOW_XID(window_contents()->window);
     Display* display = GDK_WINDOW_XDISPLAY(window_contents()->window);
     bool xi2grab =
-        TouchFactory::GetInstance()->GrabTouchDevices(display, window);
+        ui::TouchFactory::GetInstance()->GrabTouchDevices(display, window);
     // xi2grab should always succeed if has_pointer_grab_ succeeded.
     DCHECK(xi2grab);
     has_pointer_grab_ = has_pointer_grab_ && xi2grab;
 #endif
   }
 }
 
 void NativeWidgetGtk::ReleaseMouseCapture() {
   bool delegate_lost_capture = HasMouseCapture();
   if (GTK_WIDGET_HAS_GRAB(window_contents_))
     gtk_grab_remove(window_contents_);
   if (grab_notify_signal_id_) {
     g_signal_handler_disconnect(window_contents_, grab_notify_signal_id_);
     grab_notify_signal_id_ = 0;
   }
   if (has_pointer_grab_) {
     has_pointer_grab_ = false;
     gdk_pointer_ungrab(GDK_CURRENT_TIME);
 #if defined(TOUCH_UI)
-    TouchFactory::GetInstance()->UngrabTouchDevices(
+    ui::TouchFactory::GetInstance()->UngrabTouchDevices(
         GDK_WINDOW_XDISPLAY(window_contents()->window));
 #endif
   }
   if (delegate_lost_capture)
     delegate_->OnMouseCaptureLost();
 }
 
 bool NativeWidgetGtk::HasMouseCapture() const {
   return GTK_WIDGET_HAS_GRAB(window_contents_) || has_pointer_grab_;
 }
@@ skipping 343 matching lines @@
   // 3) If it's never painted before. The first expose event will
   // paint the area that has to be painted.
   if (widget_ && GTK_WIDGET_DRAWABLE(widget_) && painted_) {
     gtk_widget_queue_draw_area(widget_, rect.x(), rect.y(), rect.width(),
                                rect.height());
   }
 }
 
 void NativeWidgetGtk::SetCursor(gfx::NativeCursor cursor) {
 #if defined(TOUCH_UI)
-  if (TouchFactory::GetInstance()->keep_mouse_cursor())
+  if (ui::TouchFactory::GetInstance()->keep_mouse_cursor())
     cursor = gfx::GetCursor(GDK_ARROW);
-  else if (!TouchFactory::GetInstance()->is_cursor_visible())
+  else if (!ui::TouchFactory::GetInstance()->is_cursor_visible())
     cursor = gfx::GetCursor(GDK_BLANK_CURSOR);
 #endif
   // |window_contents_| is placed on top of |widget_|. So the cursor needs to be
   // set on |window_contents_| instead of |widget_|.
   if (window_contents_)
     gdk_window_set_cursor(window_contents_->window, cursor);
 }
 
 void NativeWidgetGtk::ClearNativeFocus() {
   DCHECK(!child_);
@@ skipping 361 matching lines @@
     return false;
 
   // Only top-level Widget should have an InputMethod instance.
   InputMethod* input_method = GetWidget()->GetInputMethod();
   if (input_method)
     input_method->OnBlur();
   return false;
 }
 
 gboolean NativeWidgetGtk::OnEventKey(GtkWidget* widget, GdkEventKey* event) {
-  KeyEvent key(reinterpret_cast<NativeEvent>(event));
+  KeyEvent key(reinterpret_cast<GdkEvent*>(event));
   InputMethod* input_method = GetWidget()->GetInputMethod();
   if (input_method)
     input_method->DispatchKeyEvent(key);
   else
     DispatchKeyEventPostIME(key);
 
   // Returns true to prevent GtkWindow's default key event handler.
   return true;
 }
 
@@ skipping 36 matching lines @@
     has_pointer_grab_ = false;
     if (has_keyboard_grab_) {
       has_keyboard_grab_ = false;
       gdk_keyboard_ungrab(GDK_CURRENT_TIME);
     }
     delegate_->OnMouseCaptureLost();
   }
   ReleaseMouseCapture();
 
 #if defined(HAVE_XINPUT2) && defined(TOUCH_UI)
-  TouchFactory::GetInstance()->UngrabTouchDevices(
+  ui::TouchFactory::GetInstance()->UngrabTouchDevices(
       GDK_WINDOW_XDISPLAY(window_contents()->window));
 #endif
   return false;  // To let other widgets get the event.
 }
 
 void NativeWidgetGtk::OnGrabNotify(GtkWidget* widget, gboolean was_grabbed) {
   // Sent when gtk_grab_add changes.
   if (!window_contents_)
     return;  // Grab broke after window destroyed, don't try processing it.
   if (!was_grabbed)  // Indicates we've been shadowed (lost grab).
@@ skipping 74 matching lines @@
   // Send the key event to View hierarchy first.
   bool handled = delegate_->OnKeyEvent(key);
 
   if (key.key_code() == ui::VKEY_PROCESSKEY || handled)
     return;
 
   // Dispatch the key event to native GtkWidget hierarchy.
   // To prevent GtkWindow from handling the key event as a keybinding, we need
   // to bypass GtkWindow's default key event handler and dispatch the event
   // here.
-  GdkEventKey* event = reinterpret_cast<GdkEventKey*>(key.native_event());
+  GdkEventKey* event = reinterpret_cast<GdkEventKey*>(key.gdk_event());
   if (!handled && event && GTK_IS_WINDOW(widget_))
     handled = gtk_window_propagate_key_event(GTK_WINDOW(widget_), event);
 
   // On Linux, in order to handle VKEY_MENU (Alt) accelerator key correctly and
   // avoid issues like: http://crbug.com/40966 and http://crbug.com/49701, we
   // should only send the key event to the focus manager if it's not handled by
   // any View or native GtkWidget.
   // The flow is different when the focus is in a RenderWidgetHostViewGtk, which
   // always consumes the key event and send it back to us later by calling
   // HandleKeyboardEvent() directly, if it's not handled by webkit.
@@ skipping 411 matching lines @@
     button_pressed = event->type == GDK_BUTTON_PRESS ||
         event->type == GDK_2BUTTON_PRESS ||
         event->type == GDK_3BUTTON_PRESS;
     gdk_event_free(event);
   }
   return button_pressed;
 }
 
 }  // namespace internal
 }  // namespace views