Add a Mojo EDK for Chrome that uses one OS pipe per message pipe.

mojo/edk/system/data_pipe_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.
 
-// This file contains tests that are shared between different implementations of
-// |DataPipeImpl|.
-
-#include "mojo/edk/system/data_pipe_impl.h"
+//#include "mojo/edk/system/data_pipe_impl.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_io_thread.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
-#include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/channel_endpoint.h"
-#include "mojo/edk/system/data_pipe.h"
-#include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
-#include "mojo/edk/system/data_pipe_producer_dispatcher.h"
+//#include "mojo/edk/system/channel.h"
+//#include "mojo/edk/system/channel_endpoint.h"
+//#include "mojo/edk/system/data_pipe.h"
+//#include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
+//#include "mojo/edk/system/data_pipe_producer_dispatcher.h"
 #include "mojo/edk/system/memory.h"
-#include "mojo/edk/system/message_pipe.h"
-#include "mojo/edk/system/raw_channel.h"
+//#include "mojo/edk/system/message_pipe.h"
+//#include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
+#include "mojo/edk/test/scoped_ipc_support.h"
+#include "mojo/public/c/system/data_pipe.h"
+#include "mojo/public/c/system/functions.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
-const MojoHandleSignals kAllSignals = MOJO_HANDLE_SIGNAL_READABLE |
-                                      MOJO_HANDLE_SIGNAL_WRITABLE |
-                                      MOJO_HANDLE_SIGNAL_PEER_CLOSED;
+const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE |
+                                     MOJO_HANDLE_SIGNAL_WRITABLE |
+                                     MOJO_HANDLE_SIGNAL_PEER_CLOSED;
 const uint32_t kSizeOfOptions =
     static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions));
 
 // In various places, we have to poll (since, e.g., we can't yet wait for a
 // certain amount of data to be available). This is the maximum number of
 // iterations (separated by a short sleep).
 // TODO(vtl): Get rid of this.
 const size_t kMaxPoll = 100;
-
+/*
 // DataPipeImplTestHelper ------------------------------------------------------
 
 class DataPipeImplTestHelper {
  public:
   virtual ~DataPipeImplTestHelper() {}
 
   virtual void SetUp() = 0;
   virtual void TearDown() = 0;
 
   virtual void Create(const MojoCreateDataPipeOptions& validated_options) = 0;
@@ skipping 218 matching lines @@
                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
       transport.End();
     }
     uint32_t context = 0;
     ASSERT_EQ(MOJO_RESULT_OK, waiter.Wait(test::ActionDeadline(), &context));
     EXPECT_EQ(987u, context);
     HandleSignalsState hss = HandleSignalsState();
     message_pipe(dest_i)->RemoveAwakable(0, &waiter, &hss);
     EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
               hss.satisfied_signals);
-    EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
+    EXPECT_EQ(kSignalAll, hss.satisfiable_signals);
     char read_buffer[100] = {};
     uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
     DispatcherVector read_dispatchers;
     uint32_t read_num_dispatchers = 10;  // Maximum to get.
     ASSERT_EQ(MOJO_RESULT_OK,
               message_pipe(dest_i)->ReadMessage(
                   0, UserPointer<void>(read_buffer),
                   MakeUserPointer(&read_buffer_size), &read_dispatchers,
                   &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, static_cast<size_t>(read_buffer_size));
@@ skipping 288 matching lines @@
                                                             &test_options[0]));
 
   for (size_t i = 0; i < MOJO_ARRAYSIZE(test_options); i++) {
     this->Create(test_options[i]);
     this->DoTransfer();
     this->ProducerClose();
     this->ConsumerClose();
     this->Reset();
   }
 }
+*/
 
-TYPED_TEST(DataPipeImplTest, SimpleReadWrite) {
+class DataPipeTest : public testing::Test {
+ public:
+  DataPipeTest()
+      : test_io_thread_(base::TestIOThread::kAutoStart) {}
+  ~DataPipeTest() override {}
+
+ protected:
+  base::TestIOThread& test_io_thread() { return test_io_thread_; }
+  scoped_refptr<base::TaskRunner> test_io_task_runner() {
+    return test_io_thread_.task_runner();
+  }
+
+ private:
+  base::MessageLoop message_loop_;
+  base::TestIOThread test_io_thread_;
+
+  MOJO_DISALLOW_COPY_AND_ASSIGN(DataPipeTest);
+};
+
+//TYPED_TEST(DataPipeImplTest, SimpleReadWrite) {
+TEST_F(DataPipeTest, SimpleReadWrite) {
   const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,                           // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
+
+  mojo::test::ScopedIPCSupport ipc_support(test_io_task_runner());
+
+  MojoHandle producer_handle, consumer_handle;
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoCreateDataPipe(&options, &producer_handle, &consumer_handle));
+
+  // We can write to a data pipe handle immediately.
+  int32_t elements[10] = {};
+  uint32_t num_bytes = 0;
+
+  num_bytes =
+      static_cast<uint32_t>(MOJO_ARRAYSIZE(elements) * sizeof(elements[0]));
+
+  elements[0] = 123;
+  elements[1] = 456;
+  num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      MojoWriteData(producer_handle, &elements[0], &num_bytes,
+                    MOJO_WRITE_DATA_FLAG_NONE));
+
+  // Now wait for the other side to become readable.
+  MojoHandleSignalsState state;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWait(consumer_handle,
+                                     MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &state));
+  EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, state.satisfied_signals);
+
+  elements[0] = -1;
+  elements[1] = -1;
+  EXPECT_EQ(MOJO_RESULT_OK,
+            MojoReadData(consumer_handle, &elements[0], &num_bytes,
+                            MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
+  EXPECT_EQ(elements[0], 123);
+  EXPECT_EQ(elements[1], 456);
+
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer_handle));
+  EXPECT_EQ(MOJO_RESULT_OK, MojoClose(consumer_handle));
+}
+
+  /*
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context;
 
   int32_t elements[10] = {};
   uint32_t num_bytes = 0;
 
@@ skipping 1026 matching lines @@
 
   // Empty again.
   num_bytes = ~0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(0u, num_bytes);
 
   this->ConsumerClose();
 }
 
-TYPED_TEST(DataPipeImplTest, TwoPhaseAllOrNone) {
+TYPED_TEST(DataPipeImplTest, DISABLED_TwoPhaseAllOrNone) {
   const MojoCreateDataPipeOptions options = {
       kSizeOfOptions,                           // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       static_cast<uint32_t>(sizeof(int32_t)),   // |element_num_bytes|.
       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
   };
   this->Create(options);
   this->DoTransfer();
 
   Waiter waiter;
@@ skipping 725 matching lines @@
 
   // Still one element available.
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             this->ConsumerQueryData(MakeUserPointer(&num_bytes)));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
 
   this->ProducerClose();
   this->ConsumerClose();
 }
-
+*/
 }  // namespace
 }  // namespace system
 }  // namespace mojo