| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <stdint.h> |
| 6 #include <stdio.h> |
| 7 #include <string.h> |
| 8 |
| 9 #include <string> |
| 10 #include <vector> |
| 11 |
| 12 #include "base/bind.h" |
| 13 #include "base/files/file_path.h" |
| 14 #include "base/files/file_util.h" |
| 15 #include "base/files/scoped_file.h" |
| 16 #include "base/files/scoped_temp_dir.h" |
| 17 #include "base/location.h" |
| 18 #include "base/logging.h" |
| 19 #include "base/test/test_io_thread.h" |
| 20 #include "build/build_config.h" // TODO(vtl): Remove this. |
| 21 #include "mojo/edk/embedder/embedder.h" |
| 22 #include "mojo/edk/embedder/platform_channel_pair.h" |
| 23 #include "mojo/edk/embedder/platform_shared_buffer.h" |
| 24 #include "mojo/edk/embedder/scoped_platform_handle.h" |
| 25 #include "mojo/edk/system/dispatcher.h" |
| 26 #include "mojo/edk/system/message_pipe_test_utils.h" |
| 27 #include "mojo/edk/system/platform_handle_dispatcher.h" |
| 28 #include "mojo/edk/system/raw_channel.h" |
| 29 #include "mojo/edk/system/shared_buffer_dispatcher.h" |
| 30 #include "mojo/edk/system/test_utils.h" |
| 31 #include "mojo/edk/test/test_utils.h" |
| 32 #include "testing/gtest/include/gtest/gtest.h" |
| 33 |
| 34 |
| 35 namespace mojo { |
| 36 namespace system { |
| 37 namespace { |
| 38 |
| 39 class MultiprocessMessagePipeTest |
| 40 : public test::MultiprocessMessagePipeTestBase {}; |
| 41 |
| 42 // For each message received, sends a reply message with the same contents |
| 43 // repeated twice, until the other end is closed or it receives "quitquitquit" |
| 44 // (which it doesn't reply to). It'll return the number of messages received, |
| 45 // not including any "quitquitquit" message, modulo 100. |
| 46 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) { |
| 47 embedder::SimplePlatformSupport platform_support; |
| 48 base::MessageLoop message_loop; |
| 49 base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart); |
| 50 mojo::test::ScopedIPCSupport ipc_support(test_io_thread.task_runner()); |
| 51 |
| 52 embedder::ScopedPlatformHandle client_platform_handle = |
| 53 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass(); |
| 54 CHECK(client_platform_handle.is_valid()); |
| 55 ScopedMessagePipeHandle mp = |
| 56 mojo::embedder::CreateMessagePipe(client_platform_handle.Pass()); |
| 57 |
| 58 const std::string quitquitquit("quitquitquit"); |
| 59 int rv = 0; |
| 60 for (;; rv = (rv + 1) % 100) { |
| 61 // Wait for our end of the message pipe to be readable. |
| 62 HandleSignalsState hss; |
| 63 MojoResult result = |
| 64 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 65 MOJO_DEADLINE_INDEFINITE, &hss); |
| 66 if (result != MOJO_RESULT_OK) { |
| 67 // It was closed, probably. |
| 68 CHECK_EQ(result, MOJO_RESULT_FAILED_PRECONDITION); |
| 69 CHECK_EQ(hss.satisfied_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 70 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 71 break; |
| 72 } else { |
| 73 CHECK((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 74 CHECK((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 75 } |
| 76 |
| 77 std::string read_buffer(1000, '\0'); |
| 78 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 79 CHECK_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 80 &read_buffer_size, nullptr, |
| 81 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 82 MOJO_RESULT_OK); |
| 83 read_buffer.resize(read_buffer_size); |
| 84 VLOG(2) << "Child got: " << read_buffer; |
| 85 |
| 86 if (read_buffer == quitquitquit) { |
| 87 VLOG(2) << "Child quitting."; |
| 88 break; |
| 89 } |
| 90 |
| 91 std::string write_buffer = read_buffer + read_buffer; |
| 92 CHECK_EQ(MojoWriteMessage(mp.get().value(), write_buffer.data(), |
| 93 write_buffer.size(), |
| 94 nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE), |
| 95 MOJO_RESULT_OK); |
| 96 } |
| 97 |
| 98 return rv; |
| 99 } |
| 100 |
| 101 // Sends "hello" to child, and expects "hellohello" back. |
| 102 #if defined(OS_ANDROID) |
| 103 // Android multi-process tests are not executing the new process. This is flaky. |
| 104 #define MAYBE_Basic DISABLED_Basic |
| 105 #else |
| 106 #define MAYBE_Basic Basic |
| 107 #endif // defined(OS_ANDROID) |
| 108 TEST_F(MultiprocessMessagePipeTest, MAYBE_Basic) { |
| 109 helper()->StartChild("EchoEcho"); |
| 110 |
| 111 ScopedMessagePipeHandle mp = mojo::embedder::CreateMessagePipe( |
| 112 helper()->server_platform_handle.Pass()); |
| 113 |
| 114 std::string hello("hello"); |
| 115 ASSERT_EQ(MOJO_RESULT_OK, |
| 116 MojoWriteMessage(mp.get().value(), hello.data(), |
| 117 hello.size(), nullptr, 0, |
| 118 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 119 |
| 120 HandleSignalsState hss; |
| 121 ASSERT_EQ(MOJO_RESULT_OK, |
| 122 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 123 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 124 // The child may or may not have closed its end of the message pipe and died |
| 125 // (and we may or may not know it yet), so our end may or may not appear as |
| 126 // writable. |
| 127 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 128 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 129 |
| 130 std::string read_buffer(1000, '\0'); |
| 131 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 132 CHECK_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 133 &read_buffer_size, nullptr, 0, |
| 134 MOJO_READ_MESSAGE_FLAG_NONE), |
| 135 MOJO_RESULT_OK); |
| 136 read_buffer.resize(read_buffer_size); |
| 137 VLOG(2) << "Parent got: " << read_buffer; |
| 138 ASSERT_EQ(hello + hello, read_buffer); |
| 139 |
| 140 MojoClose(mp.release().value()); |
| 141 |
| 142 // We sent one message. |
| 143 ASSERT_EQ(1 % 100, helper()->WaitForChildShutdown()); |
| 144 } |
| 145 |
| 146 // Sends a bunch of messages to the child. Expects them "repeated" back. Waits |
| 147 // for the child to close its end before quitting. |
| 148 #if defined(OS_ANDROID) |
| 149 // Android multi-process tests are not executing the new process. This is flaky. |
| 150 #define MAYBE_QueueMessages DISABLED_QueueMessages |
| 151 #else |
| 152 #define MAYBE_QueueMessages QueueMessages |
| 153 #endif // defined(OS_ANDROID) |
| 154 TEST_F(MultiprocessMessagePipeTest, MAYBE_QueueMessages) { |
| 155 helper()->StartChild("EchoEcho"); |
| 156 |
| 157 ScopedMessagePipeHandle mp = mojo::embedder::CreateMessagePipe( |
| 158 helper()->server_platform_handle.Pass()); |
| 159 |
| 160 static const size_t kNumMessages = 1001; |
| 161 for (size_t i = 0; i < kNumMessages; i++) { |
| 162 std::string write_buffer(i, 'A' + (i % 26)); |
| 163 ASSERT_EQ(MOJO_RESULT_OK, |
| 164 MojoWriteMessage(mp.get().value(), write_buffer.data(), |
| 165 write_buffer.size(), nullptr, 0, |
| 166 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 167 } |
| 168 |
| 169 const std::string quitquitquit("quitquitquit"); |
| 170 ASSERT_EQ(MOJO_RESULT_OK, |
| 171 MojoWriteMessage(mp.get().value(), quitquitquit.data(), |
| 172 quitquitquit.size(), nullptr, 0, |
| 173 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 174 |
| 175 for (size_t i = 0; i < kNumMessages; i++) { |
| 176 HandleSignalsState hss; |
| 177 ASSERT_EQ(MOJO_RESULT_OK, |
| 178 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 179 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 180 // The child may or may not have closed its end of the message pipe and died |
| 181 // (and we may or may not know it yet), so our end may or may not appear as |
| 182 // writable. |
| 183 ASSERT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 184 ASSERT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 185 |
| 186 std::string read_buffer(kNumMessages * 2, '\0'); |
| 187 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 188 ASSERT_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 189 &read_buffer_size, nullptr, 0, |
| 190 MOJO_READ_MESSAGE_FLAG_NONE), |
| 191 MOJO_RESULT_OK); |
| 192 read_buffer.resize(read_buffer_size); |
| 193 |
| 194 ASSERT_EQ(std::string(i * 2, 'A' + (i % 26)), read_buffer); |
| 195 } |
| 196 |
| 197 // Wait for it to become readable, which should fail (since we sent |
| 198 // "quitquitquit"). |
| 199 HandleSignalsState hss; |
| 200 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| 201 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 202 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 203 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
| 204 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
| 205 |
| 206 ASSERT_EQ(static_cast<int>(kNumMessages % 100), |
| 207 helper()->WaitForChildShutdown()); |
| 208 } |
| 209 |
| 210 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) { |
| 211 embedder::SimplePlatformSupport platform_support; |
| 212 base::MessageLoop message_loop; |
| 213 base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart); |
| 214 mojo::test::ScopedIPCSupport ipc_support(test_io_thread.task_runner()); |
| 215 |
| 216 embedder::ScopedPlatformHandle client_platform_handle = |
| 217 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass(); |
| 218 CHECK(client_platform_handle.is_valid()); |
| 219 ScopedMessagePipeHandle mp = |
| 220 mojo::embedder::CreateMessagePipe(client_platform_handle.Pass()); |
| 221 |
| 222 // Wait for the first message from our parent. |
| 223 HandleSignalsState hss; |
| 224 CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 225 MOJO_DEADLINE_INDEFINITE, &hss), |
| 226 MOJO_RESULT_OK); |
| 227 // In this test, the parent definitely doesn't close its end of the message |
| 228 // pipe before we do. |
| 229 CHECK_EQ(hss.satisfied_signals, |
| 230 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 231 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 232 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 233 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 234 |
| 235 // It should have a shared buffer. |
| 236 std::string read_buffer(100, '\0'); |
| 237 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); |
| 238 MojoHandle handles[10]; |
| 239 uint32_t num_handlers = MOJO_ARRAYSIZE(handles); // Maximum number to receive |
| 240 CHECK_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 241 &num_bytes, &handles[0], |
| 242 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
| 243 MOJO_RESULT_OK); |
| 244 read_buffer.resize(num_bytes); |
| 245 CHECK_EQ(read_buffer, std::string("go 1")); |
| 246 CHECK_EQ(num_handlers, 1u); |
| 247 |
| 248 // Make a mapping. |
| 249 void* buffer; |
| 250 CHECK_EQ(MojoMapBuffer(handles[0], 0, 100, &buffer, |
| 251 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE), |
| 252 MOJO_RESULT_OK); |
| 253 |
| 254 // Write some stuff to the shared buffer. |
| 255 static const char kHello[] = "hello"; |
| 256 memcpy(buffer, kHello, sizeof(kHello)); |
| 257 |
| 258 // We should be able to close the dispatcher now. |
| 259 MojoClose(handles[0]); |
| 260 |
| 261 // And send a message to signal that we've written stuff. |
| 262 const std::string go2("go 2"); |
| 263 CHECK_EQ(MojoWriteMessage(mp.get().value(), go2.data(), |
| 264 go2.size(), nullptr, 0, |
| 265 MOJO_WRITE_MESSAGE_FLAG_NONE), |
| 266 MOJO_RESULT_OK); |
| 267 |
| 268 // Now wait for our parent to send us a message. |
| 269 hss = HandleSignalsState(); |
| 270 CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 271 MOJO_DEADLINE_INDEFINITE, &hss), |
| 272 MOJO_RESULT_OK); |
| 273 CHECK_EQ(hss.satisfied_signals, |
| 274 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 275 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 276 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 277 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 278 |
| 279 read_buffer = std::string(100, '\0'); |
| 280 num_bytes = static_cast<uint32_t>(read_buffer.size()); |
| 281 CHECK_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], &num_bytes, |
| 282 nullptr, 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 283 MOJO_RESULT_OK); |
| 284 read_buffer.resize(num_bytes); |
| 285 CHECK_EQ(read_buffer, std::string("go 3")); |
| 286 |
| 287 // It should have written something to the shared buffer. |
| 288 static const char kWorld[] = "world!!!"; |
| 289 CHECK_EQ(memcmp(buffer, kWorld, sizeof(kWorld)), 0); |
| 290 |
| 291 // And we're done. |
| 292 |
| 293 return 0; |
| 294 } |
| 295 |
| 296 #if defined(OS_ANDROID) |
| 297 // Android multi-process tests are not executing the new process. This is flaky. |
| 298 #define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing |
| 299 #else |
| 300 #define MAYBE_SharedBufferPassing SharedBufferPassing |
| 301 #endif |
| 302 TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { |
| 303 helper()->StartChild("CheckSharedBuffer"); |
| 304 |
| 305 ScopedMessagePipeHandle mp = mojo::embedder::CreateMessagePipe( |
| 306 helper()->server_platform_handle.Pass()); |
| 307 |
| 308 // Make a shared buffer. |
| 309 MojoCreateSharedBufferOptions options; |
| 310 options.struct_size = sizeof(options); |
| 311 options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE; |
| 312 |
| 313 MojoHandle shared_buffer; |
| 314 ASSERT_EQ(MOJO_RESULT_OK, |
| 315 MojoCreateSharedBuffer(&options, 100, &shared_buffer)); |
| 316 |
| 317 // Send the shared buffer. |
| 318 const std::string go1("go 1"); |
| 319 |
| 320 MojoHandle duplicated_shared_buffer; |
| 321 ASSERT_EQ(MOJO_RESULT_OK, |
| 322 MojoDuplicateBufferHandle( |
| 323 shared_buffer, |
| 324 MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE, |
| 325 &duplicated_shared_buffer)); |
| 326 MojoHandle handles[1]; |
| 327 handles[0] = duplicated_shared_buffer; |
| 328 ASSERT_EQ(MOJO_RESULT_OK, |
| 329 MojoWriteMessage(mp.get().value(), &go1[0], go1.size(), &handles[0], |
| 330 MOJO_ARRAYSIZE(handles), |
| 331 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 332 |
| 333 // Wait for a message from the child. |
| 334 HandleSignalsState hss; |
| 335 ASSERT_EQ(MOJO_RESULT_OK, |
| 336 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 337 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 338 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 339 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 340 |
| 341 std::string read_buffer(100, '\0'); |
| 342 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); |
| 343 ASSERT_EQ(MOJO_RESULT_OK, |
| 344 MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 345 &num_bytes, nullptr, 0, |
| 346 MOJO_READ_MESSAGE_FLAG_NONE)); |
| 347 read_buffer.resize(num_bytes); |
| 348 ASSERT_EQ(std::string("go 2"), read_buffer); |
| 349 |
| 350 // After we get it, the child should have written something to the shared |
| 351 // buffer. |
| 352 static const char kHello[] = "hello"; |
| 353 void* buffer; |
| 354 CHECK_EQ(MojoMapBuffer(shared_buffer, 0, 100, &buffer, |
| 355 MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE), |
| 356 MOJO_RESULT_OK); |
| 357 ASSERT_EQ(0, memcmp(buffer, kHello, sizeof(kHello))); |
| 358 |
| 359 // Now we'll write some stuff to the shared buffer. |
| 360 static const char kWorld[] = "world!!!"; |
| 361 memcpy(buffer, kWorld, sizeof(kWorld)); |
| 362 |
| 363 // And send a message to signal that we've written stuff. |
| 364 const std::string go3("go 3"); |
| 365 ASSERT_EQ(MOJO_RESULT_OK, |
| 366 MojoWriteMessage(mp.get().value(), &go3[0], |
| 367 go3.size(), nullptr, 0, |
| 368 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 369 |
| 370 // Wait for |mp| to become readable, which should fail. |
| 371 hss = HandleSignalsState(); |
| 372 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| 373 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 374 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 375 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
| 376 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
| 377 |
| 378 MojoClose(mp.release().value()); |
| 379 |
| 380 ASSERT_EQ(0, helper()->WaitForChildShutdown()); |
| 381 } |
| 382 |
| 383 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) { |
| 384 embedder::SimplePlatformSupport platform_support; |
| 385 base::MessageLoop message_loop; |
| 386 base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart); |
| 387 mojo::test::ScopedIPCSupport ipc_support(test_io_thread.task_runner()); |
| 388 |
| 389 embedder::ScopedPlatformHandle client_platform_handle = |
| 390 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass(); |
| 391 CHECK(client_platform_handle.is_valid()); |
| 392 ScopedMessagePipeHandle mp = |
| 393 mojo::embedder::CreateMessagePipe(client_platform_handle.Pass()); |
| 394 |
| 395 HandleSignalsState hss; |
| 396 CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 397 MOJO_DEADLINE_INDEFINITE, &hss), |
| 398 MOJO_RESULT_OK); |
| 399 CHECK_EQ(hss.satisfied_signals, |
| 400 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 401 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 402 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 403 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 404 |
| 405 std::string read_buffer(100, '\0'); |
| 406 uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); |
| 407 MojoHandle handles[255]; // Maximum number to receive. |
| 408 uint32_t num_handlers = MOJO_ARRAYSIZE(handles); |
| 409 |
| 410 CHECK_EQ(MojoReadMessage(mp.get().value(), &read_buffer[0], |
| 411 &num_bytes, &handles[0], |
| 412 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
| 413 MOJO_RESULT_OK); |
| 414 MojoClose(mp.release().value()); |
| 415 |
| 416 read_buffer.resize(num_bytes); |
| 417 char hello[32]; |
| 418 int num_handles = 0; |
| 419 sscanf(read_buffer.c_str(), "%s %d", hello, &num_handles); |
| 420 CHECK_EQ(std::string("hello"), std::string(hello)); |
| 421 CHECK_GT(num_handles, 0); |
| 422 |
| 423 for (int i = 0; i < num_handles; ++i) { |
| 424 embedder::ScopedPlatformHandle h; |
| 425 CHECK_EQ(embedder::PassWrappedPlatformHandle( |
| 426 handles[i], &h), |
| 427 MOJO_RESULT_OK); |
| 428 CHECK(h.is_valid()); |
| 429 MojoClose(handles[i]); |
| 430 |
| 431 base::ScopedFILE fp(mojo::test::FILEFromPlatformHandle(h.Pass(), "r")); |
| 432 CHECK(fp); |
| 433 std::string fread_buffer(100, '\0'); |
| 434 size_t bytes_read = |
| 435 fread(&fread_buffer[0], 1, fread_buffer.size(), fp.get()); |
| 436 fread_buffer.resize(bytes_read); |
| 437 CHECK_EQ(fread_buffer, "world"); |
| 438 } |
| 439 |
| 440 return 0; |
| 441 } |
| 442 |
| 443 class MultiprocessMessagePipeTestWithPipeCount |
| 444 : public test::MultiprocessMessagePipeTestBase, |
| 445 public testing::WithParamInterface<size_t> {}; |
| 446 |
| 447 TEST_P(MultiprocessMessagePipeTestWithPipeCount, PlatformHandlePassing) { |
| 448 base::ScopedTempDir temp_dir; |
| 449 ASSERT_TRUE(temp_dir.CreateUniqueTempDir()); |
| 450 |
| 451 helper()->StartChild("CheckPlatformHandleFile"); |
| 452 ScopedMessagePipeHandle mp = mojo::embedder::CreateMessagePipe( |
| 453 helper()->server_platform_handle.Pass()); |
| 454 |
| 455 std::vector<MojoHandle> handles; |
| 456 |
| 457 size_t pipe_count = GetParam(); |
| 458 for (size_t i = 0; i < pipe_count; ++i) { |
| 459 base::FilePath unused; |
| 460 base::ScopedFILE fp( |
| 461 CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused)); |
| 462 const std::string world("world"); |
| 463 CHECK_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size()); |
| 464 fflush(fp.get()); |
| 465 rewind(fp.get()); |
| 466 MojoHandle handle; |
| 467 ASSERT_EQ(embedder::CreatePlatformHandleWrapper( |
| 468 embedder::ScopedPlatformHandle( |
| 469 mojo::test::PlatformHandleFromFILE(fp.Pass())), |
| 470 &handle), |
| 471 MOJO_RESULT_OK); |
| 472 handles.push_back(handle); |
| 473 } |
| 474 |
| 475 char message[128]; |
| 476 sprintf(message, "hello %d", static_cast<int>(pipe_count)); |
| 477 ASSERT_EQ(MOJO_RESULT_OK, |
| 478 MojoWriteMessage(mp.get().value(), message, |
| 479 strlen(message), |
| 480 &handles[0], handles.size(), |
| 481 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 482 |
| 483 // Wait for it to become readable, which should fail. |
| 484 HandleSignalsState hss; |
| 485 ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, |
| 486 MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 487 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 488 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); |
| 489 ASSERT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); |
| 490 |
| 491 MojoClose(mp.release().value()); |
| 492 |
| 493 ASSERT_EQ(0, helper()->WaitForChildShutdown()); |
| 494 } |
| 495 |
| 496 // Android multi-process tests are not executing the new process. This is flaky. |
| 497 #if !defined(OS_ANDROID) |
| 498 INSTANTIATE_TEST_CASE_P(PipeCount, |
| 499 MultiprocessMessagePipeTestWithPipeCount, |
| 500 testing::Values(1u, 128u, 140u)); |
| 501 #endif |
| 502 |
| 503 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckMessagePipe) { |
| 504 embedder::SimplePlatformSupport platform_support; |
| 505 base::MessageLoop message_loop; |
| 506 base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart); |
| 507 mojo::test::ScopedIPCSupport ipc_support(test_io_thread.task_runner()); |
| 508 |
| 509 embedder::ScopedPlatformHandle client_platform_handle = |
| 510 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass(); |
| 511 CHECK(client_platform_handle.is_valid()); |
| 512 |
| 513 ScopedMessagePipeHandle mp = |
| 514 mojo::embedder::CreateMessagePipe(client_platform_handle.Pass()); |
| 515 |
| 516 // Wait for the first message from our parent. |
| 517 HandleSignalsState hss; |
| 518 CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 519 MOJO_DEADLINE_INDEFINITE, &hss), |
| 520 MOJO_RESULT_OK); |
| 521 // In this test, the parent definitely doesn't close its end of the message |
| 522 // pipe before we do. |
| 523 CHECK_EQ(hss.satisfied_signals, |
| 524 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 525 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 526 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 527 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 528 |
| 529 // It should have a message pipe. |
| 530 MojoHandle handles[10]; |
| 531 uint32_t num_handlers = MOJO_ARRAYSIZE(handles); |
| 532 CHECK_EQ(MojoReadMessage(mp.get().value(), nullptr, |
| 533 nullptr, &handles[0], |
| 534 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
| 535 MOJO_RESULT_OK); |
| 536 CHECK_EQ(num_handlers, 1u); |
| 537 |
| 538 // Read data from the received message pipe. |
| 539 CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE, |
| 540 MOJO_DEADLINE_INDEFINITE, &hss), |
| 541 MOJO_RESULT_OK); |
| 542 CHECK_EQ(hss.satisfied_signals, |
| 543 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 544 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 545 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 546 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 547 |
| 548 std::string read_buffer(100, '\0'); |
| 549 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 550 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], |
| 551 &read_buffer_size, nullptr, |
| 552 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 553 MOJO_RESULT_OK); |
| 554 read_buffer.resize(read_buffer_size); |
| 555 CHECK_EQ(read_buffer, std::string("hello")); |
| 556 |
| 557 // Now write some data into the message pipe. |
| 558 std::string write_buffer = "world"; |
| 559 CHECK_EQ(MojoWriteMessage(handles[0], write_buffer.data(), |
| 560 write_buffer.size(), |
| 561 nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE), |
| 562 MOJO_RESULT_OK); |
| 563 MojoClose(handles[0]); |
| 564 return 0; |
| 565 } |
| 566 |
| 567 #if defined(OS_ANDROID) |
| 568 // Android multi-process tests are not executing the new process. This is flaky. |
| 569 #define MAYBE_MessagePipePassing DISABLED_MessagePipePassing |
| 570 #else |
| 571 #define MAYBE_MessagePipePassing MessagePipePassing |
| 572 #endif |
| 573 TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipePassing) { |
| 574 helper()->StartChild("CheckMessagePipe"); |
| 575 |
| 576 ScopedMessagePipeHandle mp = |
| 577 mojo::embedder::CreateMessagePipe( |
| 578 helper()->server_platform_handle.Pass()); |
| 579 MojoCreateSharedBufferOptions options; |
| 580 options.struct_size = sizeof(options); |
| 581 options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE; |
| 582 |
| 583 MojoHandle mp1, mp2; |
| 584 ASSERT_EQ(MOJO_RESULT_OK, |
| 585 MojoCreateMessagePipe(nullptr, &mp1, &mp2)); |
| 586 |
| 587 // Write a string into one end of the new message pipe and send the other end. |
| 588 const std::string hello("hello"); |
| 589 ASSERT_EQ(MOJO_RESULT_OK, |
| 590 MojoWriteMessage(mp1, &hello[0], hello.size(), nullptr, 0, |
| 591 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 592 ASSERT_EQ(MOJO_RESULT_OK, |
| 593 MojoWriteMessage(mp.get().value(), nullptr, 0, &mp2, 1, |
| 594 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 595 |
| 596 // Wait for a message from the child. |
| 597 HandleSignalsState hss; |
| 598 ASSERT_EQ(MOJO_RESULT_OK, |
| 599 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 600 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 601 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 602 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 603 |
| 604 std::string read_buffer(100, '\0'); |
| 605 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 606 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
| 607 &read_buffer_size, nullptr, |
| 608 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 609 MOJO_RESULT_OK); |
| 610 read_buffer.resize(read_buffer_size); |
| 611 CHECK_EQ(read_buffer, std::string("world")); |
| 612 |
| 613 MojoClose(mp1); |
| 614 MojoClose(mp.release().value()); |
| 615 |
| 616 ASSERT_EQ(0, helper()->WaitForChildShutdown()); |
| 617 } |
| 618 |
| 619 // Like above test, but verifies passing the other MP handle works as well. |
| 620 #if defined(OS_ANDROID) |
| 621 // Android multi-process tests are not executing the new process. This is flaky. |
| 622 #define MAYBE_MessagePipeTwoPassing DISABLED_MessagePipeTwoPassing |
| 623 #else |
| 624 #define MAYBE_MessagePipeTwoPassing MessagePipeTwoPassing |
| 625 #endif |
| 626 TEST_F(MultiprocessMessagePipeTest, MAYBE_MessagePipeTwoPassing) { |
| 627 helper()->StartChild("CheckMessagePipe"); |
| 628 |
| 629 ScopedMessagePipeHandle mp = |
| 630 mojo::embedder::CreateMessagePipe( |
| 631 helper()->server_platform_handle.Pass()); |
| 632 |
| 633 MojoHandle mp1, mp2; |
| 634 ASSERT_EQ(MOJO_RESULT_OK, |
| 635 MojoCreateMessagePipe(nullptr, &mp2, &mp1)); |
| 636 |
| 637 // Write a string into one end of the new message pipe and send the other end. |
| 638 const std::string hello("hello"); |
| 639 ASSERT_EQ(MOJO_RESULT_OK, |
| 640 MojoWriteMessage(mp1, &hello[0], hello.size(), nullptr, 0, |
| 641 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 642 ASSERT_EQ(MOJO_RESULT_OK, |
| 643 MojoWriteMessage(mp.get().value(), nullptr, 0, &mp2, 1, |
| 644 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 645 |
| 646 // Wait for a message from the child. |
| 647 HandleSignalsState hss; |
| 648 ASSERT_EQ(MOJO_RESULT_OK, |
| 649 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 650 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 651 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 652 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 653 |
| 654 std::string read_buffer(100, '\0'); |
| 655 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 656 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
| 657 &read_buffer_size, nullptr, |
| 658 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 659 MOJO_RESULT_OK); |
| 660 read_buffer.resize(read_buffer_size); |
| 661 CHECK_EQ(read_buffer, std::string("world")); |
| 662 |
| 663 MojoClose(mp.release().value()); |
| 664 |
| 665 ASSERT_EQ(0, helper()->WaitForChildShutdown()); |
| 666 } |
| 667 |
| 668 MOJO_MULTIPROCESS_TEST_CHILD_MAIN(DataPipeConsumer) { |
| 669 embedder::SimplePlatformSupport platform_support; |
| 670 base::MessageLoop message_loop; |
| 671 base::TestIOThread test_io_thread(base::TestIOThread::kAutoStart); |
| 672 mojo::test::ScopedIPCSupport ipc_support(test_io_thread.task_runner()); |
| 673 |
| 674 embedder::ScopedPlatformHandle client_platform_handle = |
| 675 mojo::test::MultiprocessTestHelper::client_platform_handle.Pass(); |
| 676 CHECK(client_platform_handle.is_valid()); |
| 677 |
| 678 ScopedMessagePipeHandle mp = |
| 679 mojo::embedder::CreateMessagePipe(client_platform_handle.Pass()); |
| 680 |
| 681 // Wait for the first message from our parent. |
| 682 HandleSignalsState hss; |
| 683 CHECK_EQ(MojoWait(mp.get().value(), MOJO_HANDLE_SIGNAL_READABLE, |
| 684 MOJO_DEADLINE_INDEFINITE, &hss), |
| 685 MOJO_RESULT_OK); |
| 686 // In this test, the parent definitely doesn't close its end of the message |
| 687 // pipe before we do. |
| 688 CHECK_EQ(hss.satisfied_signals, |
| 689 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 690 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 691 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 692 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 693 |
| 694 // It should have a message pipe. |
| 695 MojoHandle handles[10]; |
| 696 uint32_t num_handlers = MOJO_ARRAYSIZE(handles); |
| 697 CHECK_EQ(MojoReadMessage(mp.get().value(), nullptr, |
| 698 nullptr, &handles[0], |
| 699 &num_handlers, MOJO_READ_MESSAGE_FLAG_NONE), |
| 700 MOJO_RESULT_OK); |
| 701 CHECK_EQ(num_handlers, 1u); |
| 702 |
| 703 // Read data from the received message pipe. |
| 704 CHECK_EQ(MojoWait(handles[0], MOJO_HANDLE_SIGNAL_READABLE, |
| 705 MOJO_DEADLINE_INDEFINITE, &hss), |
| 706 MOJO_RESULT_OK); |
| 707 CHECK_EQ(hss.satisfied_signals, |
| 708 MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); |
| 709 CHECK_EQ(hss.satisfiable_signals, MOJO_HANDLE_SIGNAL_READABLE | |
| 710 MOJO_HANDLE_SIGNAL_WRITABLE | |
| 711 MOJO_HANDLE_SIGNAL_PEER_CLOSED); |
| 712 |
| 713 std::string read_buffer(100, '\0'); |
| 714 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 715 CHECK_EQ(MojoReadMessage(handles[0], &read_buffer[0], |
| 716 &read_buffer_size, nullptr, |
| 717 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 718 MOJO_RESULT_OK); |
| 719 read_buffer.resize(read_buffer_size); |
| 720 CHECK_EQ(read_buffer, std::string("hello")); |
| 721 |
| 722 // Now write some data into the message pipe. |
| 723 std::string write_buffer = "world"; |
| 724 CHECK_EQ(MojoWriteMessage(handles[0], write_buffer.data(), |
| 725 write_buffer.size(), |
| 726 nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE), |
| 727 MOJO_RESULT_OK); |
| 728 MojoClose(handles[0]); |
| 729 return 0; |
| 730 } |
| 731 |
| 732 #if defined(OS_ANDROID) |
| 733 // Android multi-process tests are not executing the new process. This is flaky. |
| 734 #define MAYBE_DataPipeConsumer DISABLED_DataPipeConsumer |
| 735 #else |
| 736 #define MAYBE_DataPipeConsumer DataPipeConsumer |
| 737 #endif |
| 738 TEST_F(MultiprocessMessagePipeTest, MAYBE_DataPipeConsumer) { |
| 739 helper()->StartChild("DataPipeConsumer"); |
| 740 |
| 741 ScopedMessagePipeHandle mp = |
| 742 mojo::embedder::CreateMessagePipe( |
| 743 helper()->server_platform_handle.Pass()); |
| 744 MojoCreateSharedBufferOptions options; |
| 745 options.struct_size = sizeof(options); |
| 746 options.flags = MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE; |
| 747 |
| 748 MojoHandle mp1, mp2; |
| 749 ASSERT_EQ(MOJO_RESULT_OK, |
| 750 MojoCreateMessagePipe(nullptr, &mp2, &mp1)); |
| 751 |
| 752 // Write a string into one end of the new message pipe and send the other end. |
| 753 const std::string hello("hello"); |
| 754 ASSERT_EQ(MOJO_RESULT_OK, |
| 755 MojoWriteMessage(mp1, &hello[0], hello.size(), nullptr, 0, |
| 756 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 757 ASSERT_EQ(MOJO_RESULT_OK, |
| 758 MojoWriteMessage(mp.get().value(), nullptr, 0, &mp2, 1, |
| 759 MOJO_WRITE_MESSAGE_FLAG_NONE)); |
| 760 |
| 761 // Wait for a message from the child. |
| 762 HandleSignalsState hss; |
| 763 ASSERT_EQ(MOJO_RESULT_OK, |
| 764 MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, |
| 765 MOJO_DEADLINE_INDEFINITE, &hss)); |
| 766 EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 767 EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); |
| 768 |
| 769 std::string read_buffer(100, '\0'); |
| 770 uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); |
| 771 CHECK_EQ(MojoReadMessage(mp1, &read_buffer[0], |
| 772 &read_buffer_size, nullptr, |
| 773 0, MOJO_READ_MESSAGE_FLAG_NONE), |
| 774 MOJO_RESULT_OK); |
| 775 read_buffer.resize(read_buffer_size); |
| 776 CHECK_EQ(read_buffer, std::string("world")); |
| 777 |
| 778 MojoClose(mp1); |
| 779 MojoClose(mp.release().value()); |
| 780 |
| 781 ASSERT_EQ(0, helper()->WaitForChildShutdown()); |
| 782 } |
| 783 |
| 784 } // namespace |
| 785 } // namespace system |
| 786 } // namespace mojo |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1350023003:
Add a Mojo EDK for Chrome that uses one OS pipe per message pipe. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master