[mojo-edk] Add explicit message object APIs

mojo/edk/system/wait_set_dispatcher_unittest.cc

 // Copyright 2015 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/system/wait_set_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "mojo/edk/embedder/embedder_internal.h"
 #include "mojo/edk/system/core.h"
+#include "mojo/edk/system/message_for_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/request_context.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace edk {
 namespace {
 
@@ skipping 41 matching lines @@
     pipe_id_generator_++;
 
     dispatchers_to_close_.push_back(*d0);
     dispatchers_to_close_.push_back(*d1);
   }
 
   void CloseOnShutdown(const scoped_refptr<Dispatcher>& dispatcher) {
     dispatchers_to_close_.push_back(dispatcher);
   }
 
+  void WriteMessage(MessagePipeDispatcher* dispatcher,
+                          const void* bytes,
+                          size_t num_bytes) {
+    Core* core = mojo::edk::internal::g_core;
+    void* msg;
+    ASSERT_EQ(MOJO_RESULT_OK,
+              core->CreateMessage(num_bytes, nullptr, 0,
+                                  MOJO_CREATE_MESSAGE_FLAG_NONE, &msg));
+    void* buffer;
+    ASSERT_EQ(MOJO_RESULT_OK, core->GetMessageBuffer(msg, &buffer));
+    memcpy(buffer, bytes, num_bytes);
+
+    std::unique_ptr<MessageForTransit> message(
+        static_cast<MessageForTransit*>(msg));
+    ASSERT_EQ(MOJO_RESULT_OK,
+              dispatcher->WriteMessage(std::move(message),
+                                       MOJO_WRITE_MESSAGE_FLAG_NONE));
+  }
+
+  void ReadMessage(MessagePipeDispatcher* dispatcher,
+                   void* bytes,
+                   uint32_t* num_bytes) {
+    Core* core = mojo::edk::internal::g_core;
+    std::unique_ptr<MessageForTransit> message;
+    ASSERT_EQ(MOJO_RESULT_OK,
+              dispatcher->ReadMessage(&message, num_bytes, nullptr, 0,
+                                      MOJO_READ_MESSAGE_FLAG_NONE, false));
+    void* buffer;
+    ASSERT_EQ(MOJO_RESULT_OK,
+              core->GetMessageBuffer(static_cast<void*>(message.get()),
+                                     &buffer));
+    memcpy(buffer, bytes, *num_bytes);
+  }
+
  protected:
   scoped_refptr<MessagePipeDispatcher> dispatcher0_;
   scoped_refptr<MessagePipeDispatcher> dispatcher1_;
 
  private:
   // We keep an active RequestContext for the duration of each test. It's unused
   // since these tests don't rely on the MojoWatch API.
   const RequestContext request_context_;
 
   static uint64_t pipe_id_generator_;
@@ skipping 46 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             wait_set->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss));
   EXPECT_FALSE(hss.satisfies(MOJO_HANDLE_SIGNAL_READABLE));
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
 
   // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
   char buffer[] = "abcd";
   w.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                       MOJO_WRITE_MESSAGE_FLAG_NONE));
+  WriteMessage(dispatcher1_.get(), buffer, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
   woken_dispatcher = nullptr;
   context = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
   EXPECT_EQ(dispatcher0_, woken_dispatcher);
   EXPECT_EQ(1u, context);
 
   // Again, if a ready dispatcher isn't removed, it will continue to be
   // returned.
@@ skipping 24 matching lines @@
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr));
   scoped_refptr<Dispatcher> woken_dispatcher;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
 
   // The tested behaviour below should be repeatable.
   for (size_t i = 0; i < 3; i++) {
     // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
     char buffer[] = "abcd";
     w.Init();
-    ASSERT_EQ(MOJO_RESULT_OK,
-              dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                         MOJO_WRITE_MESSAGE_FLAG_NONE));
+    WriteMessage(dispatcher1_.get(), buffer, sizeof(buffer));
     EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr));
     woken_dispatcher = nullptr;
     context = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
               GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
     EXPECT_EQ(dispatcher0_, woken_dispatcher);
     EXPECT_EQ(1u, context);
 
     // Read from |dispatcher0_| which should change it's state to non-readable.
     char read_buffer[sizeof(buffer) + 5];
     uint32_t num_bytes = sizeof(read_buffer);
-    ASSERT_EQ(MOJO_RESULT_OK,
-              dispatcher0_->ReadMessage(read_buffer, &num_bytes, nullptr,
-                                        nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
+    ReadMessage(dispatcher0_.get(), read_buffer, &num_bytes);
     EXPECT_EQ(sizeof(buffer), num_bytes);
 
     // No dispatchers are ready.
     w.Init();
     woken_dispatcher = nullptr;
     context = 0;
     EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
               GetOneReadyDispatcher(wait_set, &woken_dispatcher, &context));
     EXPECT_EQ(nullptr, woken_dispatcher);
     EXPECT_EQ(0u, context);
@@ skipping 90 matching lines @@
                                           &dispatchers_vector,
                                           results,
                                           nullptr));
   EXPECT_EQ(2u, count);
   std::sort(dispatchers_vector.begin(), dispatchers_vector.end());
   EXPECT_EQ(expected_dispatchers, dispatchers_vector);
 
   // Write to |dispatcher1_|, which should make |dispatcher0_| readable.
   char buffer[] = "abcd";
   w.Init();
-  ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
-                                       MOJO_WRITE_MESSAGE_FLAG_NONE));
+  WriteMessage(dispatcher1_.get(), buffer, sizeof(buffer));
   {
     Waiter mp_w;
     mp_w.Init();
     // Wait for |dispatcher0_| to be readable.
     if (dispatcher0_->AddAwakable(&mp_w, MOJO_HANDLE_SIGNAL_READABLE, 0,
                                   nullptr) == MOJO_RESULT_OK) {
       EXPECT_EQ(MOJO_RESULT_OK, mp_w.Wait(MOJO_DEADLINE_INDEFINITE, 0));
       dispatcher0_->RemoveAwakable(&mp_w, nullptr);
     }
   }
@@ skipping 132 matching lines @@
   EXPECT_EQ(MOJO_RESULT_OK,
             GetOneReadyDispatcher(wait_set, &woken_dispatcher, nullptr));
   EXPECT_EQ(nested_wait_set, woken_dispatcher);
 
   wait_set->RemoveAwakable(&w, nullptr);
 }
 
 }  // namespace
 }  // namespace edk
 }  // namespace mojo