mus: Fix handled status in UI event ack, add MessageLoop::NestingObserver

base/message_loop/message_loop_test.cc

 // Copyright 2013 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 "base/message_loop/message_loop_test.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 360 matching lines @@
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
 
   int depth = 100;
   MessageLoop::current()->PostTask(FROM_HERE,
                                    Bind(&NestingFunc, &depth));
   MessageLoop::current()->Run();
   EXPECT_EQ(depth, 0);
 }
 
+// A NestingObserver that tracks the number of nested message loop starts it
+// has seen.
+class TestNestingObserver : public MessageLoop::NestingObserver {
+ public:
+  TestNestingObserver() {}
+  ~TestNestingObserver() override {}
+
+  int begin_nested_loop_count() const { return begin_nested_loop_count_; }
+
+  // MessageLoop::NestingObserver:
+  void OnBeginNestedMessageLoop() override { begin_nested_loop_count_++; }
+
+ private:
+  int begin_nested_loop_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(TestNestingObserver);
+};
+
+void ExpectOneBeginNestedLoop(TestNestingObserver* observer) {
+  EXPECT_EQ(1, observer->begin_nested_loop_count());
+}
+
+// Starts a nested message loop.
+void RunNestedLoop(TestNestingObserver* observer,
+                   const Closure& quit_outer_loop) {
+  // The nested loop hasn't started yet.
+  EXPECT_EQ(0, observer->begin_nested_loop_count());
+
+  MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current());
+  RunLoop nested_loop;
+  // Verify that by the time the first task is run the observer has seen the
+  // message loop begin.
+  MessageLoop::current()->PostTask(FROM_HERE,
+                                   Bind(&ExpectOneBeginNestedLoop, observer));
+  MessageLoop::current()->PostTask(FROM_HERE, nested_loop.QuitClosure());
+  nested_loop.Run();
+
+  // Quitting message loops doesn't change the begin count.
+  EXPECT_EQ(1, observer->begin_nested_loop_count());
+
+  quit_outer_loop.Run();
+}
+
+// Tests that a NestingObserver is notified when a nested message loop begins.
+void RunTest_NestingObserver(MessagePumpFactory factory) {
+  std::unique_ptr<MessagePump> pump(factory());
+  MessageLoop outer_loop(std::move(pump));
+
+  // Observe the outer loop for nested message loops beginning.
+  TestNestingObserver nesting_observer;
+  outer_loop.AddNestingObserver(&nesting_observer);
+
+  // Post a task that runs a nested message loop.
+  outer_loop.PostTask(FROM_HERE, Bind(&RunNestedLoop, &nesting_observer,
+                                      outer_loop.QuitWhenIdleClosure()));
+  outer_loop.Run();
+
+  outer_loop.RemoveNestingObserver(&nesting_observer);
+}
+
 enum TaskType {
   MESSAGEBOX,
   ENDDIALOG,
   RECURSIVE,
   TIMEDMESSAGELOOP,
   QUITMESSAGELOOP,
   ORDERED,
   PUMPS,
   SLEEP,
   RUNS,
@@ skipping 620 matching lines @@
 void RunTest_RecursivePosts(MessagePumpFactory factory) {
   const int kNumTimes = 1 << 17;
   std::unique_ptr<MessagePump> pump(factory());
   MessageLoop loop(std::move(pump));
   loop.PostTask(FROM_HERE, Bind(&PostNTasksThenQuit, kNumTimes));
   loop.Run();
 }
 
 }  // namespace test
 }  // namespace base