Remove ifdef's for touchui stuff from events code.

Also, make sure the touch_pressed_handler_ is the view being removed before resetting it to NULL.

BUG=none
TEST=things compile and existing tests continue to pass

Review URL: http://codereview.chromium.org/7276002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@90762 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 102 insertions, 216 deletions

diff --git a/views/events/event.cc b/views/events/event.cc
index 93e5735..102243a 100644
--- a/views/events/event.cc
+++ b/views/events/event.cc
@@ -4,6 +4,7 @@
 
 #include "views/events/event.h"
 
+#include "base/logging.h"
 #include "views/view.h"
 #include "views/widget/root_view.h"
 
@@ -176,10 +177,45 @@ MouseEvent::MouseEvent(const MouseEvent& model, View* source, View* target)
     : LocatedEvent(model, source, target) {
 }
 
+MouseEvent::MouseEvent(const TouchEvent& touch,
+                       FromNativeEvent2 from_native)
+    : LocatedEvent(touch.native_event_2(), from_native) {
+  // The location of the event is correctly extracted from the native event. But
+  // it is necessary to update the event type.
+  ui::EventType mtype = ui::ET_UNKNOWN;
+  switch (touch.type()) {
+    case ui::ET_TOUCH_RELEASED:
+      mtype = ui::ET_MOUSE_RELEASED;
+      break;
+    case ui::ET_TOUCH_PRESSED:
+      mtype = ui::ET_MOUSE_PRESSED;
+      break;
+    case ui::ET_TOUCH_MOVED:
+      mtype = ui::ET_MOUSE_MOVED;
+      break;
+    default:
+      NOTREACHED() << "Invalid mouse event.";
+  }
+  set_type(mtype);
+
+  // It may not be possible to extract the button-information necessary for a
+  // MouseEvent from the native event for a TouchEvent, so the flags are
+  // explicitly updated as well. The button is approximated from the touchpoint
+  // identity.
+  int new_flags = flags() & ~(ui::EF_LEFT_BUTTON_DOWN |
+                              ui::EF_RIGHT_BUTTON_DOWN |
+                              ui::EF_MIDDLE_BUTTON_DOWN);
+  int button = ui::EF_LEFT_BUTTON_DOWN;
+  if (touch.identity() == 1)
+    button = ui::EF_RIGHT_BUTTON_DOWN;
+  else if (touch.identity() == 2)
+    button = ui::EF_MIDDLE_BUTTON_DOWN;
+  set_flags(new_flags | button);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent, public:
 
-#if defined(TOUCH_UI)
 TouchEvent::TouchEvent(ui::EventType type,
                        int x,
                        int y,
@@ -217,7 +253,6 @@ TouchEvent::TouchEvent(const TouchEvent& model, View* root)
       rotation_angle_(model.rotation_angle_),
       force_(model.force_) {
 }
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // MouseWheelEvent, public:
diff --git a/views/events/event.h b/views/events/event.h
index 531b506..03eec99 100644
--- a/views/events/event.h
+++ b/views/events/event.h
@@ -13,7 +13,7 @@
 #include "ui/gfx/point.h"
 #include "views/native_types.h"
 
-#if defined(TOUCH_UI)
+#if defined(USE_X11)
 typedef union _XEvent XEvent;
 #endif
 
@@ -79,7 +79,6 @@ class Event {
            type_ == ui::ET_MOUSEWHEEL;
   }
 
-#if defined(TOUCH_UI)
   bool IsTouchEvent() const {
     return type_ == ui::ET_TOUCH_RELEASED ||
            type_ == ui::ET_TOUCH_PRESSED ||
@@ -87,7 +86,6 @@ class Event {
            type_ == ui::ET_TOUCH_STATIONARY ||
            type_ == ui::ET_TOUCH_CANCELLED;
   }
-#endif
 
 #if defined(OS_WIN)
   // Returns the EventFlags in terms of windows flags.
@@ -165,9 +163,7 @@ class LocatedEvent : public Event {
   gfx::Point location_;
 };
 
-#if defined(TOUCH_UI)
 class TouchEvent;
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 //
@@ -186,14 +182,12 @@ class MouseEvent : public LocatedEvent {
   // from |source| coordinate system to |target| coordinate system.
   MouseEvent(const MouseEvent& model, View* source, View* target);
 
-#if defined(TOUCH_UI)
   // Creates a new MouseEvent from a TouchEvent. The location of the TouchEvent
   // is the same as the MouseEvent. Other attributes (e.g. type, flags) are
   // mapped from the TouchEvent to appropriate MouseEvent attributes.
   // GestureManager uses this to convert TouchEvents that are not handled by any
   // view.
   MouseEvent(const TouchEvent& touch, FromNativeEvent2 from_native);
-#endif
 
   // TODO(msw): Kill this legacy constructor when we update uses.
   // Create a new mouse event
@@ -241,7 +235,6 @@ class MouseEvent : public LocatedEvent {
   DISALLOW_COPY_AND_ASSIGN(MouseEvent);
 };
 
-#if defined(TOUCH_UI)
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TouchEvent class
@@ -301,7 +294,6 @@ class TouchEvent : public LocatedEvent {
 
   DISALLOW_COPY_AND_ASSIGN(TouchEvent);
 };
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // KeyEvent class
diff --git a/views/events/event_gtk.cc b/views/events/event_gtk.cc
index aaa6723..e5018df 100644
--- a/views/events/event_gtk.cc
+++ b/views/events/event_gtk.cc
@@ -106,15 +106,6 @@ int GetFlagsFromGdkState(unsigned int state) {
   return flags;
 }
 
-#if !defined(TOUCH_UI)
-uint16 GetCharacterFromGdkKeyval(guint keyval) {
-  guint32 ch = gdk_keyval_to_unicode(keyval);
-
-  // We only support BMP characters.
-  return ch < 0xFFFE ? static_cast<uint16>(ch) : 0;
-}
-#endif
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -155,16 +146,6 @@ void Event::InitWithNativeEvent(NativeEvent native_event) {
   native_event_2_ = NULL;
 }
 
-#if !defined(TOUCH_UI)
-void Event::InitWithNativeEvent2(NativeEvent2 native_event_2,
-                                 FromNativeEvent2) {
-  // No one should ever call this on non-Touch Linux.
-  // TODO(beng): remove once we rid views of Gtk/Gdk.
-  NOTREACHED();
-  native_event_2_ = NULL;
-}
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
 // LocatedEvent, protected:
 
@@ -174,16 +155,6 @@ LocatedEvent::LocatedEvent(NativeEvent native_event)
       location_(GetMouseEventLocation(native_event)) {
 }
 
-#if !defined(TOUCH_UI)
-LocatedEvent::LocatedEvent(NativeEvent2 native_event_2,
-                           FromNativeEvent2 from_native)
-    : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) {
-  // No one should ever call this on Gtk-views.
-  // TODO(msw): remove once we rid views of Gtk/Gdk.
-  NOTREACHED();
-}
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
 // MouseEvent, public:
 
@@ -191,16 +162,6 @@ MouseEvent::MouseEvent(NativeEvent native_event)
     : LocatedEvent(native_event) {
 }
 
-#if !defined(TOUCH_UI)
-MouseEvent::MouseEvent(NativeEvent2 native_event_2,
-                       FromNativeEvent2 from_native)
-    : LocatedEvent(native_event_2, from_native) {
-  // No one should ever call this on Gtk-views.
-  // TODO(msw): remove once we rid views of Gtk/Gdk.
-  NOTREACHED();
-}
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
 // KeyEvent, public:
 
@@ -211,52 +172,6 @@ KeyEvent::KeyEvent(NativeEvent native_event)
                 GetGdkEventKeyFromNative(native_event))) {
 }
 
-#if !defined(TOUCH_UI)
-KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native)
-    : Event(native_event_2, ui::ET_UNKNOWN, 0, from_native) {
-  // No one should ever call this on Gtk-views.
-  // TODO(beng): remove once we rid views of Gtk/Gdk.
-  NOTREACHED();
-}
-
-uint16 KeyEvent::GetCharacter() const {
-  // Gtk doesn't support control characters.
-  if (IsControlDown() || !native_event())
-    return GetCharacterFromKeyCode(key_code_, flags());
-
-  uint16 ch = GetCharacterFromGdkKeyval(
-      GetGdkEventKeyFromNative(native_event())->keyval);
-  return ch ? ch : GetCharacterFromKeyCode(key_code_, flags());
-}
-
-uint16 KeyEvent::GetUnmodifiedCharacter() const {
-  if (!native_event())
-    return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN);
-
-  GdkEventKey* key = GetGdkEventKeyFromNative(native_event());
-
-  static const guint kIgnoredModifiers =
-      GDK_CONTROL_MASK | GDK_LOCK_MASK | GDK_MOD1_MASK | GDK_MOD2_MASK |
-      GDK_MOD3_MASK | GDK_MOD4_MASK | GDK_MOD5_MASK | GDK_SUPER_MASK |
-      GDK_HYPER_MASK | GDK_META_MASK;
-
-  // We can't use things like (key->state & GDK_SHIFT_MASK), as it may mask out
-  // bits used by X11 or Gtk internally.
-  GdkModifierType modifiers =
-      static_cast<GdkModifierType>(key->state & ~kIgnoredModifiers);
-  guint keyval = 0;
-  uint16 ch = 0;
-  if (gdk_keymap_translate_keyboard_state(NULL, key->hardware_keycode,
-                                          modifiers, key->group, &keyval,
-                                          NULL, NULL, NULL)) {
-    ch = GetCharacterFromGdkKeyval(keyval);
-  }
-
-  return ch ? ch :
-      GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN);
-}
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
 // MouseWheelEvent, public:
 
