Explicitly coerce PostDispatchAction to uint32_t in DispatchEvent()

ui/events/platform/platform_event_source_unittest.cc

 // Copyright 2014 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/events/platform/platform_event_source.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 61 matching lines @@
  private:
   bool stop_stream_;
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventSource);
 };
 
 class TestPlatformEventDispatcher : public PlatformEventDispatcher {
  public:
   TestPlatformEventDispatcher(int id, std::vector<int>* list)
       : id_(id),
         list_(list),
-        post_dispatch_action_(POST_DISPATCH_NONE),
+        post_dispatch_action_(kPostDispatchNone),
         stop_stream_(false) {
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
   virtual ~TestPlatformEventDispatcher() {
     PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   }
 
   void set_post_dispatch_action(uint32_t action) {
     post_dispatch_action_ = action;
   }
@@ skipping 106 matching lines @@
   TestPlatformEventDispatcher first(12, &list_dispatcher);
   TestPlatformEventDispatcher second(23, &list_dispatcher);
 
   scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
   source()->Dispatch(*event);
   ASSERT_EQ(2u, list_dispatcher.size());
   EXPECT_EQ(12, list_dispatcher[0]);
   EXPECT_EQ(23, list_dispatcher[1]);
   list_dispatcher.clear();
 
-  first.set_post_dispatch_action(POST_DISPATCH_STOP_PROPAGATION);
+  first.set_post_dispatch_action(kPostDispatchStopPropagation);
   event = CreatePlatformEvent();
   source()->Dispatch(*event);
   ASSERT_EQ(1u, list_dispatcher.size());
   EXPECT_EQ(12, list_dispatcher[0]);
 }
 
 // Tests that observers receive events.
 TEST_F(PlatformEventTest, ObserverBasic) {
   std::vector<int> list_observer;
   scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
@@ skipping 69 matching lines @@
 // Tests that an overridden dispatcher can request that the default dispatchers
 // can dispatch the events.
 TEST_F(PlatformEventTest, OverriddenDispatcherInvokeDefaultDispatcher) {
   std::vector<int> list;
   TestPlatformEventDispatcher dispatcher(10, &list);
   TestPlatformEventObserver observer(15, &list);
   TestPlatformEventDispatcher overriding_dispatcher(20, &list);
   source()->RemovePlatformEventDispatcher(&overriding_dispatcher);
   scoped_ptr<ScopedEventDispatcher> handle =
       source()->OverrideDispatcher(&overriding_dispatcher);
-  overriding_dispatcher.set_post_dispatch_action(POST_DISPATCH_PERFORM_DEFAULT);
+  overriding_dispatcher.set_post_dispatch_action(kPostDispatchPerformDefault);
 
   scoped_ptr<PlatformEvent> event(CreatePlatformEvent());
   source()->Dispatch(*event);
   // First the observer, then the overriding dispatcher, then the default
   // dispatcher.
   ASSERT_EQ(3u, list.size());
   EXPECT_EQ(15, list[0]);
   EXPECT_EQ(20, list[1]);
   EXPECT_EQ(10, list[2]);
   list.clear();
 
   // Install a second overriding dispatcher.
   TestPlatformEventDispatcher second_overriding(50, &list);
   source()->RemovePlatformEventDispatcher(&second_overriding);
   scoped_ptr<ScopedEventDispatcher> second_override_handle =
       source()->OverrideDispatcher(&second_overriding);
   source()->Dispatch(*event);
   ASSERT_EQ(2u, list.size());
   EXPECT_EQ(15, list[0]);
   EXPECT_EQ(50, list[1]);
   list.clear();
 
-  second_overriding.set_post_dispatch_action(POST_DISPATCH_PERFORM_DEFAULT);
+  second_overriding.set_post_dispatch_action(kPostDispatchPerformDefault);
   source()->Dispatch(*event);
   // First the observer, then the second overriding dispatcher, then the default
   // dispatcher.
   ASSERT_EQ(3u, list.size());
   EXPECT_EQ(15, list[0]);
   EXPECT_EQ(50, list[1]);
   EXPECT_EQ(10, list[2]);
 }
 
 // Runs a callback during an event dispatch.
@@ skipping 379 matching lines @@
     scoped_ptr<ScopedEventDispatcher> second_override_handle =
         source()->OverrideDispatcher(&second_overriding);
 
     source()->Dispatch(*event);
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
     EXPECT_EQ(70, (*list)[1]);
     list->clear();
 
     second_overriding.SetScopedHandle(second_override_handle.Pass());
-    second_overriding.set_post_dispatch_action(POST_DISPATCH_NONE);
+    second_overriding.set_post_dispatch_action(kPostDispatchNone);
     base::RunLoop run_loop;
     second_overriding.set_callback(run_loop.QuitClosure());
     base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
     base::MessageLoopForUI::ScopedNestableTaskAllower allow_nested(loop);
     loop->PostTask(
         FROM_HERE,
         base::Bind(base::IgnoreResult(&TestPlatformEventSource::Dispatch),
                    base::Unretained(source()),
                    *event));
     run_loop.Run();
@@ skipping 45 matching lines @@
     ASSERT_EQ(2u, list.size());
     EXPECT_EQ(15, list[0]);
     EXPECT_EQ(10, list[1]);
   }
 };
 
 RUN_TEST_IN_MESSAGE_LOOP(
     ConsecutiveOverriddenDispatcherInTheSameMessageLoopIteration)
 
 }  // namespace ui