events: Remove ability to terminate a nested message-loop from the event-source.

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 27 matching lines @@
 }
 
 void AddDispatcher(PlatformEventDispatcher* dispatcher) {
   PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(dispatcher);
 }
 
 }  // namespace
 
 class TestPlatformEventSource : public PlatformEventSource {
  public:
-  TestPlatformEventSource() {}
+  TestPlatformEventSource()
+      : stop_stream_(false) {
+  }
   virtual ~TestPlatformEventSource() {}
 
   uint32_t Dispatch(const PlatformEvent& event) { return DispatchEvent(event); }
 
   // Dispatches the stream of events, and returns the number of events that are
   // dispatched before it is requested to stop.
   size_t DispatchEventStream(const ScopedVector<PlatformEvent>& events) {
+    stop_stream_ = false;
     for (size_t count = 0; count < events.size(); ++count) {
-      uint32_t action = DispatchEvent(*events[count]);
-      if (action & POST_DISPATCH_QUIT_LOOP)
+      DispatchEvent(*events[count]);
+      if (stop_stream_)
         return count + 1;
     }
     return events.size();
   }
 
+  // PlatformEventSource:
+  virtual void StopCurrentEventStream() OVERRIDE {
+    stop_stream_ = true;
+  }
+
  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) {
+      : 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) {
     post_dispatch_action_ = action;
   }
 
  protected:
   // PlatformEventDispatcher:
   virtual bool CanDispatchEvent(const PlatformEvent& event) OVERRIDE {
     return true;
   }
 
   virtual uint32_t 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_;
+  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 448 matching lines @@
 class DestroyScopedHandleDispatcher : public TestPlatformEventDispatcher {
  public:
   DestroyScopedHandleDispatcher(int id, std::vector<int>* list)
       : TestPlatformEventDispatcher(id, list) {}
   virtual ~DestroyScopedHandleDispatcher() {}
 
   void SetScopedHandle(scoped_ptr<ScopedEventDispatcher> handler) {
     handler_ = handler.Pass();
   }
 
+  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 {
     handler_.reset();
-    return TestPlatformEventDispatcher::DispatchEvent(event);
+    uint32_t action = TestPlatformEventDispatcher::DispatchEvent(event);
+    if (!callback_.is_null()) {
+      callback_.Run();
+      callback_ = base::Closure();
+    }
+    return action;
   }
 
   scoped_ptr<ScopedEventDispatcher> handler_;
+  base::Closure callback_;
 
   DISALLOW_COPY_AND_ASSIGN(DestroyScopedHandleDispatcher);
 };
 
 // Tests that resetting an overridden dispatcher causes the nested message-loop
 // iteration to stop and the rest of the events are dispatched in the next
 // iteration.
 class DestroyedNestedOverriddenDispatcherQuitsNestedLoopIteration
     : public PlatformEventTestWithMessageLoop {
  public:
@@ skipping 102 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_QUIT_LOOP);
+    second_overriding.set_post_dispatch_action(POST_DISPATCH_NONE);
     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();
     ASSERT_EQ(2u, list->size());
     EXPECT_EQ(15, (*list)[0]);
@@ skipping 43 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