aura: Remove aura::EventFilter.

Remove EventFilter. ui::EventHandler should now be used instead of EventFilters.
An aura window can still have a single 'filter', which is a pre-target
EventHandler owned by the Window.

BUG=159632

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

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

34 files changed, 339 insertions, 821 deletions

diff --git a/ash/accelerators/accelerator_dispatcher.cc b/ash/accelerators/accelerator_dispatcher.cc
index d8b238f..ee56cef 100644
--- a/ash/accelerators/accelerator_dispatcher.cc
+++ b/ash/accelerators/accelerator_dispatcher.cc
@@ -17,7 +17,6 @@
 #include "ash/shell.h"
 #include "ash/wm/event_rewriter_event_filter.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/events/event.h"
diff --git a/ash/magnifier/magnification_controller.h b/ash/magnifier/magnification_controller.h
index 4b0e865..b274b4c 100644
--- a/ash/magnifier/magnification_controller.h
+++ b/ash/magnifier/magnification_controller.h
@@ -8,7 +8,6 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "ui/aura/event_filter.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/rect.h"
 
diff --git a/ash/system/tray/tray_background_view.cc b/ash/system/tray/tray_background_view.cc
index 17a1f06..7ec4ed1 100644
--- a/ash/system/tray/tray_background_view.cc
+++ b/ash/system/tray/tray_background_view.cc
@@ -14,7 +14,6 @@
 #include "ash/wm/property_util.h"
 #include "ash/wm/shelf_layout_manager.h"
 #include "ash/wm/window_animations.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/base/accessibility/accessible_view_state.h"
diff --git a/ash/system/tray/tray_event_filter.cc b/ash/system/tray/tray_event_filter.cc
index 7b130e9..0c6afc0 100644
--- a/ash/system/tray/tray_event_filter.cc
+++ b/ash/system/tray/tray_event_filter.cc
@@ -13,7 +13,6 @@
 #include "ash/system/tray/tray_event_filter.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/shelf_layout_manager.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
 
diff --git a/ash/touch/touch_uma.h b/ash/touch/touch_uma.h
index 94e1164..cab7edc 100644
--- a/ash/touch/touch_uma.h
+++ b/ash/touch/touch_uma.h
@@ -8,7 +8,6 @@
 #include <map>
 
 #include "ash/shell.h"
-#include "ui/aura/event_filter.h"
 #include "ui/gfx/point.h"
 #include "ui/views/widget/widget.h"
 
diff --git a/ash/wm/window_manager_unittest.cc b/ash/wm/window_manager_unittest.cc
index 31bdaa3a..5b02d35 100644
--- a/ash/wm/window_manager_unittest.cc
+++ b/ash/wm/window_manager_unittest.cc
@@ -16,7 +16,7 @@
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
-#include "ui/aura/test/test_event_filter.h"
+#include "ui/aura/test/test_event_handler.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/base/cursor/cursor.h"
@@ -32,6 +32,43 @@ base::TimeDelta getTime() {
   return base::Time::NowFromSystemTime() - base::Time();
 }
 
