[mojo] Ports EDK

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_pipe_dispatcher.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace edk {
 namespace {
 
@@ skipping 23 matching lines @@
     if (result == MOJO_RESULT_OK) {
       CHECK_EQ(1u, dispatchers.size());
       *ready_dispatcher = dispatchers[0];
       return dispatcher_result;
     }
     return result;
   }
 
   void CreateMessagePipe(scoped_refptr<MessagePipeDispatcher>* d0,
                          scoped_refptr<MessagePipeDispatcher>* d1) {
-    *d0 = MessagePipeDispatcher::Create(
-        MessagePipeDispatcher::kDefaultCreateOptions);
-    *d1 = MessagePipeDispatcher::Create(
-        MessagePipeDispatcher::kDefaultCreateOptions);
-    (*d0)->InitNonTransferable(pipe_id_generator_);
-    (*d1)->InitNonTransferable(pipe_id_generator_);
+    MojoHandle h0, h1;
+    EXPECT_EQ(MOJO_RESULT_OK, MojoCreateMessagePipe(nullptr, &h0, &h1));
+
+    Core* core = mojo::edk::internal::GetCore();
+    *d0 = scoped_refptr<MessagePipeDispatcher>(
+        static_cast<MessagePipeDispatcher*>(core->GetDispatcher(h0).get()));
+    *d1 = scoped_refptr<MessagePipeDispatcher>(
+        static_cast<MessagePipeDispatcher*>(core->GetDispatcher(h1).get()));
     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);
   }
 
@@ skipping 53 matching lines @@
             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,
+            dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
                                        MOJO_WRITE_MESSAGE_FLAG_NONE));
   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
@@ skipping 26 matching lines @@
   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,
+              dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
                                          MOJO_WRITE_MESSAGE_FLAG_NONE));
     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.
@@ skipping 106 matching lines @@
                                           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,
+            dispatcher1_->WriteMessage(buffer, sizeof(buffer), nullptr, 0,
                                        MOJO_WRITE_MESSAGE_FLAG_NONE));
   {
     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 133 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