Stop linking in the old Mojo EDK.

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.
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 17 matching lines @@
 
 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;
 
+#if !defined(OS_IOS)
 // Used in Multiprocess test.
 const size_t kMultiprocessCapacity = 37;
 const char kMultiprocessTestData[] = "hello i'm a string that is 36 bytes";
 const int kMultiprocessMaxIter = 513;
+#endif
 
 class DataPipeTest : public testing::Test {
  public:
   DataPipeTest() : producer_(MOJO_HANDLE_INVALID),
                    consumer_(MOJO_HANDLE_INVALID) {}
 
   ~DataPipeTest() override {
     if (producer_ != MOJO_HANDLE_INVALID)
       CHECK_EQ(MOJO_RESULT_OK, MojoClose(producer_));
     if (consumer_ != MOJO_HANDLE_INVALID)
@@ skipping 1574 matching lines @@
 
   int32_t read_data;
   ASSERT_EQ(MOJO_RESULT_OK, ReadData(&read_data, &num_bytes));
   ASSERT_EQ(sizeof(read_data), num_bytes);
   ASSERT_EQ(data, read_data);
 
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(pipe0));
   ASSERT_EQ(MOJO_RESULT_OK, MojoClose(pipe1));
 }
 
+#if !defined(OS_IOS)
+
 bool WriteAllData(MojoHandle producer,
                   const void* elements,
                   uint32_t num_bytes) {
   for (size_t i = 0; i < kMaxPoll; i++) {
     // Write as much data as we can.
     uint32_t write_bytes = num_bytes;
     MojoResult result = MojoWriteData(producer, elements, &write_bytes,
                                       MOJO_WRITE_DATA_FLAG_NONE);
     if (result == MOJO_RESULT_OK) {
       num_bytes -= write_bytes;
@@ skipping 124 matching lines @@
   consumer_ = handles[0];
 
   // Read the test string twice. Once for when we sent it, and once for the
   // other end sending it.
   for (int i = 0; i < 2; ++i) {
     EXPECT_TRUE(ReadAllData(consumer_, buffer, kTestDataSize, i == 1));
     EXPECT_EQ(0, memcmp(buffer, kMultiprocessTestData, kTestDataSize));
   }
 
   // Don't have to close the consumer here because it will be done for us.
+  std::string quitquitquit("quitquitquit");
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoWriteMessage(server_mp,  quitquitquit.data(),
+                             static_cast<uint32_t>(quitquitquit.size()),
+                             nullptr, 0u, MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
   EXPECT_TRUE(multiprocess_test_helper.WaitForChildTestShutdown());
 }
 
 MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessClient) {
   ScopedPlatformHandle client_platform_handle =
       std::move(test::MultiprocessTestHelper::client_platform_handle);
   const uint32_t kTestDataSize =
       static_cast<uint32_t>(sizeof(kMultiprocessTestData));
   EXPECT_TRUE(client_platform_handle.is_valid());
@@ skipping 45 matching lines @@
   num_handles = MOJO_ARRAYSIZE(handles);
   ASSERT_EQ(MOJO_RESULT_OK,
             MojoReadMessage(client_mp, nullptr, 0, handles, &num_handles,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   ASSERT_EQ(1u, num_handles);
   producer = handles[0];
 
   // Write the test string one more time.
   EXPECT_TRUE(WriteAllData(producer, kMultiprocessTestData, kTestDataSize));
 
+  std::string quitquitquit("quitquitquit");
+  ASSERT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
+                                     MOJO_DEADLINE_INDEFINITE, &hss));
+  std::string read_buffer(1000, '\0');
+  uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
+  ASSERT_EQ(MOJO_RESULT_OK,
+            MojoReadMessage(client_mp, &read_buffer[0], &read_buffer_size,
+                            nullptr, 0, MOJO_READ_MESSAGE_FLAG_NONE));
+  read_buffer.resize(read_buffer_size);
+  ASSERT_EQ(quitquitquit, read_buffer);
+
   // We swapped ends, so close the producer.
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(producer));
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(client_mp));
 }
 
+#endif  // !defined(OS_IOS)
+
 }  // namespace
 }  // namespace edk
 }  // namespace mojo