+// A slightly changed TestEventHandler which can be configured to return a
+// specified value for key/mouse event handling.
+class CustomEventHandler : public aura::test::TestEventHandler {
+ public:
+  CustomEventHandler()
+      : key_result_(ui::ER_UNHANDLED),
+        mouse_result_(ui::ER_UNHANDLED) {
+  }
+
+  virtual ~CustomEventHandler() {}
+
+  void set_key_event_handling_result(ui::EventResult result) {
+    key_result_ = result;
+  }
+
+  void set_mouse_event_handling_result(ui::EventResult result) {
+    mouse_result_ = result;
+  }
+
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+    ui::EventResult result = aura::test::TestEventHandler::OnKeyEvent(event);
+    return key_result_ == ui::ER_UNHANDLED ? result : key_result_;
+  }
+
+  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_;
+  }
+
+ private:
+  ui::EventResult key_result_;
+  ui::EventResult mouse_result_;
+
+  DISALLOW_COPY_AND_ASSIGN(CustomEventHandler);
+};
+
 }  // namespace
 
 namespace ash {
@@ -521,14 +558,14 @@ TEST_F(WindowManagerTest, AdditionalFilters) {
   wm::ActivateWindow(w1.get());
 
   // Creates two addition filters
-  scoped_ptr<aura::test::TestEventFilter> f1(new aura::test::TestEventFilter);
-  scoped_ptr<aura::test::TestEventFilter> f2(new aura::test::TestEventFilter);
+  scoped_ptr<CustomEventHandler> f1(new CustomEventHandler);
+  scoped_ptr<CustomEventHandler> f2(new CustomEventHandler);
 
   // Adds them to root window event filter.
   views::corewm::CompoundEventFilter* env_filter =
       Shell::GetInstance()->env_filter();
-  env_filter->AddFilter(f1.get());
-  env_filter->AddFilter(f2.get());
+  env_filter->AddHandler(f1.get());
+  env_filter->AddHandler(f2.get());
 
   // Dispatches mouse and keyboard events.
   ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, false);
@@ -538,13 +575,13 @@ TEST_F(WindowManagerTest, AdditionalFilters) {
   root_window->AsRootWindowHostDelegate()->OnHostMouseEvent(&mouse_pressed);
 
   // Both filters should get the events.
-  EXPECT_EQ(1, f1->key_event_count());
-  EXPECT_EQ(1, f1->mouse_event_count());
-  EXPECT_EQ(1, f2->key_event_count());
-  EXPECT_EQ(1, f2->mouse_event_count());
+  EXPECT_EQ(1, f1->num_key_events());
+  EXPECT_EQ(1, f1->num_mouse_events());
+  EXPECT_EQ(1, f2->num_key_events());
+  EXPECT_EQ(1, f2->num_mouse_events());
 
-  f1->ResetCounts();
-  f2->ResetCounts();
+  f1->Reset();
+  f2->Reset();
 
   // Makes f1 consume events.
   f1->set_key_event_handling_result(ui::ER_CONSUMED);
@@ -557,28 +594,28 @@ TEST_F(WindowManagerTest, AdditionalFilters) {
   root_window->AsRootWindowHostDelegate()->OnHostMouseEvent(&mouse_released);
 
   // f1 should still get the events but f2 no longer gets them.
-  EXPECT_EQ(1, f1->key_event_count());
-  EXPECT_EQ(1, f1->mouse_event_count());
-  EXPECT_EQ(0, f2->key_event_count());
-  EXPECT_EQ(0, f2->mouse_event_count());
+  EXPECT_EQ(1, f1->num_key_events());
+  EXPECT_EQ(1, f1->num_mouse_events());
+  EXPECT_EQ(0, f2->num_key_events());
+  EXPECT_EQ(0, f2->num_mouse_events());
 
-  f1->ResetCounts();
-  f2->ResetCounts();
+  f1->Reset();
+  f2->Reset();
 
   // Remove f1 from additonal filters list.
-  env_filter->RemoveFilter(f1.get());
+  env_filter->RemoveHandler(f1.get());
 
   // Dispatches events.
   root_window->AsRootWindowHostDelegate()->OnHostKeyEvent(&key_event);
   root_window->AsRootWindowHostDelegate()->OnHostMouseEvent(&mouse_pressed);
 
   // f1 should get no events since it's out and f2 should get them.
-  EXPECT_EQ(0, f1->key_event_count());
-  EXPECT_EQ(0, f1->mouse_event_count());
-  EXPECT_EQ(1, f2->key_event_count());
-  EXPECT_EQ(1, f2->mouse_event_count());
+  EXPECT_EQ(0, f1->num_key_events());
+  EXPECT_EQ(0, f1->num_mouse_events());
+  EXPECT_EQ(1, f2->num_key_events());
+  EXPECT_EQ(1, f2->num_mouse_events());
 
-  env_filter->RemoveFilter(f2.get());
+  env_filter->RemoveHandler(f2.get());
 }
 
 // We should show and hide the cursor in response to mouse and touch events as
diff --git a/ash/wm/workspace/multi_window_resize_controller.cc b/ash/wm/workspace/multi_window_resize_controller.cc
index 490f1ac..b692b23 100644
--- a/ash/wm/workspace/multi_window_resize_controller.cc
+++ b/ash/wm/workspace/multi_window_resize_controller.cc
@@ -13,7 +13,6 @@
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/client/screen_position_client.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
diff --git a/content/shell/shell_stacking_client_ash.cc b/content/shell/shell_stacking_client_ash.cc
index 75a708b..0a6e9c7 100644
--- a/content/shell/shell_stacking_client_ash.cc
+++ b/content/shell/shell_stacking_client_ash.cc
@@ -18,7 +18,7 @@ ShellStackingClientAsh::ShellStackingClientAsh() {
 
 ShellStackingClientAsh::~ShellStackingClientAsh() {
   if (root_window_.get())
-    root_window_event_filter_->RemoveFilter(input_method_filter_.get());
+    root_window_event_filter_->RemoveHandler(input_method_filter_.get());
 
   aura::client::SetStackingClient(NULL);
 }
@@ -42,7 +42,7 @@ aura::Window* ShellStackingClientAsh::GetDefaultParent(
     input_method_filter_.reset(new views::corewm::InputMethodEventFilter);
     input_method_filter_->SetInputMethodPropertyInRootWindow(
         root_window_.get());
-    root_window_event_filter_->AddFilter(input_method_filter_.get());
+    root_window_event_filter_->AddHandler(input_method_filter_.get());
 
     test_activation_client_.reset(
         new aura::test::TestActivationClient(root_window_.get()));
diff --git a/ui/aura/aura.gyp b/ui/aura/aura.gyp
index 6fe1f70..5797010 100644
--- a/ui/aura/aura.gyp
+++ b/ui/aura/aura.gyp
@@ -69,8 +69,6 @@
         'env.cc',
         'env.h',
         'env_observer.h',
-        'event_filter.cc',
-        'event_filter.h',
         'focus_change_observer.h',
         'focus_manager.cc',
         'focus_manager.h',
@@ -146,8 +144,8 @@
         'test/test_activation_client.h',
         'test/test_aura_initializer.cc',
         'test/test_aura_initializer.h',
-        'test/test_event_filter.cc',
-        'test/test_event_filter.h',
+        'test/test_event_handler.cc',
+        'test/test_event_handler.h',
         'test/test_screen.cc',
         'test/test_screen.h',
         'test/test_stacking_client.cc',
@@ -261,7 +259,6 @@
         'test/test_suite.cc',
         'test/test_suite.h',
         'root_window_unittest.cc',
-        'event_filter_unittest.cc',
         'window_unittest.cc',
       ],
       'conditions': [
diff --git a/ui/aura/env.cc b/ui/aura/env.cc
index 06734c8..b967ed7 100644
--- a/ui/aura/env.cc
+++ b/ui/aura/env.cc
@@ -7,7 +7,6 @@
 #include "base/command_line.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env_observer.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/compositor.h"
diff --git a/ui/aura/env.h b/ui/aura/env.h
index 48ff533..661af25 100644
--- a/ui/aura/env.h
+++ b/ui/aura/env.h
@@ -20,7 +20,6 @@
 
 namespace aura {
 class EnvObserver;
-class EventFilter;
 class Window;
 
 #if !defined(USE_X11)
diff --git a/ui/aura/event_filter.cc b/ui/aura/event_filter.cc
deleted file mode 100644
index 06201b1..0000000
--- a/ui/aura/event_filter.cc
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ui/aura/event_filter.h"
-
-#include "ui/aura/window.h"
-#include "ui/base/events/event.h"
-
-namespace aura {
-
-bool EventFilter::PreHandleKeyEvent(Window* target, ui::KeyEvent* event) {
-  return false;
-}
-
-bool EventFilter::PreHandleMouseEvent(Window* target, ui::MouseEvent* event) {
-  return false;
-}
-
-ui::EventResult EventFilter::PreHandleTouchEvent(Window* target,
-                                                 ui::TouchEvent* event) {
-  return ui::ER_UNHANDLED;
-}
-
-ui::EventResult EventFilter::PreHandleGestureEvent(Window* target,
-                                                   ui::GestureEvent* event) {
-  return ui::ER_UNHANDLED;
-}
-
-ui::EventResult EventFilter::OnKeyEvent(ui::KeyEvent* event) {
-  return PreHandleKeyEvent(static_cast<Window*>(event->target()), event) ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
-}
-
-ui::EventResult EventFilter::OnMouseEvent(ui::MouseEvent* event) {
-  return PreHandleMouseEvent(static_cast<Window*>(event->target()), event) ?
-      ui::ER_CONSUMED : ui::ER_UNHANDLED;
-}
-
-ui::EventResult EventFilter::OnScrollEvent(ui::ScrollEvent* event) {
-  return ui::ER_UNHANDLED;
-}
-
-ui::EventResult EventFilter::OnTouchEvent(ui::TouchEvent* event) {
-  return PreHandleTouchEvent(static_cast<Window*>(event->target()), event);
-}
-
-ui::EventResult EventFilter::OnGestureEvent(ui::GestureEvent* event) {
-  return PreHandleGestureEvent(static_cast<Window*>(event->target()), event);
-}
-
-}  // namespace aura
diff --git a/ui/aura/event_filter.h b/ui/aura/event_filter.h
deleted file mode 100644
index 8b02986..0000000
--- a/ui/aura/event_filter.h
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef UI_AURA_EVENT_FILTER_H_
-#define UI_AURA_EVENT_FILTER_H_
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "ui/aura/aura_export.h"
-#include "ui/base/events/event_constants.h"
-#include "ui/base/events/event_handler.h"
-
-namespace ui {
-class GestureEvent;
-class KeyEvent;
-class MouseEvent;
-class TouchEvent;
-}
-
-namespace aura {
-
-class Window;
-
-// An object that filters events sent to an owner window. The filter can stop
-// further processing of events.
-//
-// When the Desktop receives an event, it determines the "target window" for
-// the event, this is typically the visible window whose bounds most tightly
-// enclose the event coordinates, in the case of mouse events, or the focused
-// window, in the case of key events.
-//
-// The Desktop then walks up the hierarchy from the target to its own window,
-// collecting a list of EventFilters. This list is notified in reverse order
-// (i.e. descending, from the Desktop's own event filter). Each filter gets a
-// chance to prevent further processing of the event and/or take other actions.
-class AURA_EXPORT EventFilter : public ui::EventHandler {
- public:
-  virtual ~EventFilter() {}
-
-  // Parameters: a |target| Window and the |event|. The target window is the
-  // window the event was targeted at. If |event| is a LocatedEvent, its
-  // coordinates are relative to |target|.
-
-  // For all PreHandle*() functions that return a bool, return true if the
-  // filter consumes the event and further processing (by the target, for
-  // example) is not performed. Return false if the filter does not consume the
-  // event and further processing is performed. Note that in this case the
-  // filter may still perform some action, the return value simply indicates
-  // that further processing can occur.
-
-  virtual bool PreHandleKeyEvent(Window* target, ui::KeyEvent* event);
-  virtual bool PreHandleMouseEvent(Window* target, ui::MouseEvent* event);
-
-  // Returns a value other than ui::ER_UNHANDLED if the event is
-  // consumed.
-  virtual ui::EventResult PreHandleTouchEvent(Window* target,
-                                              ui::TouchEvent* event);
-
-  // Returns a value other than ui::ER_UNHANDLED if the gesture is
-  // consumed.
-  virtual ui::EventResult PreHandleGestureEvent(Window* target,
-                                                ui::GestureEvent* event);
-
-  // 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* e) OVERRIDE;
-};
-
-}  // namespace aura
-
-#endif  // UI_AURA_EVENT_FILTER_H_
diff --git a/ui/aura/event_filter_unittest.cc b/ui/aura/event_filter_unittest.cc
deleted file mode 100644
index 93de07c..0000000
--- a/ui/aura/event_filter_unittest.cc
+++ /dev/null
@@ -1,311 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ui/aura/event_filter.h"
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "ui/aura/focus_manager.h"
-#include "ui/aura/root_window.h"
-#include "ui/aura/test/aura_test_base.h"
-#include "ui/aura/test/event_generator.h"
-#include "ui/aura/test/test_event_filter.h"
-#include "ui/aura/test/test_window_delegate.h"
-#include "ui/base/events/event.h"
-
-#if defined(OS_WIN)
-// Windows headers define macros for these function names which screw with us.
-#if defined(CreateWindow)
-#undef CreateWindow
-#endif
-#endif
-
-namespace aura {
-
-typedef test::AuraTestBase EventFilterTest;
-
-class TestEventFilterWindowDelegate : public test::TestWindowDelegate {
- public:
-  TestEventFilterWindowDelegate()
-      : key_event_count_(0),
-        mouse_event_count_(0),
-        touch_event_count_(0),
-        key_event_handling_result_(ui::ER_UNHANDLED),
-        mouse_event_handling_result_(ui::ER_UNHANDLED),
-        consumes_touch_events_(true) {}
-  virtual ~TestEventFilterWindowDelegate() {}
-
-  void ResetCounts() {
-    key_event_count_ = 0;
-    mouse_event_count_ = 0;
-    touch_event_count_ = 0;
-  }
-
-  int key_event_count() const { return key_event_count_; }
-  int mouse_event_count() const { return mouse_event_count_; }
-  int touch_event_count() const { return touch_event_count_; }
-
-  void set_key_event_handling_result(ui::EventResult result) {
-    key_event_handling_result_ = result;
-  }
-  void set_mouse_event_handling_result(ui::EventResult result) {
-    mouse_event_handling_result_ = result;
-  }
-  void set_consumes_touch_events(bool consumes_touch_events) {
-    consumes_touch_events_ = consumes_touch_events;
-  }
-
-  // Overridden from EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
-    ++key_event_count_;
-    return key_event_handling_result_;
-  }
-
-  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
-    ++mouse_event_count_;
-    return mouse_event_handling_result_;
-  }
-
-  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
-    ++touch_event_count_;
-    // TODO(sadrul): !
-    return ui::ER_UNHANDLED;
-  }
-
-  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
-    // TODO(sadrul): !
-    return ui::ER_UNHANDLED;
-  }
- private:
-  int key_event_count_;
-  int mouse_event_count_;
-  int touch_event_count_;
-  ui::EventResult key_event_handling_result_;
-  ui::EventResult mouse_event_handling_result_;
-  bool consumes_touch_events_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestEventFilterWindowDelegate);
-};
-
-Window* CreateWindow(int id, Window* parent, WindowDelegate* delegate) {
-  Window* window = new Window(
-      delegate ? delegate :
-      test::TestWindowDelegate::CreateSelfDestroyingDelegate());
-  window->set_id(id);
-  window->Init(ui::LAYER_TEXTURED);
-  window->SetParent(parent);
-  window->SetBounds(gfx::Rect(0, 0, 100, 100));
-  window->Show();
-  return window;
-}
-
-// Creates this hierarchy:
-//
-// RootWindow (EF)
-//  +- w1 (EF)
-//    +- w11
-//      +- w111 (EF)
-//        +- w1111 <-- target window
-TEST_F(EventFilterTest, PreHandle) {
-  scoped_ptr<Window> w1(CreateWindow(1, root_window(), NULL));
-  scoped_ptr<Window> w11(CreateWindow(11, w1.get(), NULL));
-  scoped_ptr<Window> w111(CreateWindow(111, w11.get(), NULL));
-  TestEventFilterWindowDelegate d1111;
-  scoped_ptr<Window> w1111(CreateWindow(1111, w111.get(), &d1111));
-
-  test::TestEventFilter* root_window_filter = new test::TestEventFilter;
-  test::TestEventFilter* w1_filter = new test::TestEventFilter;
-  test::TestEventFilter* w111_filter = new test::TestEventFilter;
-  root_window()->SetEventFilter(root_window_filter);
-  w1->SetEventFilter(w1_filter);
-  w111->SetEventFilter(w111_filter);
-
-  w1111->GetFocusManager()->SetFocusedWindow(w1111.get(), NULL);
-
-  // To start with, no one is going to consume any events. All three filters
-  // and the w1111's delegate should receive the event.
-  test::EventGenerator generator(root_window(), w1111.get());
-  generator.PressLeftButton();
-  ui::KeyEvent key_event(ui::ET_KEY_PRESSED, ui::VKEY_A, 0, false);
-  root_window()->AsRootWindowHostDelegate()->OnHostKeyEvent(&key_event);
-
-  // TODO(sadrul): TouchEvent!
-  EXPECT_EQ(1, root_window_filter->key_event_count());
-  EXPECT_EQ(1, w1_filter->key_event_count());
-  EXPECT_EQ(1, w111_filter->key_event_count());
-  EXPECT_EQ(1, d1111.key_event_count());
-  EXPECT_EQ(1, root_window_filter->mouse_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(1, w111_filter->mouse_event_count());
-  EXPECT_EQ(1, d1111.mouse_event_count());
-  EXPECT_EQ(0, root_window_filter->touch_event_count());
-  EXPECT_EQ(0, w1_filter->touch_event_count());
-  EXPECT_EQ(0, w111_filter->touch_event_count());
-  EXPECT_EQ(0, d1111.touch_event_count());
-
-  d1111.ResetCounts();
-  root_window_filter->ResetCounts();
-  w1_filter->ResetCounts();
-  w111_filter->ResetCounts();
-
-  // Now make w1's EF consume the event.
-  w1_filter->set_key_event_handling_result(ui::ER_CONSUMED);
-  w1_filter->set_mouse_event_handling_result(ui::ER_CONSUMED);
-
-  generator.ReleaseLeftButton();
-  root_window()->AsRootWindowHostDelegate()->OnHostKeyEvent(&key_event);
-
-  // TODO(sadrul): TouchEvent/GestureEvent!
-  EXPECT_EQ(1, root_window_filter->key_event_count());
-  EXPECT_EQ(1, w1_filter->key_event_count());
-  EXPECT_EQ(0, w111_filter->key_event_count());
-  EXPECT_EQ(0, d1111.key_event_count());
-  EXPECT_EQ(1, root_window_filter->mouse_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(0, w111_filter->mouse_event_count());
-  EXPECT_EQ(0, d1111.mouse_event_count());
-  EXPECT_EQ(0, root_window_filter->touch_event_count());
-  EXPECT_EQ(0, w1_filter->touch_event_count());
-  EXPECT_EQ(0, w111_filter->touch_event_count());
-  EXPECT_EQ(0, d1111.touch_event_count());
-}
-
-// Tests PostHandle* methods for this hierarchy:
-// RootWindow
-//  w1 (EF)
-//   w11 <-- target window
-TEST_F(EventFilterTest, PostHandle) {
-  scoped_ptr<Window> w1(CreateWindow(1, root_window(), NULL));
-  TestEventFilterWindowDelegate d11;
-  scoped_ptr<Window> w11(CreateWindow(11, w1.get(), &d11));
-
-  test::TestEventFilter root_window_filter;
-  test::TestEventFilter* w1_filter = new test::TestEventFilter;
-  root_window()->AddPostTargetHandler(&root_window_filter);
-  w1->AddPostTargetHandler(w1_filter);
-
-  w1->GetFocusManager()->SetFocusedWindow(w11.get(), NULL);
-
-  // TODO(sadrul): TouchEvent/GestureEvent!
-
-  // To start with, no one is going to consume any events. The post-
-  // event filters and w11's delegate will be notified.
-  test::EventGenerator generator(root_window(), w11.get());
-
-  d11.set_key_event_handling_result(ui::ER_UNHANDLED);
-  d11.set_mouse_event_handling_result(ui::ER_UNHANDLED);
-  d11.set_consumes_touch_events(false);
-
-  generator.PressKey(ui::VKEY_A, 0);
-  generator.PressLeftButton();
-
-#if defined(OS_WIN)
-  // Windows sends two WM_KEYDOWN/WM_CHAR events for one key press.
-  const int kExpectedKeyCount = 2;
-#else
-  const int kExpectedKeyCount = 1;
-#endif
-
-  EXPECT_EQ(kExpectedKeyCount, w1_filter->key_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(1, root_window_filter.mouse_event_count());
-  EXPECT_EQ(kExpectedKeyCount, d11.key_event_count());
-  EXPECT_EQ(1, d11.mouse_event_count());
-
-  root_window_filter.ResetCounts();
-  w1_filter->ResetCounts();
-  d11.ResetCounts();
-  generator.set_flags(0);
-
-  // Let |w1_filter| handle (but not consume) an event. The root-window's
-  // post-target filter should still receive the event.
-  w1_filter->set_mouse_event_handling_result(ui::ER_HANDLED);
-  generator.PressLeftButton();
-  EXPECT_EQ(1, d11.mouse_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(1, root_window_filter.mouse_event_count());
-
-  root_window_filter.ResetCounts();
-  w1_filter->ResetCounts();
-  d11.ResetCounts();
-  generator.set_flags(0);
-
-  // Let |w1_filter| consume an event. So the root-window's post-target
-  // filter should no longer receive the event.
-  w1_filter->set_mouse_event_handling_result(ui::ER_CONSUMED);
-  generator.PressLeftButton();
-  EXPECT_EQ(1, d11.mouse_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(0, root_window_filter.mouse_event_count());
-
-  // Now we'll have the delegate handle the events.
-  root_window_filter.ResetCounts();
-  w1_filter->ResetCounts();
-  d11.ResetCounts();
-  generator.set_flags(0);
-
-  w1_filter->set_mouse_event_handling_result(ui::ER_UNHANDLED);
-  d11.set_key_event_handling_result(ui::ER_HANDLED);
-  d11.set_mouse_event_handling_result(ui::ER_HANDLED);
-  d11.set_consumes_touch_events(true);
-
-  generator.PressKey(ui::VKEY_A, 0);
-  generator.PressLeftButton();
-
-  EXPECT_EQ(kExpectedKeyCount, d11.key_event_count());
-  EXPECT_EQ(1, d11.mouse_event_count());
-  // The delegate processed the event. But it should still bubble up to the
-  // post-target filters.
-  EXPECT_EQ(kExpectedKeyCount, w1_filter->key_event_count());
-  EXPECT_EQ(kExpectedKeyCount, root_window_filter.key_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(1, root_window_filter.mouse_event_count());
-
-  // Now we'll have the delegate consume the events.
-  root_window_filter.ResetCounts();
-  w1_filter->ResetCounts();
-  d11.ResetCounts();
-  generator.set_flags(0);
-
-  d11.set_key_event_handling_result(ui::ER_CONSUMED);
-  d11.set_mouse_event_handling_result(ui::ER_CONSUMED);
-  d11.set_consumes_touch_events(true);
-
-  generator.PressKey(ui::VKEY_A, 0);
-  generator.PressLeftButton();
-
-  EXPECT_EQ(kExpectedKeyCount, d11.key_event_count());
-  EXPECT_EQ(1, d11.mouse_event_count());
-  // The delegate consumed the event. So it should no longer reach the
-  // post-target filters.
-  EXPECT_EQ(0, w1_filter->key_event_count());
-  EXPECT_EQ(0, root_window_filter.key_event_count());
-  EXPECT_EQ(0, w1_filter->mouse_event_count());
-  EXPECT_EQ(0, root_window_filter.mouse_event_count());
-
-  // Now we'll have the pre-filter methods consume the events.
-  w1->RemovePostTargetHandler(w1_filter);
-  w1->SetEventFilter(w1_filter);
-  w1_filter->ResetCounts();
-  d11.ResetCounts();
-  generator.set_flags(0);
-
-  d11.set_key_event_handling_result(ui::ER_UNHANDLED);
-  d11.set_mouse_event_handling_result(ui::ER_UNHANDLED);
-  d11.set_consumes_touch_events(false);
-
-  w1_filter->set_key_event_handling_result(ui::ER_CONSUMED);
-  w1_filter->set_mouse_event_handling_result(ui::ER_CONSUMED);
-  w1_filter->set_consumes_touch_events(true);
-
-  generator.PressKey(ui::VKEY_A, 0);
-  generator.PressLeftButton();
-
-  EXPECT_EQ(kExpectedKeyCount, w1_filter->key_event_count());
-  EXPECT_EQ(0, d11.key_event_count());
-  EXPECT_EQ(1, w1_filter->mouse_event_count());
-  EXPECT_EQ(0, d11.mouse_event_count());
-}
-
-}  // namespace aura
diff --git a/ui/aura/root_window.cc b/ui/aura/root_window.cc
index e91452d..ac566ad 100644
--- a/ui/aura/root_window.cc
+++ b/ui/aura/root_window.cc
@@ -19,7 +19,6 @@
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window_host.h"
 #include "ui/aura/root_window_observer.h"
@@ -59,16 +58,6 @@ bool IsNonClientLocation(Window* target, const gfx::Point& location) {
   return hit_test_code != HTCLIENT && hit_test_code != HTNOWHERE;
 }
 
-typedef std::vector<EventFilter*> EventFilters;
-
-void GetEventFiltersToNotify(Window* target, EventFilters* filters) {
-  while (target) {
-    if (target->event_filter())
-      filters->push_back(target->event_filter());
-    target = target->parent();
-  }
-}
-
 float GetDeviceScaleFactorFromDisplay(Window* window) {
   return gfx::Screen::GetScreenFor(window)->
       GetDisplayNearestWindow(window).device_scale_factor();
diff --git a/ui/aura/root_window_unittest.cc b/ui/aura/root_window_unittest.cc
index 92fbb08..c97be64 100644
--- a/ui/aura/root_window_unittest.cc
+++ b/ui/aura/root_window_unittest.cc
@@ -9,14 +9,15 @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/event_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
+#include "ui/aura/test/test_event_handler.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/base/events/event.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/base/gestures/gesture_configuration.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/keycodes/keyboard_codes.h"
@@ -73,68 +74,20 @@ class NonClientDelegate : public test::TestWindowDelegate {
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
-// A simple EventFilter that keeps track of the number of key events that it's
-// seen.
-class EventCountFilter : public EventFilter {
+// A simple event handler that consumes key events.
+class ConsumeKeyHandler : public test::TestEventHandler {
  public:
-  EventCountFilter()
-      : num_key_events_(0),
-        num_mouse_events_(0),
-        num_touch_events_(0),
-        num_scroll_events_(0) {
-  }
-  virtual ~EventCountFilter() {}
-
-  int num_key_events() const { return num_key_events_; }
-  int num_mouse_events() const { return num_mouse_events_; }
-  int num_touch_events() const { return num_touch_events_; }
-  int num_scroll_events() const { return num_scroll_events_; }
-
-  void Reset() {
-    num_key_events_ = 0;
-    num_mouse_events_ = 0;
-    num_touch_events_ = 0;
-    num_scroll_events_ = 0;
-  }
-
-  // EventFilter overrides:
-  virtual bool PreHandleKeyEvent(Window* target, ui::KeyEvent* event) OVERRIDE {
-    num_key_events_++;
-    return true;
-  }
-  virtual bool PreHandleMouseEvent(Window* target,
-                                   ui::MouseEvent* event) OVERRIDE {
-    num_mouse_events_++;
-    return true;
-  }
-  virtual ui::EventResult PreHandleTouchEvent(
-      Window* target, ui::TouchEvent* event) OVERRIDE {
-    num_touch_events_++;
-    return ui::ER_UNHANDLED;
-  }
-  virtual ui::EventResult PreHandleGestureEvent(
-      Window* target, ui::GestureEvent* event) OVERRIDE {
-    return ui::ER_UNHANDLED;
-  }
+  ConsumeKeyHandler() {}
+  virtual ~ConsumeKeyHandler() {}
 
-  // ui::EventHandler overrides:
-  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
-    num_scroll_events_++;
-    return ui::ER_UNHANDLED;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+    test::TestEventHandler::OnKeyEvent(event);
+    return ui::ER_CONSUMED;
   }
 
  private:
-  // How many key events have been received?
-  int num_key_events_;
-
-  // How many mouse events have been received?
-  int num_mouse_events_;
-
-  int num_touch_events_;
-
-  int num_scroll_events_;
-
-  DISALLOW_COPY_AND_ASSIGN(EventCountFilter);
+  DISALLOW_COPY_AND_ASSIGN(ConsumeKeyHandler);
 };
 
 Window* CreateWindow(int id, Window* parent, WindowDelegate* delegate) {
@@ -364,8 +317,8 @@ TEST_F(RootWindowTest, CanProcessEventsWithinSubtree) {
   TestEventClient client(root_window());
   test::TestWindowDelegate d;
 
-  EventCountFilter* nonlock_ef = new EventCountFilter;
-  EventCountFilter* lock_ef = new EventCountFilter;
+  test::TestEventHandler* nonlock_ef = new test::TestEventHandler;
+  test::TestEventHandler* lock_ef = new test::TestEventHandler;
   client.GetNonLockWindow()->SetEventFilter(nonlock_ef);
   client.GetLockWindow()->SetEventFilter(lock_ef);
 
@@ -416,7 +369,7 @@ TEST_F(RootWindowTest, CanProcessEventsWithinSubtree) {
 }
 
 TEST_F(RootWindowTest, IgnoreUnknownKeys) {
-  EventCountFilter* filter = new EventCountFilter;
+  test::TestEventHandler* filter = new ConsumeKeyHandler;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   ui::KeyEvent unknown_event(ui::ET_KEY_PRESSED, ui::VKEY_UNKNOWN, 0, false);
@@ -433,7 +386,7 @@ TEST_F(RootWindowTest, IgnoreUnknownKeys) {
 // Tests that touch-events that are beyond the bounds of the root-window do get
 // propagated to the event filters correctly with the root as the target.
 TEST_F(RootWindowTest, TouchEventsOutsideBounds) {
-  EventCountFilter* filter = new EventCountFilter;
+  test::TestEventHandler* filter = new test::TestEventHandler;
   root_window()->SetEventFilter(filter);  // passes ownership
 
   gfx::Point position = root_window()->bounds().origin();
@@ -452,7 +405,7 @@ TEST_F(RootWindowTest, TouchEventsOutsideBounds) {
 
 // Tests that scroll events are dispatched correctly.
 TEST_F(RootWindowTest, ScrollEventDispatch) {
-  EventCountFilter* filter = new EventCountFilter;
+  test::TestEventHandler* filter = new test::TestEventHandler;
   root_window()->SetEventFilter(filter);
 
   test::TestWindowDelegate delegate;
@@ -473,7 +426,7 @@ TEST_F(RootWindowTest, ScrollEventDispatch) {
 namespace {
 
 // FilterFilter that tracks the types of events it's seen.
-class EventFilterRecorder : public EventFilter {
+class EventFilterRecorder : public ui::EventHandler {
  public:
   typedef std::vector<ui::EventType> Events;
 
@@ -481,25 +434,28 @@ class EventFilterRecorder : public EventFilter {
 
   Events& events() { return events_; }
 
-  // EventFilter overrides:
-  virtual bool PreHandleKeyEvent(Window* target, ui::KeyEvent* event) OVERRIDE {
+  // ui::EventHandler overrides:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return true;
+    return ui::ER_UNHANDLED;
   }
-  virtual bool PreHandleMouseEvent(Window* target,
-                                   ui::MouseEvent* event) OVERRIDE {
+
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return true;
+    return ui::ER_UNHANDLED;
   }
-  virtual ui::EventResult PreHandleTouchEvent(
-      Window* target,
-      ui::TouchEvent* event) OVERRIDE {
+
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
     events_.push_back(event->type());
     return ui::ER_UNHANDLED;
   }
-  virtual ui::EventResult PreHandleGestureEvent(
-      Window* target,
-      ui::GestureEvent* event) OVERRIDE {
+
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+    events_.push_back(event->type());
+    return ui::ER_UNHANDLED;
+  }
+
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
     events_.push_back(event->type());
     return ui::ER_UNHANDLED;
   }
@@ -669,7 +625,7 @@ TEST_F(RootWindowTest, HoldMouseMove) {
   EXPECT_TRUE(filter->events().empty());
 }
 
-class DeletingEventFilter : public EventFilter {
+class DeletingEventFilter : public ui::EventHandler {
  public:
   DeletingEventFilter()
       : delete_during_pre_handle_(false) {}
@@ -680,19 +636,29 @@ class DeletingEventFilter : public EventFilter {
   }
 
  private:
-  // Overridden from EventFilter:
-  virtual bool PreHandleKeyEvent(Window* target,
-                                 ui::KeyEvent* event) OVERRIDE {
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
-      delete target;
-    return false;
+      delete event->target();
+    return ui::ER_UNHANDLED;
   }
 
-  virtual bool PreHandleMouseEvent(Window* target,
-                                   ui::MouseEvent* event) OVERRIDE {
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
-      delete target;
-    return false;
+      delete event->target();
+    return ui::ER_UNHANDLED;
+  }
+
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
+  }
+
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
+  }
+
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
   }
 
   bool delete_during_pre_handle_;
diff --git a/ui/aura/test/test_event_filter.cc b/ui/aura/test/test_event_filter.cc
deleted file mode 100644
index cd56b36..0000000
--- a/ui/aura/test/test_event_filter.cc
+++ /dev/null
@@ -1,54 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ui/aura/test/test_event_filter.h"
-
-namespace aura {
-namespace test {
-
-TestEventFilter::TestEventFilter()
-    : key_event_count_(0),
-      mouse_event_count_(0),
-      touch_event_count_(0),
-      key_event_handling_result_(ui::ER_UNHANDLED),
-      mouse_event_handling_result_(ui::ER_UNHANDLED),
-      consumes_touch_event_(false) {
-}
-
-TestEventFilter::~TestEventFilter() {
-}
-
-void TestEventFilter::ResetCounts() {
-  key_event_count_ = 0;
-  mouse_event_count_ = 0;
-  touch_event_count_ = 0;
-}
-
-ui::EventResult TestEventFilter::OnKeyEvent(ui::KeyEvent* event) {
-  ++key_event_count_;
-  return key_event_handling_result_;
-}
-
-ui::EventResult TestEventFilter::OnMouseEvent(ui::MouseEvent* event) {
-  ++mouse_event_count_;
-  return mouse_event_handling_result_;
-}
-
-ui::EventResult TestEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
-  return ui::ER_UNHANDLED;
-}
-
-ui::EventResult TestEventFilter::OnTouchEvent(ui::TouchEvent* event) {
-  ++touch_event_count_;
-  // TODO(sadrul): !
-  return ui::ER_UNHANDLED;
-}
-
-ui::EventResult TestEventFilter::OnGestureEvent(ui::GestureEvent* event) {
-  // TODO(sadrul): !
-  return ui::ER_UNHANDLED;
-}
-
-}  // namespace test
-}  // namespace aura
diff --git a/ui/aura/test/test_event_filter.h b/ui/aura/test/test_event_filter.h
deleted file mode 100644
index 11c1bdd..0000000
--- a/ui/aura/test/test_event_filter.h
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef UI_AURA_TEST_TEST_EVENT_FILTER_H_
-#define UI_AURA_TEST_TEST_EVENT_FILTER_H_
-
-#include "base/compiler_specific.h"
-#include "ui/aura/event_filter.h"
-
-namespace aura {
-
-class Window;
-
-namespace test {
-
-// TestEventFilter counts the key, mouse and touch events it receives and can
-// optinally be set to consume those events.
-class TestEventFilter : public EventFilter {
- public:
-  TestEventFilter();
-  virtual ~TestEventFilter();
-
-  // Resets all event counters.
-  void ResetCounts();
-
-  int key_event_count() const { return key_event_count_; }
-  int mouse_event_count() const { return mouse_event_count_; }
-  int touch_event_count() const { return touch_event_count_; }
-
-  void set_key_event_handling_result(ui::EventResult result) {
-    key_event_handling_result_ = result;
-  }
-  void set_mouse_event_handling_result(ui::EventResult result) {
-    mouse_event_handling_result_ = result;
-  }
-  void set_consumes_touch_events(bool consumes) {
-    consumes_touch_event_ = consumes;
-  }
-
-  // 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:
-  int key_event_count_;
-  int mouse_event_count_;
-  int touch_event_count_;
-
-  ui::EventResult key_event_handling_result_;
-  ui::EventResult mouse_event_handling_result_;
-  bool consumes_touch_event_;
-
-  DISALLOW_COPY_AND_ASSIGN(TestEventFilter);
-};
-
-}  // namespace test
-}  // namespace aura
-
-#endif  // UI_AURA_TEST_TEST_EVENT_FILTER_H_
diff --git a/ui/aura/test/test_event_handler.cc b/ui/aura/test/test_event_handler.cc
new file mode 100644
index 0000000..45cdabc
--- /dev/null
+++ b/ui/aura/test/test_event_handler.cc
@@ -0,0 +1,54 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ui/aura/test/test_event_handler.h"
+
+namespace aura {
+namespace test {
+
+TestEventHandler::TestEventHandler()
+    : num_key_events_(0),
+      num_mouse_events_(0),
+      num_scroll_events_(0),
+      num_touch_events_(0),
+      num_gesture_events_(0) {
+}
+
+TestEventHandler::~TestEventHandler() {}
+
+void TestEventHandler::Reset() {
+  num_key_events_ = 0;
+  num_mouse_events_ = 0;
+  num_scroll_events_ = 0;
+  num_touch_events_ = 0;
+  num_gesture_events_ = 0;
+}
+
+ui::EventResult TestEventHandler::OnKeyEvent(ui::KeyEvent* event) {
+  num_key_events_++;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TestEventHandler::OnMouseEvent(ui::MouseEvent* event) {
+  num_mouse_events_++;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TestEventHandler::OnScrollEvent(ui::ScrollEvent* event) {
+  num_scroll_events_++;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TestEventHandler::OnTouchEvent(ui::TouchEvent* event) {
+  num_touch_events_++;
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult TestEventHandler::OnGestureEvent(ui::GestureEvent* event) {
+  num_gesture_events_++;
+  return ui::ER_UNHANDLED;
+}
+
+}  // namespace test
+}  // namespace aura
diff --git a/ui/aura/test/test_event_handler.h b/ui/aura/test/test_event_handler.h
new file mode 100644
index 0000000..aa74ca7
--- /dev/null
+++ b/ui/aura/test/test_event_handler.h
@@ -0,0 +1,51 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef UI_AURA_TEST_TEST_EVENT_HANDLER_H_
+#define UI_AURA_TEST_TEST_EVENT_HANDLER_H_
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ui/base/events/event_handler.h"
+
+namespace aura {
+namespace test {
+
+// A simple EventHandler that keeps track of the number of key events that it's
+// seen.
+class TestEventHandler : public ui::EventHandler {
+ public:
+  TestEventHandler();
+  virtual ~TestEventHandler();
+
+  int num_key_events() const { return num_key_events_; }
+  int num_mouse_events() const { return num_mouse_events_; }
+  int num_scroll_events() const { return num_scroll_events_; }
+  int num_touch_events() const { return num_touch_events_; }
+  int num_gesture_events() const { return num_gesture_events_; }
+
+  void Reset();
+
+  // 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;
+
+ private:
+  // How many events have been received of each type?
+  int num_key_events_;
+  int num_mouse_events_;
+  int num_scroll_events_;
+  int num_touch_events_;
+  int num_gesture_events_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestEventHandler);
+};
+
+}  // namespace test
+}  // namespace aura
+
+#endif // UI_AURA_TEST_TEST_EVENT_HANDLER_H_
diff --git a/ui/aura/window.cc b/ui/aura/window.cc
index 6303b76..1626947 100644
--- a/ui/aura/window.cc
+++ b/ui/aura/window.cc
@@ -19,7 +19,6 @@
 #include "ui/aura/client/stacking_client.h"
 #include "ui/aura/client/visibility_client.h"
 #include "ui/aura/env.h"
-#include "ui/aura/event_filter.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/root_window.h"
@@ -453,7 +452,7 @@ gfx::NativeCursor Window::GetCursor(const gfx::Point& point) const {
   return delegate_ ? delegate_->GetCursor(point) : gfx::kNullCursor;
 }
 
-void Window::SetEventFilter(EventFilter* event_filter) {
+void Window::SetEventFilter(ui::EventHandler* event_filter) {
   if (event_filter_.get())
     RemovePreTargetHandler(event_filter_.get());
   event_filter_.reset(event_filter);
diff --git a/ui/aura/window.h b/ui/aura/window.h
index f3c7749..ccfdc48 100644
--- a/ui/aura/window.h
+++ b/ui/aura/window.h
@@ -33,13 +33,13 @@ class Transform;
 }
 
 namespace ui {
+class EventHandler;
 class Layer;
 class Texture;
 }
 
 namespace aura {
 
-class EventFilter;
 class FocusManager;
 class LayoutManager;
 class RootWindow;
@@ -230,9 +230,11 @@ class AURA_EXPORT Window : public ui::LayerDelegate,
   // Returns the cursor for the specified point, in window coordinates.
   gfx::NativeCursor GetCursor(const gfx::Point& point) const;
 
-  // Window takes ownership of the EventFilter.
-  void SetEventFilter(EventFilter* event_filter);
-  EventFilter* event_filter() { return event_filter_.get(); }
+  // Sets an 'event filter' for the window. An 'event filter' for a Window is
+  // a pre-target event handler, where the window owns the handler. A window
+  // can have only one such event filter. Setting a new filter removes and
+  // destroys any previously installed filter.
+  void SetEventFilter(ui::EventHandler* event_filter);
 
   // Add/remove observer.
   void AddObserver(WindowObserver* observer);
@@ -473,7 +475,7 @@ class AURA_EXPORT Window : public ui::LayerDelegate,
   // Whether layer is initialized as non-opaque.
   bool transparent_;
 
-  scoped_ptr<EventFilter> event_filter_;
+  scoped_ptr<ui::EventHandler> event_filter_;
   scoped_ptr<LayoutManager> layout_manager_;
 
   void* user_data_;
diff --git a/ui/views/corewm/compound_event_filter.cc b/ui/views/corewm/compound_event_filter.cc
index 3e2478c..558bdd8 100644
--- a/ui/views/corewm/compound_event_filter.cc
+++ b/ui/views/corewm/compound_event_filter.cc
@@ -87,7 +87,7 @@ CompoundEventFilter::CompoundEventFilter() : cursor_hidden_by_filter_(false) {
 
 CompoundEventFilter::~CompoundEventFilter() {
   // Additional filters are not owned by CompoundEventFilter and they
-  // should all be removed when running here. |filters_| has
+  // should all be removed when running here. |handlers_| has
   // check_empty == true and will DCHECK failure if it is not empty.
 }
 
@@ -116,12 +116,12 @@ gfx::NativeCursor CompoundEventFilter::CursorForWindowComponent(
   }
 }
 
-void CompoundEventFilter::AddFilter(aura::EventFilter* filter) {
-  filters_.AddObserver(filter);
+void CompoundEventFilter::AddHandler(ui::EventHandler* handler) {
+  handlers_.AddObserver(handler);
 }
 
-void CompoundEventFilter::RemoveFilter(aura::EventFilter* filter) {
-  filters_.RemoveObserver(filter);
+void CompoundEventFilter::RemoveHandler(ui::EventHandler* handler) {
+  handlers_.RemoveObserver(handler);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -153,33 +153,33 @@ void CompoundEventFilter::UpdateCursor(aura::Window* target,
 
 ui::EventResult CompoundEventFilter::FilterKeyEvent(ui::KeyEvent* event) {
   int result = ui::ER_UNHANDLED;
-  if (filters_.might_have_observers()) {
-    ObserverListBase<aura::EventFilter>::Iterator it(filters_);
-    EventFilter* filter;
-    while (!(result & ui::ER_CONSUMED) && (filter = it.GetNext()) != NULL)
-      result |= filter->OnKeyEvent(event);
+  if (handlers_.might_have_observers()) {
+    ObserverListBase<ui::EventHandler>::Iterator it(handlers_);
+    ui::EventHandler* handler;
+    while (!(result & ui::ER_CONSUMED) && (handler = it.GetNext()) != NULL)
+      result |= handler->OnKeyEvent(event);
   }
   return static_cast<ui::EventResult>(result);
 }
 
 ui::EventResult CompoundEventFilter::FilterMouseEvent(ui::MouseEvent* event) {
   int result = ui::ER_UNHANDLED;
-  if (filters_.might_have_observers()) {
-    ObserverListBase<aura::EventFilter>::Iterator it(filters_);
-    EventFilter* filter;
-    while (!(result & ui::ER_CONSUMED) && (filter = it.GetNext()) != NULL)
-      result |= filter->OnMouseEvent(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);
   }
   return static_cast<ui::EventResult>(result);
 }
 
 ui::EventResult CompoundEventFilter::FilterTouchEvent(ui::TouchEvent* event) {
   int result = ui::ER_UNHANDLED;
-  if (filters_.might_have_observers()) {
-    ObserverListBase<aura::EventFilter>::Iterator it(filters_);
-    EventFilter* filter;
-    while (!(result & ui::ER_CONSUMED) && (filter = it.GetNext()) != NULL) {
-      result |= filter->OnTouchEvent(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->OnTouchEvent(event);
     }
   }
   return static_cast<ui::EventResult>(result);
@@ -269,11 +269,11 @@ ui::EventResult CompoundEventFilter::OnTouchEvent(ui::TouchEvent* event) {
 
 ui::EventResult CompoundEventFilter::OnGestureEvent(ui::GestureEvent* event) {
   int result = ui::ER_UNHANDLED;
-  if (filters_.might_have_observers()) {
-    ObserverListBase<aura::EventFilter>::Iterator it(filters_);
-    EventFilter* filter;
-    while (!(result & ui::ER_CONSUMED) && (filter = it.GetNext()) != NULL)
-      result |= filter->OnGestureEvent(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->OnGestureEvent(event);
   }
 
   aura::Window* window = static_cast<aura::Window*>(event->target());
diff --git a/ui/views/corewm/compound_event_filter.h b/ui/views/corewm/compound_event_filter.h
index 79679e3..9999569 100644
--- a/ui/views/corewm/compound_event_filter.h
+++ b/ui/views/corewm/compound_event_filter.h
@@ -7,8 +7,8 @@
 
 #include "base/compiler_specific.h"
 #include "base/observer_list.h"
-#include "ui/aura/event_filter.h"
 #include "ui/base/events/event.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/views/views_export.h"
 
@@ -36,7 +36,7 @@ namespace corewm {
 // consumed by any of those filters. If an event is consumed by a filter, the
 // rest of the filter(s) and CompoundEventFilter will not see the consumed
 // event.
-class VIEWS_EXPORT CompoundEventFilter : public aura::EventFilter {
+class VIEWS_EXPORT CompoundEventFilter : public ui::EventHandler {
  public:
   CompoundEventFilter();
   virtual ~CompoundEventFilter();
@@ -51,11 +51,11 @@ class VIEWS_EXPORT CompoundEventFilter : public aura::EventFilter {
   }
 
   // Adds/removes additional event filters. This does not take ownership of
-  // the EventFilter.
-  // NOTE: EventFilters are deprecated. Use env::AddPreTargetEventHandler etc.
+  // the EventHandler.
+  // NOTE: These handlers are deprecated. Use env::AddPreTargetEventHandler etc.
   // instead.
-  void AddFilter(aura::EventFilter* filter);
-  void RemoveFilter(aura::EventFilter* filter);
+  void AddHandler(ui::EventHandler* filter);
+  void RemoveHandler(ui::EventHandler* filter);
 
  private:
   // Updates the cursor if the target provides a custom one, and provides
@@ -84,8 +84,8 @@ class VIEWS_EXPORT CompoundEventFilter : public aura::EventFilter {
   virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE;
   virtual ui::EventResult OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
-  // Additional event filters that pre-handles events.
-  ObserverList<aura::EventFilter, true> filters_;
+  // Additional pre-target event handlers.
+  ObserverList<ui::EventHandler, true> handlers_;
 
   // True if the cursur was hidden by the filter.
   bool cursor_hidden_by_filter_;
diff --git a/ui/views/corewm/compound_event_filter_unittest.cc b/ui/views/corewm/compound_event_filter_unittest.cc
index af5e14b..6c93726 100644
--- a/ui/views/corewm/compound_event_filter_unittest.cc
+++ b/ui/views/corewm/compound_event_filter_unittest.cc
@@ -57,32 +57,30 @@ namespace corewm {
 namespace {
 
 // An event filter that consumes all gesture events.
-class ConsumeGestureEventFilter : public aura::EventFilter {
+class ConsumeGestureEventFilter : public ui::EventHandler {
  public:
   ConsumeGestureEventFilter() {}
   virtual ~ConsumeGestureEventFilter() {}
 
  private:
-  // Overridden from EventFilter.
-  virtual bool PreHandleKeyEvent(aura::Window* target,
-                                 ui::KeyEvent* event) OVERRIDE {
-    return false;
+  // Overridden from ui::EventHandler:
+  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
   }
 
-  virtual bool PreHandleMouseEvent(aura::Window* target,
-                                   ui::MouseEvent* event) OVERRIDE {
-    return false;
+  virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
+  }
+
+  virtual ui::EventResult OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
+    return ui::ER_UNHANDLED;
   }
 
-  virtual ui::EventResult PreHandleTouchEvent(
-      aura::Window* target,
-      ui::TouchEvent* event) OVERRIDE {
+  virtual ui::EventResult OnTouchEvent(ui::TouchEvent* event) OVERRIDE {
     return ui::ER_UNHANDLED;
   }
 
-  virtual ui::EventResult PreHandleGestureEvent(
-      aura::Window* target,
-      ui::GestureEvent* event) OVERRIDE {
+  virtual ui::EventResult OnGestureEvent(ui::GestureEvent* e) OVERRIDE {
     return ui::ER_CONSUMED;
   }
 
@@ -165,8 +163,8 @@ TEST_F(CompoundEventFilterTest, GestureFocusesWindow) {
 // window.
 TEST_F(CompoundEventFilterTest, FilterConsumedGesture) {
   scoped_ptr<CompoundEventFilter> compound_filter(new CompoundEventFilter);
-  scoped_ptr<aura::EventFilter> gesture_filter(new ConsumeGestureEventFilter);
-  compound_filter->AddFilter(gesture_filter.get());
+  scoped_ptr<ui::EventHandler> gesure_handler(new ConsumeGestureEventFilter);
+  compound_filter->AddHandler(gesure_handler.get());
   aura::Env::GetInstance()->AddPreTargetHandler(compound_filter.get());
   aura::test::TestWindowDelegate delegate;
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(&delegate, 1234,
@@ -182,7 +180,7 @@ TEST_F(CompoundEventFilterTest, FilterConsumedGesture) {
   generator.PressTouch();
   EXPECT_FALSE(window->HasFocus());
 
-  compound_filter->RemoveFilter(gesture_filter.get());
+  compound_filter->RemoveHandler(gesure_handler.get());
   aura::Env::GetInstance()->AddPreTargetHandler(compound_filter.get());
 }
 
diff --git a/ui/views/corewm/input_method_event_filter.cc b/ui/views/corewm/input_method_event_filter.cc
index 4e07655..a6ef49b 100644
--- a/ui/views/corewm/input_method_event_filter.cc
+++ b/ui/views/corewm/input_method_event_filter.cc
@@ -37,42 +37,41 @@ void InputMethodEventFilter::SetInputMethodPropertyInRootWindow(
 ////////////////////////////////////////////////////////////////////////////////
 // InputMethodEventFilter, EventFilter implementation:
 
-bool InputMethodEventFilter::PreHandleKeyEvent(aura::Window* target,
-                                               ui::KeyEvent* event) {
+ui::EventResult InputMethodEventFilter::OnKeyEvent(ui::KeyEvent* event) {
   const ui::EventType type = event->type();
   if (type == ui::ET_TRANSLATED_KEY_PRESS ||
       type == ui::ET_TRANSLATED_KEY_RELEASE) {
     // The |event| is already handled by this object, change the type of the
     // event to ui::ET_KEY_* and pass it to the next filter.
     static_cast<ui::TranslatedKeyEvent*>(event)->ConvertToKeyEvent();
-    return false;
+    return ui::ER_UNHANDLED;
   } else {
     // If the focused window is changed, all requests to IME will be
     // discarded so it's safe to update the target_root_window_ here.
+    aura::Window* target = static_cast<aura::Window*>(event->target());
     target_root_window_ = target->GetRootWindow();
     DCHECK(target_root_window_);
     if (event->HasNativeEvent())
       input_method_->DispatchKeyEvent(event->native_event());
     else
       input_method_->DispatchFabricatedKeyEvent(*event);
-    return true;
+    return ui::ER_CONSUMED;
   }
 }
 
-bool InputMethodEventFilter::PreHandleMouseEvent(aura::Window* target,
-                                                 ui::MouseEvent* event) {
-  return false;
+ui::EventResult InputMethodEventFilter::OnMouseEvent(ui::MouseEvent* event) {
+  return ui::ER_UNHANDLED;
+}
+
+ui::EventResult InputMethodEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult InputMethodEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult InputMethodEventFilter::OnTouchEvent(ui::TouchEvent* e) {
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult InputMethodEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult InputMethodEventFilter::OnGestureEvent(ui::GestureEvent* e) {
   return ui::ER_UNHANDLED;
 }
 
diff --git a/ui/views/corewm/input_method_event_filter.h b/ui/views/corewm/input_method_event_filter.h
index 4394782..efcfbd2 100644
--- a/ui/views/corewm/input_method_event_filter.h
+++ b/ui/views/corewm/input_method_event_filter.h
@@ -8,7 +8,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"
 #include "ui/base/ime/input_method_delegate.h"
 #include "ui/views/views_export.h"
 
@@ -26,7 +26,7 @@ namespace corewm {
 // An event filter that forwards a KeyEvent to a system IME, and dispatches a
 // TranslatedKeyEvent to the root window as needed.
 class VIEWS_EXPORT InputMethodEventFilter
-    : public aura::EventFilter,
+    : public ui::EventHandler,
       public ui::internal::InputMethodDelegate {
  public:
   InputMethodEventFilter();
@@ -37,17 +37,12 @@ class VIEWS_EXPORT InputMethodEventFilter
   ui::InputMethod* input_method() const { return input_method_.get(); }
 
  private:
-  // Overridden from 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 ui::internal::InputMethodDelegate.
   virtual void DispatchKeyEventPostIME(const base::NativeEvent& event) OVERRIDE;
diff --git a/ui/views/corewm/input_method_event_filter_unittest.cc b/ui/views/corewm/input_method_event_filter_unittest.cc
index c7e74e7..c4e7b5a 100644
--- a/ui/views/corewm/input_method_event_filter_unittest.cc
+++ b/ui/views/corewm/input_method_event_filter_unittest.cc
@@ -11,8 +11,8 @@
 #include "ui/views/corewm/compound_event_filter.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
+#include "ui/aura/test/test_event_handler.h"
 #include "ui/aura/test/test_activation_client.h"
-#include "ui/aura/test/test_event_filter.h"
 #include "ui/aura/test/test_windows.h"
 
 #if !defined(OS_WIN) && !defined(USE_X11)
@@ -32,16 +32,15 @@ TEST_F(InputMethodEventFilterTest, TestInputMethodProperty) {
   CompoundEventFilter* root_filter = new CompoundEventFilter;
   root_window()->SetEventFilter(root_filter);
 
-  // Add the InputMethodEventFilter before the TestEventFilter.
   InputMethodEventFilter input_method_event_filter;
-  root_filter->AddFilter(&input_method_event_filter);
+  root_filter->AddHandler(&input_method_event_filter);
 
   // Tests if InputMethodEventFilter adds a window property on its
   // construction.
   EXPECT_TRUE(root_window()->GetProperty(
       aura::client::kRootWindowInputMethodKey));
 
-  root_filter->RemoveFilter(&input_method_event_filter);
+  root_filter->RemoveHandler(&input_method_event_filter);
 }
 
 // Tests if InputMethodEventFilter dispatches a ui::ET_TRANSLATED_KEY_* event to
@@ -52,11 +51,11 @@ TEST_F(InputMethodEventFilterTest, TestInputMethodKeyEventPropagation) {
 
   // Add the InputMethodEventFilter before the TestEventFilter.
   InputMethodEventFilter input_method_event_filter;
-  root_filter->AddFilter(&input_method_event_filter);
+  root_filter->AddHandler(&input_method_event_filter);
 
   // Add TestEventFilter to the RootWindow.
-  aura::test::TestEventFilter test_filter;
-  root_filter->AddFilter(&test_filter);
+  aura::test::TestEventHandler test_filter;
+  root_filter->AddHandler(&test_filter);
 
   // We need an active window. Otherwise, the root window will not forward a key
   // event to event filters.
@@ -74,14 +73,14 @@ TEST_F(InputMethodEventFilterTest, TestInputMethodKeyEventPropagation) {
   // ui::ET_TRANSLATED_KEY_* event to the root window, which will be consumed by
   // the test event filter.
   aura::test::EventGenerator generator(root_window());
-  EXPECT_EQ(0, test_filter.key_event_count());
+  EXPECT_EQ(0, test_filter.num_key_events());
   generator.PressKey(ui::VKEY_SPACE, 0);
-  EXPECT_EQ(1, test_filter.key_event_count());
+  EXPECT_EQ(1, test_filter.num_key_events());
   generator.ReleaseKey(ui::VKEY_SPACE, 0);
-  EXPECT_EQ(2, test_filter.key_event_count());
+  EXPECT_EQ(2, test_filter.num_key_events());
 
-  root_filter->RemoveFilter(&input_method_event_filter);
-  root_filter->RemoveFilter(&test_filter);
+  root_filter->RemoveHandler(&input_method_event_filter);
+  root_filter->RemoveHandler(&test_filter);
 
   // Reset window before |test_delegate| gets deleted.
   window.reset();
diff --git a/ui/views/widget/desktop_aura/desktop_root_window_host_linux.cc b/ui/views/widget/desktop_aura/desktop_root_window_host_linux.cc
index 6b6990a..67e42e9 100644
--- a/ui/views/widget/desktop_aura/desktop_root_window_host_linux.cc
+++ b/ui/views/widget/desktop_aura/desktop_root_window_host_linux.cc
@@ -241,13 +241,13 @@ aura::RootWindow* DesktopRootWindowHostLinux::InitRootWindow(
 
   input_method_filter_.reset(new corewm::InputMethodEventFilter);
   input_method_filter_->SetInputMethodPropertyInRootWindow(root_window_);
-  root_window_event_filter_->AddFilter(input_method_filter_.get());
+  root_window_event_filter_->AddHandler(input_method_filter_.get());
 
   // TODO(erg): Unify this code once the other consumer goes away.
   x11_window_event_filter_.reset(
       new X11WindowEventFilter(root_window_, activation_client_.get()));
   x11_window_event_filter_->SetUseHostWindowBorders(false);
-  root_window_event_filter_->AddFilter(x11_window_event_filter_.get());
+  root_window_event_filter_->AddHandler(x11_window_event_filter_.get());
 
   x11_window_move_client_.reset(new X11DesktopWindowMoveClient);
   aura::client::SetWindowMoveClient(root_window_,
@@ -331,8 +331,8 @@ void DesktopRootWindowHostLinux::Close() {
 void DesktopRootWindowHostLinux::CloseNow() {
   // Remove the event listeners we've installed. We need to remove these
   // because otherwise we get assert during ~RootWindow().
-  root_window_event_filter_->RemoveFilter(x11_window_event_filter_.get());
-  root_window_event_filter_->RemoveFilter(input_method_filter_.get());
+  root_window_event_filter_->RemoveHandler(x11_window_event_filter_.get());
+  root_window_event_filter_->RemoveHandler(input_method_filter_.get());
 
   // Actually free our native resources.
   base::MessagePumpAuraX11::Current()->RemoveDispatcherForWindow(xwindow_);
diff --git a/ui/views/widget/desktop_aura/desktop_root_window_host_win.cc b/ui/views/widget/desktop_aura/desktop_root_window_host_win.cc
index 6f808dc..7952ebc 100644
--- a/ui/views/widget/desktop_aura/desktop_root_window_host_win.cc
+++ b/ui/views/widget/desktop_aura/desktop_root_window_host_win.cc
@@ -138,7 +138,7 @@ aura::RootWindow* DesktopRootWindowHostWin::Init(
 
   input_method_filter_.reset(new views::corewm::InputMethodEventFilter);
   input_method_filter_->SetInputMethodPropertyInRootWindow(root_window_);
-  root_window_event_filter_->AddFilter(input_method_filter_.get());
+  root_window_event_filter_->AddHandler(input_method_filter_.get());
 
   focus_manager_->SetFocusedWindow(content_window_, NULL);
   root_window_->SetProperty(kContentWindowForRootWindow, content_window_);
@@ -613,7 +613,7 @@ void DesktopRootWindowHostWin::HandleDestroying() {
 }
 
 void DesktopRootWindowHostWin::HandleDestroyed() {
-  root_window_event_filter_->RemoveFilter(input_method_filter_.get());
+  root_window_event_filter_->RemoveHandler(input_method_filter_.get());
   desktop_native_widget_aura_->OnHostClosed();
 }
 
diff --git a/ui/views/widget/desktop_aura/desktop_stacking_client.cc b/ui/views/widget/desktop_aura/desktop_stacking_client.cc
index 0893564..b1c62ed 100644
--- a/ui/views/widget/desktop_aura/desktop_stacking_client.cc
+++ b/ui/views/widget/desktop_aura/desktop_stacking_client.cc
@@ -22,7 +22,7 @@ DesktopStackingClient::DesktopStackingClient()
 
 DesktopStackingClient::~DesktopStackingClient() {
   if (window_event_filter_)
-    window_event_filter_->RemoveFilter(input_method_filter_.get());
+    window_event_filter_->RemoveHandler(input_method_filter_.get());
 
   aura::client::SetStackingClient(NULL);
 }
@@ -54,7 +54,7 @@ void DesktopStackingClient::CreateNULLParent() {
 
   input_method_filter_.reset(new corewm::InputMethodEventFilter);
   input_method_filter_->SetInputMethodPropertyInRootWindow(null_parent_.get());
-  window_event_filter_->AddFilter(input_method_filter_.get());
+  window_event_filter_->AddHandler(input_method_filter_.get());
 
   capture_client_.reset(
       new aura::client::DefaultCaptureClient(null_parent_.get()));
diff --git a/ui/views/widget/desktop_aura/x11_desktop_window_move_client.h b/ui/views/widget/desktop_aura/x11_desktop_window_move_client.h
index fa4cfac..be8fca9 100644
--- a/ui/views/widget/desktop_aura/x11_desktop_window_move_client.h
+++ b/ui/views/widget/desktop_aura/x11_desktop_window_move_client.h
@@ -14,7 +14,6 @@
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "ui/aura/client/window_move_client.h"
-#include "ui/aura/event_filter.h"
 #include "ui/views/views_export.h"
 #include "ui/gfx/point.h"
 
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 10e6ceb..eb849e1 100644
--- a/ui/views/widget/desktop_aura/x11_window_event_filter.cc
+++ b/ui/views/widget/desktop_aura/x11_window_event_filter.cc
@@ -88,38 +88,38 @@ void X11WindowEventFilter::SetUseHostWindowBorders(bool use_os_border) {
                   sizeof(MotifWmHints)/sizeof(long));
 }
 
-bool X11WindowEventFilter::PreHandleKeyEvent(aura::Window* target,
-                                             ui::KeyEvent* event) {
-  return false;
+ui::EventResult X11WindowEventFilter::OnKeyEvent(ui::KeyEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-bool X11WindowEventFilter::PreHandleMouseEvent(aura::Window* target,
-                                               ui::MouseEvent* event) {
+ui::EventResult X11WindowEventFilter::OnMouseEvent(ui::MouseEvent* event) {
   if (event->type() != ui::ET_MOUSE_PRESSED)
-    return false;
+    return ui::ER_UNHANDLED;
 
   if (!event->IsLeftMouseButton())
-    return false;
+    return ui::ER_UNHANDLED;
 
+  aura::Window* target = static_cast<aura::Window*>(event->target());
   int component =
       target->delegate()->GetNonClientComponent(event->location());
   if (component == HTCLIENT)
-    return false;
+    return ui::ER_UNHANDLED;
 
   // Get the |x_root_window_| location out of the native event.
   gfx::Point root_location = event->system_location();
-  return DispatchHostWindowDragMovement(component, root_location);
+  return DispatchHostWindowDragMovement(component, root_location) ?
+      ui::ER_CONSUMED : ui::ER_UNHANDLED;
+}
+
+ui::EventResult X11WindowEventFilter::OnScrollEvent(ui::ScrollEvent* event) {
+  return ui::ER_UNHANDLED;
 }
 
-ui::EventResult X11WindowEventFilter::PreHandleTouchEvent(
-    aura::Window* target,
-    ui::TouchEvent* event) {
+ui::EventResult X11WindowEventFilter::OnTouchEvent(ui::TouchEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
-ui::EventResult X11WindowEventFilter::PreHandleGestureEvent(
-    aura::Window* target,
-    ui::GestureEvent* event) {
+ui::EventResult X11WindowEventFilter::OnGestureEvent(ui::GestureEvent* event) {
   return ui::ER_UNHANDLED;
 }
 
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 27d8624..97d6be2 100644
--- a/ui/views/widget/desktop_aura/x11_window_event_filter.h
+++ b/ui/views/widget/desktop_aura/x11_window_event_filter.h
@@ -11,7 +11,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
-#include "ui/aura/event_filter.h"
+#include "ui/base/events/event_handler.h"
 #include "ui/base/x/x11_atom_cache.h"
 #include "ui/views/views_export.h"
 
@@ -29,7 +29,7 @@ class DesktopActivationClient;
 class NativeWidgetAura;
 
 // An EventFilter that sets properties on X11 windows.
-class VIEWS_EXPORT X11WindowEventFilter : public aura::EventFilter {
+class VIEWS_EXPORT X11WindowEventFilter : public ui::EventHandler {
  public:
   explicit X11WindowEventFilter(aura::RootWindow* root_window,
                                 DesktopActivationClient* activation_client);
@@ -38,17 +38,12 @@ class VIEWS_EXPORT X11WindowEventFilter : public aura::EventFilter {
   // Changes whether borders are shown on this |root_window|.
   void SetUseHostWindowBorders(bool use_os_border);
 
-  // Overridden from 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:
   // Dispatches a _NET_WM_MOVERESIZE message to the window manager to tell it