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

This is the last step. Once this is done, we can possibly hide EventResult.

BUG=163618

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

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

75 files changed, 239 insertions, 261 deletions

diff --git a/ash/display/mouse_cursor_event_filter.cc b/ash/display/mouse_cursor_event_filter.cc
index 0e336d3..eb356ff 100644
--- a/ash/display/mouse_cursor_event_filter.cc
+++ b/ash/display/mouse_cursor_event_filter.cc
@@ -71,20 +71,20 @@ void MouseCursorEventFilter::HideSharedEdgeIndicator() {
   shared_display_edge_indicator_->Hide();
 }
 
-ui::EventResult MouseCursorEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void MouseCursorEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   // Handle both MOVED and DRAGGED events here because when the mouse pointer
   // enters the other root window while dragging, the underlying window system
   // (at least X11) stops generating a ui::ET_MOUSE_MOVED event.
   if (event->type() != ui::ET_MOUSE_MOVED &&
       event->type() != ui::ET_MOUSE_DRAGGED) {
-      return ui::ER_UNHANDLED;
+      return;
   }
 
   gfx::Point point_in_screen(event->location());
   aura::Window* target = static_cast<aura::Window*>(event->target());
   wm::ConvertPointToScreen(target, &point_in_screen);
-  return WarpMouseCursorIfNecessary(target->GetRootWindow(), point_in_screen) ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  if (WarpMouseCursorIfNecessary(target->GetRootWindow(), point_in_screen))
+    event->StopPropagation();
 }
 
 bool MouseCursorEventFilter::WarpMouseCursorIfNecessary(
diff --git a/ash/display/mouse_cursor_event_filter.h b/ash/display/mouse_cursor_event_filter.h
index 2e00ea3..593448f 100644
--- a/ash/display/mouse_cursor_event_filter.h
+++ b/ash/display/mouse_cursor_event_filter.h
@@ -47,7 +47,7 @@ class ASH_EXPORT MouseCursorEventFilter : public ui::EventHandler {
   void HideSharedEdgeIndicator();
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(MouseCursorEventFilterTest, SetMouseWarpModeFlag);
diff --git a/ash/drag_drop/drag_drop_controller.cc b/ash/drag_drop/drag_drop_controller.cc
index 91aa4a7..5d1611e 100644
--- a/ash/drag_drop/drag_drop_controller.cc
+++ b/ash/drag_drop/drag_drop_controller.cc
@@ -292,19 +292,23 @@ void DragDropController::OnKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult DragDropController::OnMouseEvent(ui::MouseEvent* event) {
+void DragDropController::OnMouseEvent(ui::MouseEvent* event) {
   if (!IsDragDropInProgress())
-    return ui::ER_UNHANDLED;
+    return;
 
   // If current drag session was not started by mouse, dont process this mouse
   // event, but consume it so it does not interfere with current drag session.
-  if (current_drag_event_source_ != ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE)
-    return ui::ER_CONSUMED;
+  if (current_drag_event_source_ !=
+      ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE) {
+    event->StopPropagation();
+    return;
+  }
 
   aura::Window* translated_target = drag_drop_tracker_->GetTarget(*event);
   if (!translated_target) {
     DragCancel();
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
+    return;
   }
   scoped_ptr<ui::LocatedEvent> translated_event(
       drag_drop_tracker_->ConvertEvent(translated_target, *event));
@@ -321,7 +325,7 @@ ui::EventResult DragDropController::OnMouseEvent(ui::MouseEvent* event) {
       // (aura::RootWindow::PostMouseMoveEventAfterWindowChange).
       break;
   }
-  return ui::ER_CONSUMED;
+  event->StopPropagation();
 }
 
 void DragDropController::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ash/drag_drop/drag_drop_controller.h b/ash/drag_drop/drag_drop_controller.h
index 49dfb65ed..8c4e6bb 100644
--- a/ash/drag_drop/drag_drop_controller.h
+++ b/ash/drag_drop/drag_drop_controller.h
@@ -66,7 +66,7 @@ class ASH_EXPORT DragDropController
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ash/extended_desktop_unittest.cc b/ash/extended_desktop_unittest.cc
index 716b9f2..29f8b88 100644
--- a/ash/extended_desktop_unittest.cc
+++ b/ash/extended_desktop_unittest.cc
@@ -90,13 +90,12 @@ class MoveWindowByClickEventFilter : public ui::EventHandler {
 
  private:
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (event->type() == ui::ET_MOUSE_RELEASED) {
       Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
       DCHECK_LT(1u, root_windows.size());
       root_windows[1]->AddChild(target_);
     }
-    return ui::ER_UNHANDLED;
   }
 
   aura::Window* target_;
diff --git a/ash/launcher/launcher_tooltip_manager.cc b/ash/launcher/launcher_tooltip_manager.cc
index dfc2a4b..2435d4f 100644
--- a/ash/launcher/launcher_tooltip_manager.cc
+++ b/ash/launcher/launcher_tooltip_manager.cc
@@ -243,11 +243,11 @@ bool LauncherTooltipManager::IsVisible() {
   return widget_ && widget_->IsVisible();
 }
 
-ui::EventResult LauncherTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
+void LauncherTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(event->target());
   DCHECK(event);
   if (!widget_ || !widget_->IsVisible())
-    return ui::ER_UNHANDLED;
+    return;
 
   DCHECK(view_);
   DCHECK(launcher_view_);
@@ -255,7 +255,7 @@ ui::EventResult LauncherTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (widget_->GetNativeWindow()->GetRootWindow() != target->GetRootWindow()) {
     CloseSoon();
-    return ui::ER_UNHANDLED;
+    return;
   }
 
   gfx::Point location_in_launcher_view = event->location();
@@ -274,8 +274,6 @@ ui::EventResult LauncherTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
     // the closing event rather than directly calling Close().
     CloseSoon();
   }
-
-  return ui::ER_UNHANDLED;
 }
 
 void LauncherTooltipManager::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ash/launcher/launcher_tooltip_manager.h b/ash/launcher/launcher_tooltip_manager.h
index a4e28c5..efe27f9 100644
--- a/ash/launcher/launcher_tooltip_manager.h
+++ b/ash/launcher/launcher_tooltip_manager.h
@@ -76,7 +76,7 @@ class ASH_EXPORT LauncherTooltipManager : public ui::EventHandler,
 
 protected:
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ash/launcher/launcher_tooltip_manager_unittest.cc b/ash/launcher/launcher_tooltip_manager_unittest.cc
index 0fcbe28..249b0a0 100644
--- a/ash/launcher/launcher_tooltip_manager_unittest.cc
+++ b/ash/launcher/launcher_tooltip_manager_unittest.cc
@@ -204,14 +204,14 @@ TEST_F(LauncherTooltipManagerTest, HideForMouseEvent) {
   ui::LocatedEvent::TestApi test_api(&mouse_event);
 
   SetEventTarget(root_window, &mouse_event);
-  EXPECT_EQ(ui::ER_UNHANDLED,
-            event_handler->OnMouseEvent(&mouse_event));
+  event_handler->OnMouseEvent(&mouse_event);
+  EXPECT_FALSE(mouse_event.handled());
   EXPECT_TRUE(TooltipIsVisible());
 
   // Should hide if the mouse is out of the tooltip.
   test_api.set_location(tooltip_rect.origin() + gfx::Vector2d(-1, -1));
-  EXPECT_EQ(ui::ER_UNHANDLED,
-            event_handler->OnMouseEvent(&mouse_event));
+  event_handler->OnMouseEvent(&mouse_event);
+  EXPECT_FALSE(mouse_event.handled());
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(TooltipIsVisible());
 }
diff --git a/ash/magnifier/magnification_controller.cc b/ash/magnifier/magnification_controller.cc
index 0912e37..b7fd98d 100644
--- a/ash/magnifier/magnification_controller.cc
+++ b/ash/magnifier/magnification_controller.cc
@@ -114,7 +114,7 @@ class MagnificationControllerImpl : virtual public MagnificationController,
   void ValidateScale(float* scale);
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
 
   aura::RootWindow* root_window_;
@@ -488,8 +488,7 @@ bool MagnificationControllerImpl::IsEnabled() const {
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationControllerImpl: aura::EventFilter implementation
 
-ui::EventResult MagnificationControllerImpl::OnMouseEvent(
-    ui::MouseEvent* event) {
+void MagnificationControllerImpl::OnMouseEvent(ui::MouseEvent* event) {
   if (IsMagnified() && event->type() == ui::ET_MOUSE_MOVED) {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     aura::RootWindow* current_root = target->GetRootWindow();
@@ -502,8 +501,6 @@ ui::EventResult MagnificationControllerImpl::OnMouseEvent(
       OnMouseMove(event->root_location());
     }
   }
-
-  return ui::ER_UNHANDLED;
 }
 
 void MagnificationControllerImpl::OnScrollEvent(
diff --git a/ash/magnifier/partial_magnification_controller.cc b/ash/magnifier/partial_magnification_controller.cc
index cdabbf2..2a4ab84 100644
--- a/ash/magnifier/partial_magnification_controller.cc
+++ b/ash/magnifier/partial_magnification_controller.cc
@@ -76,8 +76,7 @@ void PartialMagnificationController::SetEnabled(bool enabled) {
 ////////////////////////////////////////////////////////////////////////////////
 // PartialMagnificationController: ui::EventHandler implementation
 
-ui::EventResult PartialMagnificationController::OnMouseEvent(
-    ui::MouseEvent* event) {
+void PartialMagnificationController::OnMouseEvent(ui::MouseEvent* event) {
   if (IsPartialMagnified() && event->type() == ui::ET_MOUSE_MOVED) {
     aura::Window* target = static_cast<aura::Window*>(event->target());
     aura::RootWindow* current_root = target->GetRootWindow();
@@ -91,8 +90,6 @@ ui::EventResult PartialMagnificationController::OnMouseEvent(
       OnMouseMove(event->root_location());
     }
   }
-
-  return ui::ER_UNHANDLED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/ash/magnifier/partial_magnification_controller.h b/ash/magnifier/partial_magnification_controller.h
index 24e57d3..dc95360c 100644
--- a/ash/magnifier/partial_magnification_controller.h
+++ b/ash/magnifier/partial_magnification_controller.h
@@ -67,7 +67,7 @@ class PartialMagnificationController
   void RemoveZoomWidgetObservers();
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // Overridden from WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
diff --git a/ash/system/tray/tray_event_filter.cc b/ash/system/tray/tray_event_filter.cc
index 4057f87..b91315a 100644
--- a/ash/system/tray/tray_event_filter.cc
+++ b/ash/system/tray/tray_event_filter.cc
@@ -30,12 +30,11 @@ TrayEventFilter::~TrayEventFilter() {
   ash::Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
-ui::EventResult TrayEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void TrayEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED &&
       ProcessLocatedEvent(event)) {
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
   }
-  return ui::ER_UNHANDLED;
 }
 
 void TrayEventFilter::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ash/system/tray/tray_event_filter.h b/ash/system/tray/tray_event_filter.h
index 65fec335..5e7fa6f 100644
--- a/ash/system/tray/tray_event_filter.h
+++ b/ash/system/tray/tray_event_filter.h
@@ -26,7 +26,7 @@ class TrayEventFilter : public ui::EventHandler {
   virtual ~TrayEventFilter();
 
   // Overridden from ui::EventHandler.
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
  private:
diff --git a/ash/tooltips/tooltip_controller.cc b/ash/tooltips/tooltip_controller.cc
index ef80f9b..391b4a6 100644
--- a/ash/tooltips/tooltip_controller.cc
+++ b/ash/tooltips/tooltip_controller.cc
@@ -259,7 +259,7 @@ void TooltipController::OnKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult TooltipController::OnMouseEvent(ui::MouseEvent* event) {
+void TooltipController::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
@@ -298,7 +298,6 @@ ui::EventResult TooltipController::OnMouseEvent(ui::MouseEvent* event) {
     default:
       break;
   }
-  return ui::ER_UNHANDLED;
 }
 
 void TooltipController::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ash/tooltips/tooltip_controller.h b/ash/tooltips/tooltip_controller.h
index 6ac7b27..5f2215a 100644
--- a/ash/tooltips/tooltip_controller.h
+++ b/ash/tooltips/tooltip_controller.h
@@ -45,7 +45,7 @@ class ASH_EXPORT TooltipController : public aura::client::TooltipClient,
 
   // Overridden from ui::EventHandler.
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
   // Overridden from SessionStateController.
diff --git a/ash/wm/activation_controller.cc b/ash/wm/activation_controller.cc
index a17109e..29058f3 100644
--- a/ash/wm/activation_controller.cc
+++ b/ash/wm/activation_controller.cc
@@ -275,10 +275,9 @@ void ActivationController::OnWindowFocused(aura::Window* gained_focus,
 void ActivationController::OnKeyEvent(ui::KeyEvent* event) {
 }
 
-ui::EventResult ActivationController::OnMouseEvent(ui::MouseEvent* event) {
+void ActivationController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED)
     FocusWindowWithEvent(event);
-  return ui::ER_UNHANDLED;
 }
 
 void ActivationController::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ash/wm/activation_controller.h b/ash/wm/activation_controller.h
index f9b023f..11e09b9 100644
--- a/ash/wm/activation_controller.h
+++ b/ash/wm/activation_controller.h
@@ -76,7 +76,7 @@ class ASH_EXPORT ActivationController
  private:
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ash/wm/app_list_controller.cc b/ash/wm/app_list_controller.cc
index 3bfe4ca..1d402ce 100644
--- a/ash/wm/app_list_controller.cc
+++ b/ash/wm/app_list_controller.cc
@@ -231,10 +231,9 @@ void AppListController::UpdateBounds() {
 ////////////////////////////////////////////////////////////////////////////////
 // AppListController, aura::EventFilter implementation:
 
-ui::EventResult AppListController::OnMouseEvent(ui::MouseEvent* event) {
+void AppListController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED)
     ProcessLocatedEvent(event);
-  return ui::ER_UNHANDLED;
 }
 
 void AppListController::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ash/wm/app_list_controller.h b/ash/wm/app_list_controller.h
index f396052..c1abead 100644
--- a/ash/wm/app_list_controller.h
+++ b/ash/wm/app_list_controller.h
@@ -77,7 +77,7 @@ class AppListController : public ui::EventHandler,
   void UpdateBounds();
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // aura::client::FocusChangeObserver overrides:
diff --git a/ash/wm/event_rewriter_event_filter.cc b/ash/wm/event_rewriter_event_filter.cc
index 81ed7e5..3b96c2d 100644
--- a/ash/wm/event_rewriter_event_filter.cc
+++ b/ash/wm/event_rewriter_event_filter.cc
@@ -39,19 +39,17 @@ void EventRewriterEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult EventRewriterEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void EventRewriterEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (!delegate_.get())
-    return ui::ER_UNHANDLED;
+    return;
 
   switch (delegate_->RewriteOrFilterLocatedEvent(event)) {
     case EventRewriterDelegate::ACTION_REWRITE_EVENT:
-      return ui::ER_UNHANDLED;
+      return;
     case EventRewriterDelegate::ACTION_DROP_EVENT:
-      return ui::ER_CONSUMED;
+      event->StopPropagation();
+      break;
   }
-
-  NOTREACHED();
-  return ui::ER_UNHANDLED;
 }
 
 }  // namespace internal
diff --git a/ash/wm/event_rewriter_event_filter.h b/ash/wm/event_rewriter_event_filter.h
index 6939001..6c267a0 100644
--- a/ash/wm/event_rewriter_event_filter.h
+++ b/ash/wm/event_rewriter_event_filter.h
@@ -28,7 +28,7 @@ class ASH_EXPORT EventRewriterEventFilter : public ui::EventHandler {
  private:
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   scoped_ptr<EventRewriterDelegate> delegate_;
 
diff --git a/ash/wm/panel_window_event_filter.cc b/ash/wm/panel_window_event_filter.cc
index 52696aa..3f5f0b4 100644
--- a/ash/wm/panel_window_event_filter.cc
+++ b/ash/wm/panel_window_event_filter.cc
@@ -35,7 +35,7 @@ PanelWindowEventFilter::~PanelWindowEventFilter() {
   panel_container_->RemovePreTargetHandler(this);
 }
 
-ui::EventResult PanelWindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void PanelWindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED: {
@@ -46,13 +46,10 @@ ui::EventResult PanelWindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
           dragged_panel_ = target;
           drag_location_in_dragged_window_ = event->location();
           drag_state_ = DRAG_CLICKED;
-          return ui::ER_CONSUMED;
-        } else {
-          return ui::ER_UNHANDLED;
+          event->StopPropagation();
         }
-      } else {
-        return ui::ER_UNHANDLED;
       }
+      return;
     }
 
     case ui::ET_MOUSE_DRAGGED:
@@ -60,35 +57,34 @@ ui::EventResult PanelWindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
         drag_state_ = DRAG_STARTED;
         layout_manager_->StartDragging(dragged_panel_);
       }
-      if (drag_state_ == DRAG_STARTED)
-        return HandleDrag(target, event) ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
-      else
-        return ui::ER_UNHANDLED;
+      if (drag_state_ == DRAG_STARTED && HandleDrag(target, event))
+        event->StopPropagation();
+      return;
 
     case ui::ET_MOUSE_CAPTURE_CHANGED:
       if (drag_state_ == DRAG_STARTED) {
         FinishDrag();
-        return ui::ER_CONSUMED;
+        event->StopPropagation();
       } else if (drag_state_ == DRAG_CLICKED) {
         drag_state_ = DRAG_NONE;
         dragged_panel_ = NULL;
-        return ui::ER_CONSUMED;
+        event->StopPropagation();
       }
-      return ui::ER_UNHANDLED;
+      return;
 
     case ui::ET_MOUSE_RELEASED:
       if (drag_state_ == DRAG_STARTED) {
         FinishDrag();
-        return ui::ER_CONSUMED;
+        event->StopPropagation();
       } else if (dragged_panel_ != NULL) {
         drag_state_ = DRAG_NONE;
         layout_manager_->ToggleMinimize(dragged_panel_);
         dragged_panel_ = NULL;
-        return ui::ER_CONSUMED;
+        event->StopPropagation();
       }
-      return ui::ER_UNHANDLED;
+      return;
     default:
-      return ui::ER_UNHANDLED;
+      return;
   }
 }
 
diff --git a/ash/wm/panel_window_event_filter.h b/ash/wm/panel_window_event_filter.h
index 29971ad..4a12338 100644
--- a/ash/wm/panel_window_event_filter.h
+++ b/ash/wm/panel_window_event_filter.h
@@ -30,7 +30,7 @@ class PanelWindowEventFilter : public ui::EventHandler,
   virtual ~PanelWindowEventFilter();
 
   // Overriden from ui::EventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // Overridden from aura::WindowObserver:
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
diff --git a/ash/wm/shelf_layout_manager.cc b/ash/wm/shelf_layout_manager.cc
index dce2fd2..a04a05f 100644
--- a/ash/wm/shelf_layout_manager.cc
+++ b/ash/wm/shelf_layout_manager.cc
@@ -74,7 +74,7 @@ class ShelfLayoutManager::AutoHideEventFilter : public ui::EventHandler {
   bool in_mouse_drag() const { return in_mouse_drag_; }
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
  private:
   ShelfLayoutManager* shelf_;
@@ -94,7 +94,7 @@ ShelfLayoutManager::AutoHideEventFilter::~AutoHideEventFilter() {
   Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
-ui::EventResult ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
+void ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
   // This also checks IsShelfWindow() to make sure we don't attempt to hide the
   // shelf if the mouse down occurs on the shelf.
@@ -104,7 +104,7 @@ ui::EventResult ShelfLayoutManager::AutoHideEventFilter::OnMouseEvent(
       !shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()));
   if (event->type() == ui::ET_MOUSE_MOVED)
     shelf_->UpdateAutoHideState();
-  return ui::ER_UNHANDLED;
+  return;
 }
 
 // ShelfLayoutManager:UpdateShelfObserver --------------------------------------
diff --git a/ash/wm/system_gesture_event_filter.cc b/ash/wm/system_gesture_event_filter.cc
index 019cf53..8dceaa0 100644
--- a/ash/wm/system_gesture_event_filter.cc
+++ b/ash/wm/system_gesture_event_filter.cc
@@ -53,7 +53,7 @@ SystemGestureEventFilter::SystemGestureEventFilter()
 SystemGestureEventFilter::~SystemGestureEventFilter() {
 }
 
-ui::EventResult SystemGestureEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void SystemGestureEventFilter::OnMouseEvent(ui::MouseEvent* event) {
 #if defined(OS_CHROMEOS)
   if (event->type() == ui::ET_MOUSE_PRESSED && event->native_event() &&
       ui::TouchFactory::GetInstance()->IsTouchDevicePresent() &&
@@ -62,7 +62,6 @@ ui::EventResult SystemGestureEventFilter::OnMouseEvent(ui::MouseEvent* event) {
       UMA_MOUSE_DOWN);
   }
 #endif
-  return ui::ER_UNHANDLED;
 }
 
 void SystemGestureEventFilter::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ash/wm/system_gesture_event_filter.h b/ash/wm/system_gesture_event_filter.h
index 984604d..ee3b786 100644
--- a/ash/wm/system_gesture_event_filter.h
+++ b/ash/wm/system_gesture_event_filter.h
@@ -45,7 +45,7 @@ class SystemGestureEventFilter : public ui::EventHandler,
   virtual ~SystemGestureEventFilter();
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
diff --git a/ash/wm/system_modal_container_event_filter.cc b/ash/wm/system_modal_container_event_filter.cc
index da9600f..532bb44 100644
--- a/ash/wm/system_modal_container_event_filter.cc
+++ b/ash/wm/system_modal_container_event_filter.cc
@@ -25,11 +25,11 @@ void SystemModalContainerEventFilter::OnKeyEvent(ui::KeyEvent* event) {
     event->StopPropagation();
 }
 
-ui::EventResult SystemModalContainerEventFilter::OnMouseEvent(
+void SystemModalContainerEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
-  return delegate_->CanWindowReceiveEvents(target) ? ui::ER_UNHANDLED :
-                                                     ui::ER_CONSUMED;
+  if (!delegate_->CanWindowReceiveEvents(target))
+    event->StopPropagation();
 }
 
 }  // namespace internal
