events: Start changing EventHandler interface to not return a value.

ui/base/events/event_dispatcher_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/base/events/event_dispatcher.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace ui {
 
@@ skipping 184 matching lines @@
   parent.AddPostTargetHandler(&h8);
 
   h5.set_expect_post_target(true);
   h6.set_expect_post_target(true);
   h7.set_expect_post_target(true);
   h8.set_expect_post_target(true);
 
   MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
       gfx::Point(3, 4), 0);
   Event::DispatcherApi event_mod(&mouse);
-  int result = dispatcher.ProcessEvent(&child, &mouse);
-  EXPECT_FALSE(result & ER_CONSUMED);
-  EXPECT_FALSE(result & ER_HANDLED);
+  dispatcher.ProcessEvent(&child, &mouse);
+  EXPECT_FALSE(mouse.stopped_propagation());
+  EXPECT_FALSE(mouse.handled());
 
   int expected[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
   EXPECT_EQ(
       std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)),
       child.handler_list());
 
   child.Reset();
   event_mod.set_phase(EP_PREDISPATCH);
   event_mod.set_result(ER_UNHANDLED);
 
   h1.set_event_result(ER_HANDLED);
-  result = dispatcher.ProcessEvent(&child, &mouse);
-  EXPECT_EQ(result, mouse.result());
+  dispatcher.ProcessEvent(&child, &mouse);
   EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
-  EXPECT_FALSE(result & ER_CONSUMED);
-  EXPECT_TRUE(result & ER_HANDLED);
+  EXPECT_FALSE(mouse.stopped_propagation());
+  EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(
       std::vector<int>(expected, expected + sizeof(expected) / sizeof(int)),
       child.handler_list());
 
   child.Reset();
   event_mod.set_phase(EP_PREDISPATCH);
   event_mod.set_result(ER_UNHANDLED);
 
   int nexpected[] = { 1, 2, 3, 4, 5 };
   h5.set_event_result(ER_CONSUMED);
-  result = dispatcher.ProcessEvent(&child, &mouse);
-  EXPECT_EQ(result, mouse.result());
+  dispatcher.ProcessEvent(&child, &mouse);
   EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
-  EXPECT_TRUE(result & ER_CONSUMED);
-  EXPECT_TRUE(result & ER_HANDLED);
+  EXPECT_TRUE(mouse.stopped_propagation());
+  EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(
       std::vector<int>(nexpected, nexpected + sizeof(nexpected) / sizeof(int)),
       child.handler_list());
 
   child.Reset();
   event_mod.set_phase(EP_PREDISPATCH);
   event_mod.set_result(ER_UNHANDLED);
 
   int exp[] = { 1 };
   h1.set_event_result(ER_CONSUMED);
-  result = dispatcher.ProcessEvent(&child, &mouse);
+  dispatcher.ProcessEvent(&child, &mouse);
   EXPECT_EQ(EP_POSTDISPATCH, mouse.phase());
-  EXPECT_EQ(result, mouse.result());
-  EXPECT_TRUE(result & ER_CONSUMED);
-  EXPECT_FALSE(result & ER_HANDLED);
+  EXPECT_TRUE(mouse.stopped_propagation());
+  EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(
       std::vector<int>(exp, exp + sizeof(exp) / sizeof(int)),
       child.handler_list());
 }
 
 // Tests that the event-phases are correct.
 TEST(EventDispatcherTest, EventDispatchPhase) {
   TestEventDispatcher dispatcher;
   TestTarget target;
 
   TestEventHandler handler(11);
 
   target.AddPreTargetHandler(&handler);
   target.AddPostTargetHandler(&handler);
   handler.set_expect_pre_target(true);
   handler.set_expect_post_target(true);
 
   MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
       gfx::Point(3, 4), 0);
   Event::DispatcherApi event_mod(&mouse);
-  int result = dispatcher.ProcessEvent(&target, &mouse);
-  EXPECT_EQ(ER_UNHANDLED, result);
+  dispatcher.ProcessEvent(&target, &mouse);
+  EXPECT_EQ(ER_UNHANDLED, mouse.result());
 
   int handlers[] = { 11, 11 };
   EXPECT_EQ(
       std::vector<int>(handlers, handlers + sizeof(handlers) / sizeof(int)),
       target.handler_list());
 }
 
 // Tests that if the dispatcher is destroyed in the middle of pre or post-target
 // dispatching events, it doesn't cause a crash.
 TEST(EventDispatcherTest, EventDispatcherDestroyTarget) {
@@ skipping 10 matching lines @@
 
     h1.set_expect_pre_target(true);
     handler.set_expect_pre_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_pre_target(false);
 
     MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
         gfx::Point(3, 4), 0);
     Event::DispatcherApi event_mod(&mouse);
-    int result = dispatcher->ProcessEvent(&target, &mouse);
-    EXPECT_EQ(ER_CONSUMED, result);
+    dispatcher->ProcessEvent(&target, &mouse);
+    EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 
   // Now test for post-target.
   {
     TestEventDispatcher* dispatcher = new TestEventDispatcher();
     TestTarget target;
     EventHandlerDestroyDispatcher handler(dispatcher, 5);
     TestEventHandler h1(1), h2(2);
 
     target.AddPostTargetHandler(&h1);
     target.AddPostTargetHandler(&handler);
     target.AddPostTargetHandler(&h2);
 
     h1.set_expect_post_target(true);
     handler.set_expect_post_target(true);
     // |h2| should not receive any events at all since |handler| will have
     // destroyed the dispatcher.
     h2.set_expect_post_target(false);
 
     MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4),
         gfx::Point(3, 4), 0);
     Event::DispatcherApi event_mod(&mouse);
-    int result = dispatcher->ProcessEvent(&target, &mouse);
-    EXPECT_EQ(ER_CONSUMED, result);
+    dispatcher->ProcessEvent(&target, &mouse);
+    EXPECT_EQ(ER_CONSUMED, mouse.result());
     EXPECT_EQ(2U, target.handler_list().size());
     EXPECT_EQ(1, target.handler_list()[0]);
     EXPECT_EQ(5, target.handler_list()[1]);
   }
 }
 
 // Tests that a target becoming invalid in the middle of pre- or post-target
 // event processing aborts processing.
 TEST(EventDispatcherTest, EventDispatcherInvalidateTarget) {
   TestEventDispatcher dispatcher;
   TestTarget target;
   TestEventHandler h1(1);
   InvalidateTargetEventHandler invalidate_handler(2);
   TestEventHandler h3(3);
 
   target.AddPreTargetHandler(&h1);
   target.AddPreTargetHandler(&invalidate_handler);
   target.AddPreTargetHandler(&h3);
 
   h1.set_expect_pre_target(true);
   invalidate_handler.set_expect_pre_target(true);
   // |h3| should not receive events as the target will be invalidated.
   h3.set_expect_pre_target(false);
 
   MouseEvent mouse(ui::ET_MOUSE_MOVED, gfx::Point(3, 4), gfx::Point(3, 4), 0);
-  int result = dispatcher.ProcessEvent(&target, &mouse);
+  dispatcher.ProcessEvent(&target, &mouse);
   EXPECT_FALSE(target.valid());
-  EXPECT_EQ(ER_CONSUMED, result);
+  EXPECT_TRUE(mouse.stopped_propagation());
   EXPECT_EQ(2U, target.handler_list().size());
   EXPECT_EQ(1, target.handler_list()[0]);
   EXPECT_EQ(2, target.handler_list()[1]);
 }
 
 }  // namespace ui