ash: Convert all remaining EventFilters into EventHandlers.

This CL converts the following list of aura::EventFilters into ui::EventHandlers:
 * MouseCursorEventFilter
 * DragDropController
 * LauncherTooltipManager
 * TooltipController
 * EventRewriterEventFilter
 * OverlayEventFilter
 * PanelWindowEventFilter
 * SystemModalContainerEventFilter
 * UserActivityDetector
 * WindowCycleEventFilter
 * WindowModalityController
 * FrameMaximizeButton::EscapeEventFilter
 * TabScrubber

Also remove AddEnvEventFilter/RemoveEnvEventFilter from Shell functions since
all the filters for the shell have been converted.

BUG=159632

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

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

32 files changed, 417 insertions, 408 deletions

diff --git a/ash/accelerators/accelerator_dispatcher.cc b/ash/accelerators/accelerator_dispatcher.cc
index a825dde..d8b238f 100644
--- a/ash/accelerators/accelerator_dispatcher.cc
+++ b/ash/accelerators/accelerator_dispatcher.cc
@@ -72,10 +72,11 @@ bool AcceleratorDispatcher::Dispatch(const base::NativeEvent& event) {
     // Modifiers can be changed by the user preference, so we need to rewrite
     // the event explicitly.
     ui::KeyEvent key_event(event, false);
-    aura::EventFilter* event_rewriter =
+    ui::EventHandler* event_rewriter =
         ash::Shell::GetInstance()->event_rewriter_filter();
     DCHECK(event_rewriter);
-    if (event_rewriter->PreHandleKeyEvent(associated_window_, &key_event))
+    ui::EventResult result = event_rewriter->OnKeyEvent(&key_event);
+    if (result & ui::ER_CONSUMED)
       return true;
     ash::AcceleratorController* accelerator_controller =
         ash::Shell::GetInstance()->accelerator_controller();
diff --git a/ash/display/mouse_cursor_event_filter.cc b/ash/display/mouse_cursor_event_filter.cc
index 7486fd7..0cb8723 100644
--- a/ash/display/mouse_cursor_event_filter.cc
+++ b/ash/display/mouse_cursor_event_filter.cc
@@ -71,35 +71,35 @@ void MouseCursorEventFilter::HideSharedEdgeIndicator() {
   shared_display_edge_indicator_->Hide();
 }
 
-bool MouseCursorEventFilter::PreHandleKeyEvent(aura::Window* target,
-                                               ui::KeyEvent* event) {
-  return false;
+ui::EventResult MouseCursorEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-bool MouseCursorEventFilter::PreHandleMouseEvent(aura::Window* target,
-                                                 ui::MouseEvent* event) {
+ui::EventResult 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 false;
+      return ui::ER_UNHANDLED;
   }
 
   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);
+  return WarpMouseCursorIfNecessary(target->GetRootWindow(), point_in_screen) ?
+      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+}
+
+ui::EventResult MouseCursorEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult MouseCursorEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult MouseCursorEventFilter::OnTouchEvent(ui::TouchEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult MouseCursorEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
+ui::EventResult MouseCursorEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   return ui::ER_UNHANDLED;
 }
