PlatformEventDispatcher::DispatchEvent() should return a PostDispatchAction

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 69 matching lines @@
       : id_(id),
         list_(list),
         post_dispatch_action_(POST_DISPATCH_NONE),
         stop_stream_(false) {
     PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
   }
   virtual ~TestPlatformEventDispatcher() {
     PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
   }
 
-  void set_post_dispatch_action(uint32_t action) {
+  void set_post_dispatch_action(ui::PostDispatchAction action) {
     post_dispatch_action_ = action;
   }
 
  protected:
   // PlatformEventDispatcher:
   virtual bool CanDispatchEvent(const PlatformEvent& event) override {
     return true;
   }
 
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  virtual ui::PostDispatchAction DispatchEvent(
+      const PlatformEvent& event) override {
     list_->push_back(id_);
     return post_dispatch_action_;
   }
 
  private:
   int id_;
   std::vector<int>* list_;
-  uint32_t post_dispatch_action_;
+  ui::PostDispatchAction post_dispatch_action_;
   bool stop_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPlatformEventDispatcher);
 };
 
 class TestPlatformEventObserver : public PlatformEventObserver {
  public:
   TestPlatformEventObserver(int id, std::vector<int>* list)
       : id_(id), list_(list) {
     PlatformEventSource::GetInstance()->AddPlatformEventObserver(this);
@@ skipping 216 matching lines @@
   RunCallbackDuringDispatch(int id, std::vector<int>* list)
       : TestPlatformEventDispatcher(id, list) {}
   virtual ~RunCallbackDuringDispatch() {}
 
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  protected:
   // PlatformEventDispatcher:
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  virtual ui::PostDispatchAction DispatchEvent(
+      const PlatformEvent& event) override {
     if (!callback_.is_null())
       callback_.Run();
     return TestPlatformEventDispatcher::DispatchEvent(event);
   }
 
  private:
   base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(RunCallbackDuringDispatch);
 };
@@ skipping 222 matching lines @@
   void set_callback(const base::Closure& callback) {
     callback_ = callback;
   }
 
  private:
   // PlatformEventDispatcher:
   virtual bool CanDispatchEvent(const PlatformEvent& event) override {
     return true;
   }
 
-  virtual uint32_t DispatchEvent(const PlatformEvent& event) override {
+  virtual ui::PostDispatchAction DispatchEvent(
+      const PlatformEvent& event) override {
     handler_.reset();
-    uint32_t action = TestPlatformEventDispatcher::DispatchEvent(event);
+    ui::PostDispatchAction action =
+        TestPlatformEventDispatcher::DispatchEvent(event);
     if (!callback_.is_null()) {
       callback_.Run();
       callback_ = base::Closure();
     }
     return action;
   }
 
   scoped_ptr<ScopedEventDispatcher> handler_;
   base::Closure callback_;
 
@@ skipping 177 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