events: Get rid of GestureStatus in favour of EventResult.

BUG=none

Review URL: https://chromiumcodereview.appspot.com/10912063

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

64 files changed, 167 insertions, 177 deletions

diff --git a/ui/app_list/contents_view.cc b/ui/app_list/contents_view.cc
index a213526..c254de5 100644
--- a/ui/app_list/contents_view.cc
+++ b/ui/app_list/contents_view.cc
@@ -191,25 +191,25 @@ void ContentsView::Layout() {
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
 }
 
-ui::GestureStatus ContentsView::OnGestureEvent(
+ui::EventResult ContentsView::OnGestureEvent(
     const ui::GestureEvent& event) {
   if (show_state_ != SHOW_APPS)
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
 
   switch (event.type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       pagination_model_->StartScroll();
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       // event.details.scroll_x() > 0 means moving contents to right. That is,
       // transitioning to previous page.
       pagination_model_->UpdateScroll(
           event.details().scroll_x() / GetContentsBounds().width());
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     case ui::ET_GESTURE_SCROLL_END:
       pagination_model_->EndScroll(pagination_model_->
           transition().progress < kFinishTransitionThreshold);
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     case ui::ET_SCROLL_FLING_START: {
       pagination_model_->EndScroll(true);
       if (fabs(event.details().velocity_x()) > kMinHorizVelocityToSwitchPage) {
@@ -217,13 +217,13 @@ ui::GestureStatus ContentsView::OnGestureEvent(
             event.details().velocity_x() < 0 ? 1 : -1,
             true);
       }
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     }
     default:
       break;
   }
 
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 bool ContentsView::OnKeyPressed(const ui::KeyEvent& event) {
diff --git a/ui/app_list/contents_view.h b/ui/app_list/contents_view.h
index cc03041..a6f6fe7 100644
--- a/ui/app_list/contents_view.h
+++ b/ui/app_list/contents_view.h
@@ -53,7 +53,7 @@ class ContentsView : public views::View {
   // Overridden from views::View:
   virtual gfx::Size GetPreferredSize() OVERRIDE;
   virtual void Layout() OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& event) OVERRIDE;
diff --git a/ui/aura/demo/demo_main.cc b/ui/aura/demo/demo_main.cc
index 0571759..e0112d1 100644
--- a/ui/aura/demo/demo_main.cc
+++ b/ui/aura/demo/demo_main.cc
@@ -62,9 +62,9 @@ class DemoWindowDelegate : public aura::WindowDelegate {
   virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     return ui::TOUCH_STATUS_END;
   }
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE {
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
   virtual bool CanFocus() OVERRIDE { return true; }
   virtual void OnCaptureLost() OVERRIDE {}
diff --git a/ui/aura/event_filter.cc b/ui/aura/event_filter.cc
index 1a6fbac..9f2c357 100644
--- a/ui/aura/event_filter.cc
+++ b/ui/aura/event_filter.cc
@@ -21,9 +21,9 @@ ui::TouchStatus EventFilter::PreHandleTouchEvent(Window* target,
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus EventFilter::PreHandleGestureEvent(Window* target,
-                                                     ui::GestureEvent* event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+ui::EventResult EventFilter::PreHandleGestureEvent(Window* target,
+                                                   ui::GestureEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
 ui::EventResult EventFilter::OnKeyEvent(ui::EventTarget* target,
@@ -50,8 +50,7 @@ ui::TouchStatus EventFilter::OnTouchEvent(ui::EventTarget* target,
 
 ui::EventResult EventFilter::OnGestureEvent(ui::EventTarget* target,
                                             ui::GestureEvent* event) {
-  return PreHandleGestureEvent(static_cast<Window*>(target), event) ==
-      ui::GESTURE_STATUS_CONSUMED ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  return PreHandleGestureEvent(static_cast<Window*>(target), event);
 }
 
 }  // namespace aura
diff --git a/ui/aura/event_filter.h b/ui/aura/event_filter.h
index b782905..8ff0923 100644
--- a/ui/aura/event_filter.h
+++ b/ui/aura/event_filter.h
@@ -57,10 +57,10 @@ class AURA_EXPORT EventFilter : public ui::EventHandler {
   virtual ui::TouchStatus PreHandleTouchEvent(Window* target,
                                               ui::TouchEvent* event);
 
-  // Returns a value other than ui::GESTURE_STATUS_UNKNOWN if the gesture is
+  // Returns a value other than ui::ER_UNHANDLED if the gesture is
   // consumed.
-  virtual ui::GestureStatus PreHandleGestureEvent(Window* target,
-                                                  ui::GestureEvent* event);
+  virtual ui::EventResult PreHandleGestureEvent(Window* target,
+                                                ui::GestureEvent* event);
 
   virtual ui::EventResult OnKeyEvent(ui::EventTarget* target,
                                      ui::KeyEvent* event) OVERRIDE;
diff --git a/ui/aura/event_filter_unittest.cc b/ui/aura/event_filter_unittest.cc
index 935658d..d7d7103 100644
--- a/ui/aura/event_filter_unittest.cc
+++ b/ui/aura/event_filter_unittest.cc
@@ -70,10 +70,10 @@ class TestEventFilterWindowDelegate : public test::TestWindowDelegate {
     // TODO(sadrul): !
     return ui::TOUCH_STATUS_UNKNOWN;
   }
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE {
     // TODO(sadrul): !
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
  private:
diff --git a/ui/aura/gestures/gesture_recognizer_unittest.cc b/ui/aura/gestures/gesture_recognizer_unittest.cc
index bf16f00..79d9536 100644
--- a/ui/aura/gestures/gesture_recognizer_unittest.cc
+++ b/ui/aura/gestures/gesture_recognizer_unittest.cc
@@ -132,7 +132,7 @@ class GestureEventConsumeDelegate : public TestWindowDelegate {
   const gfx::Rect& bounding_box() const { return bounding_box_; }
   int tap_count() const { return tap_count_; }
 
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* gesture) OVERRIDE {
     bounding_box_ = gesture->details().bounding_box();
     switch (gesture->type()) {
@@ -201,7 +201,7 @@ class GestureEventConsumeDelegate : public TestWindowDelegate {
       default:
         NOTREACHED();
     }
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
  private:
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index d667f0d..7d14d52 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -302,8 +302,8 @@ bool RootWindow::DispatchGestureEvent(ui::GestureEvent* event) {
 
   if (target) {
     event->ConvertLocationToTarget(static_cast<Window*>(this), target);
-    ui::GestureStatus status = ProcessGestureEvent(target, event);
-    return status != ui::GESTURE_STATUS_UNKNOWN;
+    ui::EventResult status = ProcessGestureEvent(target, event);
+    return status != ui::ER_UNHANDLED;
   }
 
   return false;
@@ -672,14 +672,12 @@ ui::TouchStatus RootWindow::ProcessTouchEvent(Window* target,
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus RootWindow::ProcessGestureEvent(Window* target,
-                                                  ui::GestureEvent* event) {
+ui::EventResult RootWindow::ProcessGestureEvent(Window* target,
+                                                ui::GestureEvent* event) {
   if (!target)
     target = this;
   AutoReset<Window*> reset(&event_dispatch_target_, target);
-  if (ProcessEvent(target, event) != ui::ER_UNHANDLED)
-    return ui::GESTURE_STATUS_CONSUMED;
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return static_cast<ui::EventResult>(ProcessEvent(target, event));
 }
 
 bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
@@ -688,7 +686,7 @@ bool RootWindow::ProcessGestures(ui::GestureRecognizer::Gestures* gestures) {
   bool handled = false;
   for (unsigned int i = 0; i < gestures->size(); i++) {
     ui::GestureEvent* gesture = gestures->get().at(i);
-    if (DispatchGestureEvent(gesture) != ui::GESTURE_STATUS_UNKNOWN)
+    if (DispatchGestureEvent(gesture) != ui::ER_UNHANDLED)
       handled = true;
   }
   return handled;
diff --git a/ui/aura/root_window.h b/ui/aura/root_window.h
index ed74a8c..4aca5ad 100644
--- a/ui/aura/root_window.h
+++ b/ui/aura/root_window.h
@@ -280,8 +280,8 @@ class AURA_EXPORT RootWindow : public ui::CompositorDelegate,
   bool ProcessMouseEvent(Window* target, ui::MouseEvent* event);
   bool ProcessKeyEvent(Window* target, ui::KeyEvent* event);
   ui::TouchStatus ProcessTouchEvent(Window* target, ui::TouchEvent* event);
-  ui::GestureStatus ProcessGestureEvent(Window* target,
-                                        ui::GestureEvent* event);
+  ui::EventResult ProcessGestureEvent(Window* target,
+                                      ui::GestureEvent* event);
   bool ProcessGestures(ui::GestureRecognizer::Gestures* gestures);
 
   // Called when a Window is attached or detached from the RootWindow.
diff --git a/ui/aura/root_window_unittest.cc b/ui/aura/root_window_unittest.cc
index 00a1afe..cd8e52c 100644
--- a/ui/aura/root_window_unittest.cc
+++ b/ui/aura/root_window_unittest.cc
@@ -108,9 +108,9 @@ class EventCountFilter : public EventFilter {
     num_touch_events_++;
     return ui::TOUCH_STATUS_UNKNOWN;
   }
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target, ui::GestureEvent* event) OVERRIDE {
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
  private:
@@ -460,11 +460,11 @@ class EventFilterRecorder : public EventFilter {
     events_.push_back(event->type());
     return ui::TOUCH_STATUS_UNKNOWN;
   }
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target,
       ui::GestureEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
  private:
diff --git a/ui/aura/shared/compound_event_filter.cc b/ui/aura/shared/compound_event_filter.cc
index 9ace7c6..ca2343f 100644
--- a/ui/aura/shared/compound_event_filter.cc
+++ b/ui/aura/shared/compound_event_filter.cc
@@ -133,14 +133,14 @@ ui::TouchStatus CompoundEventFilter::PreHandleTouchEvent(
   return status;
 }
 
-ui::GestureStatus CompoundEventFilter::PreHandleGestureEvent(
+ui::EventResult CompoundEventFilter::PreHandleGestureEvent(
     Window* target,
     ui::GestureEvent* event) {
-  ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
+  ui::EventResult status = ui::ER_UNHANDLED;
   if (filters_.might_have_observers()) {
     ObserverListBase<EventFilter>::Iterator it(filters_);
     EventFilter* filter;
-    while (status == ui::GESTURE_STATUS_UNKNOWN &&
+    while (status == ui::ER_UNHANDLED &&
         (filter = it.GetNext()) != NULL) {
       status = filter->PreHandleGestureEvent(target, event);
     }
@@ -148,7 +148,7 @@ ui::GestureStatus CompoundEventFilter::PreHandleGestureEvent(
 
   if (event->type() == ui::ET_GESTURE_BEGIN &&
       event->details().touch_points() == 1 &&
-      status != ui::GESTURE_STATUS_CONSUMED &&
+      status != ui::ER_CONSUMED &&
       target->GetRootWindow() &&
       GetActiveWindow(target) != target) {
     target->GetFocusManager()->SetFocusedWindow(
diff --git a/ui/aura/shared/compound_event_filter.h b/ui/aura/shared/compound_event_filter.h
index 6707e29..7ae8e04 100644
--- a/ui/aura/shared/compound_event_filter.h
+++ b/ui/aura/shared/compound_event_filter.h
@@ -57,7 +57,7 @@ class AURA_EXPORT CompoundEventFilter : public EventFilter {
   virtual ui::TouchStatus PreHandleTouchEvent(
       Window* target,
       ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target,
       ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ui/aura/shared/compound_event_filter_unittest.cc b/ui/aura/shared/compound_event_filter_unittest.cc
index bc981ae..478ef2e 100644
--- a/ui/aura/shared/compound_event_filter_unittest.cc
+++ b/ui/aura/shared/compound_event_filter_unittest.cc
@@ -70,10 +70,10 @@ class ConsumeGestureEventFilter : public EventFilter {
     return ui::TOUCH_STATUS_UNKNOWN;
   }
 
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target,
       ui::GestureEvent* event) OVERRIDE {
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
   DISALLOW_COPY_AND_ASSIGN(ConsumeGestureEventFilter);
diff --git a/ui/aura/shared/input_method_event_filter.cc b/ui/aura/shared/input_method_event_filter.cc
index 8b1dedc..9cefcaa 100644
--- a/ui/aura/shared/input_method_event_filter.cc
+++ b/ui/aura/shared/input_method_event_filter.cc
@@ -67,10 +67,10 @@ ui::TouchStatus InputMethodEventFilter::PreHandleTouchEvent(
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus InputMethodEventFilter::PreHandleGestureEvent(
+ui::EventResult InputMethodEventFilter::PreHandleGestureEvent(
     aura::Window* target,
     ui::GestureEvent* event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/ui/aura/shared/input_method_event_filter.h b/ui/aura/shared/input_method_event_filter.h
index 95d847e..e8dfb5f 100644
--- a/ui/aura/shared/input_method_event_filter.h
+++ b/ui/aura/shared/input_method_event_filter.h
@@ -40,7 +40,7 @@ class AURA_EXPORT InputMethodEventFilter
   virtual ui::TouchStatus PreHandleTouchEvent(
       Window* target,
       ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target,
       ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ui/aura/test/test_event_filter.cc b/ui/aura/test/test_event_filter.cc
index b2ad6cc..ab5210d 100644
--- a/ui/aura/test/test_event_filter.cc
+++ b/ui/aura/test/test_event_filter.cc
@@ -44,11 +44,11 @@ ui::TouchStatus TestEventFilter::PreHandleTouchEvent(
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus TestEventFilter::PreHandleGestureEvent(
+ui::EventResult TestEventFilter::PreHandleGestureEvent(
     Window* target,
     ui::GestureEvent* event) {
   // TODO(sadrul): !
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 }  // namespace test
diff --git a/ui/aura/test/test_event_filter.h b/ui/aura/test/test_event_filter.h
index 4b4a439..fe02e9e 100644
--- a/ui/aura/test/test_event_filter.h
+++ b/ui/aura/test/test_event_filter.h
@@ -45,7 +45,7 @@ class TestEventFilter : public EventFilter {
   virtual ui::TouchStatus PreHandleTouchEvent(
       Window* target,
       ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       Window* target,
       ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ui/aura/test/test_window_delegate.cc b/ui/aura/test/test_window_delegate.cc
index 807daea..20ab7bc 100644
--- a/ui/aura/test/test_window_delegate.cc
+++ b/ui/aura/test/test_window_delegate.cc
@@ -64,9 +64,9 @@ ui::TouchStatus TestWindowDelegate::OnTouchEvent(ui::TouchEvent* event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus TestWindowDelegate::OnGestureEvent(
+ui::EventResult TestWindowDelegate::OnGestureEvent(
     ui::GestureEvent* event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 bool TestWindowDelegate::CanFocus() {
diff --git a/ui/aura/test/test_window_delegate.h b/ui/aura/test/test_window_delegate.h
index e17311c..532ad13 100644
--- a/ui/aura/test/test_window_delegate.h
+++ b/ui/aura/test/test_window_delegate.h
@@ -39,7 +39,7 @@ class TestWindowDelegate : public WindowDelegate {
       const gfx::Point& location) OVERRIDE;
   virtual bool OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE;
   virtual bool CanFocus() OVERRIDE;
   virtual void OnCaptureLost() OVERRIDE;
diff --git a/ui/aura/window_delegate.cc b/ui/aura/window_delegate.cc
index 62c0f7a..b5f7387 100644
--- a/ui/aura/window_delegate.cc
+++ b/ui/aura/window_delegate.cc
@@ -28,8 +28,7 @@ ui::TouchStatus WindowDelegate::OnTouchEvent(ui::EventTarget* target,
 
 ui::EventResult WindowDelegate::OnGestureEvent(ui::EventTarget* target,
                                                ui::GestureEvent* event) {
-  return OnGestureEvent(event) == ui::GESTURE_STATUS_CONSUMED ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  return OnGestureEvent(event);
 }
 
 }  // namespace aura
diff --git a/ui/aura/window_delegate.h b/ui/aura/window_delegate.h
index 6f5aca9..d8abbfb 100644
--- a/ui/aura/window_delegate.h
+++ b/ui/aura/window_delegate.h
@@ -62,7 +62,7 @@ class AURA_EXPORT WindowDelegate : public ui::EventHandler {
 
   virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) = 0;
 
-  virtual ui::GestureStatus OnGestureEvent(ui::GestureEvent* event) = 0;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) = 0;
 
   // Returns true of the window can be focused.
   virtual bool CanFocus() = 0;
diff --git a/ui/aura/window_unittest.cc b/ui/aura/window_unittest.cc
index 09be9ea..b48b723 100644
--- a/ui/aura/window_unittest.cc
+++ b/ui/aura/window_unittest.cc
@@ -175,10 +175,10 @@ class CaptureWindowDelegateImpl : public TestWindowDelegate {
     touch_event_count_++;
     return ui::TOUCH_STATUS_UNKNOWN;
   }
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE {
     gesture_event_count_++;
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
   virtual void OnCaptureLost() OVERRIDE {
     capture_lost_count_++;
@@ -218,10 +218,10 @@ class GestureTrackPositionDelegate : public TestWindowDelegate {
  public:
   GestureTrackPositionDelegate() {}
 
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE {
     position_ = event->location();
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
   const gfx::Point& position() const { return position_; }
diff --git a/ui/base/events.h b/ui/base/events.h
index 69d04f8..891fc32 100644
--- a/ui/base/events.h
+++ b/ui/base/events.h
@@ -95,6 +95,16 @@ enum MouseEventFlags {
                                     // from an unconsumed touch/gesture event.
 };
 
+// Result of dispatching an event.
+enum EventResult {
+  ER_UNHANDLED = 0,  // The event hasn't been handled. The event can be
+                     // propagated to other handlers.
+  ER_HANDLED,        // The event has already been handled, but it can still be
+                     // propagated to other handlers.
+  ER_CONSUMED,       // The event has been handled, and it should not be
+                     // propagated to other handlers.
+};
+
 enum TouchStatus {
   TOUCH_STATUS_UNKNOWN = 0,  // Unknown touch status. This is used to indicate
                              // that the touch event was not handled.
@@ -118,13 +128,6 @@ enum TouchStatus {
 // Updates the list of devices for cached properties.
 UI_EXPORT void UpdateDeviceList();
 
-enum GestureStatus {
-  GESTURE_STATUS_UNKNOWN = 0,  // Unknown Gesture status. This is used to
-                               // indicate that the Gesture event was not
-                               // handled.
-  GESTURE_STATUS_CONSUMED,     // The Gesture event got consumed.
-};
-
 // Get the EventType from a native event.
 UI_EXPORT EventType EventTypeFromNative(const base::NativeEvent& native_event);
 
diff --git a/ui/base/events/event_handler.h b/ui/base/events/event_handler.h
index 96ea5bd..7411536 100644
--- a/ui/base/events/event_handler.h
+++ b/ui/base/events/event_handler.h
@@ -20,15 +20,6 @@ class TouchEvent;
 
 class EventTarget;
 
-enum EventResult {
-  ER_UNHANDLED = 0,  // The event hasn't been handled. The event can be
-                     // propagated to other handlers.
-  ER_HANDLED,        // The event has already been handled, but it can still be
-                     // propagated to other handlers.
-  ER_CONSUMED,       // The event has been handled, and it should not be
-                     // propagated to other handlers.
-};
-
 // Dispatches events to appropriate targets.
 class UI_EXPORT EventHandler {
  public:
diff --git a/ui/views/color_chooser/color_chooser_view.cc b/ui/views/color_chooser/color_chooser_view.cc
index cb99d07..dc35ff1 100644
--- a/ui/views/color_chooser/color_chooser_view.cc
+++ b/ui/views/color_chooser/color_chooser_view.cc
@@ -73,15 +73,15 @@ class LocatedEventHandlerView : public views::View {
     return true;
   }
 
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE {
     if (event.type() == ui::ET_GESTURE_TAP ||
         event.type() == ui::ET_GESTURE_TAP_DOWN ||
         event.IsScrollGestureEvent()) {
       ProcessEventAtLocation(event.location());
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     }
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
   DISALLOW_COPY_AND_ASSIGN(LocatedEventHandlerView);
diff --git a/ui/views/controls/button/custom_button.cc b/ui/views/controls/button/custom_button.cc
index 4c131b6..1224141 100644
--- a/ui/views/controls/button/custom_button.cc
+++ b/ui/views/controls/button/custom_button.cc
@@ -204,7 +204,7 @@ bool CustomButton::OnKeyReleased(const ui::KeyEvent& event) {
   return true;
 }
 
-ui::GestureStatus CustomButton::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult CustomButton::OnGestureEvent(const ui::GestureEvent& event) {
   if (state_ == BS_DISABLED)
     return Button::OnGestureEvent(event);
 
@@ -215,13 +215,13 @@ ui::GestureStatus CustomButton::OnGestureEvent(const ui::GestureEvent& event) {
     SetState(BS_HOT);
     hover_animation_->Reset(1.0);
     NotifyClick(event);
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   } else if (event.type() == ui::ET_GESTURE_TAP_DOWN &&
              ShouldEnterPushedState(event)) {
     SetState(BS_PUSHED);
     if (request_focus_on_press_)
       RequestFocus();
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   } else {
     SetState(BS_NORMAL);
   }
diff --git a/ui/views/controls/button/custom_button.h b/ui/views/controls/button/custom_button.h
index fcb07ab..03f9f33 100644
--- a/ui/views/controls/button/custom_button.h
+++ b/ui/views/controls/button/custom_button.h
@@ -87,7 +87,7 @@ class VIEWS_EXPORT CustomButton : public Button,
   virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool OnKeyReleased(const ui::KeyEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) OVERRIDE;
   virtual void ShowContextMenu(const gfx::Point& p,
diff --git a/ui/views/controls/button/menu_button.cc b/ui/views/controls/button/menu_button.cc
index 8724cc5..0e06515 100644
--- a/ui/views/controls/button/menu_button.cc
+++ b/ui/views/controls/button/menu_button.cc
@@ -219,11 +219,11 @@ void MenuButton::OnMouseExited(const ui::MouseEvent& event) {
   }
 }
 
-ui::GestureStatus MenuButton::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult MenuButton::OnGestureEvent(const ui::GestureEvent& event) {
   if (state() != BS_DISABLED && event.type() == ui::ET_GESTURE_TAP) {
     if (Activate())
-      return ui::GESTURE_STATUS_CONSUMED;
-    return ui::GESTURE_STATUS_UNKNOWN;
+      return ui::ER_CONSUMED;
+    return ui::ER_UNHANDLED;
   }
   return TextButton::OnGestureEvent(event);
 }
diff --git a/ui/views/controls/button/menu_button.h b/ui/views/controls/button/menu_button.h
index 59eb51e..34f1866 100644
--- a/ui/views/controls/button/menu_button.h
+++ b/ui/views/controls/button/menu_button.h
@@ -62,7 +62,7 @@ class VIEWS_EXPORT MenuButton : public TextButton {
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool OnKeyReleased(const ui::KeyEvent& event) OVERRIDE;
diff --git a/ui/views/controls/combobox/native_combobox_views.cc b/ui/views/controls/combobox/native_combobox_views.cc
index 1b24eb0..50f18da 100644
--- a/ui/views/controls/combobox/native_combobox_views.cc
+++ b/ui/views/controls/combobox/native_combobox_views.cc
@@ -92,12 +92,12 @@ bool NativeComboboxViews::OnMouseDragged(const ui::MouseEvent& mouse_event) {
   return true;
 }
 
-ui::GestureStatus NativeComboboxViews::OnGestureEvent(
+ui::EventResult NativeComboboxViews::OnGestureEvent(
     const ui::GestureEvent& gesture_event) {
   if (gesture_event.type() == ui::ET_GESTURE_TAP) {
     UpdateFromModel();
     ShowDropDownMenu();
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
   return View::OnGestureEvent(gesture_event);
 }
diff --git a/ui/views/controls/combobox/native_combobox_views.h b/ui/views/controls/combobox/native_combobox_views.h
index c5b37e1..b23c268 100644
--- a/ui/views/controls/combobox/native_combobox_views.h
+++ b/ui/views/controls/combobox/native_combobox_views.h
@@ -33,7 +33,7 @@ class NativeComboboxViews : public views::View,
   // views::View overrides:
   virtual bool OnMousePressed(const ui::MouseEvent& mouse_event) OVERRIDE;
   virtual bool OnMouseDragged(const ui::MouseEvent& mouse_event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& gesture_event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& key_event) OVERRIDE;
   virtual bool OnKeyReleased(const ui::KeyEvent& key_event) OVERRIDE;
diff --git a/ui/views/controls/link.cc b/ui/views/controls/link.cc
index 63c3fa6..62e3ac4 100644
--- a/ui/views/controls/link.cc
+++ b/ui/views/controls/link.cc
@@ -111,9 +111,9 @@ bool Link::OnKeyPressed(const ui::KeyEvent& event) {
   return true;
 }
 
-ui::GestureStatus Link::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult Link::OnGestureEvent(const ui::GestureEvent& event) {
   if (!enabled())
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
 
   if (event.type() == ui::ET_GESTURE_TAP_DOWN) {
     SetPressed(true);
@@ -123,9 +123,9 @@ ui::GestureStatus Link::OnGestureEvent(const ui::GestureEvent& event) {
       listener_->LinkClicked(this, event.flags());
   } else {
     SetPressed(false);
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
-  return ui::GESTURE_STATUS_CONSUMED;
+  return ui::ER_CONSUMED;
 }
 
 bool Link::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) {
diff --git a/ui/views/controls/link.h b/ui/views/controls/link.h
index b7147a6..5fcce6f 100644
--- a/ui/views/controls/link.h
+++ b/ui/views/controls/link.h
@@ -39,7 +39,7 @@ class VIEWS_EXPORT Link : public Label {
   virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool SkipDefaultKeyEventProcessing(
diff --git a/ui/views/controls/menu/menu_controller.cc b/ui/views/controls/menu/menu_controller.cc
index bf45d9a..d4adac9 100644
--- a/ui/views/controls/menu/menu_controller.cc
+++ b/ui/views/controls/menu/menu_controller.cc
@@ -521,17 +521,17 @@ bool MenuController::OnMouseWheel(SubmenuView* source,
 }
 #endif
 
-ui::GestureStatus MenuController::OnGestureEvent(
+ui::EventResult MenuController::OnGestureEvent(
     SubmenuView* source,
     const ui::GestureEvent& event) {
   MenuPart part = GetMenuPart(source, event.location());
   if (event.type() == ui::ET_GESTURE_TAP_DOWN) {
     SetSelectionOnPointerDown(source, event);
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   } else if (event.type() == ui::ET_GESTURE_LONG_PRESS) {
     if (part.type == MenuPart::MENU_ITEM && part.menu) {
       if (ShowContextMenu(part.menu, source, event))
-        return ui::GESTURE_STATUS_CONSUMED;
+        return ui::ER_CONSUMED;
     }
   } else if (event.type() == ui::ET_GESTURE_TAP) {
     if (!part.is_scroll() && part.menu &&
@@ -540,16 +540,16 @@ ui::GestureStatus MenuController::OnGestureEvent(
           part.menu, event)) {
         Accept(part.menu, 0);
       }
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     } else if (part.type == MenuPart::MENU_ITEM) {
       // User either tapped on empty space, or a menu that has children.
       SetSelection(part.menu ? part.menu : state_.item,
                    SELECTION_OPEN_SUBMENU | SELECTION_UPDATE_IMMEDIATELY);
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     }
   }
   if (!part.submenu)
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   return part.submenu->OnGestureEvent(event);
 }
 
diff --git a/ui/views/controls/menu/menu_controller.h b/ui/views/controls/menu/menu_controller.h
index 27386af..9604d18 100644
--- a/ui/views/controls/menu/menu_controller.h
+++ b/ui/views/controls/menu/menu_controller.h
@@ -118,7 +118,7 @@ class VIEWS_EXPORT MenuController
 #if defined(OS_LINUX)
   bool OnMouseWheel(SubmenuView* source, const ui::MouseWheelEvent& event);
 #endif
-  ui::GestureStatus OnGestureEvent(SubmenuView* source,
+  ui::EventResult OnGestureEvent(SubmenuView* source,
                                    const ui::GestureEvent& event);
 
   bool GetDropFormats(
diff --git a/ui/views/controls/menu/menu_host_root_view.cc b/ui/views/controls/menu/menu_host_root_view.cc
index c029007..feda2d1 100644
--- a/ui/views/controls/menu/menu_host_root_view.cc
+++ b/ui/views/controls/menu/menu_host_root_view.cc
@@ -62,13 +62,13 @@ bool MenuHostRootView::OnMouseWheel(const ui::MouseWheelEvent& event) {
 #endif
 }
 
-ui::GestureStatus MenuHostRootView::OnGestureEvent(
+ui::EventResult MenuHostRootView::OnGestureEvent(
     const ui::GestureEvent& event) {
   RootView::OnGestureEvent(event);
   // ChromeOS uses MenuController to forward events like other
   // mouse events.
   if (!GetMenuController())
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   return GetMenuController()->OnGestureEvent(submenu_, event);
 }
 
diff --git a/ui/views/controls/menu/menu_host_root_view.h b/ui/views/controls/menu/menu_host_root_view.h
index 743c8ca..b47d396 100644
--- a/ui/views/controls/menu/menu_host_root_view.h
+++ b/ui/views/controls/menu/menu_host_root_view.h
@@ -30,7 +30,7 @@ class MenuHostRootView : public internal::RootView {
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseMoved(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
 
  private:
diff --git a/ui/views/controls/menu/submenu_view.cc b/ui/views/controls/menu/submenu_view.cc
index a44fc7b0..cf8a27e 100644
--- a/ui/views/controls/menu/submenu_view.cc
+++ b/ui/views/controls/menu/submenu_view.cc
@@ -260,8 +260,8 @@ bool SubmenuView::OnMouseWheel(const ui::MouseWheelEvent& e) {
   return true;
 }
 
-ui::GestureStatus SubmenuView::OnGestureEvent(const ui::GestureEvent& e) {
-  ui::GestureStatus to_return = ui::GESTURE_STATUS_CONSUMED;
+ui::EventResult SubmenuView::OnGestureEvent(const ui::GestureEvent& e) {
+  ui::EventResult to_return = ui::ER_CONSUMED;
   switch (e.type()) {
     case ui::ET_GESTURE_SCROLL_BEGIN:
       scroll_animator_->Stop();
@@ -280,7 +280,7 @@ ui::GestureStatus SubmenuView::OnGestureEvent(const ui::GestureEvent& e) {
       scroll_animator_->Stop();
       break;
     default:
-      to_return = ui::GESTURE_STATUS_UNKNOWN;
+      to_return = ui::ER_UNHANDLED;
       break;
   }
   return to_return;
diff --git a/ui/views/controls/menu/submenu_view.h b/ui/views/controls/menu/submenu_view.h
index e73d3fb..1a7db2d 100644
--- a/ui/views/controls/menu/submenu_view.h
+++ b/ui/views/controls/menu/submenu_view.h
@@ -76,7 +76,7 @@ class VIEWS_EXPORT SubmenuView : public View,
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& e) OVERRIDE;
 
   // Scrolls on menu item boundaries.
-  virtual ui::GestureStatus OnGestureEvent(const ui::GestureEvent& e) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(const ui::GestureEvent& e) OVERRIDE;
 
   // Returns true if the menu is showing.
   bool IsShowing();
diff --git a/ui/views/controls/scroll_view.cc b/ui/views/controls/scroll_view.cc
index 2e8e5a0..013e585 100644
--- a/ui/views/controls/scroll_view.cc
+++ b/ui/views/controls/scroll_view.cc
@@ -400,8 +400,8 @@ bool ScrollView::OnKeyPressed(const ui::KeyEvent& event) {
   return processed;
 }
 
-ui::GestureStatus ScrollView::OnGestureEvent(const ui::GestureEvent& event) {
-  ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
+ui::EventResult ScrollView::OnGestureEvent(const ui::GestureEvent& event) {
+  ui::EventResult status = ui::ER_UNHANDLED;
 
   // If the event happened on one of the scrollbars, then those events are
   // sent directly to the scrollbars. Otherwise, only scroll events are sent to
@@ -415,7 +415,7 @@ ui::GestureStatus ScrollView::OnGestureEvent(const ui::GestureEvent& event) {
     if (vert_sb_->bounds().Contains(event.location()) || scroll_event)
       status = vert_sb_->OnGestureEvent(event);
   }
-  if (status == ui::GESTURE_STATUS_UNKNOWN && horiz_sb_->visible()) {
+  if (status == ui::ER_UNHANDLED && horiz_sb_->visible()) {
     if (horiz_sb_->bounds().Contains(event.location()) || scroll_event)
       status = horiz_sb_->OnGestureEvent(event);
   }
diff --git a/ui/views/controls/scroll_view.h b/ui/views/controls/scroll_view.h
index 4c2d0a9..29ad616 100644
--- a/ui/views/controls/scroll_view.h
+++ b/ui/views/controls/scroll_view.h
@@ -73,7 +73,7 @@ class VIEWS_EXPORT ScrollView : public View, public ScrollBarController {
 
   // Keyboard events
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& e) OVERRIDE;
 
diff --git a/ui/views/controls/scrollbar/base_scroll_bar.cc b/ui/views/controls/scrollbar/base_scroll_bar.cc
index 2fb30bb..bbf5e3a 100644
--- a/ui/views/controls/scrollbar/base_scroll_bar.cc
+++ b/ui/views/controls/scrollbar/base_scroll_bar.cc
@@ -167,7 +167,7 @@ bool BaseScrollBar::OnKeyPressed(const ui::KeyEvent& event) {
   return false;
 }
 
-ui::GestureStatus BaseScrollBar::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult BaseScrollBar::OnGestureEvent(const ui::GestureEvent& event) {
   // If a fling is in progress, then stop the fling for any incoming gesture
   // event (except for the GESTURE_END event that is generated at the end of the
   // fling).
@@ -179,13 +179,13 @@ ui::GestureStatus BaseScrollBar::OnGestureEvent(const ui::GestureEvent& event) {
 
   if (event.type() == ui::ET_GESTURE_TAP_DOWN) {
     ProcessPressEvent(event);
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
   if (event.type() == ui::ET_GESTURE_LONG_PRESS) {
     // For a long-press, the repeater started in tap-down should continue. So
     // return early.
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
   ResetState();
@@ -193,17 +193,17 @@ ui::GestureStatus BaseScrollBar::OnGestureEvent(const ui::GestureEvent& event) {
   if (event.type() == ui::ET_GESTURE_TAP) {
     // TAP_DOWN would have already scrolled some amount. So scrolling again on
     // TAP is not necessary.
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
   if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN ||
       event.type() == ui::ET_GESTURE_SCROLL_END)
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
 
   if (event.type() == ui::ET_GESTURE_SCROLL_UPDATE) {
     ScrollByContentsOffset(IsHorizontal() ? event.details().scroll_x() :
                                             event.details().scroll_y());
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
   if (event.type() == ui::ET_SCROLL_FLING_START) {
@@ -211,10 +211,10 @@ ui::GestureStatus BaseScrollBar::OnGestureEvent(const ui::GestureEvent& event) {
       scroll_animator_.reset(new ScrollAnimator(this));
     scroll_animator_->Start(IsHorizontal() ? event.details().velocity_x() : 0.f,
         IsHorizontal() ? 0.f : event.details().velocity_y());
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 bool BaseScrollBar::OnMouseWheel(const ui::MouseWheelEvent& event) {
diff --git a/ui/views/controls/scrollbar/base_scroll_bar.h b/ui/views/controls/scrollbar/base_scroll_bar.h
index 0d09c71..c674dde1 100644
--- a/ui/views/controls/scrollbar/base_scroll_bar.h
+++ b/ui/views/controls/scrollbar/base_scroll_bar.h
@@ -64,7 +64,7 @@ class VIEWS_EXPORT BaseScrollBar : public ScrollBar,
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& event) OVERRIDE;
 
diff --git a/ui/views/controls/scrollbar/native_scroll_bar.cc b/ui/views/controls/scrollbar/native_scroll_bar.cc
index 8b08a86..0ed04d7 100644
--- a/ui/views/controls/scrollbar/native_scroll_bar.cc
+++ b/ui/views/controls/scrollbar/native_scroll_bar.cc
@@ -76,10 +76,10 @@ bool NativeScrollBar::OnKeyPressed(const ui::KeyEvent& event) {
   return native_wrapper_->GetView()->OnKeyPressed(event);
 }
 
-ui::GestureStatus NativeScrollBar::OnGestureEvent(
+ui::EventResult NativeScrollBar::OnGestureEvent(
     const ui::GestureEvent& event) {
   if (!native_wrapper_)
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   return native_wrapper_->GetView()->OnGestureEvent(event);
 }
 
diff --git a/ui/views/controls/scrollbar/native_scroll_bar.h b/ui/views/controls/scrollbar/native_scroll_bar.h
index dbeb552..7e3416c 100644
--- a/ui/views/controls/scrollbar/native_scroll_bar.h
+++ b/ui/views/controls/scrollbar/native_scroll_bar.h
@@ -45,7 +45,7 @@ class VIEWS_EXPORT NativeScrollBar : public ScrollBar {
 
   // Overrideen from View for keyboard UI purpose.
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(const ui::GestureEvent& e) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(const ui::GestureEvent& e) OVERRIDE;
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& e) OVERRIDE;
 
   // Overridden from ScrollBar.
diff --git a/ui/views/controls/slider.cc b/ui/views/controls/slider.cc
index ab3d5886..890a28f 100644
--- a/ui/views/controls/slider.cc
+++ b/ui/views/controls/slider.cc
@@ -261,15 +261,15 @@ bool Slider::OnKeyPressed(const ui::KeyEvent& event) {
   return false;
 }
 
-ui::GestureStatus Slider::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult Slider::OnGestureEvent(const ui::GestureEvent& event) {
   if (event.type() == ui::ET_GESTURE_SCROLL_UPDATE ||
       event.type() == ui::ET_GESTURE_SCROLL_BEGIN ||
       event.type() == ui::ET_GESTURE_SCROLL_END ||
       event.type() == ui::ET_GESTURE_TAP_DOWN) {
     MoveButtonTo(event.location());
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 void Slider::AnimationProgressed(const ui::Animation* animation) {
diff --git a/ui/views/controls/slider.h b/ui/views/controls/slider.h
index 8215f08..25a445b 100644
--- a/ui/views/controls/slider.h
+++ b/ui/views/controls/slider.h
@@ -84,7 +84,7 @@ class VIEWS_EXPORT Slider : public View,
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
diff --git a/ui/views/controls/textfield/native_textfield_views.cc b/ui/views/controls/textfield/native_textfield_views.cc
index c1afcea..058293f 100644
--- a/ui/views/controls/textfield/native_textfield_views.cc
+++ b/ui/views/controls/textfield/native_textfield_views.cc
@@ -146,10 +146,10 @@ void NativeTextfieldViews::OnMouseReleased(const ui::MouseEvent& event) {
   OnAfterUserAction();
 }
 
-ui::GestureStatus NativeTextfieldViews::OnGestureEvent(
+ui::EventResult NativeTextfieldViews::OnGestureEvent(
     const ui::GestureEvent& event) {
-  ui::GestureStatus status = textfield_->OnGestureEvent(event);
-  if (status != ui::GESTURE_STATUS_UNKNOWN)
+  ui::EventResult status = textfield_->OnGestureEvent(event);
+  if (status != ui::ER_UNHANDLED)
     return status;
 
   switch (event.type()) {
@@ -162,16 +162,16 @@ ui::GestureStatus NativeTextfieldViews::OnGestureEvent(
           MoveCursorTo(event.location(), false))
         SchedulePaint();
       OnAfterUserAction();
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     case ui::ET_GESTURE_DOUBLE_TAP:
       SelectAll(false);
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       OnBeforeUserAction();
       if (MoveCursorTo(event.location(), true))
         SchedulePaint();
       OnAfterUserAction();
-      return ui::GESTURE_STATUS_CONSUMED;
+      return ui::ER_CONSUMED;
     default:
       break;
   }
diff --git a/ui/views/controls/textfield/native_textfield_views.h b/ui/views/controls/textfield/native_textfield_views.h
index 3e4213c..b48b0e0 100644
--- a/ui/views/controls/textfield/native_textfield_views.h
+++ b/ui/views/controls/textfield/native_textfield_views.h
@@ -56,7 +56,7 @@ class VIEWS_EXPORT NativeTextfieldViews : public TouchSelectionClientView,
   virtual bool OnMousePressed(const ui::MouseEvent& event) OVERRIDE;
   virtual bool OnMouseDragged(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const ui::MouseEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool OnKeyPressed(const ui::KeyEvent& event) OVERRIDE;
   virtual bool GetDropFormats(
diff --git a/ui/views/view.cc b/ui/views/view.cc
index 7d58f30..f074554 100644
--- a/ui/views/view.cc
+++ b/ui/views/view.cc
@@ -829,8 +829,8 @@ ui::TouchStatus View::OnTouchEvent(const ui::TouchEvent& event) {
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus View::OnGestureEvent(const ui::GestureEvent& event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+ui::EventResult View::OnGestureEvent(const ui::GestureEvent& event) {
+  return ui::ER_UNHANDLED;
 }
 
 void View::SetMouseHandler(View* new_mouse_handler) {
@@ -1965,14 +1965,14 @@ ui::TouchStatus View::ProcessTouchEvent(const ui::TouchEvent& event) {
   return OnTouchEvent(event);
 }
 
-ui::GestureStatus View::ProcessGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult View::ProcessGestureEvent(const ui::GestureEvent& event) {
   if (context_menu_controller_ &&
       (event.type() == ui::ET_GESTURE_LONG_PRESS ||
        event.type() == ui::ET_GESTURE_TWO_FINGER_TAP)) {
     gfx::Point location(event.location());
     ConvertPointToScreen(this, &location);
     ShowContextMenu(location, true);
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
   return OnGestureEvent(event);
 }
diff --git a/ui/views/view.h b/ui/views/view.h
index 1b29fd0..6ac619c 100644
--- a/ui/views/view.h
+++ b/ui/views/view.h
@@ -579,7 +579,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
 
   // This method is invoked for each GestureEvent created by GestureRecognizer.
   // Default implementation does nothing. Override as needed.
-  // If a View returns ui::GESTURE_STATUS_CONSUMED from OnGestureEvent, then
+  // If a View returns ui::ER_CONSUMED from OnGestureEvent, then
   // subsequent gestures will be dispatched to the same View, until the gesture
   // ends (i.e. all touch-points are released).
   // Scroll gesture events are handled slightly differently: if a View starts
@@ -590,7 +590,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
   // scroll-gesture events will be sent to this View. However all the other
   // gesture-events (e.g. ET_GESTURE_END, ET_GESTURE_PINCH_BEGIN etc.) will
   // continue to be dispatched to the first View.
-  virtual ui::GestureStatus OnGestureEvent(const ui::GestureEvent& event);
+  virtual ui::EventResult OnGestureEvent(const ui::GestureEvent& event);
 
   // Set the MouseHandler for a drag session.
   //
@@ -1286,7 +1286,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
 
   // RootView will invoke this with incoming GestureEvents. This will invoke
   // OnGestureEvent and return the result.
-  ui::GestureStatus ProcessGestureEvent(const ui::GestureEvent& event);
+  ui::EventResult ProcessGestureEvent(const ui::GestureEvent& event);
 
   // Accelerators --------------------------------------------------------------
 
diff --git a/ui/views/view_unittest.cc b/ui/views/view_unittest.cc
index c902b17..f34d9fc 100644
--- a/ui/views/view_unittest.cc
+++ b/ui/views/view_unittest.cc
@@ -232,7 +232,7 @@ class TestView : public View {
   virtual void OnMouseExited(const ui::MouseEvent& event) OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) OVERRIDE;
   // Ignores GestureEvent by default.
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual void Paint(gfx::Canvas* canvas) OVERRIDE;
   virtual void SchedulePaintInRect(const gfx::Rect& rect) OVERRIDE;
@@ -285,11 +285,11 @@ class TestViewConsumeGesture : public TestView {
   virtual ~TestViewConsumeGesture() {}
 
  protected:
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE {
     last_gesture_event_type_ = event.type();
     location_.SetPoint(event.x(), event.y());
-    return ui::GESTURE_STATUS_CONSUMED;
+    return ui::ER_CONSUMED;
   }
 
  private:
@@ -303,9 +303,9 @@ class TestViewIgnoreGesture: public TestView {
   virtual ~TestViewIgnoreGesture() {}
 
  private:
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE {
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
   DISALLOW_COPY_AND_ASSIGN(TestViewIgnoreGesture);
@@ -319,10 +319,10 @@ class TestViewIgnoreScrollGestures : public TestViewConsumeGesture {
   virtual ~TestViewIgnoreScrollGestures() {}
 
  private:
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE {
     if (event.IsScrollGestureEvent())
-      return ui::GESTURE_STATUS_UNKNOWN;
+      return ui::ER_UNHANDLED;
     return TestViewConsumeGesture::OnGestureEvent(event);
   }
 
@@ -589,8 +589,8 @@ TEST_F(ViewTest, TouchEvent) {
   widget->CloseNow();
 }
 
-ui::GestureStatus TestView::OnGestureEvent(const ui::GestureEvent& event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+ui::EventResult TestView::OnGestureEvent(const ui::GestureEvent& event) {
+  return ui::ER_UNHANDLED;
 }
 
 TEST_F(ViewTest, GestureEvent) {
diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc
index 98ba00e..8252eaf 100644
--- a/ui/views/widget/native_widget_aura.cc
+++ b/ui/views/widget/native_widget_aura.cc
@@ -822,7 +822,7 @@ ui::TouchStatus NativeWidgetAura::OnTouchEvent(ui::TouchEvent* event) {
   return delegate_->OnTouchEvent(*event);
 }
 
-ui::GestureStatus NativeWidgetAura::OnGestureEvent(
+ui::EventResult NativeWidgetAura::OnGestureEvent(
     ui::GestureEvent* event) {
   DCHECK(window_->IsVisible());
   return delegate_->OnGestureEvent(*event);
diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h
index 4e1a7cb..3349ffe 100644
--- a/ui/views/widget/native_widget_aura.h
+++ b/ui/views/widget/native_widget_aura.h
@@ -143,7 +143,7 @@ class VIEWS_EXPORT NativeWidgetAura : public internal::NativeWidgetPrivate,
       const gfx::Point& location) OVERRIDE;
   virtual bool OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       ui::GestureEvent* event) OVERRIDE;
   virtual bool CanFocus() OVERRIDE;
   virtual void OnCaptureLost() OVERRIDE;
diff --git a/ui/views/widget/native_widget_aura_unittest.cc b/ui/views/widget/native_widget_aura_unittest.cc
index 594ebb3..b61fa3e 100644
--- a/ui/views/widget/native_widget_aura_unittest.cc
+++ b/ui/views/widget/native_widget_aura_unittest.cc
@@ -216,11 +216,11 @@ class GestureTrackingView : public views::View {
   }
 
   // View overrides:
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE {
     got_gesture_event_ = true;
-    return consume_gesture_event_ ? ui::GESTURE_STATUS_CONSUMED :
-        ui::GESTURE_STATUS_UNKNOWN;
+    return consume_gesture_event_ ? ui::ER_CONSUMED :
+        ui::ER_UNHANDLED;
   }
 
  private:
diff --git a/ui/views/widget/native_widget_delegate.h b/ui/views/widget/native_widget_delegate.h
index cdb5a65..50cf9a1 100644
--- a/ui/views/widget/native_widget_delegate.h
+++ b/ui/views/widget/native_widget_delegate.h
@@ -109,7 +109,7 @@ class VIEWS_EXPORT NativeWidgetDelegate {
   virtual bool OnMouseEvent(const ui::MouseEvent& event) = 0;
   virtual void OnMouseCaptureLost() = 0;
   virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) = 0;
-  virtual ui::GestureStatus OnGestureEvent(const ui::GestureEvent& event) = 0;
+  virtual ui::EventResult OnGestureEvent(const ui::GestureEvent& event) = 0;
 
   // Runs the specified native command. Returns true if the command is handled.
   virtual bool ExecuteCommand(int command_id) = 0;
diff --git a/ui/views/widget/root_view.cc b/ui/views/widget/root_view.cc
index def2484..ed6a276 100644
--- a/ui/views/widget/root_view.cc
+++ b/ui/views/widget/root_view.cc
@@ -455,8 +455,8 @@ ui::TouchStatus RootView::OnTouchEvent(const ui::TouchEvent& event) {
   return status;
 }
 
-ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
-  ui::GestureStatus status = ui::GESTURE_STATUS_UNKNOWN;
+ui::EventResult RootView::OnGestureEvent(const ui::GestureEvent& event) {
+  ui::EventResult status = ui::ER_UNHANDLED;
 
   if (gesture_handler_) {
     // |gesture_handler_| (or |scroll_gesture_handler_|) can be deleted during
@@ -466,7 +466,7 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
             scroll_gesture_handler_ : gesture_handler_;
     ui::GestureEvent handler_event(event, static_cast<View*>(this), handler);
 
-    ui::GestureStatus status = handler->ProcessGestureEvent(handler_event);
+    ui::EventResult status = handler->ProcessGestureEvent(handler_event);
 
     if (event.type() == ui::ET_GESTURE_END &&
         event.details().touch_points() <= 1)
@@ -476,10 +476,10 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
                                     event.type() == ui::ET_SCROLL_FLING_START))
       scroll_gesture_handler_ = NULL;
 
-    if (status == ui::GESTURE_STATUS_CONSUMED)
+    if (status == ui::ER_CONSUMED)
       return status;
 
-    DCHECK_EQ(ui::GESTURE_STATUS_UNKNOWN, status);
+    DCHECK_EQ(ui::ER_UNHANDLED, status);
 
     if (event.type() == ui::ET_GESTURE_SCROLL_BEGIN &&
         !scroll_gesture_handler_) {
@@ -493,13 +493,13 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
         ui::GestureEvent gesture_event(event, static_cast<View*>(this),
                                        scroll_gesture_handler_);
         status = scroll_gesture_handler_->ProcessGestureEvent(gesture_event);
-        if (status == ui::GESTURE_STATUS_CONSUMED)
+        if (status == ui::ER_CONSUMED)
           return status;
       }
       scroll_gesture_handler_ = NULL;
     }
 
-    return ui::GESTURE_STATUS_UNKNOWN;
+    return ui::ER_UNHANDLED;
   }
 
   // Walk up the tree until we find a view that wants the gesture event.
@@ -508,7 +508,7 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
       gesture_handler_ = gesture_handler_->parent()) {
     if (!gesture_handler_->enabled()) {
       // Disabled views eat events but are treated as not handled.
-      return ui::GESTURE_STATUS_UNKNOWN;
+      return ui::ER_UNHANDLED;
     }
 
     // See if this view wants to handle the Gesture.
@@ -520,9 +520,9 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
     // OnGestureEvent(). So handle as per OnMousePressed. NB: we
     // assume that the RootView itself cannot be so removed.
     if (!gesture_handler_)
-      return ui::GESTURE_STATUS_UNKNOWN;
+      return ui::ER_UNHANDLED;
 
-    if (status == ui::GESTURE_STATUS_CONSUMED) {
+    if (status == ui::ER_CONSUMED) {
       if (gesture_event.type() == ui::ET_GESTURE_SCROLL_BEGIN)
         scroll_gesture_handler_ = gesture_handler_;
       return status;
@@ -530,7 +530,7 @@ ui::GestureStatus RootView::OnGestureEvent(const ui::GestureEvent& event) {
 
     // The gesture event wasn't processed. Go up the view hierarchy and
     // dispatch the gesture event.
-    DCHECK_EQ(ui::GESTURE_STATUS_UNKNOWN, status);
+    DCHECK_EQ(ui::ER_UNHANDLED, status);
   }
 
   gesture_handler_ = NULL;
diff --git a/ui/views/widget/root_view.h b/ui/views/widget/root_view.h
index f6e0ce4..1af6d59 100644
--- a/ui/views/widget/root_view.h
+++ b/ui/views/widget/root_view.h
@@ -106,7 +106,7 @@ class VIEWS_EXPORT RootView : public View, public FocusTraversable {
   virtual bool OnMouseWheel(const ui::MouseWheelEvent& event) OVERRIDE;
   virtual bool OnScrollEvent(const ui::ScrollEvent& event) OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual void SetMouseHandler(View* new_mouse_handler) OVERRIDE;
   virtual void GetAccessibleState(ui::AccessibleViewState* state) OVERRIDE;
diff --git a/ui/views/widget/widget.cc b/ui/views/widget/widget.cc
index b0e769c..ed30d7e 100644
--- a/ui/views/widget/widget.cc
+++ b/ui/views/widget/widget.cc
@@ -1126,7 +1126,7 @@ ui::TouchStatus Widget::OnTouchEvent(const ui::TouchEvent& event) {
   return GetRootView()->OnTouchEvent(event);
 }
 
-ui::GestureStatus Widget::OnGestureEvent(const ui::GestureEvent& event) {
+ui::EventResult Widget::OnGestureEvent(const ui::GestureEvent& event) {
   ScopedEvent scoped(this, event);
   switch (event.type()) {
     case ui::ET_GESTURE_TAP_DOWN:
diff --git a/ui/views/widget/widget.h b/ui/views/widget/widget.h
index 4c442c0..3f0a2b7 100644
--- a/ui/views/widget/widget.h
+++ b/ui/views/widget/widget.h
@@ -641,7 +641,7 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate,
   virtual bool OnMouseEvent(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
   virtual ui::TouchStatus OnTouchEvent(const ui::TouchEvent& event) OVERRIDE;
-  virtual ui::GestureStatus OnGestureEvent(
+  virtual ui::EventResult OnGestureEvent(
       const ui::GestureEvent& event) OVERRIDE;
   virtual bool ExecuteCommand(int command_id) OVERRIDE;
   virtual InputMethod* GetInputMethodDirect() OVERRIDE;
diff --git a/ui/views/widget/x11_desktop_window_move_client.cc b/ui/views/widget/x11_desktop_window_move_client.cc
index 7d5e535..07f7041 100644
--- a/ui/views/widget/x11_desktop_window_move_client.cc
+++ b/ui/views/widget/x11_desktop_window_move_client.cc
@@ -63,10 +63,10 @@ ui::TouchStatus X11DesktopWindowMoveClient::PreHandleTouchEvent(
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus X11DesktopWindowMoveClient::PreHandleGestureEvent(
+ui::EventResult X11DesktopWindowMoveClient::PreHandleGestureEvent(
     aura::Window* target,
     ui::GestureEvent* event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 void X11DesktopWindowMoveClient::RunMoveLoop(aura::Window* source,
diff --git a/ui/views/widget/x11_desktop_window_move_client.h b/ui/views/widget/x11_desktop_window_move_client.h
index b0e910c..114e5b7 100644
--- a/ui/views/widget/x11_desktop_window_move_client.h
+++ b/ui/views/widget/x11_desktop_window_move_client.h
@@ -29,7 +29,7 @@ class VIEWS_EXPORT X11DesktopWindowMoveClient
                                    ui::MouseEvent* event) OVERRIDE;
   virtual ui::TouchStatus PreHandleTouchEvent(aura::Window* target,
                                               ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       aura::Window* target,
       ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ui/views/widget/x11_window_event_filter.cc b/ui/views/widget/x11_window_event_filter.cc
index 8edf91d..192c6ff 100644
--- a/ui/views/widget/x11_window_event_filter.cc
+++ b/ui/views/widget/x11_window_event_filter.cc
@@ -116,10 +116,10 @@ ui::TouchStatus X11WindowEventFilter::PreHandleTouchEvent(
   return ui::TOUCH_STATUS_UNKNOWN;
 }
 
-ui::GestureStatus X11WindowEventFilter::PreHandleGestureEvent(
+ui::EventResult X11WindowEventFilter::PreHandleGestureEvent(
     aura::Window* target,
     ui::GestureEvent* event) {
-  return ui::GESTURE_STATUS_UNKNOWN;
+  return ui::ER_UNHANDLED;
 }
 
 bool X11WindowEventFilter::DispatchHostWindowDragMovement(
diff --git a/ui/views/widget/x11_window_event_filter.h b/ui/views/widget/x11_window_event_filter.h
index d7dfbe3..01c5bd5 100644
--- a/ui/views/widget/x11_window_event_filter.h
+++ b/ui/views/widget/x11_window_event_filter.h
@@ -44,7 +44,7 @@ class VIEWS_EXPORT X11WindowEventFilter : public aura::EventFilter {
   virtual ui::TouchStatus PreHandleTouchEvent(
       aura::Window* target,
       ui::TouchEvent* event) OVERRIDE;
-  virtual ui::GestureStatus PreHandleGestureEvent(
+  virtual ui::EventResult PreHandleGestureEvent(
       aura::Window* target,
       ui::GestureEvent* event) OVERRIDE;