@@ -265,14 +180,4 @@ MouseWheelEvent::MouseWheelEvent(NativeEvent native_event)
       offset_(GetMouseWheelOffset(native_event)) {
 }
 
-#if !defined(TOUCH_UI)
-MouseWheelEvent::MouseWheelEvent(NativeEvent2 native_event_2,
-                                 FromNativeEvent2 from_native)
-    : MouseEvent(native_event_2, from_native) {
-  // No one should ever call this on Gtk-views.
-  // TODO(msw): remove once we rid views of Gtk/Gdk.
-  NOTREACHED();
-}
-#endif
-
 }  // namespace views
diff --git a/views/events/event_x.cc b/views/events/event_x.cc
index ec1d722..1849728 100644
--- a/views/events/event_x.cc
+++ b/views/events/event_x.cc
@@ -268,6 +268,21 @@ float GetTouchForceFromXEvent(XEvent* xev) {
   return force;
 }
 
+// The following two functions are copied from event_gtk.cc. These will be
+// removed when GTK dependency is removed.
+uint16 GetCharacterFromGdkKeyval(guint keyval) {
+  guint32 ch = gdk_keyval_to_unicode(keyval);
+
+  // We only support BMP characters.
+  return ch < 0xFFFE ? static_cast<uint16>(ch) : 0;
+}
+
+GdkEventKey* GetGdkEventKeyFromNative(NativeEvent native_event) {
+  DCHECK(native_event->type == GDK_KEY_PRESS ||
+         native_event->type == GDK_KEY_RELEASE);
+  return &native_event->key;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -304,8 +319,15 @@ KeyEvent::KeyEvent(NativeEvent2 native_event_2, FromNativeEvent2 from_native)
 }
 
 uint16 KeyEvent::GetCharacter() const {
-  if (!native_event_2())
-    return GetCharacterFromKeyCode(key_code_, flags());
+  if (!native_event_2()) {
+    // This event may have been created from a Gdk event.
+    if (IsControlDown() || !native_event())
+      return GetCharacterFromKeyCode(key_code_, flags());
+
+    uint16 ch = GetCharacterFromGdkKeyval(
+        GetGdkEventKeyFromNative(native_event())->keyval);
+    return ch ? ch : GetCharacterFromKeyCode(key_code_, flags());
+  }
 
   DCHECK(native_event_2()->type == KeyPress ||
          native_event_2()->type == KeyRelease);
@@ -315,8 +337,33 @@ uint16 KeyEvent::GetCharacter() const {
 }
 
 uint16 KeyEvent::GetUnmodifiedCharacter() const {
-  if (!native_event_2())
-    return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN);
+  if (!native_event_2()) {
+    // This event may have been created from a Gdk event.
+    if (!native_event())
+      return GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN);
+
+    GdkEventKey* key = GetGdkEventKeyFromNative(native_event());
+
+    static const guint kIgnoredModifiers =
+      GDK_CONTROL_MASK | GDK_LOCK_MASK | GDK_MOD1_MASK | GDK_MOD2_MASK |
+      GDK_MOD3_MASK | GDK_MOD4_MASK | GDK_MOD5_MASK | GDK_SUPER_MASK |
+      GDK_HYPER_MASK | GDK_META_MASK;
+
+    // We can't use things like (key->state & GDK_SHIFT_MASK), as it may mask
+    // out bits used by X11 or Gtk internally.
+    GdkModifierType modifiers =
+      static_cast<GdkModifierType>(key->state & ~kIgnoredModifiers);
+    guint keyval = 0;
+    uint16 ch = 0;
+    if (gdk_keymap_translate_keyboard_state(NULL, key->hardware_keycode,
+          modifiers, key->group, &keyval,
+          NULL, NULL, NULL)) {
+      ch = GetCharacterFromGdkKeyval(keyval);
+    }
+
+    return ch ? ch :
+      GetCharacterFromKeyCode(key_code_, flags() & ui::EF_SHIFT_DOWN);
+  }
 
   DCHECK(native_event_2()->type == KeyPress ||
          native_event_2()->type == KeyRelease);
@@ -342,42 +389,6 @@ MouseEvent::MouseEvent(NativeEvent2 native_event_2,
     : LocatedEvent(native_event_2, from_native) {
 }
 
-MouseEvent::MouseEvent(const TouchEvent& touch,
-                       FromNativeEvent2 from_native)
-    : LocatedEvent(touch.native_event_2(), from_native) {
-  // The location of the event is correctly extracted from the native event. But
-  // it is necessary to update the event type.
-  ui::EventType mtype = ui::ET_UNKNOWN;
-  switch (touch.type()) {
-    case ui::ET_TOUCH_RELEASED:
-      mtype = ui::ET_MOUSE_RELEASED;
-      break;
-    case ui::ET_TOUCH_PRESSED:
-      mtype = ui::ET_MOUSE_PRESSED;
-      break;
-    case ui::ET_TOUCH_MOVED:
-      mtype = ui::ET_MOUSE_MOVED;
-      break;
-    default:
-      NOTREACHED() << "Invalid mouse event.";
-  }
-  set_type(mtype);
-
-  // It may not be possible to extract the button-information necessary for a
-  // MouseEvent from the native event for a TouchEvent, so the flags are
-  // explicitly updated as well. The button is approximated from the touchpoint
-  // identity.
-  int new_flags = flags() & ~(ui::EF_LEFT_BUTTON_DOWN |
-                              ui::EF_RIGHT_BUTTON_DOWN |
-                              ui::EF_MIDDLE_BUTTON_DOWN);
-  int button = ui::EF_LEFT_BUTTON_DOWN;
-  if (touch.identity() == 1)
-    button = ui::EF_RIGHT_BUTTON_DOWN;
-  else if (touch.identity() == 2)
-    button = ui::EF_MIDDLE_BUTTON_DOWN;
-  set_flags(new_flags | button);
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // MouseWheelEvent, public:
 
diff --git a/views/native_types.h b/views/native_types.h
index d3690a9..7d8f503 100644
--- a/views/native_types.h
+++ b/views/native_types.h
@@ -11,7 +11,7 @@
 #if defined(OS_LINUX)
 typedef union _GdkEvent GdkEvent;
 #endif
-#if defined(TOUCH_UI)
+#if defined(USE_X11)
 typedef union _XEvent XEvent;
 #endif
 
@@ -35,7 +35,7 @@ typedef MSG NativeEvent;
 #if defined(OS_LINUX)
 typedef GdkEvent* NativeEvent;
 #endif
-#if defined(TOUCH_UI)
+#if defined(USE_X11)
 typedef XEvent* NativeEvent2;
 #else
 typedef void* NativeEvent2;
diff --git a/views/view.cc b/views/view.cc
index eca7c75..db5f589 100644
--- a/views/view.cc
+++ b/views/view.cc
@@ -864,12 +864,10 @@ void View::OnMouseEntered(const MouseEvent& event) {
 void View::OnMouseExited(const MouseEvent& event) {
 }
 
-#if defined(TOUCH_UI)
 ui::TouchStatus View::OnTouchEvent(const TouchEvent& event) {
   DVLOG(1) << "visited the OnTouchEvent";
   return ui::TOUCH_STATUS_UNKNOWN;
 }
-#endif
 
 void View::SetMouseHandler(View *new_mouse_handler) {
   // It is valid for new_mouse_handler to be NULL
@@ -1834,13 +1832,11 @@ void View::ProcessMouseReleased(const MouseEvent& event) {
   // WARNING: we may have been deleted.
 }
 
-#if defined(TOUCH_UI)
 ui::TouchStatus View::ProcessTouchEvent(const TouchEvent& event) {
   // TODO(rjkroege): Implement a grab scheme similar to as
   // as is found in MousePressed.
   return OnTouchEvent(event);
 }
-#endif
 
 // Accelerators ----------------------------------------------------------------
 
diff --git a/views/view.h b/views/view.h
index 03374bc..a76b125 100644
--- a/views/view.h
+++ b/views/view.h
@@ -38,9 +38,7 @@ class Layer;
 class Texture;
 class ThemeProvider;
 class Transform;
-#if defined(TOUCH_UI)
 enum TouchStatus;
-#endif
 }
 
 #if defined(OS_WIN)
@@ -569,11 +567,9 @@ class View : public AcceleratorTarget {
   // Default implementation does nothing. Override as needed.
   virtual void OnMouseExited(const MouseEvent& event);
 
-#if defined(TOUCH_UI)
   // This method is invoked for each touch event. Default implementation
   // does nothing. Override as needed.
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event);
-#endif
 
   // Set the MouseHandler for a drag session.
   //
@@ -1243,11 +1239,9 @@ class View : public AcceleratorTarget {
   bool ProcessMouseDragged(const MouseEvent& event, DragInfo* drop_info);
   void ProcessMouseReleased(const MouseEvent& event);
 
-#if defined(TOUCH_UI)
   // RootView will invoke this with incoming TouchEvents. Returns the
   // the result of OnTouchEvent.
   ui::TouchStatus ProcessTouchEvent(const TouchEvent& event);
-#endif
 
   // Accelerators --------------------------------------------------------------
 
diff --git a/views/view_unittest.cc b/views/view_unittest.cc
index bd6a030..16e4d99 100644
--- a/views/view_unittest.cc
+++ b/views/view_unittest.cc
@@ -27,6 +27,7 @@
 #include "views/focus/view_storage.h"
 #include "views/layer_property_setter.h"
 #include "views/test/views_test_base.h"
+#include "views/touchui/gesture_manager.h"
 #include "views/view.h"
 #include "views/views_delegate.h"
 #include "views/widget/native_widget.h"
@@ -37,9 +38,6 @@
 #include "views/controls/button/native_button_win.h"
 #include "views/test/test_views_delegate.h"
 #endif
-#if defined(TOUCH_UI)
-#include "views/touchui/gesture_manager.h"
-#endif
 
 using ::testing::_;
 
@@ -54,7 +52,7 @@ typedef ViewsTestBase ViewTest;
 ////////////////////////////////////////////////////////////////////////////////
 class TestView : public View {
  public:
-  TestView() : View() {
+  TestView() : View(), in_touch_sequence_(false) {
   }
 
   virtual ~TestView() {}
@@ -64,10 +62,8 @@ class TestView : public View {
     did_change_bounds_ = false;
     last_mouse_event_type_ = 0;
     location_.SetPoint(0, 0);
-#if defined(TOUCH_UI)
     last_touch_event_type_ = 0;
     last_touch_event_was_handled_ = false;
-#endif
     last_clip_.setEmpty();
     accelerator_count_map_.clear();
   }
@@ -76,9 +72,7 @@ class TestView : public View {
   virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE;
-#if defined(TOUCH_UI)
-  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event);
-#endif
+  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas) OVERRIDE;
   virtual void SchedulePaintInternal(const gfx::Rect& rect) OVERRIDE;
   virtual bool AcceleratorPressed(const Accelerator& accelerator) OVERRIDE;
@@ -94,12 +88,10 @@ class TestView : public View {
   // Painting
   std::vector<gfx::Rect> scheduled_paint_rects_;
 
-  #if defined(TOUCH_UI)
   // TouchEvent
   int last_touch_event_type_;
   bool last_touch_event_was_handled_;
   bool in_touch_sequence_;
-#endif
 
   // Painting
   SkRect last_clip_;
@@ -108,7 +100,6 @@ class TestView : public View {
   std::map<Accelerator, int> accelerator_count_map_;
 };
 
-#if defined(TOUCH_UI)
 // Mock instance of the GestureManager for testing.
 class MockGestureManager : public GestureManager {
  public:
@@ -141,9 +132,8 @@ class TestViewIgnoreTouch : public TestView {
 
   virtual ~TestViewIgnoreTouch() {}
  private:
-  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event);
+  virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
 };
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // OnBoundsChanged
@@ -251,7 +241,6 @@ TEST_F(ViewTest, MouseEvent) {
   widget->CloseNow();
 }
 
-#if defined(TOUCH_UI)
 ////////////////////////////////////////////////////////////////////////////////
 // TouchEvent
 ////////////////////////////////////////////////////////////////////////////////
@@ -379,6 +368,7 @@ TEST_F(ViewTest, TouchEvent) {
                      0, /* no flags */
                      0, /* first finger touch */
                      1.0, 0.0, 1.0, 0.0);
+
   root->OnTouchEvent(dragged);
   EXPECT_EQ(v2->last_touch_event_type_, ui::ET_TOUCH_MOVED);
   EXPECT_EQ(v2->location_.x(), -50);
@@ -409,7 +399,6 @@ TEST_F(ViewTest, TouchEvent) {
 
   widget->CloseNow();
 }
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // Painting
@@ -2250,7 +2239,7 @@ TEST_F(ViewTest, GetViewByID) {
 // Layers
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(VIEWS_COMPOSITOR) || defined(TOUCH_UI)
+#if defined(VIEWS_COMPOSITOR)
 
 namespace {
 
@@ -2563,6 +2552,6 @@ TEST_F(ViewLayerTest, PaintAll) {
   EXPECT_EQ(view->GetLocalBounds(), texture->bounds_of_last_paint());
 }
 
-#endif  // VIEWS_COMPOSITOR || TOUCH_UI
+#endif  // VIEWS_COMPOSITOR
 
 }  // namespace views
diff --git a/views/views.gyp b/views/views.gyp
index 043803f..9003a44 100644
--- a/views/views.gyp
+++ b/views/views.gyp
@@ -46,12 +46,11 @@
         ['include', '_(win)\\.cc$'],
         ['include', '/win/'],
         ['include', '/win_[^/]*\\.cc$'],
+        ['exclude', 'touchui/touch_factory.cc'],
       ]}],
       ['touchui==0', {'sources/': [
-        ['exclude', 'events/event_x.cc$'],
         ['exclude', 'native_menu_x.cc$'],
         ['exclude', 'native_menu_x.h$'],
-        ['exclude', 'touchui/'],
         ['exclude', '_(touch)\\.cc$'],
         ['exclude', 'widget/tooltip_manager_views.cc$'],
       ]}],
diff --git a/views/widget/native_widget_delegate.h b/views/widget/native_widget_delegate.h
index ec6a941..41b4246 100644
--- a/views/widget/native_widget_delegate.h
+++ b/views/widget/native_widget_delegate.h
@@ -89,9 +89,7 @@ class NativeWidgetDelegate {
   virtual bool OnKeyEvent(const KeyEvent& event) = 0;
   virtual bool OnMouseEvent(const MouseEvent& event) = 0;
   virtual void OnMouseCaptureLost() = 0;
-#if defined(TOUCH_UI)
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) = 0;
-#endif
 
   // Runs the specified native command. Returns true if the command is handled.
   virtual bool ExecuteCommand(int command_id) = 0;
diff --git a/views/widget/native_widget_view.cc b/views/widget/native_widget_view.cc
index ff26a06..d54a91d 100644
--- a/views/widget/native_widget_view.cc
+++ b/views/widget/native_widget_view.cc
@@ -82,11 +82,9 @@ void NativeWidgetView::OnMouseExited(const MouseEvent& event) {
   delegate()->OnMouseEvent(event);
 }
 
-#if defined(TOUCH_UI)
 ui::TouchStatus NativeWidgetView::OnTouchEvent(const TouchEvent& event) {
   return delegate()->OnTouchEvent(event);
 }
-#endif
 
 bool NativeWidgetView::OnKeyPressed(const KeyEvent& event) {
   return delegate()->OnKeyEvent(event);
diff --git a/views/widget/native_widget_view.h b/views/widget/native_widget_view.h
index 5359eba..78f3b2d 100644
--- a/views/widget/native_widget_view.h
+++ b/views/widget/native_widget_view.h
@@ -10,11 +10,9 @@
 #include "views/widget/native_widget_delegate.h"
 #include "views/widget/native_widget_views.h"
 
-#if defined(TOUCH_UI)
 namespace ui {
 enum TouchStatus;
 }
-#endif
 
 namespace views {
 class NativeWidgetViews;
@@ -55,9 +53,7 @@ class NativeWidgetView : public View {
   virtual void OnMouseMoved(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseEntered(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const MouseEvent& event) OVERRIDE;
-#if defined(TOUCH_UI)
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
-#endif
   virtual bool OnKeyPressed(const KeyEvent& event) OVERRIDE;
   virtual bool OnKeyReleased(const KeyEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const MouseWheelEvent& event) OVERRIDE;
diff --git a/views/widget/root_view.cc b/views/widget/root_view.cc
index b50fbba..e4f4d52 100644
--- a/views/widget/root_view.cc
+++ b/views/widget/root_view.cc
@@ -14,11 +14,8 @@
 #include "ui/gfx/canvas_skia.h"
 #include "views/focus/view_storage.h"
 #include "views/layout/fill_layout.h"
-#include "views/widget/widget.h"
-
-#if defined(TOUCH_UI)
 #include "views/touchui/gesture_manager.h"
-#endif
+#include "views/widget/widget.h"
 
 namespace views {
 namespace internal {
@@ -40,10 +37,8 @@ RootView::RootView(Widget* widget)
       last_mouse_event_flags_(0),
       last_mouse_event_x_(-1),
       last_mouse_event_y_(-1),
-#if defined(TOUCH_UI)
       gesture_manager_(GestureManager::GetInstance()),
       touch_pressed_handler_(NULL),
-#endif
       ALLOW_THIS_IN_INITIALIZER_LIST(focus_search_(this, false, false)),
       focus_traversable_parent_(NULL),
       focus_traversable_parent_view_(NULL) {
@@ -328,7 +323,6 @@ bool RootView::OnMouseWheel(const MouseWheelEvent& event) {
   return consumed;
 }
 
-#if defined(TOUCH_UI)
 ui::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
   TouchEvent e(event, this);
 
@@ -392,7 +386,6 @@ ui::TouchStatus RootView::OnTouchEvent(const TouchEvent& event) {
     status = ui::TOUCH_STATUS_SYNTH_MOUSE;
   return status;
 }
-#endif
 
 void RootView::SetMouseHandler(View *new_mh) {
   // If we're clearing the mouse handler, clear explicit_mouse_handler_ as well.
@@ -415,10 +408,8 @@ void RootView::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
       mouse_pressed_handler_ = NULL;
     if (mouse_move_handler_ == child)
       mouse_move_handler_ = NULL;
-#if defined(TOUCH_UI)
-    if (touch_pressed_handler_)
+    if (touch_pressed_handler_ == child)
       touch_pressed_handler_ = NULL;
-#endif
   }
 }
 
diff --git a/views/widget/root_view.h b/views/widget/root_view.h
index 733988c..99980c5 100644
--- a/views/widget/root_view.h
+++ b/views/widget/root_view.h
@@ -13,18 +13,14 @@
 #include "views/focus/focus_search.h"
 #include "views/view.h"
 
-#if defined(TOUCH_UI)
 namespace ui {
 enum TouchStatus;
 }
-#endif
 
 namespace views {
 
 class Widget;
-#if defined(TOUCH_UI)
 class GestureManager;
-#endif
 
 // This is a views-internal API and should not be used externally.
 // Widget exposes this object as a View*.
@@ -72,7 +68,7 @@ class RootView : public View,
   // it. Returns whether anyone consumed the event.
   bool OnKeyEvent(const KeyEvent& event);
 
-#if defined(TOUCH_UI) && defined(UNIT_TEST)
+#if defined(UNIT_TEST)
   // For unit testing purposes, we use this method to set a mock
   // GestureManager
   void SetGestureManager(GestureManager* g) { gesture_manager_ = g; }
@@ -116,9 +112,7 @@ class RootView : public View,
   virtual void OnMouseMoved(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const MouseEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const MouseWheelEvent& event) OVERRIDE;
-#if defined(TOUCH_UI)
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
-#endif
   virtual void SetMouseHandler(View* new_mouse_handler) OVERRIDE;
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
 
@@ -130,21 +124,17 @@ class RootView : public View,
   virtual const ui::Compositor* GetCompositor() const OVERRIDE;
   virtual ui::Compositor* GetCompositor() OVERRIDE;
 
-#if defined(TOUCH_UI)
   View* touch_pressed_handler() const {
     return touch_pressed_handler_;
   }
-#endif
 
  private:
   friend class View;
   friend class Widget;
 
-#if defined(TOUCH_UI)
   // Required so the GestureManager can call the Process* entry points
   // with synthetic events as necessary.
   friend class GestureManager;
-#endif
 
   // Input ---------------------------------------------------------------------
 
@@ -188,13 +178,11 @@ class RootView : public View,
   int last_mouse_event_x_;
   int last_mouse_event_y_;
 
-#if defined(TOUCH_UI)
   // The gesture_manager_ for this.
   GestureManager* gesture_manager_;
 
   // The view currently handling touch events.
   View* touch_pressed_handler_;
-#endif
 
   // Focus ---------------------------------------------------------------------
 
diff --git a/views/widget/widget.cc b/views/widget/widget.cc
index c633158..6f1e5cf 100644
--- a/views/widget/widget.cc
+++ b/views/widget/widget.cc
@@ -840,12 +840,10 @@ void Widget::OnMouseCaptureLost() {
   is_mouse_button_pressed_ = false;
 }
 
-#if defined(TOUCH_UI)
 ui::TouchStatus Widget::OnTouchEvent(const TouchEvent& event) {
   ScopedEvent scoped(this, event);
   return static_cast<internal::RootView*>(GetRootView())->OnTouchEvent(event);
 }
-#endif
 
 bool Widget::ExecuteCommand(int command_id) {
   return widget_delegate_->ExecuteWindowsCommand(command_id);
diff --git a/views/widget/widget.h b/views/widget/widget.h
index 07096ae..86d62ee 100644
--- a/views/widget/widget.h
+++ b/views/widget/widget.h
@@ -43,9 +43,7 @@ class Accelerator;
 class Compositor;
 class OSExchangeData;
 class ThemeProvider;
-#if defined(TOUCH_UI)
 enum TouchStatus;
-#endif
 }
 using ui::ThemeProvider;
 
@@ -525,9 +523,7 @@ class Widget : public internal::NativeWidgetDelegate,
   virtual bool OnKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual bool OnMouseEvent(const MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
-#if defined(TOUCH_UI)
   virtual ui::TouchStatus OnTouchEvent(const TouchEvent& event) OVERRIDE;
-#endif
   virtual bool ExecuteCommand(int command_id) OVERRIDE;
   virtual Widget* AsWidget() OVERRIDE;
   virtual const Widget* AsWidget() const OVERRIDE;