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

ui/aura/root_window_unittest.cc

 // 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/root_window.h"
 
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/event_client.h"
@@ skipping 63 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(NonClientDelegate);
 };
 
 // A simple event handler that consumes key events.
 class ConsumeKeyHandler : public test::TestEventHandler {
  public:
   ConsumeKeyHandler() {}
   virtual ~ConsumeKeyHandler() {}
 
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     test::TestEventHandler::OnKeyEvent(event);
-    return ui::ER_CONSUMED;
+    event->StopPropagation();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConsumeKeyHandler);
 };
 
 Window* CreateWindow(int id, Window* parent, WindowDelegate* delegate) {
   Window* window = new Window(
       delegate ? delegate :
       test::TestWindowDelegate::CreateSelfDestroyingDelegate());
@@ skipping 337 matching lines @@
 // FilterFilter that tracks the types of events it's seen.
 class EventFilterRecorder : public ui::EventHandler {
  public:
   typedef std::vector<ui::EventType> Events;
 
   EventFilterRecorder() {}
 
   Events& events() { return events_; }
 
   // ui::EventHandler overrides:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     events_.push_back(event->type());
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     events_.push_back(event->type());
     return ui::ER_UNHANDLED;
   }
 
   virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE {
     events_.push_back(event->type());
   }
@@ skipping 176 matching lines @@
   DeletingEventFilter()
       : delete_during_pre_handle_(false) {}
   virtual ~DeletingEventFilter() {}
 
   void Reset(bool delete_during_pre_handle) {
     delete_during_pre_handle_ = delete_during_pre_handle;
   }
 
  private:
   // Overridden from ui::EventHandler:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
       delete event->target();
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (delete_during_pre_handle_)
       delete event->target();
     return ui::ER_UNHANDLED;
   }
 
   bool delete_during_pre_handle_;
 
@@ skipping 10 matching lines @@
 
   void Reset(Window* window, bool delete_during_handle) {
     window_ = window;
     delete_during_handle_ = delete_during_handle;
     got_event_ = false;
   }
   bool got_event() const { return got_event_; }
 
  private:
   // Overridden from WindowDelegate:
-  virtual ui::EventResult OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
-    return ui::ER_UNHANDLED;
   }
 
   virtual ui::EventResult OnMouseEvent(ui::MouseEvent* event) OVERRIDE {
     if (delete_during_handle_)
       delete window_;
     got_event_ = true;
     return ui::ER_UNHANDLED;
   }
 
   Window* window_;
@@ skipping 76 matching lines @@
 TEST_F(RootWindowTest, GestureRecognizerResetsTargetWhenParentHides) {
   scoped_ptr<Window> w1(CreateWindow(1, root_window(), NULL));
   DetachesParentOnTapDelegate delegate;
   scoped_ptr<Window> parent(CreateWindow(22, w1.get(), NULL));
   Window* child = CreateWindow(11, parent.get(), &delegate);
   test::EventGenerator generator(root_window(), child);
   generator.GestureTapAt(gfx::Point(40, 40));
 }
 
 }  // namespace aura