Add embedder::AsyncWait()

mojo/edk/embedder/embedder_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 "mojo/edk/embedder/embedder.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_io_thread.h"
+#include "base/test/test_timeouts.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/test_embedder.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/test/multiprocess_test_helper.h"
 #include "mojo/public/c/system/core.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace embedder {
 namespace {
@@ skipping 127 matching lines @@
     // the server and client channels were completely created).
     server_channel.WaitForChannelCreationCompletion();
     client_channel.WaitForChannelCreationCompletion();
     EXPECT_TRUE(server_channel.channel_info());
     EXPECT_TRUE(client_channel.channel_info());
   }
 
   EXPECT_TRUE(test::Shutdown());
 }
 
+class TestAsyncWaiter {
+ public:
+  TestAsyncWaiter() : event_(true, false), wait_result_(MOJO_RESULT_UNKNOWN) {}
+
+  void Awake(MojoResult result) {
+    base::AutoLock l(result_lock_);
+    wait_result_ = result;
+    event_.Signal();
+  }
+
+  bool TryWait() { return event_.TimedWait(TestTimeouts::action_timeout()); }
+
+  MojoResult wait_result() const {
+    base::AutoLock l(result_lock_);
+    return wait_result_;
+  }
+
+ private:
+  base::WaitableEvent event_;
+
+  mutable base::Lock result_lock_;
+  MojoResult wait_result_;

[viettrungluu, 2014/12/12 21:39:30]

You should probably call this just "result_", or the lock "wait_result_lock_".

[gmorrita, 2014/12/12 22:56:27]

Done.

+
+  DISALLOW_COPY_AND_ASSIGN(TestAsyncWaiter);
+};
+
+void ReadAndIgnore(MojoHandle pipe) {

[viettrungluu, 2014/12/12 21:39:30]

Since you only use this function once (and not as a posted task), maybe you
don't need a function at all.

(Also, it occurs to me that we should just use the C++ wrappers throughout this
file, since I let that ship sail a long time ago.[*])

[*] The embedder API actually uses the C++ wrappers. (I'm not entirely sure this
is a good thing.)

[viettrungluu, 2014/12/12 21:40:22]

I'm not implying that you need to do that here, BTW.

[gmorrita, 2014/12/12 22:56:27]

Did this for readability but apparently not worth it :-/
Inlined.
I was wondering this as well. Let me go the C++ way. 

+  char buffer[1000] = {};

[viettrungluu, 2014/12/12 21:39:30]

Since you're not actually going to look at |buffer| afterwards, there's no piont
in initializing it.

[gmorrita, 2014/12/12 22:56:27]

Done.

+  uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
+  CHECK_EQ(MOJO_RESULT_OK,
+           MojoReadMessage(pipe, buffer, &num_bytes, nullptr, nullptr,
+                           MOJO_READ_MESSAGE_FLAG_NONE));
+}
+
+void WriteHello(MojoHandle pipe) {
+  const char kHello[] = "hello";

[viettrungluu, 2014/12/12 21:39:30]

nit: static const char

[gmorrita, 2014/12/12 22:56:27]

Done.

+  CHECK_EQ(MOJO_RESULT_OK,
+           MojoWriteMessage(pipe, kHello, static_cast<uint32_t>(sizeof(kHello)),
+                            nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
+}
+
+void CloseScopedHandle(ScopedMessagePipeHandle handle) {
+  // Do nothing and the destructor will close it.
+}
+
+TEST_F(EmbedderTest, AsyncWait) {
+  mojo::embedder::test::InitWithSimplePlatformSupport();
+
+  {
+    ScopedMessagePipeHandle client_mp;
+    ScopedMessagePipeHandle server_mp;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              mojo::CreateMessagePipe(nullptr, &client_mp, &server_mp));
+
+    TestAsyncWaiter waiter;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                        base::Bind(&TestAsyncWaiter::Awake,
+                                   base::Unretained(&waiter))));
+
+    test_io_thread()->task_runner()->PostTask(
+        FROM_HERE, base::Bind(&WriteHello, server_mp.get().value()));
+    EXPECT_TRUE(waiter.TryWait());
+    EXPECT_EQ(MOJO_RESULT_OK, waiter.wait_result());
+
+    // If message is in the queue, it does't allow us to wait.
+    TestAsyncWaiter waiter_that_doesnt_wait;
+    EXPECT_EQ(
+        MOJO_RESULT_ALREADY_EXISTS,
+        AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                  base::Bind(&TestAsyncWaiter::Awake,
+                             base::Unretained(&waiter_that_doesnt_wait))));
+
+    ReadAndIgnore(client_mp.get().value());
+
+    TestAsyncWaiter unsatisfiable_waiter;
+    EXPECT_EQ(MOJO_RESULT_OK,
+              AsyncWait(client_mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE,
+                        base::Bind(&TestAsyncWaiter::Awake,
+                                   base::Unretained(&unsatisfiable_waiter))));
+
+    test_io_thread()->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&CloseScopedHandle, base::Passed(server_mp.Pass())));
+
+    EXPECT_TRUE(unsatisfiable_waiter.TryWait());
+    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+              unsatisfiable_waiter.wait_result());
+  }
+
+  EXPECT_TRUE(test::Shutdown());
+}
+
 TEST_F(EmbedderTest, ChannelsHandlePassing) {
   mojo::embedder::test::InitWithSimplePlatformSupport();
 
   {
     PlatformChannelPair channel_pair;
     ScopedTestChannel server_channel(test_io_thread()->task_runner(),
                                      channel_pair.PassServerHandle());
     MojoHandle server_mp = server_channel.bootstrap_message_pipe();
     EXPECT_NE(server_mp, MOJO_HANDLE_INVALID);
     ScopedTestChannel client_channel(test_io_thread()->task_runner(),
@@ skipping 372 matching lines @@
 
   EXPECT_TRUE(test::Shutdown());
 }
 
 // TODO(vtl): Test immediate write & close.
 // TODO(vtl): Test broken-connection cases.
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo