events: Update key-event handlers to not return EventResult.

BUG=163618

Review URL: https://codereview.chromium.org/11570012

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

33 files changed, 83 insertions, 84 deletions

diff --git a/ui/aura/root_window_unittest.cc b/ui/aura/root_window_unittest.cc
index e76c787c..9f97cb7 100644
--- a/ui/aura/root_window_unittest.cc
+++ b/ui/aura/root_window_unittest.cc
@@ -81,9 +81,9 @@ class ConsumeKeyHandler : public test::TestEventHandler {
   virtual ~ConsumeKeyHandler() {}
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     test::TestEventHandler::OnKeyEvent(event);
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
   }
 
  private:
@@ -441,9 +441,8 @@ class EventFilterRecorder : public ui::EventHandler {
   Events& events() { return events_; }
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
@@ -640,10 +639,9 @@ class DeletingEventFilter : public ui::EventHandler {
 
  private:
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
       delete event->target();
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
@@ -674,11 +672,10 @@ class DeletingWindowDelegate : public test::TestWindowDelegate {
 
  private:
   // Overridden from WindowDelegate:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
diff --git a/ui/aura/test/test_event_handler.cc b/ui/aura/test/test_event_handler.cc
index 910b301..8e05579 100644
--- a/ui/aura/test/test_event_handler.cc
+++ b/ui/aura/test/test_event_handler.cc
@@ -25,9 +25,8 @@ void TestEventHandler::Reset() {
   num_gesture_events_ = 0;
 }
 
-ui::EventResult TestEventHandler::OnKeyEvent(ui::KeyEvent* event) {
+void TestEventHandler::OnKeyEvent(ui::KeyEvent* event) {
   num_key_events_++;
-  return ui::ER_UNHANDLED;
 }
 
 ui::EventResult TestEventHandler::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/aura/test/test_event_handler.h b/ui/aura/test/test_event_handler.h
index c934136..443232d 100644
--- a/ui/aura/test/test_event_handler.h
+++ b/ui/aura/test/test_event_handler.h
@@ -28,7 +28,7 @@ class TestEventHandler : public ui::EventHandler {
   void Reset();
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/aura/test/test_window_delegate.cc b/ui/aura/test/test_window_delegate.cc
index eb34561..155e343 100644
--- a/ui/aura/test/test_window_delegate.cc
+++ b/ui/aura/test/test_window_delegate.cc
@@ -102,16 +102,19 @@ ColorTestWindowDelegate::ColorTestWindowDelegate(SkColor color)
     : color_(color),
       last_key_code_(ui::VKEY_UNKNOWN) {
 }
+
 ColorTestWindowDelegate::~ColorTestWindowDelegate() {
 }
 
-ui::EventResult ColorTestWindowDelegate::OnKeyEvent(ui::KeyEvent* event) {
+void ColorTestWindowDelegate::OnKeyEvent(ui::KeyEvent* event) {
   last_key_code_ = event->key_code();
-  return ui::ER_HANDLED;
+  event->SetHandled();
 }
+
 void ColorTestWindowDelegate::OnWindowDestroyed() {
   delete this;
 }
+
 void ColorTestWindowDelegate::OnPaint(gfx::Canvas* canvas) {
   canvas->DrawColor(color_, SkXfermode::kSrc_Mode);
 }
@@ -144,7 +147,7 @@ EventCountDelegate::EventCountDelegate()
     key_release_count_(0) {
 }
 
-ui::EventResult EventCountDelegate::OnKeyEvent(ui::KeyEvent* event) {
+void EventCountDelegate::OnKeyEvent(ui::KeyEvent* event) {
   switch (event->type()) {
     case ui::ET_KEY_PRESSED:
       key_press_count_++;
@@ -154,7 +157,6 @@ ui::EventResult EventCountDelegate::OnKeyEvent(ui::KeyEvent* event) {
     default:
       break;
   }
-  return ui::ER_UNHANDLED;
 }
 
 ui::EventResult EventCountDelegate::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/aura/test/test_window_delegate.h b/ui/aura/test/test_window_delegate.h
index 209f98c..1abd955 100644
--- a/ui/aura/test/test_window_delegate.h
+++ b/ui/aura/test/test_window_delegate.h
@@ -78,7 +78,7 @@ class ColorTestWindowDelegate : public TestWindowDelegate {
   ui::KeyboardCode last_key_code() const { return last_key_code_; }
 
   // Overridden from TestWindowDelegate:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual void OnWindowDestroyed() OVERRIDE;
   virtual void OnPaint(gfx::Canvas* canvas) OVERRIDE;
 
@@ -110,7 +110,7 @@ class EventCountDelegate : public TestWindowDelegate {
   EventCountDelegate();
 
   // Overridden from TestWindowDelegate:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // Returns the counts of mouse motion events in the
diff --git a/ui/base/events/event_dispatcher_unittest.cc b/ui/base/events/event_dispatcher_unittest.cc
index 1cc8ba6..41eed09 100644
--- a/ui/base/events/event_dispatcher_unittest.cc
+++ b/ui/base/events/event_dispatcher_unittest.cc
@@ -80,9 +80,9 @@ class TestEventHandler : public EventHandler {
 
  private:
   // Overridden from EventHandler:
-  virtual EventResult OnKeyEvent(KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(KeyEvent* event) OVERRIDE {
     ReceivedEvent(event);
-    return event_result_;
+    SetStatusOnEvent(event);
   }
 
   virtual EventResult OnMouseEvent(MouseEvent* event) OVERRIDE {
diff --git a/ui/base/events/event_handler.cc b/ui/base/events/event_handler.cc
index df35e59..85ec7d5 100644
--- a/ui/base/events/event_handler.cc
+++ b/ui/base/events/event_handler.cc
@@ -23,7 +23,7 @@ EventHandler::~EventHandler() {
 void EventHandler::OnEvent(Event* event) {
   ui::EventResult result = ui::ER_UNHANDLED;
   if (event->IsKeyEvent())
-    result = OnKeyEvent(static_cast<KeyEvent*>(event));
+    OnKeyEvent(static_cast<KeyEvent*>(event));
   else if (event->IsMouseEvent())
     result = OnMouseEvent(static_cast<MouseEvent*>(event));
   else if (event->IsScrollEvent())
@@ -39,8 +39,7 @@ void EventHandler::OnEvent(Event* event) {
     event->SetHandled();
 }
 
-EventResult EventHandler::OnKeyEvent(KeyEvent* event) {
-  return ui::ER_UNHANDLED;
+void EventHandler::OnKeyEvent(KeyEvent* event) {
 }
 
 EventResult EventHandler::OnMouseEvent(MouseEvent* event) {
diff --git a/ui/base/events/event_handler.h b/ui/base/events/event_handler.h
index 233b5cb..1084889 100644
--- a/ui/base/events/event_handler.h
+++ b/ui/base/events/event_handler.h
@@ -36,7 +36,7 @@ class UI_EXPORT EventHandler {
   // default implementation for un-handled events.
   virtual void OnEvent(Event* event);
 
-  virtual EventResult OnKeyEvent(KeyEvent* event);
+  virtual void OnKeyEvent(KeyEvent* event);
 
   virtual EventResult OnMouseEvent(MouseEvent* event);
 
diff --git a/ui/base/events/event_target.cc b/ui/base/events/event_target.cc
index c587877..649c722 100644
--- a/ui/base/events/event_target.cc
+++ b/ui/base/events/event_target.cc
@@ -52,9 +52,10 @@ void EventTarget::OnEvent(Event* event) {
     EventHandler::OnEvent(event);
 }
 
-EventResult EventTarget::OnKeyEvent(KeyEvent* event) {
+void EventTarget::OnKeyEvent(KeyEvent* event) {
   CHECK_EQ(this, event->target());
-  return target_handler_ ? target_handler_->OnKeyEvent(event) : ER_UNHANDLED;
+  if (target_handler_)
+    target_handler_->OnKeyEvent(event);
 }
 
 EventResult EventTarget::OnMouseEvent(MouseEvent* event) {
diff --git a/ui/base/events/event_target.h b/ui/base/events/event_target.h
index 1bd5033..c54fa2b 100644
--- a/ui/base/events/event_target.h
+++ b/ui/base/events/event_target.h
@@ -73,7 +73,7 @@ class UI_EXPORT EventTarget : public EventHandler {
 
   // Overridden from EventHandler:
   virtual void OnEvent(Event* event) OVERRIDE;
-  virtual EventResult OnKeyEvent(KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(KeyEvent* event) OVERRIDE;
   virtual EventResult OnMouseEvent(MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(TouchEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/compound_event_filter.cc b/ui/views/corewm/compound_event_filter.cc
index 9e857c6..0b77b28 100644
--- a/ui/views/corewm/compound_event_filter.cc
+++ b/ui/views/corewm/compound_event_filter.cc
@@ -139,15 +139,13 @@ void CompoundEventFilter::UpdateCursor(aura::Window* target,
   }
 }
 
-ui::EventResult CompoundEventFilter::FilterKeyEvent(ui::KeyEvent* event) {
-  int result = ui::ER_UNHANDLED;
+void CompoundEventFilter::FilterKeyEvent(ui::KeyEvent* event) {
   if (handlers_.might_have_observers()) {
     ObserverListBase<ui::EventHandler>::Iterator it(handlers_);
     ui::EventHandler* handler;
-    while (!(result & ui::ER_CONSUMED) && (handler = it.GetNext()) != NULL)
-      result |= handler->OnKeyEvent(event);
+    while (!event->stopped_propagation() && (handler = it.GetNext()) != NULL)
+      handler->OnKeyEvent(event);
   }
-  return static_cast<ui::EventResult>(result);
 }
 
 ui::EventResult CompoundEventFilter::FilterMouseEvent(ui::MouseEvent* event) {
@@ -192,13 +190,13 @@ void CompoundEventFilter::SetCursorVisibilityOnEvent(aura::Window* target,
 ////////////////////////////////////////////////////////////////////////////////
 // CompoundEventFilter, ui::EventHandler implementation:
 
-ui::EventResult CompoundEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+void CompoundEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   if (ShouldHideCursorOnKeyEvent(*event)) {
     SetCursorVisibilityOnEvent(
         static_cast<aura::Window*>(event->target()), event, false);
   }
 
-  return FilterKeyEvent(event);
+  FilterKeyEvent(event);
 }
 
 ui::EventResult CompoundEventFilter::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/corewm/compound_event_filter.h b/ui/views/corewm/compound_event_filter.h
index 223b0b6..685c606 100644
--- a/ui/views/corewm/compound_event_filter.h
+++ b/ui/views/corewm/compound_event_filter.h
@@ -63,7 +63,7 @@ class VIEWS_EXPORT CompoundEventFilter : public ui::EventHandler {
   void UpdateCursor(aura::Window* target, ui::MouseEvent* event);
 
   // Dispatches event to additional filters.
-  ui::EventResult FilterKeyEvent(ui::KeyEvent* event);
+  void FilterKeyEvent(ui::KeyEvent* event);
   ui::EventResult FilterMouseEvent(ui::MouseEvent* event);
   void FilterTouchEvent(ui::TouchEvent* event);
 
@@ -78,7 +78,7 @@ class VIEWS_EXPORT CompoundEventFilter : public ui::EventHandler {
                                   bool show);
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/focus_controller.cc b/ui/views/corewm/focus_controller.cc
index 4f273af..b5bbd90 100644
--- a/ui/views/corewm/focus_controller.cc
+++ b/ui/views/corewm/focus_controller.cc
@@ -149,8 +149,7 @@ void FocusController::OnWindowHiddenInRootWindow(
 
 ////////////////////////////////////////////////////////////////////////////////
 // FocusController, ui::EventHandler implementation:
-ui::EventResult FocusController::OnKeyEvent(ui::KeyEvent* event) {
-  return ui::ER_UNHANDLED;
+void FocusController::OnKeyEvent(ui::KeyEvent* event) {
 }
 
 ui::EventResult FocusController::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/corewm/focus_controller.h b/ui/views/corewm/focus_controller.h
index a14968a..afd45cd 100644
--- a/ui/views/corewm/focus_controller.h
+++ b/ui/views/corewm/focus_controller.h
@@ -71,7 +71,7 @@ class VIEWS_EXPORT FocusController : public aura::client::ActivationClient,
                                           bool destroyed) OVERRIDE;
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/input_method_event_filter.cc b/ui/views/corewm/input_method_event_filter.cc
index f80d3ca..d7a1d38 100644
--- a/ui/views/corewm/input_method_event_filter.cc
+++ b/ui/views/corewm/input_method_event_filter.cc
@@ -37,14 +37,13 @@ void InputMethodEventFilter::SetInputMethodPropertyInRootWindow(
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodEventFilter, EventFilter implementation:
 
-ui::EventResult InputMethodEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+void InputMethodEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   const ui::EventType type = event->type();
   if (type == ui::ET_TRANSLATED_KEY_PRESS ||
       type == ui::ET_TRANSLATED_KEY_RELEASE) {
     // The |event| is already handled by this object, change the type of the
     // event to ui::ET_KEY_* and pass it to the next filter.
     static_cast<ui::TranslatedKeyEvent*>(event)->ConvertToKeyEvent();
-    return ui::ER_UNHANDLED;
   } else {
     // If the focused window is changed, all requests to IME will be
     // discarded so it's safe to update the target_root_window_ here.
@@ -55,7 +54,7 @@ ui::EventResult InputMethodEventFilter::OnKeyEvent(ui::KeyEvent* event) {
       input_method_->DispatchKeyEvent(event->native_event());
     else
       input_method_->DispatchFabricatedKeyEvent(*event);
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
   }
 }
 
diff --git a/ui/views/corewm/input_method_event_filter.h b/ui/views/corewm/input_method_event_filter.h
index c0d3a94..67633fc 100644
--- a/ui/views/corewm/input_method_event_filter.h
+++ b/ui/views/corewm/input_method_event_filter.h
@@ -39,7 +39,7 @@ class VIEWS_EXPORT InputMethodEventFilter
 
  private:
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
 
   // Overridden from ui::internal::InputMethodDelegate.
   virtual void DispatchKeyEventPostIME(const base::NativeEvent& event) OVERRIDE;
diff --git a/ui/views/corewm/window_modality_controller.cc b/ui/views/corewm/window_modality_controller.cc
index dd91a20..c6b2a37 100644
--- a/ui/views/corewm/window_modality_controller.cc
+++ b/ui/views/corewm/window_modality_controller.cc
@@ -103,9 +103,10 @@ WindowModalityController::~WindowModalityController() {
 ////////////////////////////////////////////////////////////////////////////////
 // WindowModalityController, aura::EventFilter implementation:
 
-ui::EventResult WindowModalityController::OnKeyEvent(ui::KeyEvent* event) {
+void WindowModalityController::OnKeyEvent(ui::KeyEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
-  return GetModalTransient(target) ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  if (GetModalTransient(target))
+    event->StopPropagation();
 }
 
 ui::EventResult WindowModalityController::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/corewm/window_modality_controller.h b/ui/views/corewm/window_modality_controller.h
index d6efc02..29fa047 100644
--- a/ui/views/corewm/window_modality_controller.h
+++ b/ui/views/corewm/window_modality_controller.h
@@ -38,7 +38,7 @@ class VIEWS_EXPORT WindowModalityController : public ui::EventHandler,
   virtual ~WindowModalityController();
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
diff --git a/ui/views/view.cc b/ui/views/view.cc
index 2fb4fdf..b40faee 100644
--- a/ui/views/view.cc
+++ b/ui/views/view.cc
@@ -867,8 +867,7 @@ bool View::OnMouseWheel(const ui::MouseWheelEvent& event) {
   return false;
 }
 
-ui::EventResult View::OnKeyEvent(ui::KeyEvent* event) {
-  return ui::ER_UNHANDLED;
+void View::OnKeyEvent(ui::KeyEvent* event) {
 }
 
 ui::EventResult View::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/view.h b/ui/views/view.h
index d19bec6..6acbd05 100644
--- a/ui/views/view.h
+++ b/ui/views/view.h
@@ -651,7 +651,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
   virtual ui::EventTarget* GetParentTarget() OVERRIDE;
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/widget/desktop_aura/desktop_activation_client.cc b/ui/views/widget/desktop_aura/desktop_activation_client.cc
index 0581e1b..181f1dd 100644
--- a/ui/views/widget/desktop_aura/desktop_activation_client.cc
+++ b/ui/views/widget/desktop_aura/desktop_activation_client.cc
@@ -158,8 +158,7 @@ bool DesktopActivationClient::CanActivateWindow(aura::Window* window) const {
        aura::client::GetActivationDelegate(window)->ShouldActivate());
 }
 
-ui::EventResult DesktopActivationClient::OnKeyEvent(ui::KeyEvent* event) {
-  return ui::ER_UNHANDLED;
+void DesktopActivationClient::OnKeyEvent(ui::KeyEvent* event) {
 }
 
 ui::EventResult DesktopActivationClient::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/widget/desktop_aura/desktop_activation_client.h b/ui/views/widget/desktop_aura/desktop_activation_client.h
index b4d5759..9d426f0 100644
--- a/ui/views/widget/desktop_aura/desktop_activation_client.h
+++ b/ui/views/widget/desktop_aura/desktop_activation_client.h
@@ -60,7 +60,7 @@ class VIEWS_EXPORT DesktopActivationClient
                                aura::Window* lost_focus) OVERRIDE;
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc b/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc
index 9d706bc..36c4fba 100644
--- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc
+++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc
@@ -544,27 +544,26 @@ scoped_refptr<ui::Texture> DesktopNativeWidgetAura::CopyTexture() {
 ////////////////////////////////////////////////////////////////////////////////
 // DesktopNativeWidgetAura, ui::EventHandler implementation:
 
-ui::EventResult DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
+void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   if (event->is_char()) {
     // If a ui::InputMethod object is attached to the root window, character
     // events are handled inside the object and are not passed to this function.
     // If such object is not attached, character events might be sent (e.g. on
     // Windows). In this case, we just skip these.
-    return ui::ER_UNHANDLED;
+    return;
   }
   // Renderer may send a key event back to us if the key event wasn't handled,
   // and the window may be invisible by that time.
   if (!window_->IsVisible())
-    return ui::ER_UNHANDLED;
+    return;
 
-  if (native_widget_delegate_->OnKeyEvent(*event))
-    return ui::ER_HANDLED;
+  native_widget_delegate_->OnKeyEvent(event);
+  if (event->handled())
+    return;
 
   if (GetWidget()->HasFocusManager() &&
       !GetWidget()->GetFocusManager()->OnKeyEvent(*event))
-    return ui::ER_HANDLED;
-
-  return ui::ER_UNHANDLED;
+    event->SetHandled();
 }
 
 ui::EventResult DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
@@ -671,7 +670,8 @@ void DesktopNativeWidgetAura::OnWindowFocused(aura::Window* gained_focus,
 void DesktopNativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
   FocusManager* focus_manager =
       native_widget_delegate_->AsWidget()->GetFocusManager();
-  if (native_widget_delegate_->OnKeyEvent(key) || !focus_manager)
+  native_widget_delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key));
+  if (key.handled() || !focus_manager)
     return;
   focus_manager->OnKeyEvent(key);
 }
diff --git a/ui/views/widget/desktop_aura/desktop_native_widget_aura.h b/ui/views/widget/desktop_aura/desktop_native_widget_aura.h
index b81c77b..38c5fad 100644
--- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.h
+++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.h
@@ -171,7 +171,7 @@ class VIEWS_EXPORT DesktopNativeWidgetAura
   virtual scoped_refptr<ui::Texture> CopyTexture() OVERRIDE;
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc
index 52c7748..e9b29c5 100644
--- a/ui/views/widget/native_widget_aura.cc
+++ b/ui/views/widget/native_widget_aura.cc
@@ -647,7 +647,8 @@ ui::NativeTheme* NativeWidgetAura::GetNativeTheme() const {
 
 void NativeWidgetAura::DispatchKeyEventPostIME(const ui::KeyEvent& key) {
   FocusManager* focus_manager = GetWidget()->GetFocusManager();
-  if (delegate_->OnKeyEvent(key) || !focus_manager)
+  delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&key));
+  if (key.handled() || !focus_manager)
     return;
   focus_manager->OnKeyEvent(key);
 }
@@ -768,20 +769,20 @@ scoped_refptr<ui::Texture> NativeWidgetAura::CopyTexture() {
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetAura, ui::EventHandler implementation:
 
-ui::EventResult NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
+void NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   if (event->is_char()) {
     // If a ui::InputMethod object is attached to the root window, character
     // events are handled inside the object and are not passed to this function.
     // If such object is not attached, character events might be sent (e.g. on
     // Windows). In this case, we just skip these.
-    return ui::ER_UNHANDLED;
+    return;
   }
   // Renderer may send a key event back to us if the key event wasn't handled,
   // and the window may be invisible by that time.
   if (!window_->IsVisible())
-    return ui::ER_UNHANDLED;
+    return;
   GetWidget()->GetInputMethod()->DispatchKeyEvent(*event);
-  return ui::ER_HANDLED;
+  event->SetHandled();
 }
 
 ui::EventResult NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h
index 3910f61..1796fab 100644
--- a/ui/views/widget/native_widget_aura.h
+++ b/ui/views/widget/native_widget_aura.h
@@ -156,7 +156,7 @@ class VIEWS_EXPORT NativeWidgetAura
   virtual scoped_refptr<ui::Texture> CopyTexture() OVERRIDE;
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/widget/native_widget_delegate.h b/ui/views/widget/native_widget_delegate.h
index e23a8d5..a29b095 100644
--- a/ui/views/widget/native_widget_delegate.h
+++ b/ui/views/widget/native_widget_delegate.h
@@ -106,7 +106,7 @@ class VIEWS_EXPORT NativeWidgetDelegate {
   virtual int GetNonClientComponent(const gfx::Point& point) = 0;
 
   // Mouse and key event handlers.
-  virtual bool OnKeyEvent(const ui::KeyEvent& event) = 0;
+  virtual void OnKeyEvent(ui::KeyEvent* event) = 0;
   virtual bool OnMouseEvent(const ui::MouseEvent& event) = 0;
   virtual void OnMouseCaptureLost() = 0;
 
diff --git a/ui/views/widget/native_widget_win.cc b/ui/views/widget/native_widget_win.cc
index d83af80..061cb7a 100644
--- a/ui/views/widget/native_widget_win.cc
+++ b/ui/views/widget/native_widget_win.cc
@@ -764,7 +764,8 @@ bool NativeWidgetWin::HandleMouseEvent(const ui::MouseEvent& event) {
 }
 
 bool NativeWidgetWin::HandleKeyEvent(const ui::KeyEvent& event) {
-  return delegate_->OnKeyEvent(event);
+  delegate_->OnKeyEvent(const_cast<ui::KeyEvent*>(&event));
+  return event.handled();
 }
 
 bool NativeWidgetWin::HandleUntranslatedKeyEvent(const ui::KeyEvent& event) {
diff --git a/ui/views/widget/root_view.cc b/ui/views/widget/root_view.cc
index 03dc04a..5b0de0b 100644
--- a/ui/views/widget/root_view.cc
+++ b/ui/views/widget/root_view.cc
@@ -111,7 +111,7 @@ void RootView::NotifyNativeViewHierarchyChanged(bool attached,
 
 // Input -----------------------------------------------------------------------
 
-ui::EventResult RootView::DispatchKeyEvent(const ui::KeyEvent& event) {
+void RootView::DispatchKeyEvent(ui::KeyEvent* event) {
   bool consumed = false;
 
   View* v = NULL;
@@ -119,17 +119,19 @@ ui::EventResult RootView::DispatchKeyEvent(const ui::KeyEvent& event) {
     v = GetFocusManager()->GetFocusedView();
   // Special case to handle right-click context menus triggered by the
   // keyboard.
-  if (v && v->enabled() && ((event.key_code() == ui::VKEY_APPS) ||
-     (event.key_code() == ui::VKEY_F10 && event.IsShiftDown()))) {
+  if (v && v->enabled() && ((event->key_code() == ui::VKEY_APPS) ||
+     (event->key_code() == ui::VKEY_F10 && event->IsShiftDown()))) {
     v->ShowContextMenu(v->GetKeyboardContextMenuLocation(), false);
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
+    return;
   }
   for (; v && v != this && !consumed; v = v->parent()) {
-    consumed = (event.type() == ui::ET_KEY_PRESSED) ?
-        v->OnKeyPressed(event) : v->OnKeyReleased(event);
+    consumed = (event->type() == ui::ET_KEY_PRESSED) ?
+        v->OnKeyPressed(*event) : v->OnKeyReleased(*event);
   }
 
-  return consumed ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  if (consumed)
+    event->StopPropagation();
 }
 
 void RootView::DispatchScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/views/widget/root_view.h b/ui/views/widget/root_view.h
index 1ee1b26..e8be227 100644
--- a/ui/views/widget/root_view.h
+++ b/ui/views/widget/root_view.h
@@ -61,7 +61,7 @@ class VIEWS_EXPORT RootView : public View, public FocusTraversable {
   // Process a key event. Send the event to the focused view and up the focus
   // path, and finally to the default keyboard handler, until someone consumes
   // it. Returns whether anyone consumed the event.
-  ui::EventResult DispatchKeyEvent(const ui::KeyEvent& event);
+  void DispatchKeyEvent(ui::KeyEvent* event);
   void DispatchScrollEvent(ui::ScrollEvent* event);
   void DispatchTouchEvent(ui::TouchEvent* event);
   virtual void DispatchGestureEvent(ui::GestureEvent* event);
diff --git a/ui/views/widget/widget.cc b/ui/views/widget/widget.cc
index 4ecf46b..627e1cd 100644
--- a/ui/views/widget/widget.cc
+++ b/ui/views/widget/widget.cc
@@ -1111,10 +1111,10 @@ int Widget::GetNonClientComponent(const gfx::Point& point) {
       HTNOWHERE;
 }
 
-bool Widget::OnKeyEvent(const ui::KeyEvent& event) {
-  ScopedEvent scoped(this, event);
-  return static_cast<internal::RootView*>(GetRootView())->
-      DispatchKeyEvent(event) != ui::ER_UNHANDLED;
+void Widget::OnKeyEvent(ui::KeyEvent* event) {
+  ScopedEvent scoped(this, *event);
+  static_cast<internal::RootView*>(GetRootView())->
+      DispatchKeyEvent(event);
 }
 
 bool Widget::OnMouseEvent(const ui::MouseEvent& event) {
diff --git a/ui/views/widget/widget.h b/ui/views/widget/widget.h
index 93d258b..b74d0da 100644
--- a/ui/views/widget/widget.h
+++ b/ui/views/widget/widget.h
@@ -667,7 +667,7 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate,
       const gfx::Rect& dirty_region) OVERRIDE;
   virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE;
   virtual int GetNonClientComponent(const gfx::Point& point) OVERRIDE;
-  virtual bool OnKeyEvent(const ui::KeyEvent& event) OVERRIDE;
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
   virtual bool OnMouseEvent(const ui::MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
diff --git a/ui/views/widget/widget_unittest.cc b/ui/views/widget/widget_unittest.cc
index b57ccbd..5a001b8 100644
--- a/ui/views/widget/widget_unittest.cc
+++ b/ui/views/widget/widget_unittest.cc
@@ -1029,9 +1029,11 @@ TEST_F(WidgetTest, KeyboardInputEvent) {
 
   // The press gets handled. The release doesn't have an effect.
   ui::KeyEvent backspace_p(ui::ET_KEY_PRESSED, ui::VKEY_DELETE, 0, false);
-  EXPECT_TRUE(toplevel->OnKeyEvent(backspace_p));
+  toplevel->OnKeyEvent(&backspace_p);
+  EXPECT_TRUE(backspace_p.stopped_propagation());
   ui::KeyEvent backspace_r(ui::ET_KEY_RELEASED, ui::VKEY_DELETE, 0, false);
-  EXPECT_FALSE(toplevel->OnKeyEvent(backspace_r));
+  toplevel->OnKeyEvent(&backspace_r);
+  EXPECT_FALSE(backspace_r.handled());
 
   toplevel->Close();
 }