diff --git a/ash/display/mouse_cursor_event_filter.h b/ash/display/mouse_cursor_event_filter.h
index e38e4e6..48a370d 100644
--- a/ash/display/mouse_cursor_event_filter.h
+++ b/ash/display/mouse_cursor_event_filter.h
@@ -9,7 +9,7 @@
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/aura/event_filter.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/rect.h"
 
 namespace aura {
@@ -24,7 +24,7 @@ class SharedDisplayEdgeIndicator;
 
 // An event filter that controls mouse location in extended desktop
 // environment.
-class ASH_EXPORT MouseCursorEventFilter : public aura::EventFilter {
+class ASH_EXPORT MouseCursorEventFilter : public ui::EventHandler {
  public:
   enum MouseWarpMode {
     WARP_ALWAYS,   // Always warp the mouse when possible.
@@ -46,17 +46,12 @@ class ASH_EXPORT MouseCursorEventFilter : public aura::EventFilter {
   void ShowSharedEdgeIndicator(const aura::RootWindow* from);
   void HideSharedEdgeIndicator();
 
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* 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 a7c73fd..7234b30 100644
--- a/ash/drag_drop/drag_drop_controller.cc
+++ b/ash/drag_drop/drag_drop_controller.cc
@@ -46,11 +46,11 @@ DragDropController::DragDropController()
       drag_operation_(0),
       drag_window_(NULL),
       should_block_during_drag_drop_(true) {
-  Shell::GetInstance()->AddEnvEventFilter(this);
+  Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 DragDropController::~DragDropController() {
-  Shell::GetInstance()->RemoveEnvEventFilter(this);
+  Shell::GetInstance()->RemovePreTargetHandler(this);
   Cleanup();
   if (drag_image_.get())
     drag_image_.reset();
@@ -196,23 +196,21 @@ bool DragDropController::IsDragDropInProgress() {
   return !!drag_drop_tracker_.get();
 }
 
-bool DragDropController::PreHandleKeyEvent(aura::Window* target,
-                                           ui::KeyEvent* event) {
+ui::EventResult DragDropController::OnKeyEvent(ui::KeyEvent* event) {
   if (IsDragDropInProgress() && event->key_code() == ui::VKEY_ESCAPE) {
     DragCancel();
-    return true;
+    return ui::ER_CONSUMED;
   }
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-bool DragDropController::PreHandleMouseEvent(aura::Window* target,
-                                             ui::MouseEvent* event) {
+ui::EventResult DragDropController::OnMouseEvent(ui::MouseEvent* event) {
   if (!IsDragDropInProgress())
-    return false;
+    return ui::ER_UNHANDLED;
   aura::Window* translated_target = drag_drop_tracker_->GetTarget(*event);
   if (!translated_target) {
     DragCancel();
-    return true;
+    return ui::ER_CONSUMED;
   }
   scoped_ptr<ui::MouseEvent> translated_event(
       drag_drop_tracker_->ConvertMouseEvent(translated_target, *event));
@@ -229,15 +227,18 @@ bool DragDropController::PreHandleMouseEvent(aura::Window* target,
       // (aura::RootWindow::PostMouseMoveEventAfterWindowChange).
       break;
   }
-  return true;
+  return ui::ER_CONSUMED;
+}
+
+ui::EventResult DragDropController::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult DragDropController::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult DragDropController::OnTouchEvent(ui::TouchEvent* event) {
   // TODO(sad): Also check for the touch-id.
   // TODO(varunjain): Add code for supporting drag-and-drop across displays
   // (http://crbug.com/114755).
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (!IsDragDropInProgress())
     return ui::ER_UNHANDLED;
   switch (event->type()) {
@@ -256,9 +257,7 @@ ui::EventResult DragDropController::PreHandleTouchEvent(
   return ui::ER_CONSUMED;
 }
 
-ui::EventResult DragDropController::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult DragDropController::OnGestureEvent(ui::GestureEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
diff --git a/ash/drag_drop/drag_drop_controller.h b/ash/drag_drop/drag_drop_controller.h
index 1925bbe..a0e8629 100644
--- a/ash/drag_drop/drag_drop_controller.h
+++ b/ash/drag_drop/drag_drop_controller.h
@@ -8,10 +8,10 @@
 #include "ash/ash_export.h"
 #include "base/callback.h"
 #include "ui/aura/client/drag_drop_client.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events/event_constants.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/gfx/point.h"
 
@@ -37,7 +37,7 @@ class DragImageView;
 
 class ASH_EXPORT DragDropController
     : public aura::client::DragDropClient,
-      public aura::EventFilter,
+      public ui::EventHandler,
       public ui::ImplicitAnimationObserver,
       public aura::WindowObserver {
  public:
@@ -63,17 +63,12 @@ class ASH_EXPORT DragDropController
   virtual void DragCancel() OVERRIDE;
   virtual bool IsDragDropInProgress() OVERRIDE;
 
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // Overridden from aura::WindowObserver.
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
diff --git a/ash/launcher/launcher_tooltip_manager.cc b/ash/launcher/launcher_tooltip_manager.cc
index f403a8c..a218aba 100644
--- a/ash/launcher/launcher_tooltip_manager.cc
+++ b/ash/launcher/launcher_tooltip_manager.cc
@@ -149,7 +149,7 @@ LauncherTooltipManager::LauncherTooltipManager(
   if (shelf_layout_manager)
     shelf_layout_manager->AddObserver(this);
   if (Shell::HasInstance())
-    Shell::GetInstance()->AddEnvEventFilter(this);
+    Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 LauncherTooltipManager::~LauncherTooltipManager() {
@@ -158,7 +158,7 @@ LauncherTooltipManager::~LauncherTooltipManager() {
   if (shelf_layout_manager_)
     shelf_layout_manager_->RemoveObserver(this);
   if (Shell::HasInstance())
-    Shell::GetInstance()->RemoveEnvEventFilter(this);
+    Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void LauncherTooltipManager::ShowDelayed(views::View* anchor,
@@ -254,25 +254,23 @@ bool LauncherTooltipManager::IsVisible() {
   return widget_ && widget_->IsVisible();
 }
 
-bool LauncherTooltipManager::PreHandleKeyEvent(aura::Window* target,
-                                               ui::KeyEvent* event) {
-  // Not handled.
-  return false;
+ui::EventResult LauncherTooltipManager::OnKeyEvent(ui::KeyEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-bool LauncherTooltipManager::PreHandleMouseEvent(aura::Window* target,
-                                                 ui::MouseEvent* event) {
-  DCHECK(target);
+ui::EventResult LauncherTooltipManager::OnMouseEvent(ui::MouseEvent* event) {
+  DCHECK(event->target());
   DCHECK(event);
   if (!widget_ || !widget_->IsVisible())
-    return false;
+    return ui::ER_UNHANDLED;
 
   DCHECK(view_);
   DCHECK(launcher_view_);
 
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (widget_->GetNativeWindow()->GetRootWindow() != target->GetRootWindow()) {
     CloseSoon();
-    return false;
+    return ui::ER_UNHANDLED;
   }
 
   gfx::Point location_in_launcher_view = event->location();
@@ -292,18 +290,22 @@ bool LauncherTooltipManager::PreHandleMouseEvent(aura::Window* target,
     CloseSoon();
   }
 
-  return false;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult LauncherTooltipManager::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult LauncherTooltipManager::PreHandleTouchEvent(
-    aura::Window* target, ui::TouchEvent* event) {
+ui::EventResult LauncherTooltipManager::OnTouchEvent(ui::TouchEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (widget_ && widget_->IsVisible() && widget_->GetNativeWindow() != target)
     Close();
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult LauncherTooltipManager::PreHandleGestureEvent(
-    aura::Window* target, ui::GestureEvent* event) {
+ui::EventResult LauncherTooltipManager::OnGestureEvent(
+    ui::GestureEvent* event) {
   if (widget_ && widget_->IsVisible()) {
     // Because this mouse event may arrive to |view_|, here we just schedule
     // the closing event rather than directly calling Close().
diff --git a/ash/launcher/launcher_tooltip_manager.h b/ash/launcher/launcher_tooltip_manager.h
index 8bdc61b..874fa63 100644
--- a/ash/launcher/launcher_tooltip_manager.h
+++ b/ash/launcher/launcher_tooltip_manager.h
@@ -10,7 +10,7 @@
 #include "ash/wm/shelf_types.h"
 #include "base/basictypes.h"
 #include "base/string16.h"
-#include "ui/aura/event_filter.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/bubble/bubble_border.h"
 #include "ui/views/bubble/bubble_delegate.h"
@@ -35,7 +35,7 @@ class LauncherView;
 
 // LauncherTooltipManager manages the tooltip balloon poping up on launcher
 // items.
-class ASH_EXPORT LauncherTooltipManager : public aura::EventFilter,
+class ASH_EXPORT LauncherTooltipManager : public ui::EventHandler,
                                           public ShelfLayoutManager::Observer {
  public:
   LauncherTooltipManager(ShelfAlignment alignment,
@@ -70,17 +70,12 @@ class ASH_EXPORT LauncherTooltipManager : public aura::EventFilter,
   bool IsVisible();
 
 protected:
-  // aura::EventFilter overrides:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // ui::EventHandler overrides:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // ShelfLayoutManager::Observer overrides:
   virtual void WillDeleteShelf() OVERRIDE;
diff --git a/ash/launcher/launcher_tooltip_manager_unittest.cc b/ash/launcher/launcher_tooltip_manager_unittest.cc
index 896ba4e..94b4c28 100644
--- a/ash/launcher/launcher_tooltip_manager_unittest.cc
+++ b/ash/launcher/launcher_tooltip_manager_unittest.cc
@@ -11,13 +11,23 @@
 #include "ash/wm/window_util.h"
 #include "base/string16.h"
 #include "base/time.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_constants.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/views/widget/widget.h"
 
+namespace {
+
+void SetEventTarget(ui::EventTarget* target,
+                    ui::Event* event) {
+  ui::Event::DispatcherApi dispatch_helper(event);
+  dispatch_helper.set_target(target);
+}
+
+}
+
 namespace ash {
 namespace test {
 
@@ -59,7 +69,7 @@ class LauncherTooltipManagerTest : public AshTestBase {
     return tooltip_manager_->timer_.get() != NULL;
   }
 
-  aura::EventFilter* GetEventFilter() {
+  ui::EventHandler* GetEventHandler() {
     return tooltip_manager_.get();
   }
 
@@ -143,26 +153,29 @@ TEST_F(LauncherTooltipManagerTest, ShouldHideForEvents) {
   ASSERT_TRUE(TooltipIsVisible());
 
   aura::RootWindow* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
-  aura::EventFilter* event_filter = GetEventFilter();
+  ui::EventHandler* event_handler = GetEventHandler();
 
   // Should not hide for key events.
   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE, false);
-  EXPECT_FALSE(event_filter->PreHandleKeyEvent(root_window, &key_event));
+  SetEventTarget(root_window, &key_event);
+  EXPECT_EQ(ui::ER_UNHANDLED,
+            event_handler->OnKeyEvent(&key_event));
   EXPECT_TRUE(TooltipIsVisible());
 
   // Should hide for touch events.
   ui::TouchEvent touch_event(
       ui::ET_TOUCH_PRESSED, gfx::Point(), 0, base::TimeDelta());
+  SetEventTarget(root_window, &touch_event);
   EXPECT_EQ(ui::ER_UNHANDLED,
-            event_filter->PreHandleTouchEvent(root_window, &touch_event));
+            event_handler->OnTouchEvent(&touch_event));
   EXPECT_FALSE(TooltipIsVisible());
 
   // Shouldn't hide if the touch happens on the tooltip.
   ShowImmediately();
   views::Widget* tooltip_widget = GetTooltipWidget();
+  SetEventTarget(tooltip_widget->GetNativeWindow(), &touch_event);
   EXPECT_EQ(ui::ER_UNHANDLED,
-            event_filter->PreHandleTouchEvent(
-                tooltip_widget->GetNativeWindow(), &touch_event));
+            event_handler->OnTouchEvent(&touch_event));
   EXPECT_TRUE(TooltipIsVisible());
 
   // Should hide for gesture events.
@@ -170,8 +183,9 @@ TEST_F(LauncherTooltipManagerTest, ShouldHideForEvents) {
       ui::ET_GESTURE_BEGIN, 0, 0, ui::EF_NONE,
       base::TimeDelta::FromMilliseconds(base::Time::Now().ToDoubleT() * 1000),
       ui::GestureEventDetails(ui::ET_GESTURE_BEGIN, 0.0f, 0.0f), 0);
+  SetEventTarget(tooltip_widget->GetNativeWindow(), &gesture_event);
   EXPECT_EQ(ui::ER_UNHANDLED,
-            event_filter->PreHandleGestureEvent(root_window, &gesture_event));
+            event_handler->OnGestureEvent(&gesture_event));
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(TooltipIsVisible());
 }
@@ -181,7 +195,7 @@ TEST_F(LauncherTooltipManagerTest, HideForMouseEvent) {
   ASSERT_TRUE(TooltipIsVisible());
 
   aura::RootWindow* root_window = Shell::GetInstance()->GetPrimaryRootWindow();
-  aura::EventFilter* event_filter = GetEventFilter();
+  ui::EventHandler* event_handler = GetEventHandler();
 
   gfx::Rect tooltip_rect = GetTooltipWidget()->GetNativeWindow()->bounds();
   ASSERT_FALSE(tooltip_rect.IsEmpty());
@@ -191,12 +205,15 @@ TEST_F(LauncherTooltipManagerTest, HideForMouseEvent) {
                              tooltip_rect.CenterPoint(), ui::EF_NONE);
   ui::LocatedEvent::TestApi test_api(&mouse_event);
 
-  EXPECT_FALSE(event_filter->PreHandleMouseEvent(root_window, &mouse_event));
+  SetEventTarget(root_window, &mouse_event);
+  EXPECT_EQ(ui::ER_UNHANDLED,
+            event_handler->OnMouseEvent(&mouse_event));
   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_FALSE(event_filter->PreHandleMouseEvent(root_window, &mouse_event));
+  EXPECT_EQ(ui::ER_UNHANDLED,
+            event_handler->OnMouseEvent(&mouse_event));
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(TooltipIsVisible());
 }
diff --git a/ash/root_window_controller.cc b/ash/root_window_controller.cc
index 81b619a..82c4b21 100644
--- a/ash/root_window_controller.cc
+++ b/ash/root_window_controller.cc
@@ -291,7 +291,7 @@ void RootWindowController::InitForPrimaryDisplay() {
       internal::kShellWindowId_PanelContainer);
   panel_layout_manager_ =
       new internal::PanelLayoutManager(panel_container);
-  panel_container->SetEventFilter(
+  panel_container->AddPreTargetHandler(
       new internal::PanelWindowEventFilter(
           panel_container, panel_layout_manager_));
   panel_container->SetLayoutManager(panel_layout_manager_);
diff --git a/ash/shell.cc b/ash/shell.cc
index 579bd76..11fe19f 100644
--- a/ash/shell.cc
+++ b/ash/shell.cc
@@ -229,13 +229,13 @@ Shell::~Shell() {
     active_root_window_->GetFocusManager()->SetFocusedWindow(NULL, NULL);
 
   // Please keep in same order as in Init() because it's easy to miss one.
-  RemoveEnvEventFilter(user_activity_detector_.get());
-  RemoveEnvEventFilter(event_rewriter_filter_.get());
-  RemoveEnvEventFilter(overlay_filter_.get());
-  RemoveEnvEventFilter(input_method_filter_.get());
-  RemoveEnvEventFilter(window_modality_controller_.get());
+  RemovePreTargetHandler(user_activity_detector_.get());
+  RemovePreTargetHandler(event_rewriter_filter_.get());
+  RemovePreTargetHandler(overlay_filter_.get());
+  RemovePreTargetHandler(input_method_filter_.get());
+  RemovePreTargetHandler(window_modality_controller_.get());
   if (mouse_cursor_filter_.get())
-    RemoveEnvEventFilter(mouse_cursor_filter_.get());
+    RemovePreTargetHandler(mouse_cursor_filter_.get());
   RemovePreTargetHandler(system_gesture_filter_.get());
 #if !defined(OS_MACOSX)
   RemovePreTargetHandler(accelerator_filter_.get());
@@ -244,7 +244,7 @@ Shell::~Shell() {
     RemovePreTargetHandler(touch_observer_hud_.get());
 
   // TooltipController is deleted with the Shell so removing its references.
-  RemoveEnvEventFilter(tooltip_controller_.get());
+  RemovePreTargetHandler(tooltip_controller_.get());
 
   // AppList needs to be released before shelf layout manager, which is
   // destroyed with launcher container in the loop below. However, app list
@@ -389,7 +389,7 @@ void Shell::Init() {
   views::FocusManagerFactory::Install(new AshFocusManagerFactory);
 
   env_filter_.reset(new views::corewm::CompoundEventFilter);
-  AddEnvEventFilter(env_filter_.get());
+  AddPreTargetHandler(env_filter_.get());
 
   focus_manager_.reset(new aura::FocusManager);
   activation_controller_.reset(
@@ -413,17 +413,17 @@ void Shell::Init() {
 
   // The order in which event filters are added is significant.
   user_activity_detector_.reset(new UserActivityDetector);
-  AddEnvEventFilter(user_activity_detector_.get());
+  AddPreTargetHandler(user_activity_detector_.get());
 
   event_rewriter_filter_.reset(new internal::EventRewriterEventFilter);
-  AddEnvEventFilter(event_rewriter_filter_.get());
+  AddPreTargetHandler(event_rewriter_filter_.get());
 
   overlay_filter_.reset(new internal::OverlayEventFilter);
-  AddEnvEventFilter(overlay_filter_.get());
+  AddPreTargetHandler(overlay_filter_.get());
   AddShellObserver(overlay_filter_.get());
 
   input_method_filter_.reset(new views::corewm::InputMethodEventFilter);
-  AddEnvEventFilter(input_method_filter_.get());
+  AddPreTargetHandler(input_method_filter_.get());
 
 #if !defined(OS_MACOSX)
   accelerator_filter_.reset(new internal::AcceleratorFilter);
@@ -449,7 +449,7 @@ void Shell::Init() {
   }
 
   mouse_cursor_filter_.reset(new internal::MouseCursorEventFilter());
-  AddEnvEventFilter(mouse_cursor_filter_.get());
+  AddPreTargetHandler(mouse_cursor_filter_.get());
 
   // Create Controllers that may need root window.
   // TODO(oshima): Move as many controllers before creating
@@ -459,7 +459,7 @@ void Shell::Init() {
   drag_drop_controller_.reset(new internal::DragDropController);
   user_action_client_.reset(delegate_->CreateUserActionClient());
   window_modality_controller_.reset(new internal::WindowModalityController);
-  AddEnvEventFilter(window_modality_controller_.get());
+  AddPreTargetHandler(window_modality_controller_.get());
 
   magnification_controller_.reset(
       internal::MagnificationController::CreateInstance());
@@ -471,7 +471,7 @@ void Shell::Init() {
 
   tooltip_controller_.reset(new internal::TooltipController(
       drag_drop_controller_.get()));
-  AddEnvEventFilter(tooltip_controller_.get());
+  AddPreTargetHandler(tooltip_controller_.get());
 
   event_client_.reset(new internal::EventClientImpl);
 
@@ -529,14 +529,6 @@ void Shell::Init() {
   env_filter_->set_cursor_hidden_by_filter(true);
 }
 
-void Shell::AddEnvEventFilter(aura::EventFilter* filter) {
-  AddPreTargetHandler(filter);
-}
-
-void Shell::RemoveEnvEventFilter(aura::EventFilter* filter) {
-  RemovePreTargetHandler(filter);
-}
-
 void Shell::ShowContextMenu(const gfx::Point& location_in_screen) {
   // No context menus if user have not logged in.
   if (!delegate_->IsUserLoggedIn())
@@ -704,7 +696,7 @@ void Shell::SetDimming(bool should_dim) {
 void Shell::CreateModalBackground(aura::Window* window) {
   if (!modality_filter_.get()) {
     modality_filter_.reset(new internal::SystemModalContainerEventFilter(this));
-    AddEnvEventFilter(modality_filter_.get());
+    AddPreTargetHandler(modality_filter_.get());
   }
   RootWindowControllerList controllers = GetAllRootWindowControllers();
   for (RootWindowControllerList::iterator iter = controllers.begin();
@@ -721,7 +713,7 @@ void Shell::OnModalWindowRemoved(aura::Window* removed) {
         ActivateNextModalWindow();
   }
   if (!activated) {
-    RemoveEnvEventFilter(modality_filter_.get());
+    RemovePreTargetHandler(modality_filter_.get());
     modality_filter_.reset();
     for (RootWindowControllerList::iterator iter = controllers.begin();
          iter != controllers.end(); ++iter)
diff --git a/ash/shell.h b/ash/shell.h
index d25998e..6ceb339 100644
--- a/ash/shell.h
+++ b/ash/shell.h
@@ -193,11 +193,6 @@ class ASH_EXPORT Shell : internal::SystemModalContainerEventFilterDelegate,
     active_root_window_ = active_root_window;
   }
 
-  // Adds or removes |filter| from the aura::Env's pre-target event-handler
-  // list.
-  void AddEnvEventFilter(aura::EventFilter* filter);
-  void RemoveEnvEventFilter(aura::EventFilter* filter);
-
   // Shows the context menu for the background and launcher at
   // |location_in_screen| (in screen coordinates).
   void ShowContextMenu(const gfx::Point& location_in_screen);
diff --git a/ash/tooltips/tooltip_controller.cc b/ash/tooltips/tooltip_controller.cc
index f9d053e7..aa19e31 100644
--- a/ash/tooltips/tooltip_controller.cc
+++ b/ash/tooltips/tooltip_controller.cc
@@ -247,8 +247,7 @@ void TooltipController::SetTooltipsEnabled(bool enable) {
   UpdateTooltip(tooltip_window_);
 }
 
-bool TooltipController::PreHandleKeyEvent(aura::Window* target,
-                                          ui::KeyEvent* event) {
+ui::EventResult TooltipController::OnKeyEvent(ui::KeyEvent* event) {
   // On key press, we want to hide the tooltip and not show it until change.
   // This is the same behavior as hiding tooltips on timeout. Hence, we can
   // simply simulate a timeout.
@@ -256,11 +255,11 @@ bool TooltipController::PreHandleKeyEvent(aura::Window* target,
     tooltip_shown_timer_.Stop();
     TooltipShownTimerFired();
   }
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-bool TooltipController::PreHandleMouseEvent(aura::Window* target,
-                                            ui::MouseEvent* event) {
+ui::EventResult TooltipController::OnMouseEvent(ui::MouseEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
@@ -298,12 +297,14 @@ bool TooltipController::PreHandleMouseEvent(aura::Window* target,
     default:
       break;
   }
-  return false;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TooltipController::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult TooltipController::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult TooltipController::OnTouchEvent(ui::TouchEvent* event) {
   // TODO(varunjain): need to properly implement tooltips for
   // touch events.
   // Hide the tooltip for touch events.
@@ -315,9 +316,7 @@ ui::EventResult TooltipController::PreHandleTouchEvent(
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult TooltipController::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult TooltipController::OnGestureEvent(ui::GestureEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
diff --git a/ash/tooltips/tooltip_controller.h b/ash/tooltips/tooltip_controller.h
index 08b2f12..dba89d2 100644
--- a/ash/tooltips/tooltip_controller.h
+++ b/ash/tooltips/tooltip_controller.h
@@ -5,13 +5,13 @@
 #ifndef ASH_TOOLTIPS_TOOLTIP_CONTROLLER_H_
 #define ASH_TOOLTIPS_TOOLTIP_CONTROLLER_H_
 
+#include "ash/ash_export.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "ui/aura/client/tooltip_client.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/window_observer.h"
-#include "ash/ash_export.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/point.h"
 
 namespace aura {
@@ -31,7 +31,7 @@ namespace internal {
 
 // TooltipController provides tooltip functionality for aura shell.
 class ASH_EXPORT TooltipController : public aura::client::TooltipClient,
-                                     public aura::EventFilter,
+                                     public ui::EventHandler,
                                      public aura::WindowObserver {
  public:
   explicit TooltipController(aura::client::DragDropClient* drag_drop_client);
@@ -41,16 +41,12 @@ class ASH_EXPORT TooltipController : public aura::client::TooltipClient,
   virtual void UpdateTooltip(aura::Window* target) OVERRIDE;
   virtual void SetTooltipsEnabled(bool enable) OVERRIDE;
 
-  // Overridden from aura::EventFilter.
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler.
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // Overridden from aura::WindowObserver.
   virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE;
diff --git a/ash/wm/event_rewriter_event_filter.cc b/ash/wm/event_rewriter_event_filter.cc
index e0a9707..7031581 100644
--- a/ash/wm/event_rewriter_event_filter.cc
+++ b/ash/wm/event_rewriter_event_filter.cc
@@ -20,52 +20,54 @@ void EventRewriterEventFilter::SetEventRewriterDelegate(
   delegate_.swap(delegate);
 }
 
-bool EventRewriterEventFilter::PreHandleKeyEvent(
-    aura::Window* target, ui::KeyEvent* event) {
+ui::EventResult EventRewriterEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   if (!delegate_.get())
-    return false;
+    return ui::ER_UNHANDLED;
 
   // Do not consume a translated key event which is generated by an IME.
   if (event->type() == ui::ET_TRANSLATED_KEY_PRESS ||
       event->type() == ui::ET_TRANSLATED_KEY_RELEASE) {
-    return false;
+    return ui::ER_UNHANDLED;
   }
 
   switch (delegate_->RewriteOrFilterKeyEvent(event)) {
     case EventRewriterDelegate::ACTION_REWRITE_EVENT:
-      return false;
+      return ui::ER_UNHANDLED;
     case EventRewriterDelegate::ACTION_DROP_EVENT:
-      return true;
+      return ui::ER_CONSUMED;
   }
 
   NOTREACHED();
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-bool EventRewriterEventFilter::PreHandleMouseEvent(
-    aura::Window* target, ui::MouseEvent* event) {
+ui::EventResult EventRewriterEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (!delegate_.get())
-    return false;
+    return ui::ER_UNHANDLED;
 
   switch (delegate_->RewriteOrFilterLocatedEvent(event)) {
     case EventRewriterDelegate::ACTION_REWRITE_EVENT:
-      return false;
+      return ui::ER_UNHANDLED;
     case EventRewriterDelegate::ACTION_DROP_EVENT:
-      return true;
+      return ui::ER_CONSUMED;
   }
 
   NOTREACHED();
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult EventRewriterEventFilter::PreHandleTouchEvent(
-    aura::Window* target, ui::TouchEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+ui::EventResult EventRewriterEventFilter::OnScrollEvent(
+    ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult EventRewriterEventFilter::PreHandleGestureEvent(
-    aura::Window* target, ui::GestureEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+ui::EventResult EventRewriterEventFilter::OnTouchEvent(ui::TouchEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult EventRewriterEventFilter::OnGestureEvent(
+    ui::GestureEvent* event) {
+  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 7c849c5..9473e99 100644
--- a/ash/wm/event_rewriter_event_filter.h
+++ b/ash/wm/event_rewriter_event_filter.h
@@ -9,7 +9,7 @@
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/aura/event_filter.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 
@@ -18,7 +18,7 @@ class EventRewriterDelegate;
 namespace internal {
 
 // An event filter that rewrites or drops an event.
-class ASH_EXPORT EventRewriterEventFilter : public aura::EventFilter {
+class ASH_EXPORT EventRewriterEventFilter : public ui::EventHandler {
  public:
   EventRewriterEventFilter();
   virtual ~EventRewriterEventFilter();
@@ -26,17 +26,12 @@ class ASH_EXPORT EventRewriterEventFilter : public aura::EventFilter {
   void SetEventRewriterDelegate(scoped_ptr<EventRewriterDelegate> delegate);
 
  private:
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   scoped_ptr<EventRewriterDelegate> delegate_;
 
diff --git a/ash/wm/overlay_event_filter.cc b/ash/wm/overlay_event_filter.cc
index 2166f9a..3540a0b 100644
--- a/ash/wm/overlay_event_filter.cc
+++ b/ash/wm/overlay_event_filter.cc
@@ -21,10 +21,9 @@ OverlayEventFilter::~OverlayEventFilter() {
   delegate_ = NULL;
 }
 
-bool OverlayEventFilter::PreHandleKeyEvent(
-    aura::Window* target, ui::KeyEvent* event) {
+ui::EventResult OverlayEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   if (!delegate_)
-    return false;
+    return ui::ER_UNHANDLED;
 
   // Do not consume a translated key event which is generated by an IME (e.g.,
   // ui::VKEY_PROCESSKEY) since the key event is generated in response to a key
@@ -32,7 +31,7 @@ bool OverlayEventFilter::PreHandleKeyEvent(
   // confuse key event handling JavaScript code in a page.
   if (event->type() == ui::ET_TRANSLATED_KEY_PRESS ||
       event->type() == ui::ET_TRANSLATED_KEY_RELEASE) {
-    return false;
+    return ui::ER_UNHANDLED;
   }
 
   if (delegate_ && delegate_->IsCancelingKeyEvent(event))
@@ -40,33 +39,36 @@ bool OverlayEventFilter::PreHandleKeyEvent(
 
   // Handle key events only when they are sent to a child of the delegate's
   // window.
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (delegate_ && delegate_->GetWindow()->Contains(target))
     target->delegate()->OnKeyEvent(event);
 
   // Always handled: other windows shouldn't receive input while we're
   // displaying an overlay.
-  return true;
+  return ui::ER_CONSUMED;
 }
 
-bool OverlayEventFilter::PreHandleMouseEvent(
-    aura::Window* target, ui::MouseEvent* event) {
+ui::EventResult OverlayEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   // Handle mouse events only when they are sent to a child of the delegate's
   // window.
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   if (delegate_ && delegate_->GetWindow()->Contains(target)) {
     target->delegate()->OnMouseEvent(event);
-    return true;
+    return ui::ER_CONSUMED;
   }
-  return false;  // Not handled.
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult OverlayEventFilter::PreHandleTouchEvent(
-    aura::Window* target, ui::TouchEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+ui::EventResult OverlayEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult OverlayEventFilter::PreHandleGestureEvent(
-    aura::Window* target, ui::GestureEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+ui::EventResult OverlayEventFilter::OnTouchEvent(ui::TouchEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult OverlayEventFilter::OnGestureEvent(ui::GestureEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
 void OverlayEventFilter::OnLoginStateChanged(
diff --git a/ash/wm/overlay_event_filter.h b/ash/wm/overlay_event_filter.h
index bdc7654..31c7223 100644
--- a/ash/wm/overlay_event_filter.h
+++ b/ash/wm/overlay_event_filter.h
@@ -7,7 +7,8 @@
 
 #include "ash/shell_observer.h"
 #include "base/compiler_specific.h"
-#include "ui/aura/event_filter.h"
+#include "ui/aura/window.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 namespace internal {
@@ -18,7 +19,7 @@ namespace internal {
 // called.  The main task of this event filter is just to stop propagation
 // of any key events during activation, and also signal cancellation when keys
 // for canceling are pressed.
-class OverlayEventFilter : public aura::EventFilter,
+class OverlayEventFilter : public ui::EventHandler,
                            public ShellObserver {
  public:
   // Windows that need to receive events from OverlayEventFilter implement this.
@@ -49,15 +50,12 @@ class OverlayEventFilter : public aura::EventFilter,
   // Cancels the partial screenshot UI.  Do nothing if it's not activated.
   void Cancel();
 
-  // aura::EventFilter overrides:
-  virtual bool PreHandleKeyEvent(
-      aura::Window* target, ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(
-      aura::Window* target, ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target, ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target, ui::GestureEvent* event) OVERRIDE;
+  // ui::EventHandler overrides:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // ShellObserver overrides:
   virtual void OnLoginStateChanged(user::LoginStatus status) OVERRIDE;
diff --git a/ash/wm/panel_window_event_filter.cc b/ash/wm/panel_window_event_filter.cc
index ca3f7c0..9891c87 100644
--- a/ash/wm/panel_window_event_filter.cc
+++ b/ash/wm/panel_window_event_filter.cc
@@ -23,23 +23,24 @@ namespace internal {
 PanelWindowEventFilter::PanelWindowEventFilter(
     aura::Window* panel_container,
     PanelLayoutManager* layout_manager)
-    : aura::EventFilter(),
-      panel_container_(panel_container),
+    : panel_container_(panel_container),
       layout_manager_(layout_manager),
       dragged_panel_(NULL),
       drag_state_(DRAG_NONE) {
+  panel_container_->AddObserver(this);
 }
 
 PanelWindowEventFilter::~PanelWindowEventFilter() {
+  panel_container_->RemoveObserver(this);
+  panel_container_->RemovePreTargetHandler(this);
 }
 
-bool PanelWindowEventFilter::PreHandleKeyEvent(aura::Window* target,
-                                               ui::KeyEvent* event) {
-  return false;
+ui::EventResult PanelWindowEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-bool PanelWindowEventFilter::PreHandleMouseEvent(aura::Window* target,
-                                                 ui::MouseEvent* event) {
+ui::EventResult PanelWindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   switch (event->type()) {
     case ui::ET_MOUSE_PRESSED: {
       int hitResult = target->delegate()->
@@ -49,12 +50,12 @@ bool PanelWindowEventFilter::PreHandleMouseEvent(aura::Window* target,
           dragged_panel_ = target;
           drag_location_in_dragged_window_ = event->location();
           drag_state_ = DRAG_CLICKED;
-          return true;
+          return ui::ER_CONSUMED;
         } else {
-          return false;
+          return ui::ER_UNHANDLED;
         }
       } else {
-        return false;
+        return ui::ER_UNHANDLED;
       }
     }
 
@@ -64,48 +65,54 @@ bool PanelWindowEventFilter::PreHandleMouseEvent(aura::Window* target,
         layout_manager_->StartDragging(dragged_panel_);
       }
       if (drag_state_ == DRAG_STARTED)
-        return HandleDrag(target, event);
+        return HandleDrag(target, event) ? ui::ER_CONSUMED : ui::ER_UNHANDLED;
       else
-        return false;
+        return ui::ER_UNHANDLED;
 
     case ui::ET_MOUSE_CAPTURE_CHANGED:
       if (drag_state_ == DRAG_STARTED) {
         FinishDrag();
-        return true;
+        return ui::ER_CONSUMED;
       } else if (drag_state_ == DRAG_CLICKED) {
         drag_state_ = DRAG_NONE;
         dragged_panel_ = NULL;
-        return true;
+        return ui::ER_CONSUMED;
       }
-      return false;
+      return ui::ER_UNHANDLED;
 
     case ui::ET_MOUSE_RELEASED:
       if (drag_state_ == DRAG_STARTED) {
         FinishDrag();
-        return true;
+        return ui::ER_CONSUMED;
       } else if (dragged_panel_ != NULL) {
         drag_state_ = DRAG_NONE;
         layout_manager_->ToggleMinimize(dragged_panel_);
         dragged_panel_ = NULL;
-        return true;
+        return ui::ER_CONSUMED;
       }
-      return false;
+      return ui::ER_UNHANDLED;
     default:
-      return false;
+      return ui::ER_UNHANDLED;
   }
 }
 
-ui::EventResult PanelWindowEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult PanelWindowEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult PanelWindowEventFilter::PreHandleGestureEvent(
-    aura::Window* target, ui::GestureEvent* event) {
+ui::EventResult PanelWindowEventFilter::OnTouchEvent(ui::TouchEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
+ui::EventResult PanelWindowEventFilter::OnGestureEvent(
+    ui::GestureEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+void PanelWindowEventFilter::OnWindowDestroying(aura::Window* window) {
+  CHECK_EQ(panel_container_, window);
+  delete this;
+}
 
 bool PanelWindowEventFilter::HandleDrag(aura::Window* target,
                                         ui::LocatedEvent* event) {
diff --git a/ash/wm/panel_window_event_filter.h b/ash/wm/panel_window_event_filter.h
index cb4d89f..88ca570 100644
--- a/ash/wm/panel_window_event_filter.h
+++ b/ash/wm/panel_window_event_filter.h
@@ -5,8 +5,9 @@
 #ifndef ASH_WM_PANEL_WINDOW_EVENT_FILTER_H
 #define ASH_WM_PANEL_WINDOW_EVENT_FILTER_H
 
-#include "ui/aura/event_filter.h"
 #include "ash/wm/panel_layout_manager.h"
+#include "ui/aura/window_observer.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 
@@ -21,23 +22,22 @@ class LocatedEvent;
 namespace ash {
 namespace internal {
 
-class PanelWindowEventFilter : public aura::EventFilter {
+class PanelWindowEventFilter : public ui::EventHandler,
+                               public aura::WindowObserver {
  public:
   PanelWindowEventFilter(aura::Window* panel_container,
                          PanelLayoutManager* layout_manager);
   virtual ~PanelWindowEventFilter();
 
-  // Overriden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overriden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+
+  // Overridden from aura::WindowObserver:
+  virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 
  private:
   enum DragState {
diff --git a/ash/wm/system_modal_container_event_filter.cc b/ash/wm/system_modal_container_event_filter.cc
index 9932120..693e696 100644
--- a/ash/wm/system_modal_container_event_filter.cc
+++ b/ash/wm/system_modal_container_event_filter.cc
@@ -5,6 +5,7 @@
 #include "ash/wm/system_modal_container_event_filter.h"
 
 #include "ash/wm/system_modal_container_event_filter_delegate.h"
+#include "ui/aura/window.h"
 #include "ui/base/events/event.h"
 
 namespace ash {
@@ -18,27 +19,32 @@ SystemModalContainerEventFilter::SystemModalContainerEventFilter(
 SystemModalContainerEventFilter::~SystemModalContainerEventFilter() {
 }
 
-bool SystemModalContainerEventFilter::PreHandleKeyEvent(
-    aura::Window* target,
+ui::EventResult SystemModalContainerEventFilter::OnKeyEvent(
     ui::KeyEvent* event) {
-  return !delegate_->CanWindowReceiveEvents(target);
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  return delegate_->CanWindowReceiveEvents(target) ? ui::ER_UNHANDLED :
+                                                     ui::ER_CONSUMED;
 }
 
-bool SystemModalContainerEventFilter::PreHandleMouseEvent(
-    aura::Window* target,
+ui::EventResult SystemModalContainerEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
-  return !delegate_->CanWindowReceiveEvents(target);
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  return delegate_->CanWindowReceiveEvents(target) ? ui::ER_UNHANDLED :
+                                                     ui::ER_CONSUMED;
 }
 
-ui::EventResult SystemModalContainerEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
+ui::EventResult SystemModalContainerEventFilter::OnScrollEvent(
+    ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult SystemModalContainerEventFilter::OnTouchEvent(
     ui::TouchEvent* event) {
   // TODO(sadrul): !
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult SystemModalContainerEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
+ui::EventResult SystemModalContainerEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   // TODO(sad):
   return ui::ER_UNHANDLED;
diff --git a/ash/wm/system_modal_container_event_filter.h b/ash/wm/system_modal_container_event_filter.h
index f2f1380..b4cc2b6 100644
--- a/ash/wm/system_modal_container_event_filter.h
+++ b/ash/wm/system_modal_container_event_filter.h
@@ -5,32 +5,28 @@
 #ifndef ASH_WM_SYSTEM_MODAL_CONTAINER_EVENT_FILTER_H_
 #define ASH_WM_SYSTEM_MODAL_CONTAINER_EVENT_FILTER_H_
 
-#include "base/compiler_specific.h"
-#include "ui/aura/event_filter.h"
 #include "ash/ash_export.h"
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 namespace internal {
 
 class SystemModalContainerEventFilterDelegate;
 
-class ASH_EXPORT SystemModalContainerEventFilter : public aura::EventFilter {
+class ASH_EXPORT SystemModalContainerEventFilter : public ui::EventHandler {
  public:
   explicit SystemModalContainerEventFilter(
       SystemModalContainerEventFilterDelegate* delegate);
   virtual ~SystemModalContainerEventFilter();
 
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
  private:
   SystemModalContainerEventFilterDelegate* delegate_;
diff --git a/ash/wm/user_activity_detector.cc b/ash/wm/user_activity_detector.cc
index cf20988..f245d55 100644
--- a/ash/wm/user_activity_detector.cc
+++ b/ash/wm/user_activity_detector.cc
@@ -34,32 +34,31 @@ void UserActivityDetector::OnAllOutputsTurnedOff() {
   ignore_next_mouse_event_ = true;
 }
 
-bool UserActivityDetector::PreHandleKeyEvent(aura::Window* target,
-                                             ui::KeyEvent* event) {
+ui::EventResult UserActivityDetector::OnKeyEvent(ui::KeyEvent* event) {
   MaybeNotify();
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-bool UserActivityDetector::PreHandleMouseEvent(aura::Window* target,
-                                               ui::MouseEvent* event) {
+ui::EventResult 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 false;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult UserActivityDetector::OnScrollEvent(ui::ScrollEvent* event) {
+  MaybeNotify();
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult UserActivityDetector::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult UserActivityDetector::OnTouchEvent(ui::TouchEvent* event) {
   MaybeNotify();
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult UserActivityDetector::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult UserActivityDetector::OnGestureEvent(ui::GestureEvent* event) {
   MaybeNotify();
   return ui::ER_UNHANDLED;
 }
diff --git a/ash/wm/user_activity_detector.h b/ash/wm/user_activity_detector.h
index 1affe65..a555034 100644
--- a/ash/wm/user_activity_detector.h
+++ b/ash/wm/user_activity_detector.h
@@ -10,14 +10,14 @@
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
 #include "base/time.h"
-#include "ui/aura/event_filter.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 
 class UserActivityObserver;
 
 // Watches for input events and notifies observers that the user is active.
-class ASH_EXPORT UserActivityDetector : public aura::EventFilter {
+class ASH_EXPORT UserActivityDetector : public ui::EventHandler {
  public:
   // Minimum amount of time between notifications to observers.
   static const double kNotifyIntervalMs;
@@ -34,19 +34,12 @@ class ASH_EXPORT UserActivityDetector : public aura::EventFilter {
   // Called when chrome has received a request to turn of all displays.
   void OnAllOutputsTurnedOff();
 
-  // aura::EventFilter implementation.
-  virtual bool PreHandleKeyEvent(
-      aura::Window* target,
-      ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(
-      aura::Window* target,
-      ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // ui::EventHandler implementation.
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
  private:
   // Notifies observers if enough time has passed since the last notification.
diff --git a/ash/wm/user_activity_detector_unittest.cc b/ash/wm/user_activity_detector_unittest.cc
index dcfde22..8213677 100644
--- a/ash/wm/user_activity_detector_unittest.cc
+++ b/ash/wm/user_activity_detector_unittest.cc
@@ -17,6 +17,15 @@
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/gfx/point.h"
 
+namespace {
+
+void SetEventTarget(ui::EventTarget* target, ui::Event* event) {
+  ui::Event::DispatcherApi dispatch_helper(event);
+  dispatch_helper.set_target(target);
+}
+
+}
+
 namespace ash {
 namespace test {
 
@@ -83,7 +92,8 @@ TEST_F(UserActivityDetectorTest, Basic) {
       aura::test::CreateTestWindowWithId(12345, NULL));
 
   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE, false);
-  EXPECT_FALSE(detector_->PreHandleKeyEvent(window.get(), &key_event));
+  SetEventTarget(window.get(), &key_event);
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnKeyEvent(&key_event));
   EXPECT_EQ(1, observer_->num_invocations());
   observer_->reset_stats();
 
@@ -92,21 +102,23 @@ TEST_F(UserActivityDetectorTest, Basic) {
   AdvanceTime(advance_delta);
   ui::MouseEvent mouse_event(
       ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(), ui::EF_NONE);
-  EXPECT_FALSE(detector_->PreHandleMouseEvent(window.get(), &mouse_event));
+  SetEventTarget(window.get(), &mouse_event);
+  EXPECT_FALSE(detector_->OnMouseEvent(&mouse_event));
   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_FALSE(detector_->PreHandleMouseEvent(window.get(), &mouse_event));
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnMouseEvent(&mouse_event));
   EXPECT_EQ(0, observer_->num_invocations());
   observer_->reset_stats();
 
   AdvanceTime(advance_delta);
   ui::TouchEvent touch_event(
       ui::ET_TOUCH_PRESSED, gfx::Point(), 0, base::TimeDelta());
-  EXPECT_FALSE(detector_->PreHandleTouchEvent(window.get(), &touch_event));
+  SetEventTarget(window.get(), &touch_event);
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnTouchEvent(&touch_event));
   EXPECT_EQ(1, observer_->num_invocations());
   observer_->reset_stats();
 
@@ -115,7 +127,8 @@ TEST_F(UserActivityDetectorTest, Basic) {
       ui::ET_GESTURE_TAP, 0, 0, ui::EF_NONE,
       base::TimeDelta::FromMilliseconds(base::Time::Now().ToDoubleT() * 1000),
       ui::GestureEventDetails(ui::ET_GESTURE_TAP, 0, 0), 0U);
-  EXPECT_FALSE(detector_->PreHandleGestureEvent(window.get(), &gesture_event));
+  SetEventTarget(window.get(), &gesture_event);
+  EXPECT_FALSE(detector_->OnGestureEvent(&gesture_event));
   EXPECT_EQ(1, observer_->num_invocations());
   observer_->reset_stats();
 }
@@ -127,13 +140,14 @@ TEST_F(UserActivityDetectorTest, RateLimitNotifications) {
 
   // The observer should be notified about a key event.
   ui::KeyEvent event(ui::ET_KEY_PRESSED, ui::VKEY_A, ui::EF_NONE, false);
-  EXPECT_FALSE(detector_->PreHandleKeyEvent(window.get(), &event));
+  SetEventTarget(window.get(), &event);
+  EXPECT_FALSE(detector_->OnKeyEvent(&event));
   EXPECT_EQ(1, observer_->num_invocations());
   observer_->reset_stats();
 
   // It shouldn't be notified if a second event occurs
   // in the same instant in time.
-  EXPECT_FALSE(detector_->PreHandleKeyEvent(window.get(), &event));
+  EXPECT_FALSE(detector_->OnKeyEvent(&event));
   EXPECT_EQ(0, observer_->num_invocations());
   observer_->reset_stats();
 
@@ -141,7 +155,7 @@ TEST_F(UserActivityDetectorTest, RateLimitNotifications) {
   AdvanceTime(
       base::TimeDelta::FromMilliseconds(
           UserActivityDetector::kNotifyIntervalMs - 100));
-  EXPECT_FALSE(detector_->PreHandleKeyEvent(window.get(), &event));
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnKeyEvent(&event));
   EXPECT_EQ(0, observer_->num_invocations());
   observer_->reset_stats();
 
@@ -150,7 +164,7 @@ TEST_F(UserActivityDetectorTest, RateLimitNotifications) {
   AdvanceTime(base::TimeDelta::FromMilliseconds(
       UserActivityDetector::kNotifyIntervalMs));
 
-  EXPECT_FALSE(detector_->PreHandleKeyEvent(window.get(), &event));
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnKeyEvent(&event));
   EXPECT_EQ(1, observer_->num_invocations());
 }
 
@@ -160,7 +174,8 @@ TEST_F(UserActivityDetectorTest, IgnoreSyntheticMouseEvents) {
       aura::test::CreateTestWindowWithId(12345, NULL));
   ui::MouseEvent mouse_event(
       ui::ET_MOUSE_MOVED, gfx::Point(), gfx::Point(), ui::EF_IS_SYNTHESIZED);
-  EXPECT_FALSE(detector_->PreHandleMouseEvent(window.get(), &mouse_event));
+  SetEventTarget(window.get(), &mouse_event);
+  EXPECT_EQ(ui::ER_UNHANDLED, detector_->OnMouseEvent(&mouse_event));
   EXPECT_EQ(0, observer_->num_invocations());
 }
 
diff --git a/ash/wm/window_cycle_controller.cc b/ash/wm/window_cycle_controller.cc
index 1098ae9..49c815c 100644
--- a/ash/wm/window_cycle_controller.cc
+++ b/ash/wm/window_cycle_controller.cc
@@ -12,9 +12,9 @@
 #include "ash/wm/window_cycle_list.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ash {
 
@@ -28,22 +28,17 @@ const int kContainerIds[] = {
 
 // Filter to watch for the termination of a keyboard gesture to cycle through
 // multiple windows.
-class WindowCycleEventFilter : public aura::EventFilter {
+class WindowCycleEventFilter : public ui::EventHandler {
  public:
   WindowCycleEventFilter();
   virtual ~WindowCycleEventFilter();
 
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
  private:
   DISALLOW_COPY_AND_ASSIGN(WindowCycleEventFilter);
 };
@@ -55,34 +50,31 @@ WindowCycleEventFilter::WindowCycleEventFilter() {
 WindowCycleEventFilter::~WindowCycleEventFilter() {
 }
 
-bool WindowCycleEventFilter::PreHandleKeyEvent(
-    aura::Window* target,
-    ui::KeyEvent* event) {
+ui::EventResult WindowCycleEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   // Views uses VKEY_MENU for both left and right Alt keys.
   if (event->key_code() == ui::VKEY_MENU &&
       event->type() == ui::ET_KEY_RELEASED) {
     Shell::GetInstance()->window_cycle_controller()->AltKeyReleased();
     // Warning: |this| will be deleted from here on.
   }
-  return false;  // Always let the event propagate.
+  return ui::ER_UNHANDLED;  // Always let the event propagate.
 }
 
-bool WindowCycleEventFilter::PreHandleMouseEvent(
-    aura::Window* target,
-    ui::MouseEvent* event) {
-  return false;  // Not handled.
+ui::EventResult WindowCycleEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult WindowCycleEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+ui::EventResult WindowCycleEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult WindowCycleEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
+ui::EventResult WindowCycleEventFilter::OnTouchEvent(ui::TouchEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult WindowCycleEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
-  return ui::ER_UNHANDLED;  // Not handled.
+  return ui::ER_UNHANDLED;
 }
 
 // Adds all the children of |window| to |windows|.
@@ -267,9 +259,9 @@ void WindowCycleController::Step(Direction direction) {
 void WindowCycleController::StopCycling() {
   windows_.reset();
   // Remove our key event filter.
-  if (event_filter_.get()) {
-    Shell::GetInstance()->RemoveEnvEventFilter(event_filter_.get());
-    event_filter_.reset();
+  if (event_handler_.get()) {
+    Shell::GetInstance()->RemovePreTargetHandler(event_handler_.get());
+    event_handler_.reset();
   }
 
   // Add the currently focused window to the MRU list
@@ -291,8 +283,8 @@ bool WindowCycleController::IsTrackedContainer(aura::Window* window) {
 }
 
 void WindowCycleController::InstallEventFilter() {
-  event_filter_.reset(new WindowCycleEventFilter());
-  Shell::GetInstance()->AddEnvEventFilter(event_filter_.get());
+  event_handler_.reset(new WindowCycleEventFilter());
+  Shell::GetInstance()->AddPreTargetHandler(event_handler_.get());
 }
 
 void WindowCycleController::OnWindowActivated(aura::Window* active,
diff --git a/ash/wm/window_cycle_controller.h b/ash/wm/window_cycle_controller.h
index 76836cb..2d6a0ae 100644
--- a/ash/wm/window_cycle_controller.h
+++ b/ash/wm/window_cycle_controller.h
@@ -15,11 +15,14 @@
 #include "ui/aura/window_observer.h"
 
 namespace aura {
-class EventFilter;
 class RootWindow;
 class Window;
 }
 
+namespace ui {
+class EventHandler;
+}
+
 namespace ash {
 
 namespace internal {
@@ -106,8 +109,8 @@ class ASH_EXPORT WindowCycleController
 
   scoped_ptr<WindowCycleList> windows_;
 
-  // Event filter to watch for release of alt key.
-  scoped_ptr<aura::EventFilter> event_filter_;
+  // Event handler to watch for release of alt key.
+  scoped_ptr<ui::EventHandler> event_handler_;
 
   // List of windows that have been activated in containers that we cycle
   // through, sorted by most recently used.
diff --git a/ash/wm/window_manager_unittest.cc b/ash/wm/window_manager_unittest.cc
index cab64d8..31bdaa3a 100644
--- a/ash/wm/window_manager_unittest.cc
+++ b/ash/wm/window_manager_unittest.cc
@@ -73,7 +73,7 @@ TEST_F(WindowManagerTest, Focus) {
   // The IME event filter interferes with the basic key event propagation we
   // attempt to do here, so we remove it.
   Shell::TestApi shell_test(Shell::GetInstance());
-  Shell::GetInstance()->RemoveEnvEventFilter(
+  Shell::GetInstance()->RemovePreTargetHandler(
       shell_test.input_method_event_filter());
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
@@ -510,7 +510,7 @@ TEST_F(WindowManagerTest, AdditionalFilters) {
   // The IME event filter interferes with the basic key event propagation we
   // attempt to do here, so we remove it.
   Shell::TestApi shell_test(Shell::GetInstance());
-  Shell::GetInstance()->RemoveEnvEventFilter(
+  Shell::GetInstance()->RemovePreTargetHandler(
       shell_test.input_method_event_filter());
 
   aura::RootWindow* root_window = Shell::GetPrimaryRootWindow();
diff --git a/ash/wm/window_modality_controller.cc b/ash/wm/window_modality_controller.cc
index 0d8e87a..d60bf96 100644
--- a/ash/wm/window_modality_controller.cc
+++ b/ash/wm/window_modality_controller.cc
@@ -74,25 +74,30 @@ WindowModalityController::~WindowModalityController() {
 ////////////////////////////////////////////////////////////////////////////////
 // WindowModalityController, aura::EventFilter implementation:
 
-bool WindowModalityController::PreHandleKeyEvent(aura::Window* target,
-                                                 ui::KeyEvent* event) {
-  return !!wm::GetWindowModalTransient(target);
+ui::EventResult WindowModalityController::OnKeyEvent(ui::KeyEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  return wm::GetWindowModalTransient(target) ? ui::ER_CONSUMED :
+                                               ui::ER_UNHANDLED;
 }
 
-bool WindowModalityController::PreHandleMouseEvent(aura::Window* target,
-                                                   ui::MouseEvent* event) {
-  return ProcessLocatedEvent(target, event);
+ui::EventResult WindowModalityController::OnMouseEvent(ui::MouseEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
+  return ProcessLocatedEvent(target, event) ? ui::ER_CONSUMED :
+                                              ui::ER_UNHANDLED;
+}
+
+ui::EventResult WindowModalityController::OnScrollEvent(
+    ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult WindowModalityController::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult WindowModalityController::OnTouchEvent(ui::TouchEvent* event) {
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   return ProcessLocatedEvent(target, event) ? ui::ER_CONSUMED :
                                               ui::ER_UNHANDLED;
 }
 
-ui::EventResult WindowModalityController::PreHandleGestureEvent(
-    aura::Window* target,
+ui::EventResult WindowModalityController::OnGestureEvent(
     ui::GestureEvent* event) {
   // TODO: make gestures work with modals.
   return ui::ER_UNHANDLED;
diff --git a/ash/wm/window_modality_controller.h b/ash/wm/window_modality_controller.h
index 9e6b5eb..6f685f6 100644
--- a/ash/wm/window_modality_controller.h
+++ b/ash/wm/window_modality_controller.h
@@ -10,8 +10,8 @@
 #include "ash/ash_export.h"
 #include "base/compiler_specific.h"
 #include "ui/aura/env_observer.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/window_observer.h"
+#include "ui/base/events/event_handler.h"
 
 namespace ui {
 class LocatedEvent;
@@ -30,24 +30,19 @@ namespace internal {
 // WindowModalityController is an event filter that consumes events sent to
 // windows that are the transient parents of window-modal windows. This filter
 // must be added to the CompoundEventFilter so that activation works properly.
-class WindowModalityController : public aura::EventFilter,
+class WindowModalityController : public ui::EventHandler,
                                  public aura::EnvObserver,
                                  public aura::WindowObserver {
  public:
   WindowModalityController();
   virtual ~WindowModalityController();
 
-  // Overridden from aura::EventFilter:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // Overridden from aura::EnvObserver:
   virtual void OnWindowInitialized(aura::Window* window) OVERRIDE;
diff --git a/ash/wm/workspace/frame_maximize_button.cc b/ash/wm/workspace/frame_maximize_button.cc
index 29a9e45..e920a89 100644
--- a/ash/wm/workspace/frame_maximize_button.cc
+++ b/ash/wm/workspace/frame_maximize_button.cc
@@ -12,9 +12,9 @@
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "grit/ash_strings.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image.h"
@@ -41,22 +41,17 @@ const int kMinSnapSizePercent = 50;
 // EscapeEventFilter is installed on the RootWindow to track when the escape key
 // is pressed. We use an EventFilter for this as the FrameMaximizeButton
 // normally does not get focus.
-class FrameMaximizeButton::EscapeEventFilter : public aura::EventFilter {
+class FrameMaximizeButton::EscapeEventFilter : public ui::EventHandler {
  public:
   explicit EscapeEventFilter(FrameMaximizeButton* button);
   virtual ~EscapeEventFilter();
 
   // EventFilter overrides:
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE;
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE;
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE;
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
  private:
   FrameMaximizeButton* button_;
@@ -67,37 +62,38 @@ class FrameMaximizeButton::EscapeEventFilter : public aura::EventFilter {
 FrameMaximizeButton::EscapeEventFilter::EscapeEventFilter(
     FrameMaximizeButton* button)
     : button_(button) {
-  Shell::GetInstance()->AddEnvEventFilter(this);
+  Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 FrameMaximizeButton::EscapeEventFilter::~EscapeEventFilter() {
-  Shell::GetInstance()->RemoveEnvEventFilter(this);
+  Shell::GetInstance()->RemovePreTargetHandler(this);
 }
 
-bool FrameMaximizeButton::EscapeEventFilter::PreHandleKeyEvent(
-    aura::Window* target,
+ui::EventResult FrameMaximizeButton::EscapeEventFilter::OnKeyEvent(
     ui::KeyEvent* event) {
   if (event->type() == ui::ET_KEY_PRESSED &&
       event->key_code() == ui::VKEY_ESCAPE) {
     button_->Cancel(false);
   }
-  return false;
+  return ui::ER_UNHANDLED;
 }
 
-bool FrameMaximizeButton::EscapeEventFilter::PreHandleMouseEvent(
-    aura::Window* target,
+ui::EventResult FrameMaximizeButton::EscapeEventFilter::OnMouseEvent(
     ui::MouseEvent* event) {
-  return false;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult FrameMaximizeButton::EscapeEventFilter::OnScrollEvent(
+    ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult FrameMaximizeButton::EscapeEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
+ui::EventResult FrameMaximizeButton::EscapeEventFilter::OnTouchEvent(
     ui::TouchEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult FrameMaximizeButton::EscapeEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
+ui::EventResult FrameMaximizeButton::EscapeEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   return ui::ER_UNHANDLED;
 }
diff --git a/chrome/browser/ui/views/ash/tab_scrubber.cc b/chrome/browser/ui/views/ash/tab_scrubber.cc
index 8c75a22..5a0eec6 100644
--- a/chrome/browser/ui/views/ash/tab_scrubber.cc
+++ b/chrome/browser/ui/views/ash/tab_scrubber.cc
@@ -30,20 +30,23 @@ TabScrubber::TabScrubber()
       browser_(NULL),
       initial_tab_index_(-1),
       initial_x_(-1) {
-  ash::Shell::GetInstance()->AddEnvEventFilter(this);
+  ash::Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
 TabScrubber::~TabScrubber() {
 }
 
-bool TabScrubber::PreHandleMouseEvent(aura::Window* target,
-                                      ui::MouseEvent* event) {
+ui::EventResult TabScrubber::OnKeyEvent(ui::KeyEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TabScrubber::OnMouseEvent(ui::MouseEvent* event) {
   Browser* browser = GetActiveBrowser();
 
   if (!(event->type() == ui::ET_MOUSE_PRESSED ||
       event->type() == ui::ET_MOUSE_DRAGGED ||
       event->type() == ui::ET_MOUSE_RELEASED))
-    return false;
+    return ui::ER_UNHANDLED;
 
   if (!browser ||
       (event->type() == ui::ET_MOUSE_RELEASED) ||
@@ -52,7 +55,7 @@ bool TabScrubber::PreHandleMouseEvent(aura::Window* target,
       (browser_ && browser != browser_)) {
     if (scrubbing_)
       StopScrubbing();
-    return false;
+    return ui::ER_UNHANDLED;
   }
 
   if (!scrubbing_) {
@@ -72,7 +75,7 @@ bool TabScrubber::PreHandleMouseEvent(aura::Window* target,
     Tab* initial_tab = tab_strip->tab_at(initial_tab_index_);
     if (!initial_tab) {
       StopScrubbing();
-      return false;
+      return ui::ER_UNHANDLED;
     }
 
     gfx::Point tab_point((initial_tab->width() / 2) + event->x() - initial_x_,
@@ -84,7 +87,19 @@ bool TabScrubber::PreHandleMouseEvent(aura::Window* target,
     }
   }
 
-  return true;
+  return ui::ER_CONSUMED;
+}
+
+ui::EventResult TabScrubber::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TabScrubber::OnTouchEvent(ui::TouchEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TabScrubber::OnGestureEvent(ui::GestureEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
 void TabScrubber::Observe(int type,
diff --git a/chrome/browser/ui/views/ash/tab_scrubber.h b/chrome/browser/ui/views/ash/tab_scrubber.h
index 82b6654..5f92ac0 100644
--- a/chrome/browser/ui/views/ash/tab_scrubber.h
+++ b/chrome/browser/ui/views/ash/tab_scrubber.h
@@ -5,9 +5,10 @@
 #ifndef CHROME_BROWSER_UI_VIEWS_ASH_TAB_SCRUBBER_H_
 #define CHROME_BROWSER_UI_VIEWS_ASH_TAB_SCRUBBER_H_
 
-#include "ui/aura/event_filter.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "ui/aura/window.h"
+#include "ui/base/events/event_handler.h"
 
 class Browser;
 class Tab;
@@ -16,7 +17,7 @@ class Tab;
 // Notes: this is experimental, and disables ctrl-clicks. It should not be
 // enabled other than through flags until we implement 3 finger drag as the
 // mechanism to invoke it. At that point we will add test coverage.
-class TabScrubber : public aura::EventFilter,
+class TabScrubber : public ui::EventHandler,
                     public content::NotificationObserver {
  public:
   static TabScrubber* GetInstance();
@@ -25,9 +26,12 @@ class TabScrubber : public aura::EventFilter,
   TabScrubber();
   virtual ~TabScrubber();
 
-  // aura::EventFilter overrides:
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE;
+  // ui::EventHandler overrides:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
   // content::NotificationObserver overrides:
   virtual void Observe(int type,