diff --git a/ash/wm/system_modal_container_event_filter.h b/ash/wm/system_modal_container_event_filter.h
index f1ac513..64d522d 100644
--- a/ash/wm/system_modal_container_event_filter.h
+++ b/ash/wm/system_modal_container_event_filter.h
@@ -23,7 +23,7 @@ class ASH_EXPORT SystemModalContainerEventFilter : public ui::EventHandler {
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
  private:
   SystemModalContainerEventFilterDelegate* delegate_;
diff --git a/ash/wm/toplevel_window_event_handler.cc b/ash/wm/toplevel_window_event_handler.cc
index 96f26e2..4320a7f 100644
--- a/ash/wm/toplevel_window_event_handler.cc
+++ b/ash/wm/toplevel_window_event_handler.cc
@@ -130,29 +130,33 @@ void ToplevelWindowEventHandler::OnKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult ToplevelWindowEventHandler::OnMouseEvent(
+void ToplevelWindowEventHandler::OnMouseEvent(
     ui::MouseEvent* event) {
   if ((event->flags() &
       (ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON)) != 0)
-    return ui::ER_UNHANDLED;
+    return;
 
   aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
-      return HandleMousePressed(target, event);
+      HandleMousePressed(target, event);
+      break;
     case ui::ET_MOUSE_DRAGGED:
-      return HandleDrag(target, event) ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
+      HandleDrag(target, event);
+      break;
     case ui::ET_MOUSE_CAPTURE_CHANGED:
     case ui::ET_MOUSE_RELEASED:
-      return HandleMouseReleased(target, event);
+      HandleMouseReleased(target, event);
+      break;
     case ui::ET_MOUSE_MOVED:
-      return HandleMouseMoved(target, event);
+      HandleMouseMoved(target, event);
+      break;
     case ui::ET_MOUSE_EXITED:
-      return HandleMouseExited(target, event);
+      HandleMouseExited(target, event);
+      break;
     default:
       break;
   }
-  return ui::ER_UNHANDLED;
 }
 
 void ToplevelWindowEventHandler::OnGestureEvent(ui::GestureEvent* event) {
@@ -321,13 +325,13 @@ void ToplevelWindowEventHandler::CompleteDrag(DragCompletionStatus status,
   }
 }
 
-ui::EventResult ToplevelWindowEventHandler::HandleMousePressed(
+void ToplevelWindowEventHandler::HandleMousePressed(
     aura::Window* target,
     ui::MouseEvent* event) {
   // Move/size operations are initiated post-target handling to give the target
   // an opportunity to cancel this default behavior by returning ER_HANDLED.
   if (ui::EventCanceledDefaultHandling(*event))
-    return ui::ER_UNHANDLED;
+    return;
 
   // We also update the current window component here because for the
   // mouse-drag-release-press case, where the mouse is released and
@@ -343,15 +347,15 @@ ui::EventResult ToplevelWindowEventHandler::HandleMousePressed(
   } else {
     window_resizer_.reset();
   }
-  return WindowResizer::GetBoundsChangeForWindowComponent(component) != 0 ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  if (WindowResizer::GetBoundsChangeForWindowComponent(component) != 0)
+    event->StopPropagation();
 }
 
-ui::EventResult ToplevelWindowEventHandler::HandleMouseReleased(
+void ToplevelWindowEventHandler::HandleMouseReleased(
     aura::Window* target,
     ui::MouseEvent* event) {
   if (event->phase() != ui::EP_PRETARGET)
-    return ui::ER_UNHANDLED;
+    return;
 
   CompleteDrag(event->type() == ui::ET_MOUSE_RELEASED ?
                     DRAG_COMPLETE : DRAG_REVERT,
@@ -365,12 +369,11 @@ ui::EventResult ToplevelWindowEventHandler::HandleMouseReleased(
   // they see the event on a hidden window.
   if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED &&
       !target->IsVisible()) {
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
   }
-  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult ToplevelWindowEventHandler::HandleDrag(
+void ToplevelWindowEventHandler::HandleDrag(
     aura::Window* target,
     ui::LocatedEvent* event) {
   // This function only be triggered to move window
@@ -382,23 +385,23 @@ ui::EventResult ToplevelWindowEventHandler::HandleDrag(
   // Drag actions are performed pre-target handling to prevent spurious mouse
   // moves from the move/size operation from being sent to the target.
   if (event->phase() != ui::EP_PRETARGET)
-    return ui::ER_UNHANDLED;
+    return;
 
   if (!window_resizer_.get())
-    return ui::ER_UNHANDLED;
+    return;
   window_resizer_->resizer()->Drag(
       ConvertPointToParent(target, event->location()), event->flags());
-  return ui::ER_CONSUMED;
+  event->StopPropagation();
 }
 
-ui::EventResult ToplevelWindowEventHandler::HandleMouseMoved(
+void ToplevelWindowEventHandler::HandleMouseMoved(
     aura::Window* target,
     ui::LocatedEvent* event) {
   // Shadow effects are applied after target handling. Note that we don't
   // respect ER_HANDLED here right now since we have not had a reason to allow
   // the target to cancel shadow rendering.
   if (event->phase() != ui::EP_POSTTARGET)
-    return ui::ER_UNHANDLED;
+    return;
 
   // TODO(jamescook): Move the resize cursor update code into here from
   // CompoundEventFilter?
@@ -413,23 +416,21 @@ ui::EventResult ToplevelWindowEventHandler::HandleMouseMoved(
       controller->HideShadow(target);
     }
   }
-  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult ToplevelWindowEventHandler::HandleMouseExited(
+void ToplevelWindowEventHandler::HandleMouseExited(
     aura::Window* target,
     ui::LocatedEvent* event) {
   // Shadow effects are applied after target handling. Note that we don't
   // respect ER_HANDLED here right now since we have not had a reason to allow
   // the target to cancel shadow rendering.
   if (event->phase() != ui::EP_POSTTARGET)
-    return ui::ER_UNHANDLED;
+    return;
 
   internal::ResizeShadowController* controller =
       Shell::GetInstance()->resize_shadow_controller();
   if (controller)
     controller->HideShadow(target);
-  return ui::ER_UNHANDLED;
 }
 
 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
diff --git a/ash/wm/toplevel_window_event_handler.h b/ash/wm/toplevel_window_event_handler.h
index 1340937..71f1497 100644
--- a/ash/wm/toplevel_window_event_handler.h
+++ b/ash/wm/toplevel_window_event_handler.h
@@ -39,7 +39,7 @@ class ASH_EXPORT ToplevelWindowEventHandler
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // Overridden form aura::client::WindowMoveClient:
@@ -66,24 +66,20 @@ class ASH_EXPORT ToplevelWindowEventHandler
   // Finishes the drag.
   void CompleteDrag(DragCompletionStatus status, int event_flags);
 
-  ui::EventResult HandleMousePressed(aura::Window* target,
-                                     ui::MouseEvent* event);
-  ui::EventResult HandleMouseReleased(aura::Window* target,
-                                      ui::MouseEvent* event);
+  void HandleMousePressed(aura::Window* target, ui::MouseEvent* event);
+  void HandleMouseReleased(aura::Window* target, ui::MouseEvent* event);
 
   // Called during a drag to resize/position the window.
   // The return value is returned by OnMouseEvent() above.
-  ui::EventResult HandleDrag(aura::Window* target, ui::LocatedEvent* event);
+  void HandleDrag(aura::Window* target, ui::LocatedEvent* event);
 
   // Called during mouse moves to update window resize shadows.
   // Return value is returned by OnMouseEvent() above.
-  ui::EventResult HandleMouseMoved(aura::Window* target,
-                                   ui::LocatedEvent* event);
+  void HandleMouseMoved(aura::Window* target, ui::LocatedEvent* event);
 
   // Called for mouse exits to hide window resize shadows.
   // Return value is returned by OnMouseEvent() above.
-  ui::EventResult HandleMouseExited(aura::Window* target,
-                                    ui::LocatedEvent* event);
+  void HandleMouseExited(aura::Window* target, ui::LocatedEvent* event);
 
   // Invoked from ScopedWindowResizer if the window is destroyed.
   void ResizerWindowDestroyed();
diff --git a/ash/wm/user_activity_detector.cc b/ash/wm/user_activity_detector.cc
index 6c55f89..fccc6d8 100644
--- a/ash/wm/user_activity_detector.cc
+++ b/ash/wm/user_activity_detector.cc
@@ -38,13 +38,12 @@ void UserActivityDetector::OnKeyEvent(ui::KeyEvent* event) {
   MaybeNotify();
 }
 
-ui::EventResult UserActivityDetector::OnMouseEvent(ui::MouseEvent* event) {
+void UserActivityDetector::OnMouseEvent(ui::MouseEvent* event) {
   VLOG_IF(1, ignore_next_mouse_event_) << "ignoring mouse event";
   if (!(event->flags() & ui::EF_IS_SYNTHESIZED) &&
       !ignore_next_mouse_event_)
     MaybeNotify();
   ignore_next_mouse_event_ = false;
-  return ui::ER_UNHANDLED;
 }
 
 void UserActivityDetector::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ash/wm/user_activity_detector.h b/ash/wm/user_activity_detector.h
index 9d8ec28..55a685c 100644
--- a/ash/wm/user_activity_detector.h
+++ b/ash/wm/user_activity_detector.h
@@ -36,7 +36,7 @@ class ASH_EXPORT UserActivityDetector : public ui::EventHandler {
 
   // ui::EventHandler implementation.
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ash/wm/user_activity_detector_unittest.cc b/ash/wm/user_activity_detector_unittest.cc
index 979c9ea..e0108d4 100644
--- a/ash/wm/user_activity_detector_unittest.cc
+++ b/ash/wm/user_activity_detector_unittest.cc
@@ -103,14 +103,16 @@ TEST_F(UserActivityDetectorTest, Basic) {
   ui::MouseEvent mouse_event(
       ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(), ui::EF_NONE);
   SetEventTarget(window.get(), &mouse_event);
-  EXPECT_FALSE(detector_->OnMouseEvent(&mouse_event));
+  detector_->OnMouseEvent(&mouse_event);
+  EXPECT_FALSE(mouse_event.handled());
   EXPECT_EQ(1, observer_->num_invocations());
   observer_->reset_stats();
 
   // Ignore one mouse event when all displays are turned off.
   detector_->OnAllOutputsTurnedOff();
   AdvanceTime(advance_delta);
-  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnMouseEvent(&mouse_event));
+  detector_->OnMouseEvent(&mouse_event);
+  EXPECT_FALSE(mouse_event.handled());
   EXPECT_EQ(0, observer_->num_invocations());
   observer_->reset_stats();
 
@@ -179,7 +181,8 @@ TEST_F(UserActivityDetectorTest, IgnoreSyntheticMouseEvents) {
   ui::MouseEvent mouse_event(
       ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(), ui::EF_IS_SYNTHESIZED);
   SetEventTarget(window.get(), &mouse_event);
-  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnMouseEvent(&mouse_event));
+  detector_->OnMouseEvent(&mouse_event);
+  EXPECT_FALSE(mouse_event.handled());
   EXPECT_EQ(0, observer_->num_invocations());
 }
 
diff --git a/ash/wm/window_manager_unittest.cc b/ash/wm/window_manager_unittest.cc
index 773a4a6..2328850 100644
--- a/ash/wm/window_manager_unittest.cc
+++ b/ash/wm/window_manager_unittest.cc
@@ -62,9 +62,12 @@ class CustomEventHandler : public aura::test::TestEventHandler {
       event->StopPropagation();
   }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
-    ui::EventResult result = aura::test::TestEventHandler::OnMouseEvent(event);
-    return mouse_result_ == ui::ER_UNHANDLED ? result : mouse_result_;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+    aura::test::TestEventHandler::OnMouseEvent(event);
+    if (mouse_result_ & ui::ER_HANDLED)
+      event->SetHandled();
+    if (mouse_result_ & ui::ER_CONSUMED)
+      event->StopPropagation();
   }
 
  private:
diff --git a/ash/wm/workspace/workspace_event_handler.cc b/ash/wm/workspace/workspace_event_handler.cc
index 929d09c..5e1a8a6 100644
--- a/ash/wm/workspace/workspace_event_handler.cc
+++ b/ash/wm/workspace/workspace_event_handler.cc
@@ -65,7 +65,7 @@ WorkspaceEventHandler::~WorkspaceEventHandler() {
     *destroyed_ = true;
 }
 
-ui::EventResult WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
+void WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED: {
@@ -83,8 +83,10 @@ ui::EventResult WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
     case ui::ET_MOUSE_PRESSED: {
       // Maximize behavior is implemented as post-target handling so the target
       // can cancel it.
-      if (ui::EventCanceledDefaultHandling(*event))
-        return ToplevelWindowEventHandler::OnMouseEvent(event);
+      if (ui::EventCanceledDefaultHandling(*event)) {
+        ToplevelWindowEventHandler::OnMouseEvent(event);
+        return;
+      }
 
       if (event->flags() & ui::EF_IS_DOUBLE_CLICK &&
           target->delegate()->GetNonClientComponent(event->location()) ==
@@ -93,7 +95,7 @@ ui::EventResult WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
         destroyed_ = &destroyed;
         ToggleMaximizedState(target);
         if (destroyed)
-          return ui::ER_UNHANDLED;
+          return;
         destroyed_ = NULL;
       }
       multi_window_resize_controller_.Hide();
@@ -103,7 +105,7 @@ ui::EventResult WorkspaceEventHandler::OnMouseEvent(ui::MouseEvent* event) {
     default:
       break;
   }
-  return ToplevelWindowEventHandler::OnMouseEvent(event);
+  ToplevelWindowEventHandler::OnMouseEvent(event);
 }
 
 void WorkspaceEventHandler::OnGestureEvent(ui::GestureEvent* event) {
diff --git a/ash/wm/workspace/workspace_event_handler.h b/ash/wm/workspace/workspace_event_handler.h
index 66e10d0..f175408 100644
--- a/ash/wm/workspace/workspace_event_handler.h
+++ b/ash/wm/workspace/workspace_event_handler.h
@@ -23,7 +23,7 @@ class WorkspaceEventHandler : public ToplevelWindowEventHandler {
   virtual ~WorkspaceEventHandler();
 
   // Overridden from ToplevelWindowEventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
  private:
diff --git a/chrome/browser/ui/views/immersive_mode_controller.cc b/chrome/browser/ui/views/immersive_mode_controller.cc
index 93b69de..d0f1b30 100644
--- a/chrome/browser/ui/views/immersive_mode_controller.cc
+++ b/chrome/browser/ui/views/immersive_mode_controller.cc
@@ -318,9 +318,9 @@ void ImmersiveModeController::CancelReveal() {
 ////////////////////////////////////////////////////////////////////////////////
 
 // ui::EventHandler overrides:
-ui::EventResult ImmersiveModeController::OnMouseEvent(ui::MouseEvent* event) {
+void ImmersiveModeController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_MOVED)
-    return ui::ER_UNHANDLED;
+    return;
   if (event->location().y() == 0) {
     // Use a timer to detect if the cursor stays at the top past a delay.
     if (!top_timer_.IsRunning()) {
@@ -333,7 +333,6 @@ ui::EventResult ImmersiveModeController::OnMouseEvent(ui::MouseEvent* event) {
     top_timer_.Stop();
   }
   // Pass along event for further handling.
-  return ui::ER_UNHANDLED;
 }
 
 // ui::ImplicitAnimationObserver overrides:
diff --git a/chrome/browser/ui/views/immersive_mode_controller.h b/chrome/browser/ui/views/immersive_mode_controller.h
index 192de61..46b6804 100644
--- a/chrome/browser/ui/views/immersive_mode_controller.h
+++ b/chrome/browser/ui/views/immersive_mode_controller.h
@@ -59,7 +59,7 @@ class ImmersiveModeController : public ui::EventHandler,
   void CancelReveal();
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // ui::ImplicitAnimationObserver overrides:
   virtual void OnImplicitAnimationsCompleted() OVERRIDE;
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index ce0c3c8..5f76a19 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -1502,7 +1502,7 @@ void RenderWidgetHostViewAura::OnKeyEvent(ui::KeyEvent* event) {
   event->SetHandled();
 }
 
-ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
+void RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewAura::OnMouseEvent");
 
   if (mouse_locked_) {
@@ -1535,8 +1535,7 @@ ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
       if (CanRendererHandleEvent(event))
         host_->ForwardMouseEvent(mouse_event);
     }
-
-    return ui::ER_UNHANDLED;
+    return;
   }
 
   // As the overscroll is handled during scroll events from the trackpad, the
@@ -1550,7 +1549,8 @@ ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
       event->flags() & ui::EF_IS_SYNTHESIZED &&
       (event->type() == ui::ET_MOUSE_ENTERED ||
        event->type() == ui::ET_MOUSE_MOVED)) {
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
+    return;
   }
 
   if (event->type() == ui::ET_MOUSEWHEEL) {
@@ -1583,8 +1583,7 @@ ui::EventResult RenderWidgetHostViewAura::OnMouseEvent(ui::MouseEvent* event) {
   if (window_->parent()->delegate())
     window_->parent()->delegate()->OnMouseEvent(event);
 
-  // Return true so that we receive released/drag events.
-  return ui::ER_HANDLED;
+  event->SetHandled();
 }
 
 void RenderWidgetHostViewAura::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index c078ffb..93cc7e2 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -197,7 +197,7 @@ class RenderWidgetHostViewAura
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/content/browser/web_contents/web_contents_view_aura.cc b/content/browser/web_contents/web_contents_view_aura.cc
index c31128b..e060383 100644
--- a/content/browser/web_contents/web_contents_view_aura.cc
+++ b/content/browser/web_contents/web_contents_view_aura.cc
@@ -911,9 +911,9 @@ scoped_refptr<ui::Texture> WebContentsViewAura::CopyTexture() {
 void WebContentsViewAura::OnKeyEvent(ui::KeyEvent* event) {
 }
 
-ui::EventResult WebContentsViewAura::OnMouseEvent(ui::MouseEvent* event) {
+void WebContentsViewAura::OnMouseEvent(ui::MouseEvent* event) {
   if (!web_contents_->GetDelegate())
-    return ui::ER_UNHANDLED;
+    return;
 
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
@@ -928,7 +928,6 @@ ui::EventResult WebContentsViewAura::OnMouseEvent(ui::MouseEvent* event) {
     default:
       break;
   }
-  return ui::ER_UNHANDLED;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/content/browser/web_contents/web_contents_view_aura.h b/content/browser/web_contents/web_contents_view_aura.h
index 6b2a1d0..e2b8948 100644
--- a/content/browser/web_contents/web_contents_view_aura.h
+++ b/content/browser/web_contents/web_contents_view_aura.h
@@ -152,7 +152,7 @@ class CONTENT_EXPORT WebContentsViewAura
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // Overridden from aura::client::DragDropDelegate:
   virtual void OnDragEntered(const ui::DropTargetEvent& event) OVERRIDE;
diff --git a/ui/aura/gestures/gesture_recognizer_unittest.cc b/ui/aura/gestures/gesture_recognizer_unittest.cc
index 59a2e75..6156b4c 100644
--- a/ui/aura/gestures/gesture_recognizer_unittest.cc
+++ b/ui/aura/gestures/gesture_recognizer_unittest.cc
@@ -373,7 +373,7 @@ class GestureEventSynthDelegate : public TestWindowDelegate {
   bool mouse_release() const { return mouse_release_; }
   bool double_click() const { return double_click_; }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     switch (event->type()) {
       case ui::ET_MOUSE_PRESSED:
         double_click_ = event->flags() & ui::EF_IS_DOUBLE_CLICK;
@@ -394,7 +394,7 @@ class GestureEventSynthDelegate : public TestWindowDelegate {
       default:
         NOTREACHED();
     }
-    return ui::ER_HANDLED;
+    event->SetHandled();
   }
 
  private:
diff --git a/ui/aura/root_window_unittest.cc b/ui/aura/root_window_unittest.cc
index 9f97cb7..a7298e9 100644
--- a/ui/aura/root_window_unittest.cc
+++ b/ui/aura/root_window_unittest.cc
@@ -57,11 +57,11 @@ class NonClientDelegate : public test::TestWindowDelegate {
     self->non_client_location_ = location;
     return HTTOPLEFT;
   }
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     mouse_event_count_++;
     mouse_event_location_ = event->location();
     mouse_event_flags_ = event->flags();
-    return ui::ER_HANDLED;
+    event->SetHandled();
   }
 
  private:
@@ -445,9 +445,8 @@ class EventFilterRecorder : public ui::EventHandler {
     events_.push_back(event->type());
   }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return ui::ER_UNHANDLED;
   }
 
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
@@ -644,10 +643,9 @@ class DeletingEventFilter : public ui::EventHandler {
       delete event->target();
   }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
       delete event->target();
-    return ui::ER_UNHANDLED;
   }
 
   bool delete_during_pre_handle_;
@@ -678,11 +676,10 @@ class DeletingWindowDelegate : public test::TestWindowDelegate {
     got_event_ = true;
   }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
-    return ui::ER_UNHANDLED;
   }
 
   Window* window_;
diff --git a/ui/aura/test/test_event_handler.cc b/ui/aura/test/test_event_handler.cc
index 8e05579..daf7495 100644
--- a/ui/aura/test/test_event_handler.cc
+++ b/ui/aura/test/test_event_handler.cc
@@ -29,9 +29,8 @@ void TestEventHandler::OnKeyEvent(ui::KeyEvent* event) {
   num_key_events_++;
 }
 
-ui::EventResult TestEventHandler::OnMouseEvent(ui::MouseEvent* event) {
+void TestEventHandler::OnMouseEvent(ui::MouseEvent* event) {
   num_mouse_events_++;
-  return ui::ER_UNHANDLED;
 }
 
 void TestEventHandler::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/aura/test/test_event_handler.h b/ui/aura/test/test_event_handler.h
index 443232d..0bd8ed8 100644
--- a/ui/aura/test/test_event_handler.h
+++ b/ui/aura/test/test_event_handler.h
@@ -29,7 +29,7 @@ class TestEventHandler : public ui::EventHandler {
 
   // ui::EventHandler overrides:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ui/aura/test/test_window_delegate.cc b/ui/aura/test/test_window_delegate.cc
index 155e343..462cd70 100644
--- a/ui/aura/test/test_window_delegate.cc
+++ b/ui/aura/test/test_window_delegate.cc
@@ -159,7 +159,7 @@ void EventCountDelegate::OnKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult EventCountDelegate::OnMouseEvent(ui::MouseEvent* event) {
+void EventCountDelegate::OnMouseEvent(ui::MouseEvent* event) {
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
       mouse_move_count_++;
@@ -179,7 +179,6 @@ ui::EventResult EventCountDelegate::OnMouseEvent(ui::MouseEvent* event) {
     default:
       break;
   }
-  return ui::ER_UNHANDLED;
 }
 
 std::string EventCountDelegate::GetMouseMotionCountsAndReset() {
diff --git a/ui/aura/test/test_window_delegate.h b/ui/aura/test/test_window_delegate.h
index 1abd955..1b14578 100644
--- a/ui/aura/test/test_window_delegate.h
+++ b/ui/aura/test/test_window_delegate.h
@@ -111,7 +111,7 @@ class EventCountDelegate : public TestWindowDelegate {
 
   // Overridden from TestWindowDelegate:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
   // Returns the counts of mouse motion events in the
   // form of "<enter> <move> <leave>".
diff --git a/ui/aura/window_unittest.cc b/ui/aura/window_unittest.cc
index 6289000..1aec91f 100644
--- a/ui/aura/window_unittest.cc
+++ b/ui/aura/window_unittest.cc
@@ -171,11 +171,10 @@ class CaptureWindowDelegateImpl : public TestWindowDelegate {
   int touch_event_count() const { return touch_event_count_; }
   int gesture_event_count() const { return gesture_event_count_; }
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED)
       capture_changed_event_count_++;
     mouse_event_count_++;
-    return ui::ER_UNHANDLED;
   }
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     touch_event_count_++;
@@ -1072,7 +1071,7 @@ class MouseEnterExitWindowDelegate : public TestWindowDelegate {
  public:
   MouseEnterExitWindowDelegate() : entered_(false), exited_(false) {}
 
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     switch (event->type()) {
       case ui::ET_MOUSE_ENTERED:
         entered_ = true;
@@ -1083,7 +1082,6 @@ class MouseEnterExitWindowDelegate : public TestWindowDelegate {
       default:
         break;
     }
-    return ui::ER_UNHANDLED;
   }
 
   bool entered() const { return entered_; }
diff --git a/ui/base/events/event_dispatcher_unittest.cc b/ui/base/events/event_dispatcher_unittest.cc
index 41eed09..4b61cb4 100644
--- a/ui/base/events/event_dispatcher_unittest.cc
+++ b/ui/base/events/event_dispatcher_unittest.cc
@@ -85,9 +85,9 @@ class TestEventHandler : public EventHandler {
     SetStatusOnEvent(event);
   }
 
-  virtual EventResult OnMouseEvent(MouseEvent* event) OVERRIDE {
+  virtual void OnMouseEvent(MouseEvent* event) OVERRIDE {
     ReceivedEvent(event);
-    return event_result_;
+    SetStatusOnEvent(event);
   }
 
   virtual void OnScrollEvent(ScrollEvent* event) OVERRIDE {
diff --git a/ui/base/events/event_handler.cc b/ui/base/events/event_handler.cc
index 85ec7d5..e36a01f 100644
--- a/ui/base/events/event_handler.cc
+++ b/ui/base/events/event_handler.cc
@@ -21,29 +21,22 @@ EventHandler::~EventHandler() {
 }
 
 void EventHandler::OnEvent(Event* event) {
-  ui::EventResult result = ui::ER_UNHANDLED;
   if (event->IsKeyEvent())
     OnKeyEvent(static_cast<KeyEvent*>(event));
   else if (event->IsMouseEvent())
-    result = OnMouseEvent(static_cast<MouseEvent*>(event));
+    OnMouseEvent(static_cast<MouseEvent*>(event));
   else if (event->IsScrollEvent())
     OnScrollEvent(static_cast<ScrollEvent*>(event));
   else if (event->IsTouchEvent())
     OnTouchEvent(static_cast<TouchEvent*>(event));
   else if (event->IsGestureEvent())
     OnGestureEvent(static_cast<GestureEvent*>(event));
-
-  if (result & ui::ER_CONSUMED)
-    event->StopPropagation();
-  if (result & ui::ER_HANDLED)
-    event->SetHandled();
 }
 
 void EventHandler::OnKeyEvent(KeyEvent* event) {
 }
 
-EventResult EventHandler::OnMouseEvent(MouseEvent* event) {
-  return ui::ER_UNHANDLED;
+void EventHandler::OnMouseEvent(MouseEvent* event) {
 }
 
 void EventHandler::OnScrollEvent(ScrollEvent* event) {
diff --git a/ui/base/events/event_handler.h b/ui/base/events/event_handler.h
index 1084889..b4ed5fd 100644
--- a/ui/base/events/event_handler.h
+++ b/ui/base/events/event_handler.h
@@ -38,7 +38,7 @@ class UI_EXPORT EventHandler {
 
   virtual void OnKeyEvent(KeyEvent* event);
 
-  virtual EventResult OnMouseEvent(MouseEvent* event);
+  virtual void OnMouseEvent(MouseEvent* event);
 
   virtual void OnScrollEvent(ScrollEvent* event);
 
diff --git a/ui/base/events/event_target.cc b/ui/base/events/event_target.cc
index 649c722..57d5d2d 100644
--- a/ui/base/events/event_target.cc
+++ b/ui/base/events/event_target.cc
@@ -58,9 +58,10 @@ void EventTarget::OnKeyEvent(KeyEvent* event) {
     target_handler_->OnKeyEvent(event);
 }
 
-EventResult EventTarget::OnMouseEvent(MouseEvent* event) {
+void EventTarget::OnMouseEvent(MouseEvent* event) {
   CHECK_EQ(this, event->target());
-  return target_handler_ ? target_handler_->OnMouseEvent(event) : ER_UNHANDLED;
+  if (target_handler_)
+    target_handler_->OnMouseEvent(event);
 }
 
 void EventTarget::OnScrollEvent(ScrollEvent* event) {
diff --git a/ui/base/events/event_target.h b/ui/base/events/event_target.h
index c54fa2b..3b063e8 100644
--- a/ui/base/events/event_target.h
+++ b/ui/base/events/event_target.h
@@ -74,7 +74,7 @@ class UI_EXPORT EventTarget : public EventHandler {
   // Overridden from EventHandler:
   virtual void OnEvent(Event* event) OVERRIDE;
   virtual void OnKeyEvent(KeyEvent* event) OVERRIDE;
-  virtual EventResult OnMouseEvent(MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(GestureEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/compound_event_filter.cc b/ui/views/corewm/compound_event_filter.cc
index 0b77b28..83e6106 100644
--- a/ui/views/corewm/compound_event_filter.cc
+++ b/ui/views/corewm/compound_event_filter.cc
@@ -148,15 +148,13 @@ void CompoundEventFilter::FilterKeyEvent(ui::KeyEvent* event) {
   }
 }
 
-ui::EventResult CompoundEventFilter::FilterMouseEvent(ui::MouseEvent* event) {
-  int result = ui::ER_UNHANDLED;
+void CompoundEventFilter::FilterMouseEvent(ui::MouseEvent* 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->OnMouseEvent(event);
+    while (!event->stopped_propagation() && (handler = it.GetNext()) != NULL)
+      handler->OnMouseEvent(event);
   }
-  return static_cast<ui::EventResult>(result);
 }
 
 void CompoundEventFilter::FilterTouchEvent(ui::TouchEvent* event) {
@@ -199,7 +197,7 @@ void CompoundEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   FilterKeyEvent(event);
 }
 
-ui::EventResult CompoundEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void CompoundEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* window = static_cast<aura::Window*>(event->target());
   aura::WindowTracker window_tracker;
   window_tracker.Add(window);
@@ -220,7 +218,7 @@ ui::EventResult CompoundEventFilter::OnMouseEvent(ui::MouseEvent* event) {
     UpdateCursor(window, event);
   }
 
-  return FilterMouseEvent(event);
+  FilterMouseEvent(event);
 }
 
 void CompoundEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/views/corewm/compound_event_filter.h b/ui/views/corewm/compound_event_filter.h
index 685c606..e2dba41 100644
--- a/ui/views/corewm/compound_event_filter.h
+++ b/ui/views/corewm/compound_event_filter.h
@@ -64,7 +64,7 @@ class VIEWS_EXPORT CompoundEventFilter : public ui::EventHandler {
 
   // Dispatches event to additional filters.
   void FilterKeyEvent(ui::KeyEvent* event);
-  ui::EventResult FilterMouseEvent(ui::MouseEvent* event);
+  void FilterMouseEvent(ui::MouseEvent* event);
   void FilterTouchEvent(ui::TouchEvent* event);
 
   // Sets the visibility of the cursor if the event is not synthesized and
@@ -79,7 +79,7 @@ class VIEWS_EXPORT CompoundEventFilter : public ui::EventHandler {
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/focus_controller.cc b/ui/views/corewm/focus_controller.cc
index b5bbd90..f095bbe 100644
--- a/ui/views/corewm/focus_controller.cc
+++ b/ui/views/corewm/focus_controller.cc
@@ -152,10 +152,9 @@ void FocusController::OnWindowHiddenInRootWindow(
 void FocusController::OnKeyEvent(ui::KeyEvent* event) {
 }
 
-ui::EventResult FocusController::OnMouseEvent(ui::MouseEvent* event) {
+void FocusController::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED)
     WindowFocusedFromInputEvent(static_cast<aura::Window*>(event->target()));
-  return ui::ER_UNHANDLED;
 }
 
 void FocusController::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/views/corewm/focus_controller.h b/ui/views/corewm/focus_controller.h
index afd45cd..9666499 100644
--- a/ui/views/corewm/focus_controller.h
+++ b/ui/views/corewm/focus_controller.h
@@ -72,7 +72,7 @@ class VIEWS_EXPORT FocusController : public aura::client::ActivationClient,
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ui/views/corewm/window_modality_controller.cc b/ui/views/corewm/window_modality_controller.cc
index c6b2a37..58ea579 100644
--- a/ui/views/corewm/window_modality_controller.cc
+++ b/ui/views/corewm/window_modality_controller.cc
@@ -109,10 +109,10 @@ void WindowModalityController::OnKeyEvent(ui::KeyEvent* event) {
     event->StopPropagation();
 }
 
-ui::EventResult WindowModalityController::OnMouseEvent(ui::MouseEvent* event) {
+void WindowModalityController::OnMouseEvent(ui::MouseEvent* event) {
   aura::Window* target = static_cast<aura::Window*>(event->target());
-  return ProcessLocatedEvent(target, event) ? ui::ER_CONSUMED :
-                                              ui::ER_UNHANDLED;
+  if (ProcessLocatedEvent(target, event))
+   event->StopPropagation();
 }
 
 void WindowModalityController::OnTouchEvent(ui::TouchEvent* event) {
diff --git a/ui/views/corewm/window_modality_controller.h b/ui/views/corewm/window_modality_controller.h
index 29fa047..4787a97 100644
--- a/ui/views/corewm/window_modality_controller.h
+++ b/ui/views/corewm/window_modality_controller.h
@@ -39,7 +39,7 @@ class VIEWS_EXPORT WindowModalityController : public ui::EventHandler,
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
 
   // Overridden from aura::EnvObserver:
diff --git a/ui/views/view.cc b/ui/views/view.cc
index b40faee..a38ccb7 100644
--- a/ui/views/view.cc
+++ b/ui/views/view.cc
@@ -870,8 +870,7 @@ bool View::OnMouseWheel(const ui::MouseWheelEvent& event) {
 void View::OnKeyEvent(ui::KeyEvent* event) {
 }
 
-ui::EventResult View::OnMouseEvent(ui::MouseEvent* event) {
-  return ui::ER_UNHANDLED;
+void View::OnMouseEvent(ui::MouseEvent* event) {
 }
 
 void View::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/views/view.h b/ui/views/view.h
index 6acbd05..1d0f564 100644
--- a/ui/views/view.h
+++ b/ui/views/view.h
@@ -652,7 +652,7 @@ class VIEWS_EXPORT View : public ui::LayerDelegate,
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* 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 181f1dd..14bf80e 100644
--- a/ui/views/widget/desktop_aura/desktop_activation_client.cc
+++ b/ui/views/widget/desktop_aura/desktop_activation_client.cc
@@ -161,10 +161,9 @@ bool DesktopActivationClient::CanActivateWindow(aura::Window* window) const {
 void DesktopActivationClient::OnKeyEvent(ui::KeyEvent* event) {
 }
 
-ui::EventResult DesktopActivationClient::OnMouseEvent(ui::MouseEvent* event) {
+void DesktopActivationClient::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() == ui::ET_MOUSE_PRESSED)
     FocusWindowWithEvent(event);
-  return ui::ER_UNHANDLED;
 }
 
 void DesktopActivationClient::OnScrollEvent(ui::ScrollEvent* event) {
diff --git a/ui/views/widget/desktop_aura/desktop_activation_client.h b/ui/views/widget/desktop_aura/desktop_activation_client.h
index 9d426f0..b341817 100644
--- a/ui/views/widget/desktop_aura/desktop_activation_client.h
+++ b/ui/views/widget/desktop_aura/desktop_activation_client.h
@@ -61,7 +61,7 @@ class VIEWS_EXPORT DesktopActivationClient
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* 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 36c4fba..ca09d1d 100644
--- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc
+++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.cc
@@ -566,15 +566,15 @@ void DesktopNativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
     event->SetHandled();
 }
 
-ui::EventResult DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
+void DesktopNativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(window_->IsVisible());
   if (event->type() == ui::ET_MOUSEWHEEL) {
-    return native_widget_delegate_->OnMouseEvent(*event) ?
-        ui::ER_HANDLED : ui::ER_UNHANDLED;
+    native_widget_delegate_->OnMouseEvent(event);
+    if (event->handled())
+      return;
   }
 
-  return native_widget_delegate_->OnMouseEvent(*event) ?
-      ui::ER_HANDLED : ui::ER_UNHANDLED;
+  native_widget_delegate_->OnMouseEvent(event);
 }
 
 void DesktopNativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
@@ -585,7 +585,8 @@ void DesktopNativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
 
     // Convert unprocessed scroll events into wheel events.
     ui::MouseWheelEvent mwe(*static_cast<ui::ScrollEvent*>(event));
-    if (native_widget_delegate_->OnMouseEvent(mwe))
+    native_widget_delegate_->OnMouseEvent(&mwe);
+    if (mwe.handled())
       event->SetHandled();
   } else {
     native_widget_delegate_->OnScrollEvent(event);
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 38c5fad..1953dbc 100644
--- a/ui/views/widget/desktop_aura/desktop_native_widget_aura.h
+++ b/ui/views/widget/desktop_aura/desktop_native_widget_aura.h
@@ -172,7 +172,7 @@ class VIEWS_EXPORT DesktopNativeWidgetAura
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ui/views/widget/desktop_aura/x11_window_event_filter.cc b/ui/views/widget/desktop_aura/x11_window_event_filter.cc
index 42269bd..b5c3cf2 100644
--- a/ui/views/widget/desktop_aura/x11_window_event_filter.cc
+++ b/ui/views/widget/desktop_aura/x11_window_event_filter.cc
@@ -88,23 +88,23 @@ void X11WindowEventFilter::SetUseHostWindowBorders(bool use_os_border) {
                   sizeof(MotifWmHints)/sizeof(long));
 }
 
-ui::EventResult X11WindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+void X11WindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_PRESSED)
-    return ui::ER_UNHANDLED;
+    return;
 
   if (!event->IsLeftMouseButton())
-    return ui::ER_UNHANDLED;
+    return;
 
   aura::Window* target = static_cast<aura::Window*>(event->target());
   int component =
       target->delegate()->GetNonClientComponent(event->location());
   if (component == HTCLIENT)
-    return ui::ER_UNHANDLED;
+    return;
 
   // Get the |x_root_window_| location out of the native event.
   gfx::Point root_location = event->system_location();
-  return DispatchHostWindowDragMovement(component, root_location) ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+  if (DispatchHostWindowDragMovement(component, root_location))
+    event->StopPropagation();
 }
 
 bool X11WindowEventFilter::DispatchHostWindowDragMovement(
diff --git a/ui/views/widget/desktop_aura/x11_window_event_filter.h b/ui/views/widget/desktop_aura/x11_window_event_filter.h
index 5f7bedc..6280b18 100644
--- a/ui/views/widget/desktop_aura/x11_window_event_filter.h
+++ b/ui/views/widget/desktop_aura/x11_window_event_filter.h
@@ -39,7 +39,7 @@ class VIEWS_EXPORT X11WindowEventFilter : public ui::EventHandler {
   void SetUseHostWindowBorders(bool use_os_border);
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
 
  private:
   // Dispatches a _NET_WM_MOVERESIZE message to the window manager to tell it
diff --git a/ui/views/widget/native_widget_aura.cc b/ui/views/widget/native_widget_aura.cc
index e9b29c5..3eff315 100644
--- a/ui/views/widget/native_widget_aura.cc
+++ b/ui/views/widget/native_widget_aura.cc
@@ -785,14 +785,17 @@ void NativeWidgetAura::OnKeyEvent(ui::KeyEvent* event) {
   event->SetHandled();
 }
 
-ui::EventResult NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
+void NativeWidgetAura::OnMouseEvent(ui::MouseEvent* event) {
   DCHECK(window_->IsVisible());
-  if (event->type() == ui::ET_MOUSEWHEEL)
-    return delegate_->OnMouseEvent(*event) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
+  if (event->type() == ui::ET_MOUSEWHEEL) {
+    delegate_->OnMouseEvent(event);
+    if (event->handled())
+      return;
+  }
 
   if (tooltip_manager_.get())
     tooltip_manager_->UpdateTooltip();
-  return delegate_->OnMouseEvent(*event) ? ui::ER_HANDLED : ui::ER_UNHANDLED;
+  delegate_->OnMouseEvent(event);
 }
 
 void NativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
@@ -803,8 +806,9 @@ void NativeWidgetAura::OnScrollEvent(ui::ScrollEvent* event) {
 
     // Convert unprocessed scroll events into wheel events.
     ui::MouseWheelEvent mwe(*static_cast<ui::ScrollEvent*>(event));
-    if (delegate_->OnMouseEvent(mwe))
-     event->SetHandled();
+    delegate_->OnMouseEvent(&mwe);
+    if (mwe.handled())
+      event->SetHandled();
     return;
   }
   delegate_->OnScrollEvent(event);
diff --git a/ui/views/widget/native_widget_aura.h b/ui/views/widget/native_widget_aura.h
index 1796fab..b82cd36 100644
--- a/ui/views/widget/native_widget_aura.h
+++ b/ui/views/widget/native_widget_aura.h
@@ -157,7 +157,7 @@ class VIEWS_EXPORT NativeWidgetAura
 
   // Overridden from ui::EventHandler:
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
diff --git a/ui/views/widget/native_widget_delegate.h b/ui/views/widget/native_widget_delegate.h
index a29b095..40636a2 100644
--- a/ui/views/widget/native_widget_delegate.h
+++ b/ui/views/widget/native_widget_delegate.h
@@ -107,7 +107,7 @@ class VIEWS_EXPORT NativeWidgetDelegate {
 
   // Mouse and key event handlers.
   virtual void OnKeyEvent(ui::KeyEvent* event) = 0;
-  virtual bool OnMouseEvent(const ui::MouseEvent& event) = 0;
+  virtual void OnMouseEvent(ui::MouseEvent* event) = 0;
   virtual void OnMouseCaptureLost() = 0;
 
   virtual void OnTouchEvent(ui::TouchEvent* event) = 0;
diff --git a/ui/views/widget/native_widget_win.cc b/ui/views/widget/native_widget_win.cc
index fcdc948..892c283 100644
--- a/ui/views/widget/native_widget_win.cc
+++ b/ui/views/widget/native_widget_win.cc
@@ -765,7 +765,8 @@ void NativeWidgetWin::HandleNativeBlur(HWND focused_window) {
 }
 
 bool NativeWidgetWin::HandleMouseEvent(const ui::MouseEvent& event) {
-  return delegate_->OnMouseEvent(event);
+  delegate_->OnMouseEvent(const_cast<ui::MouseEvent*>(&event));
+  return event.handled();
 }
 
 bool NativeWidgetWin::HandleKeyEvent(const ui::KeyEvent& event) {
diff --git a/ui/views/widget/widget.cc b/ui/views/widget/widget.cc
index ab30708..8aaa88a 100644
--- a/ui/views/widget/widget.cc
+++ b/ui/views/widget/widget.cc
@@ -1115,20 +1115,20 @@ void Widget::OnKeyEvent(ui::KeyEvent* event) {
       DispatchKeyEvent(event);
 }
 
-bool Widget::OnMouseEvent(const ui::MouseEvent& event) {
-  ScopedEvent scoped(this, event);
-  switch (event.type()) {
+void Widget::OnMouseEvent(ui::MouseEvent* event) {
+  ScopedEvent scoped(this, *event);
+  switch (event->type()) {
     case ui::ET_MOUSE_PRESSED:
       last_mouse_event_was_move_ = false;
       // Make sure we're still visible before we attempt capture as the mouse
       // press processing may have made the window hide (as happens with menus).
-      if (GetRootView()->OnMousePressed(event) && IsVisible()) {
+      if (GetRootView()->OnMousePressed(*event) && IsVisible()) {
         is_mouse_button_pressed_ = true;
         if (!native_widget_->HasCapture())
           native_widget_->SetCapture();
-        return true;
+        event->SetHandled();
       }
-      return false;
+      return;
     case ui::ET_MOUSE_RELEASED:
       last_mouse_event_was_move_ = false;
       is_mouse_button_pressed_ = false;
@@ -1137,31 +1137,35 @@ bool Widget::OnMouseEvent(const ui::MouseEvent& event) {
           ShouldReleaseCaptureOnMouseReleased()) {
         native_widget_->ReleaseCapture();
       }
-      GetRootView()->OnMouseReleased(event);
-      return ((event.flags() & ui::EF_IS_NON_CLIENT) == 0);
+      GetRootView()->OnMouseReleased(*event);
+      if ((event->flags() & ui::EF_IS_NON_CLIENT) == 0)
+        event->SetHandled();
+      return;
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
       if (native_widget_->HasCapture() && is_mouse_button_pressed_) {
         last_mouse_event_was_move_ = false;
-        GetRootView()->OnMouseDragged(event);
+        GetRootView()->OnMouseDragged(*event);
       } else if (!last_mouse_event_was_move_ ||
-                 last_mouse_event_position_ != event.location()) {
-        last_mouse_event_position_ = event.location();
+                 last_mouse_event_position_ != event->location()) {
+        last_mouse_event_position_ = event->location();
         last_mouse_event_was_move_ = true;
-        GetRootView()->OnMouseMoved(event);
+        GetRootView()->OnMouseMoved(*event);
       }
-      return false;
+      return;
     case ui::ET_MOUSE_EXITED:
       last_mouse_event_was_move_ = false;
-      GetRootView()->OnMouseExited(event);
-      return false;
+      GetRootView()->OnMouseExited(*event);
+      return;
     case ui::ET_MOUSEWHEEL:
-      return GetRootView()->OnMouseWheel(
-          reinterpret_cast<const ui::MouseWheelEvent&>(event));
+      if (GetRootView()->OnMouseWheel(
+          reinterpret_cast<const ui::MouseWheelEvent&>(*event)))
+        event->SetHandled();
+      return;
     default:
-      return false;
+      return;
   }
-  return true;
+  event->SetHandled();
 }
 
 void Widget::OnMouseCaptureLost() {
diff --git a/ui/views/widget/widget.h b/ui/views/widget/widget.h
index 5c2dcc2..0eaa78a 100644
--- a/ui/views/widget/widget.h
+++ b/ui/views/widget/widget.h
@@ -671,7 +671,7 @@ class VIEWS_EXPORT Widget : public internal::NativeWidgetDelegate,
   virtual void OnNativeWidgetPaint(gfx::Canvas* canvas) OVERRIDE;
   virtual int GetNonClientComponent(const gfx::Point& point) OVERRIDE;
   virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual bool OnMouseEvent(const ui::MouseEvent& event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
   virtual void OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
diff --git a/ui/views/widget/widget_unittest.cc b/ui/views/widget/widget_unittest.cc
index 5a001b8..120e39f 100644
--- a/ui/views/widget/widget_unittest.cc
+++ b/ui/views/widget/widget_unittest.cc
@@ -284,7 +284,7 @@ TEST_F(WidgetTest, DISABLED_GrabUngrab) {
   gfx::Point p1(45, 45);
   ui::MouseEvent pressed(ui::ET_MOUSE_PRESSED, p1, p1,
                          ui::EF_LEFT_MOUSE_BUTTON);
-  toplevel->OnMouseEvent(pressed);
+  toplevel->OnMouseEvent(&pressed);
 
   EXPECT_TRUE(WidgetHasMouseCapture(toplevel));
   EXPECT_TRUE(WidgetHasMouseCapture(child1));
@@ -292,7 +292,7 @@ TEST_F(WidgetTest, DISABLED_GrabUngrab) {
 
   ui::MouseEvent released(ui::ET_MOUSE_RELEASED, p1, p1,
                           ui::EF_LEFT_MOUSE_BUTTON);
-  toplevel->OnMouseEvent(released);
+  toplevel->OnMouseEvent(&released);
 
   EXPECT_FALSE(WidgetHasMouseCapture(toplevel));
   EXPECT_FALSE(WidgetHasMouseCapture(child1));
@@ -304,14 +304,15 @@ TEST_F(WidgetTest, DISABLED_GrabUngrab) {
   gfx::Point p2(315, 45);
   ui::MouseEvent pressed2(ui::ET_MOUSE_PRESSED, p2, p2,
                           ui::EF_LEFT_MOUSE_BUTTON);
-  EXPECT_TRUE(toplevel->OnMouseEvent(pressed2));
+  toplevel->OnMouseEvent(&pressed2);
+  EXPECT_TRUE(pressed2.handled());
   EXPECT_TRUE(WidgetHasMouseCapture(toplevel));
   EXPECT_TRUE(WidgetHasMouseCapture(child2));
   EXPECT_FALSE(WidgetHasMouseCapture(child1));
 
   ui::MouseEvent released2(ui::ET_MOUSE_RELEASED, p2, p2,
                            ui::EF_LEFT_MOUSE_BUTTON);
-  toplevel->OnMouseEvent(released2);
+  toplevel->OnMouseEvent(&released2);
   EXPECT_FALSE(WidgetHasMouseCapture(toplevel));
   EXPECT_FALSE(WidgetHasMouseCapture(child1));
   EXPECT_FALSE(WidgetHasMouseCapture(child2));
@@ -336,26 +337,26 @@ TEST_F(WidgetTest, CheckResizeControllerEvents) {
   // Move to an outside position.
   gfx::Point p1(200, 200);
   ui::MouseEvent moved_out(ui::ET_MOUSE_MOVED, p1, p1, ui::EF_NONE);
-  toplevel->OnMouseEvent(moved_out);
+  toplevel->OnMouseEvent(&moved_out);
   EXPECT_EQ(0, view->EnteredCalls());
   EXPECT_EQ(0, view->ExitedCalls());
 
   // Move onto the active view.
   gfx::Point p2(95, 95);
   ui::MouseEvent moved_over(ui::ET_MOUSE_MOVED, p2, p2, ui::EF_NONE);
-  toplevel->OnMouseEvent(moved_over);
+  toplevel->OnMouseEvent(&moved_over);
   EXPECT_EQ(1, view->EnteredCalls());
   EXPECT_EQ(0, view->ExitedCalls());
 
   // Move onto the outer resizing border.
   gfx::Point p3(102, 95);
   ui::MouseEvent moved_resizer(ui::ET_MOUSE_MOVED, p3, p3, ui::EF_NONE);
-  toplevel->OnMouseEvent(moved_resizer);
+  toplevel->OnMouseEvent(&moved_resizer);
   EXPECT_EQ(0, view->EnteredCalls());
   EXPECT_EQ(1, view->ExitedCalls());
 
   // Move onto the view again.
-  toplevel->OnMouseEvent(moved_over);
+  toplevel->OnMouseEvent(&moved_over);
   EXPECT_EQ(1, view->EnteredCalls());
   EXPECT_EQ(0, view->ExitedCalls());
 
@@ -997,15 +998,15 @@ TEST_F(WidgetTest, ResetCaptureOnGestureEnd) {
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, click_location, click_location,
       ui::EF_LEFT_MOUSE_BUTTON);
 
-  toplevel->OnMouseEvent(press);
-  toplevel->OnMouseEvent(release);
+  toplevel->OnMouseEvent(&press);
+  toplevel->OnMouseEvent(&release);
   EXPECT_EQ(0, mouse->pressed());
 
   // The end of the gesture should release the capture, and pressing on |mouse|
   // should now reach |mouse|.
   toplevel->OnGestureEvent(&end);
-  toplevel->OnMouseEvent(press);
-  toplevel->OnMouseEvent(release);
+  toplevel->OnMouseEvent(&press);
+  toplevel->OnMouseEvent(&release);
   EXPECT_EQ(1, mouse->pressed());
 
   toplevel->Close();