Fix a bunch of mojo_public_*_unittests with the new EDK.

mojo/message_pump/message_pump_mojo_unittest.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 "mojo/message_pump/message_pump_mojo.h"
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop_test.h"
 #include "base/run_loop.h"
 #include "mojo/message_pump/message_pump_mojo_handler.h"
@@ skipping 51 matching lines @@
   CountingMojoHandler handler;
   MessagePipe handles;
   MessagePumpMojo::current()->AddHandler(&handler,
                                          handles.handle0.get(),
                                          MOJO_HANDLE_SIGNAL_READABLE,
                                          base::TimeTicks());
   WriteMessageRaw(
       handles.handle1.get(), NULL, 0, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
   WriteMessageRaw(
       handles.handle1.get(), NULL, 0, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
+  MojoHandleSignalsState hss;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWait(handles.handle0.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                      MOJO_DEADLINE_INDEFINITE, &hss));
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();

[yzshen1, 2016/01/04 18:54:25]

Even when we wait till the handle is readable, it doesn't guarantee that the
second message (line 70) is available when RunUntilIdle() is called, right?
Theoretically the run loop can become idle again before the second message
arrives at the loop.

That makes me think that RunUntilIdle() is not very useful anymore, because
writing messages to the pipe doesn't make it "not idle" immediately nor
guarantee that it will stay "non idle" until all messages are consumed. (I don't
think this is the new EDK's fault, though.) Do you have good idea to fix this?
Or maybe we should avoid using this method?

Thanks!

[jam, 2016/01/04 21:00:06]

good point. I've switched these tests to use callbacks as well.

   EXPECT_EQ(2, handler.success_count());
 }
 
 TEST(MessagePumpMojo, Observer) {
   base::MessageLoop message_loop(MessagePumpMojo::Create());
 
   CountingObserver observer;
   MessagePumpMojo::current()->AddObserver(&observer);
 
   CountingMojoHandler handler;
   MessagePipe handles;
   MessagePumpMojo::current()->AddHandler(&handler,
                                          handles.handle0.get(),
                                          MOJO_HANDLE_SIGNAL_READABLE,
                                          base::TimeTicks());
   WriteMessageRaw(
       handles.handle1.get(), NULL, 0, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
+
+  MojoHandleSignalsState hss;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWait(handles.handle0.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                      MOJO_DEADLINE_INDEFINITE, &hss));
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
   EXPECT_EQ(1, handler.success_count());
   EXPECT_EQ(1, observer.will_signal_handler_count);
   EXPECT_EQ(1, observer.did_signal_handler_count);
   MessagePumpMojo::current()->RemoveObserver(&observer);
 
   WriteMessageRaw(
       handles.handle1.get(), NULL, 0, NULL, 0, MOJO_WRITE_MESSAGE_FLAG_NONE);
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWait(handles.handle0.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                      MOJO_DEADLINE_INDEFINITE, &hss));
   base::RunLoop run_loop2;
   run_loop2.RunUntilIdle();
   EXPECT_EQ(2, handler.success_count());
   EXPECT_EQ(1, observer.will_signal_handler_count);
   EXPECT_EQ(1, observer.did_signal_handler_count);
 }
 
 TEST(MessagePumpMojo, UnregisterAfterDeadline) {
   base::MessageLoop message_loop(MessagePumpMojo::Create());
   CountingMojoHandler handler;
   MessagePipe handles;
   MessagePumpMojo::current()->AddHandler(
       &handler,
       handles.handle0.get(),
       MOJO_HANDLE_SIGNAL_READABLE,
       base::TimeTicks::Now() - base::TimeDelta::FromSeconds(1));
   for (int i = 0; i < 2; ++i) {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
   EXPECT_EQ(1, handler.error_count());
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo