diff options
Diffstat (limited to 'mojo/edk')
75 files changed, 1607 insertions, 983 deletions
diff --git a/mojo/edk/DEPS b/mojo/edk/DEPS index 5fe1410..9a51b60 100644 --- a/mojo/edk/DEPS +++ b/mojo/edk/DEPS @@ -2,4 +2,6 @@ include_rules = [ "-mojo", "+mojo/edk", "+mojo/public", + + "+third_party/ashmem", ] diff --git a/mojo/edk/embedder/BUILD.gn b/mojo/edk/embedder/BUILD.gn index 5271e66..3d808d8 100644 --- a/mojo/edk/embedder/BUILD.gn +++ b/mojo/edk/embedder/BUILD.gn @@ -2,10 +2,12 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. -source_set("embedder") { +import("../mojo_edk.gni") + +mojo_edk_source_set("embedder") { # This isn't really a standalone target; it must be linked into the # mojo_system_impl component. - visibility = [ "//mojo/edk/system" ] + mojo_edk_visibility = [ "mojo/edk/system" ] sources = [ "channel_info_forward.h", @@ -30,11 +32,14 @@ source_set("embedder") { "MOJO_SYSTEM_IMPLEMENTATION", ] - configs += [ "//mojo/edk/system:system_config" ] + mojo_edk_configs = [ "mojo/edk/system:system_config" ] public_deps = [ ":platform", - "//mojo/public/cpp/system", + ] + + mojo_sdk_public_deps = [ + "mojo/public/cpp/system", ] deps = [ @@ -42,12 +47,15 @@ source_set("embedder") { ] } -source_set("platform") { +mojo_edk_source_set("platform") { # This isn't really a standalone target; it must be linked into the # mojo_system_impl component. visibility = [ ":embedder", - "//mojo/edk/system", + ] + + mojo_edk_visibility = [ + "mojo/edk/system", ] sources = [ @@ -68,6 +76,7 @@ source_set("platform") { "scoped_platform_handle.h", "simple_platform_shared_buffer.cc", "simple_platform_shared_buffer.h", + "simple_platform_shared_buffer_android.cc", "simple_platform_shared_buffer_posix.cc", "simple_platform_shared_buffer_win.cc", "simple_platform_support.cc", @@ -76,16 +85,16 @@ source_set("platform") { defines = [ "MOJO_SYSTEM_IMPL_IMPLEMENTATION" ] - configs += [ "//mojo/edk/system:system_config" ] + mojo_edk_configs = [ "mojo/edk/system:system_config" ] deps = [ "//base", ] } -source_set("embedder_unittests") { +mojo_edk_source_set("embedder_unittests") { testonly = true - visibility = [ "//mojo/edk/system:mojo_system_unittests" ] + mojo_edk_visibility = [ "mojo/edk/system:mojo_system_unittests" ] sources = [ "embedder_unittest.cc", @@ -96,8 +105,12 @@ source_set("embedder_unittests") { deps = [ "//base", "//base/test:test_support", - "//mojo/edk/test:test_support", - "//mojo/edk/system", "//testing/gtest", ] + + mojo_edk_deps = [ + "mojo/edk/test:test_support", + "mojo/edk/system", + "mojo/edk/system:test_utils", + ] } diff --git a/mojo/edk/embedder/channel_init.cc b/mojo/edk/embedder/channel_init.cc index 0e7a7b6..9a0bfce 100644 --- a/mojo/edk/embedder/channel_init.cc +++ b/mojo/edk/embedder/channel_init.cc @@ -22,7 +22,7 @@ ChannelInit::~ChannelInit() { ScopedMessagePipeHandle ChannelInit::Init( base::PlatformFile file, scoped_refptr<base::TaskRunner> io_thread_task_runner) { - DCHECK(!io_thread_task_runner_.get()); // Should only init once. + DCHECK(!io_thread_task_runner_); // Should only init once. io_thread_task_runner_ = io_thread_task_runner; ScopedMessagePipeHandle message_pipe = CreateChannel( diff --git a/mojo/edk/embedder/embedder.cc b/mojo/edk/embedder/embedder.cc index 9c73eb0..d538810 100644 --- a/mojo/edk/embedder/embedder.cc +++ b/mojo/edk/embedder/embedder.cc @@ -62,7 +62,7 @@ void CreateChannelHelper( MakeChannel(platform_handle.Pass(), channel_endpoint); // Hand the channel back to the embedder. - if (callback_thread_task_runner.get()) { + if (callback_thread_task_runner) { callback_thread_task_runner->PostTask( FROM_HERE, base::Bind(callback, channel_info.release())); } else { @@ -118,7 +118,7 @@ ScopedMessagePipeHandle CreateChannel( DidCreateChannelCallback callback, scoped_refptr<base::TaskRunner> callback_thread_task_runner) { DCHECK(platform_handle.is_valid()); - DCHECK(io_thread_task_runner.get()); + DCHECK(io_thread_task_runner); DCHECK(!callback.is_null()); scoped_refptr<system::ChannelEndpoint> channel_endpoint; @@ -195,7 +195,7 @@ MojoResult PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle, DCHECK(internal::g_core); scoped_refptr<system::Dispatcher> dispatcher( internal::g_core->GetDispatcher(platform_handle_wrapper_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; if (dispatcher->GetType() != system::Dispatcher::kTypePlatformHandle) diff --git a/mojo/edk/embedder/embedder_unittest.cc b/mojo/edk/embedder/embedder_unittest.cc index b138a2d..0393748 100644 --- a/mojo/edk/embedder/embedder_unittest.cc +++ b/mojo/edk/embedder/embedder_unittest.cc @@ -24,6 +24,13 @@ namespace mojo { namespace embedder { namespace { +const MojoHandleSignals kSignalReadadableWritable = + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE; + +const MojoHandleSignals kSignalAll = MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE | + MOJO_HANDLE_SIGNAL_PEER_CLOSED; + class ScopedTestChannel { public: // Creates a channel that lives on a given I/O thread (determined by the given @@ -123,8 +130,12 @@ TEST_F(EmbedderTest, ChannelsBasic) { 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Now wait for the other side to become readable. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + MojoHandleSignalsState state; + EXPECT_EQ(MOJO_RESULT_OK, + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); char buffer[1000] = {}; uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer)); @@ -188,8 +199,12 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) { nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait for |client_mp| to become readable. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + MojoHandleSignalsState state; + EXPECT_EQ(MOJO_RESULT_OK, + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); // Read a message from |client_mp|. char buffer[1000] = {}; @@ -206,8 +221,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) { h1 = handles[0]; // Wait for |h1| to become readable. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h1, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); // Read a message from |h1|. memset(buffer, 0, sizeof(buffer)); @@ -222,8 +239,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) { EXPECT_EQ(0u, num_handles); // Wait for |h1| to become readable (again). - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h1, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); // Read the second message from |h1|. memset(buffer, 0, sizeof(buffer)); @@ -242,8 +261,10 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) { nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait for |h0| to become readable. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(h0, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); // Read a message from |h0|. memset(buffer, 0, sizeof(buffer)); @@ -282,6 +303,7 @@ TEST_F(EmbedderTest, ChannelsHandlePassing) { // 10. (close) // 11. (wait/cl.) // 12. (wait/cl.) + #if defined(OS_ANDROID) // Android multi-process tests are not executing the new process. This is flaky. #define MAYBE_MultiprocessChannels DISABLED_MultiprocessChannels @@ -313,8 +335,13 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) { // |server_mp|), we die with a fatal error in |Channel::HandleLocalError()|. // 2. Read a message from |server_mp|. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + MojoHandleSignalsState state; + EXPECT_EQ(MOJO_RESULT_OK, + MojoNewWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); + char buffer[1000] = {}; uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, @@ -346,8 +373,11 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) { EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp)); // 9. Read a message from |mp0|, which should have |mp2| attached. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp0, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); + memset(buffer, 0, sizeof(buffer)); num_bytes = static_cast<uint32_t>(sizeof(buffer)); MojoHandle mp2 = MOJO_HANDLE_INVALID; @@ -362,8 +392,13 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) { EXPECT_NE(mp2, MOJO_HANDLE_INVALID); // 7. Read a message from |mp2|. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, + state.satisfied_signals); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, + state.satisfiable_signals); + memset(buffer, 0, sizeof(buffer)); num_bytes = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, @@ -380,8 +415,11 @@ TEST_F(EmbedderTest, MAYBE_MultiprocessChannels) { // TODO(vtl): crbug.com/351768 #if 0 EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + MojoNewWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + &state)); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfied_signals); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_NONE, state.satisfiable_signals); #endif EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp2)); } @@ -407,8 +445,13 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) { CHECK(client_channel.channel_info() != nullptr); // 1. Read the first message from |client_mp|. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + MojoHandleSignalsState state; + EXPECT_EQ(MOJO_RESULT_OK, + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); + char buffer[1000] = {}; uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, @@ -426,8 +469,15 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) { 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); // 4. Read a message from |client_mp|, which should have |mp1| attached. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, + MojoNewWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + // The other end of the handle may or may not be closed at this point, so we + // can't test MOJO_HANDLE_SIGNAL_WRITABLE or MOJO_HANDLE_SIGNAL_PEER_CLOSED. + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, + state.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, + state.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE); // TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd // die (again due to |Channel::HandleLocalError()|). memset(buffer, 0, sizeof(buffer)); @@ -470,8 +520,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) { mp2 = MOJO_HANDLE_INVALID; // 3. Read a message from |mp1|. - EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_OK, MojoNewWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(kSignalReadadableWritable, state.satisfied_signals); + EXPECT_EQ(kSignalAll, state.satisfiable_signals); + memset(buffer, 0, sizeof(buffer)); num_bytes = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, @@ -482,9 +535,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_TEST(MultiprocessChannelsClient) { EXPECT_STREQ(kFoo, buffer); // 11. Wait on |mp1| (which should eventually fail) and then close it. - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + MojoNewWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, &state)); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals); + EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals); EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp1)); } diff --git a/mojo/edk/embedder/entrypoints.cc b/mojo/edk/embedder/entrypoints.cc index 7b2e53f..6ecdd14 100644 --- a/mojo/edk/embedder/entrypoints.cc +++ b/mojo/edk/embedder/entrypoints.cc @@ -41,6 +41,25 @@ MojoResult MojoWaitMany(const MojoHandle* handles, : result; } +MojoResult MojoNewWait(MojoHandle handle, + MojoHandleSignals signals, + MojoDeadline deadline, + MojoHandleSignalsState* signals_state) { + return g_core->Wait(handle, signals, deadline, + MakeUserPointer(signals_state)); +} + +MojoResult MojoNewWaitMany(const MojoHandle* handles, + const MojoHandleSignals* signals, + uint32_t num_handles, + MojoDeadline deadline, + uint32_t* result_index, + MojoHandleSignalsState* signals_states) { + return g_core->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), + num_handles, deadline, MakeUserPointer(result_index), + MakeUserPointer(signals_states)); +} + MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options, MojoHandle* message_pipe_handle0, MojoHandle* message_pipe_handle1) { diff --git a/mojo/edk/embedder/simple_platform_shared_buffer_android.cc b/mojo/edk/embedder/simple_platform_shared_buffer_android.cc new file mode 100644 index 0000000..3517db3 --- /dev/null +++ b/mojo/edk/embedder/simple_platform_shared_buffer_android.cc @@ -0,0 +1,74 @@ +// Copyright 2014 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/embedder/simple_platform_shared_buffer.h" + +#include <stdint.h> +#include <sys/mman.h> // For |mmap()|/|munmap()|. +#include <sys/types.h> // For |off_t|. +#include <unistd.h> + +#include <limits> + +#include "base/files/scoped_file.h" +#include "base/logging.h" +#include "base/macros.h" +#include "mojo/edk/embedder/platform_handle.h" +#include "third_party/ashmem/ashmem.h" + +namespace mojo { +namespace embedder { + +// SimplePlatformSharedBuffer -------------------------------------------------- + +bool SimplePlatformSharedBuffer::Init() { + DCHECK(!handle_.is_valid()); + + if (static_cast<uint64_t>(num_bytes_) > + static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { + return false; + } + + base::ScopedFD fd(ashmem_create_region(nullptr, num_bytes_)); + if (!fd.is_valid()) { + DPLOG(ERROR) << "ashmem_create_region()"; + return false; + } + + if (ashmem_set_prot_region(fd.get(), PROT_READ | PROT_WRITE) < 0) { + DPLOG(ERROR) << "ashmem_set_prot_region()"; + return false; + } + + handle_.reset(PlatformHandle(fd.release())); + return true; +} + +bool SimplePlatformSharedBuffer::InitFromPlatformHandle( + ScopedPlatformHandle platform_handle) { + DCHECK(!handle_.is_valid()); + + if (static_cast<uint64_t>(num_bytes_) > + static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { + return false; + } + + int size = ashmem_get_size_region(platform_handle.get().fd); + + if (size < 0) { + DPLOG(ERROR) << "ashmem_get_size_region()"; + return false; + } + + if (static_cast<size_t>(size) != num_bytes_) { + LOG(ERROR) << "Shared memory region has the wrong size"; + return false; + } + + handle_ = platform_handle.Pass(); + return true; +} + +} // namespace embedder +} // namespace mojo diff --git a/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc b/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc index 8dfcf44..a3d10ef 100644 --- a/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc +++ b/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc @@ -33,6 +33,10 @@ namespace embedder { // SimplePlatformSharedBuffer -------------------------------------------------- +// The implementation for android uses ashmem to generate the file descriptor +// for the shared memory. See simple_platform_shared_buffer_android.cc +#if !defined(OS_ANDROID) + bool SimplePlatformSharedBuffer::Init() { DCHECK(!handle_.is_valid()); @@ -115,6 +119,8 @@ bool SimplePlatformSharedBuffer::InitFromPlatformHandle( return true; } +#endif // !defined(OS_ANDROID) + scoped_ptr<PlatformSharedBufferMapping> SimplePlatformSharedBuffer::MapImpl( size_t offset, size_t length) { diff --git a/mojo/edk/embedder/simple_platform_shared_buffer_unittest.cc b/mojo/edk/embedder/simple_platform_shared_buffer_unittest.cc index 45d27b9..4644b7b 100644 --- a/mojo/edk/embedder/simple_platform_shared_buffer_unittest.cc +++ b/mojo/edk/embedder/simple_platform_shared_buffer_unittest.cc @@ -24,7 +24,7 @@ TEST(SimplePlatformSharedBufferTest, Basic) { // Make some memory. scoped_refptr<SimplePlatformSharedBuffer> buffer( SimplePlatformSharedBuffer::Create(kNumBytes)); - ASSERT_TRUE(buffer.get()); + ASSERT_TRUE(buffer); // Map it all, scribble some stuff, and then unmap it. { @@ -100,7 +100,7 @@ TEST(SimplePlatformSharedBufferTest, Basic) { TEST(SimplePlatformSharedBufferTest, InvalidMappings) { scoped_refptr<SimplePlatformSharedBuffer> buffer( SimplePlatformSharedBuffer::Create(100)); - ASSERT_TRUE(buffer.get()); + ASSERT_TRUE(buffer); // Zero length not allowed. EXPECT_FALSE(buffer->Map(0, 0)); @@ -133,7 +133,7 @@ TEST(SimplePlatformSharedBufferTest, TooBig) { SimplePlatformSharedBuffer::Create(kMaxSizeT)); // But, assuming |sizeof(size_t) == sizeof(void*)|, mapping all of it should // always fail. - if (buffer.get()) + if (buffer) EXPECT_FALSE(buffer->Map(0, kMaxSizeT)); } diff --git a/mojo/edk/js/BUILD.gn b/mojo/edk/js/BUILD.gn index 5a7e3d5..9a066d3 100644 --- a/mojo/edk/js/BUILD.gn +++ b/mojo/edk/js/BUILD.gn @@ -2,7 +2,9 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. -source_set("js") { +import("../mojo_edk.gni") + +mojo_edk_source_set("js") { sources = [ "core.cc", "core.h", @@ -27,22 +29,28 @@ source_set("js") { "//v8", ] - deps = [ - "//mojo/public/cpp/environment", - "//mojo/public/cpp/system", + mojo_sdk_deps = [ + "mojo/public/cpp/environment", + "mojo/public/cpp/system", ] } -source_set("js_unittests") { +mojo_edk_source_set("js_unittests") { testonly = true sources = [ "handle_unittest.cc", ] deps = [ - "//mojo/edk/js", - "//mojo/edk/test:test_support", - "//mojo/public/cpp/system", "//testing/gtest", ] + + mojo_edk_deps = [ + "mojo/edk/js", + "mojo/edk/test:test_support", + ] + + mojo_sdk_deps = [ + "mojo/public/cpp/system", + ] } diff --git a/mojo/edk/js/test/BUILD.gn b/mojo/edk/js/test/BUILD.gn index be3a641..6e9792c 100644 --- a/mojo/edk/js/test/BUILD.gn +++ b/mojo/edk/js/test/BUILD.gn @@ -4,17 +4,17 @@ test("js_unittests") { deps = [ + "../../js", + "../../js:js_unittests", + "../../test:run_all_unittests", + "../../test:test_support", + "../../../environment:chromium", + "../../../public/cpp/environment", + "../../../public/cpp/system", + "../../../public/cpp/utility", + "../../../public/interfaces/bindings/tests:test_interfaces", "//base", "//gin:gin_test", - "//mojo/edk/js", - "//mojo/edk/js:js_unittests", - "//mojo/edk/test:run_all_unittests", - "//mojo/edk/test:test_support", - "//mojo/public/cpp/environment", - "//mojo/public/cpp/system", - "//mojo/public/cpp/utility", - "//mojo/environment:chromium", - "//mojo/public/interfaces/bindings/tests:test_interfaces", ] sources = [ @@ -24,15 +24,15 @@ test("js_unittests") { test("js_integration_tests") { deps = [ + "../../js", + "../../js/tests:js_to_cpp_tests", + "../../test:run_all_unittests", + "../../test:test_support", + "../../../environment:chromium", + "../../../public/cpp/bindings", + "../../../public/interfaces/bindings/tests:test_interfaces", "//base", "//gin:gin_test", - "//mojo/edk/js", - "//mojo/edk/js/tests:js_to_cpp_tests", - "//mojo/edk/test:run_all_unittests", - "//mojo/edk/test:test_support", - "//mojo/public/cpp/bindings", - "//mojo/environment:chromium", - "//mojo/public/interfaces/bindings/tests:test_interfaces", ] sources = [ diff --git a/mojo/edk/js/tests/BUILD.gn b/mojo/edk/js/tests/BUILD.gn index c7f568b..c9711c7 100644 --- a/mojo/edk/js/tests/BUILD.gn +++ b/mojo/edk/js/tests/BUILD.gn @@ -2,19 +2,26 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. -import("//mojo/public/tools/bindings/mojom.gni") +import("../../mojo_edk.gni") +import("../../../public/tools/bindings/mojom.gni") -source_set("js_to_cpp_tests") { +mojo_edk_source_set("js_to_cpp_tests") { testonly = true deps = [ ":js_to_cpp_bindings", "//gin:gin_test", - "//mojo/edk/js", - "//mojo/edk/test:test_support", - "//mojo/public/cpp/bindings", - "//mojo/public/cpp/system", - "//mojo/public/interfaces/bindings/tests:test_interfaces", + ] + + mojo_edk_deps = [ + "mojo/edk/js", + "mojo/edk/test:test_support", + ] + + mojo_sdk_deps = [ + "mojo/public/cpp/bindings", + "mojo/public/cpp/system", + "mojo/public/interfaces/bindings/tests:test_interfaces", ] sources = [ diff --git a/mojo/edk/js/tests/connection_tests.js b/mojo/edk/js/tests/connection_tests.js index 6649dfe..17009d9 100644 --- a/mojo/edk/js/tests/connection_tests.js +++ b/mojo/edk/js/tests/connection_tests.js @@ -81,14 +81,20 @@ define([ threading.quit(); }.bind(this)); + function createPeerConnection(handle, stubClass, proxyClass) { + var c = new connection.Connection(handle, stubClass, proxyClass); + c.local.peer = c.remote; + c.remote.peer = c.local; + return c; + } + function testClientServer() { var receivedFrobinate = false; var receivedDidFrobinate = false; // ServiceImpl ------------------------------------------------------------ - function ServiceImpl(peer) { - this.peer = peer; + function ServiceImpl() { } ServiceImpl.prototype = Object.create( @@ -106,8 +112,7 @@ define([ // ServiceClientImpl ------------------------------------------------------ - function ServiceClientImpl(peer) { - this.peer = peer; + function ServiceClientImpl() { } ServiceClientImpl.prototype = @@ -123,10 +128,10 @@ define([ var anotherPipe = core.createMessagePipe(); var sourcePipe = core.createMessagePipe(); - var connection0 = new connection.Connection( + var connection0 = createPeerConnection( pipe.handle0, ServiceImpl, sample_service.ServiceClient.proxyClass); - var connection1 = new connection.Connection( + var connection1 = createPeerConnection( pipe.handle1, ServiceClientImpl, sample_service.Service.proxyClass); var foo = new sample_service.Foo(); @@ -163,7 +168,7 @@ define([ function testWriteToClosedPipe() { var pipe = core.createMessagePipe(); - var connection1 = new connection.Connection( + var connection1 = createPeerConnection( pipe.handle1, function() {}, sample_service.Service.proxyClass); // Close the other end of the pipe. @@ -192,8 +197,7 @@ define([ // ProviderImpl ------------------------------------------------------------ - function ProviderImpl(peer) { - this.peer = peer; + function ProviderImpl() { } ProviderImpl.prototype = @@ -211,8 +215,7 @@ define([ // ProviderClientImpl ------------------------------------------------------ - function ProviderClientImpl(peer) { - this.peer = peer; + function ProviderClientImpl() { } ProviderClientImpl.prototype = @@ -220,12 +223,12 @@ define([ var pipe = core.createMessagePipe(); - var connection0 = new connection.Connection( + var connection0 = createPeerConnection( pipe.handle0, ProviderImpl, sample_interfaces.ProviderClient.proxyClass); - var connection1 = new connection.Connection( + var connection1 = createPeerConnection( pipe.handle1, ProviderClientImpl, sample_interfaces.Provider.proxyClass); diff --git a/mojo/edk/js/tests/js_to_cpp_tests.js b/mojo/edk/js/tests/js_to_cpp_tests.js index c32f0af..140ad4c 100644 --- a/mojo/edk/js/tests/js_to_cpp_tests.js +++ b/mojo/edk/js/tests/js_to_cpp_tests.js @@ -19,9 +19,7 @@ define('mojo/edk/js/tests/js_to_cpp_tests', [ capacityNumBytes: 64 }; - function JsSideConnection(cppSide) { - this.cppSide_ = cppSide; - cppSide.startTest(); + function JsSideConnection() { } JsSideConnection.prototype = @@ -205,6 +203,12 @@ define('mojo/edk/js/tests/js_to_cpp_tests', [ }, null); } + function createCppSideConnection(handle, stubClass, proxyClass) { + var c = new connection.Connection(handle, stubClass, proxyClass); + c.local.cppSide_ = c.remote; + return c; + } + return function(handle) { var i; sampleData = new Uint8Array(DATA_PIPE_PARAMS.capacityNumBytes); @@ -215,7 +219,8 @@ define('mojo/edk/js/tests/js_to_cpp_tests', [ for (i = 0; i < sampleMessage.length; ++i) { sampleMessage[i] = 255 - i; } - retainedConnection = new connection.Connection(handle, JsSideConnection, - jsToCpp.CppSide.proxyClass); + retainedConnection = createCppSideConnection( + handle, JsSideConnection,jsToCpp.CppSide.proxyClass); + retainedConnection.remote.startTest(); }; }); diff --git a/mojo/edk/mojo_edk.gni b/mojo/edk/mojo_edk.gni new file mode 100644 index 0000000..34b82d4 --- /dev/null +++ b/mojo/edk/mojo_edk.gni @@ -0,0 +1,96 @@ +# Copyright 2014 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. + +import("../public/mojo_sdk.gni") + +# A mojo_edk_source_set is a mojo_sdk_source_set that does not restrict +# external dependencies and understands the following additional variables, all +# of which admit a list of the relevant elements specified relative to the +# location of the Mojo EDK: +# mojo_edk_configs +# allow_circular_mojo_edk_includes_from +# mojo_edk_public_deps +# mojo_edk_deps + +# Note that it is assumed that the Mojo EDK is a sibling of the Mojo SDK in a +# client repo; the distinctions made above are for the sake of clarity in +# writing targets. +template("mojo_edk_source_set") { + mojo_sdk_source_set(target_name) { + restrict_external_deps = false + + if (defined(invoker.visibility)) { + visibility = invoker.visibility + } + if (defined(invoker.mojo_edk_visibility)) { + mojo_sdk_visibility = invoker.mojo_edk_visibility + } + if (defined(invoker.testonly)) { + testonly = invoker.testonly + } + if (defined(invoker.sources)) { + sources = invoker.sources + } + if (defined(invoker.defines)) { + defines = invoker.defines + } + if (defined(invoker.public_configs)) { + public_configs = invoker.public_configs + } + + configs = [] + if (defined(invoker.configs)) { + configs = invoker.configs + } + if (defined(invoker.mojo_edk_configs)) { + foreach(edk_config, invoker.mojo_edk_configs) { + # Check that the EDK config was not mistakenly given as an absolute + # path. + assert(get_path_info(edk_config, "abspath") != edk_config) + configs += [ rebase_path(edk_config, ".", mojo_root) ] + } + } + + allow_circular_includes_from = [] + if (defined(invoker.allow_circular_includes_from)) { + allow_circular_includes_from += invoker.allow_circular_includes_from + } + if (defined(invoker.allow_circular_mojo_edk_includes_from)) { + foreach(edk_target, invoker.allow_circular_mojo_edk_includes_from) { + # Check that the EDK target was not mistakenly given as an absolute + # path. + assert(get_path_info(edk_target, "abspath") != edk_target) + allow_circular_includes_from += [ + rebase_path(edk_target, ".", mojo_root) + ] + } + } + + if (defined(invoker.public_deps)) { + public_deps = invoker.public_deps + } + mojo_sdk_public_deps = [] + if (defined(invoker.mojo_edk_public_deps)) { + # The EDK is required to be a sibling of the SDK, so the relative + # dependencies are rewritten in the same way. + mojo_sdk_public_deps = invoker.mojo_edk_public_deps + } + if (defined(invoker.mojo_sdk_public_deps)) { + mojo_sdk_public_deps += invoker.mojo_sdk_public_deps + } + + if (defined(invoker.deps)) { + deps = invoker.deps + } + mojo_sdk_deps = [] + if (defined(invoker.mojo_edk_deps)) { + # The EDK is required to be a sibling of the SDK, so the relative + # dependencies are rewritten in the same way. + mojo_sdk_deps = invoker.mojo_edk_deps + } + if (defined(invoker.mojo_sdk_deps)) { + mojo_sdk_deps += invoker.mojo_sdk_deps + } + } +} diff --git a/mojo/edk/mojo_edk_system_impl.gypi b/mojo/edk/mojo_edk_system_impl.gypi index a0af387..bab747b 100644 --- a/mojo/edk/mojo_edk_system_impl.gypi +++ b/mojo/edk/mojo_edk_system_impl.gypi @@ -37,10 +37,14 @@ 'embedder/scoped_platform_handle.h', 'embedder/simple_platform_shared_buffer.cc', 'embedder/simple_platform_shared_buffer.h', + 'embedder/simple_platform_shared_buffer_android.cc', 'embedder/simple_platform_shared_buffer_posix.cc', 'embedder/simple_platform_shared_buffer_win.cc', 'embedder/simple_platform_support.cc', 'embedder/simple_platform_support.h', + 'system/awakable.h', + 'system/awakable_list.cc', + 'system/awakable_list.h', 'system/channel.cc', 'system/channel.h', 'system/channel_endpoint.cc', @@ -64,6 +68,8 @@ 'system/data_pipe_producer_dispatcher.h', 'system/dispatcher.cc', 'system/dispatcher.h', + 'system/endpoint_relayer.cc', + 'system/endpoint_relayer.h', 'system/handle_signals_state.h', 'system/handle_table.cc', 'system/handle_table.h', @@ -102,8 +108,6 @@ 'system/transport_data.h', 'system/waiter.cc', 'system/waiter.h', - 'system/waiter_list.cc', - 'system/waiter_list.h', # Test-only code: # TODO(vtl): It's a little unfortunate that these end up in the same # component as non-test-only code. In the static build, this code @@ -115,4 +119,11 @@ # Ensures that dependent projects import the core functions on Windows. 'defines': ['MOJO_USE_SYSTEM_IMPL'], }, + 'conditions': [ + ['OS=="android"', { + "dependencies": [ + "<(DEPTH)/third_party/ashmem/ashmem.gyp:ashmem", + ], + }], + ], } diff --git a/mojo/edk/mojo_edk_tests.gyp b/mojo/edk/mojo_edk_tests.gyp index b877967..a571069 100644 --- a/mojo/edk/mojo_edk_tests.gyp +++ b/mojo/edk/mojo_edk_tests.gyp @@ -168,6 +168,7 @@ 'embedder/embedder_unittest.cc', 'embedder/platform_channel_pair_posix_unittest.cc', 'embedder/simple_platform_shared_buffer_unittest.cc', + 'system/awakable_list_unittest.cc', 'system/channel_endpoint_id_unittest.cc', 'system/channel_manager_unittest.cc', 'system/channel_unittest.cc', @@ -192,7 +193,6 @@ 'system/simple_dispatcher_unittest.cc', 'system/test_utils.cc', 'system/test_utils.h', - 'system/waiter_list_unittest.cc', 'system/waiter_test_utils.cc', 'system/waiter_test_utils.h', 'system/waiter_unittest.cc', diff --git a/mojo/edk/system/BUILD.gn b/mojo/edk/system/BUILD.gn index 8cc8905..8d24a08 100644 --- a/mojo/edk/system/BUILD.gn +++ b/mojo/edk/system/BUILD.gn @@ -2,6 +2,8 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. +import("../mojo_edk.gni") + if (is_android) { import("//build/config/android/config.gni") import("//build/config/android/rules.gni") @@ -18,6 +20,9 @@ component("system") { output_name = "mojo_system_impl" sources = [ + "awakable.h", + "awakable_list.cc", + "awakable_list.h", "channel.cc", "channel.h", "channel_endpoint.cc", @@ -41,6 +46,8 @@ component("system") { "data_pipe_producer_dispatcher.h", "dispatcher.cc", "dispatcher.h", + "endpoint_relayer.cc", + "endpoint_relayer.h", "handle_signals_state.h", "handle_table.cc", "handle_table.h", @@ -79,8 +86,6 @@ component("system") { "transport_data.h", "waiter.cc", "waiter.h", - "waiter_list.cc", - "waiter_list.h", ] defines = [ @@ -91,9 +96,9 @@ component("system") { all_dependent_configs = [ ":system_config" ] public_deps = [ - "//mojo/edk/embedder", - "//mojo/edk/embedder:platform", - "//mojo/public/c/system", + "../embedder", + "../embedder:platform", + "../../public/c/system", ] deps = [ @@ -101,13 +106,28 @@ component("system") { "//base/third_party/dynamic_annotations", ] - allow_circular_includes_from = [ "//mojo/edk/embedder" ] + allow_circular_includes_from = [ "../embedder" ] +} + +mojo_edk_source_set("test_utils") { + testonly = true + + sources = [ + "test_utils.cc", + "test_utils.h", + ] + + deps = [ + "//base", + "//base/test:test_support", + ] } # GYP version: mojo/edk/mojo_edk.gyp:mojo_system_unittests test("mojo_system_unittests") { sources = [ "../test/multiprocess_test_helper_unittest.cc", + "awakable_list_unittest.cc", "channel_endpoint_id_unittest.cc", "channel_manager_unittest.cc", "channel_unittest.cc", @@ -130,11 +150,6 @@ test("mojo_system_unittests") { "run_all_unittests.cc", "shared_buffer_dispatcher_unittest.cc", "simple_dispatcher_unittest.cc", - - # TODO(vtl): Factor test_utils.* into their own source set. - "test_utils.cc", - "test_utils.h", - "waiter_list_unittest.cc", "waiter_test_utils.cc", "waiter_test_utils.h", "waiter_unittest.cc", @@ -142,10 +157,11 @@ test("mojo_system_unittests") { deps = [ ":system", + ":test_utils", + "../embedder:embedder_unittests", + "../test:test_support", "//base", "//base/test:test_support", - "//mojo/edk/embedder:embedder_unittests", - "//mojo/edk/test:test_support", "//testing/gtest", ] @@ -153,7 +169,7 @@ test("mojo_system_unittests") { deps += [ "//testing/android:native_test_native_code" ] } - allow_circular_includes_from = [ "//mojo/edk/embedder:embedder_unittests" ] + allow_circular_includes_from = [ "../embedder:embedder_unittests" ] } # GYP version: mojo/edk/mojo_edk.gyp:mojo_message_pipe_perftests @@ -162,16 +178,15 @@ test("mojo_message_pipe_perftests") { "message_pipe_perftest.cc", "message_pipe_test_utils.h", "message_pipe_test_utils.cc", - "test_utils.cc", - "test_utils.h", ] deps = [ ":system", + ":test_utils", + "../test:test_support", "//base", "//base/test:test_support", "//base/test:test_support_perf", - "//mojo/edk/test:test_support", "//testing/gtest", ] } diff --git a/mojo/edk/system/awakable.h b/mojo/edk/system/awakable.h new file mode 100644 index 0000000..5479912 --- /dev/null +++ b/mojo/edk/system/awakable.h @@ -0,0 +1,32 @@ +// Copyright 2013 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. + +#ifndef MOJO_EDK_SYSTEM_AWAKABLE_H_ +#define MOJO_EDK_SYSTEM_AWAKABLE_H_ + +#include <stdint.h> + +#include "mojo/edk/system/system_impl_export.h" +#include "mojo/public/c/system/types.h" + +namespace mojo { +namespace system { + +// An interface that may be waited on |AwakableList|. +class MOJO_SYSTEM_IMPL_EXPORT Awakable { + public: + // |Awake()| must satisfy the following contract: + // * As this is called from any thread, this must be thread-safe. + // * As this is called inside a lock, this must not call anything that takes + // "non-terminal" locks, i.e., those which are always safe to take. + virtual void Awake(MojoResult result, uintptr_t context) = 0; + + protected: + Awakable() {} +}; + +} // namespace system +} // namespace mojo + +#endif // MOJO_EDK_SYSTEM_AWAKABLE_H_ diff --git a/mojo/edk/system/awakable_list.cc b/mojo/edk/system/awakable_list.cc new file mode 100644 index 0000000..6af305b --- /dev/null +++ b/mojo/edk/system/awakable_list.cc @@ -0,0 +1,58 @@ +// Copyright 2013 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/awakable_list.h" + +#include "base/logging.h" +#include "mojo/edk/system/awakable.h" +#include "mojo/edk/system/handle_signals_state.h" + +namespace mojo { +namespace system { + +AwakableList::AwakableList() { +} + +AwakableList::~AwakableList() { + DCHECK(awakables_.empty()); +} + +void AwakableList::AwakeForStateChange(const HandleSignalsState& state) { + for (AwakeInfoList::iterator it = awakables_.begin(); it != awakables_.end(); + ++it) { + if (state.satisfies(it->signals)) + it->awakable->Awake(MOJO_RESULT_OK, it->context); + else if (!state.can_satisfy(it->signals)) + it->awakable->Awake(MOJO_RESULT_FAILED_PRECONDITION, it->context); + } +} + +void AwakableList::CancelAll() { + for (AwakeInfoList::iterator it = awakables_.begin(); it != awakables_.end(); + ++it) { + it->awakable->Awake(MOJO_RESULT_CANCELLED, it->context); + } + awakables_.clear(); +} + +void AwakableList::Add(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context) { + awakables_.push_back(AwakeInfo(awakable, signals, context)); +} + +void AwakableList::Remove(Awakable* awakable) { + // We allow a thread to wait on the same handle multiple times simultaneously, + // so we need to scan the entire list and remove all occurrences of |waiter|. + for (AwakeInfoList::iterator it = awakables_.begin(); + it != awakables_.end();) { + AwakeInfoList::iterator maybe_delete = it; + ++it; + if (maybe_delete->awakable == awakable) + awakables_.erase(maybe_delete); + } +} + +} // namespace system +} // namespace mojo diff --git a/mojo/edk/system/awakable_list.h b/mojo/edk/system/awakable_list.h new file mode 100644 index 0000000..19c03c8 --- /dev/null +++ b/mojo/edk/system/awakable_list.h @@ -0,0 +1,58 @@ +// Copyright 2013 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. + +#ifndef MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_ +#define MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_ + +#include <stdint.h> + +#include <list> + +#include "base/macros.h" +#include "mojo/edk/system/system_impl_export.h" +#include "mojo/public/c/system/types.h" + +namespace mojo { +namespace system { + +class Awakable; +struct HandleSignalsState; + +// |AwakableList| tracks all the |Waiter|s that are waiting on a given +// handle/|Dispatcher|. There should be a |AwakableList| for each handle that +// can be waited on (in any way). In the simple case, the |AwakableList| is +// owned by the |Dispatcher|, whereas in more complex cases it is owned by the +// secondary object (see simple_dispatcher.* and the explanatory comment in +// core.cc). This class is thread-unsafe (all concurrent access must be +// protected by some lock). +class MOJO_SYSTEM_IMPL_EXPORT AwakableList { + public: + AwakableList(); + ~AwakableList(); + + void AwakeForStateChange(const HandleSignalsState& state); + void CancelAll(); + void Add(Awakable* awakable, MojoHandleSignals signals, uint32_t context); + void Remove(Awakable* awakable); + + private: + struct AwakeInfo { + AwakeInfo(Awakable* awakable, MojoHandleSignals signals, uint32_t context) + : awakable(awakable), signals(signals), context(context) {} + + Awakable* awakable; + MojoHandleSignals signals; + uint32_t context; + }; + typedef std::list<AwakeInfo> AwakeInfoList; + + AwakeInfoList awakables_; + + DISALLOW_COPY_AND_ASSIGN(AwakableList); +}; + +} // namespace system +} // namespace mojo + +#endif // MOJO_EDK_SYSTEM_AWAKABLE_LIST_H_ diff --git a/mojo/edk/system/waiter_list_unittest.cc b/mojo/edk/system/awakable_list_unittest.cc index 129df71..201b751 100644 --- a/mojo/edk/system/waiter_list_unittest.cc +++ b/mojo/edk/system/awakable_list_unittest.cc @@ -7,7 +7,7 @@ // increase tolerance and reduce observed flakiness (though doing so reduces the // meaningfulness of the test). -#include "mojo/edk/system/waiter_list.h" +#include "mojo/edk/system/awakable_list.h" #include "base/threading/platform_thread.h" // For |Sleep()|. #include "base/time/time.h" @@ -21,29 +21,29 @@ namespace mojo { namespace system { namespace { -TEST(WaiterListTest, BasicCancel) { +TEST(AwakableListTest, BasicCancel) { MojoResult result; uint32_t context; // Cancel immediately after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); - waiter_list.CancelAllWaiters(); + awakable_list.CancelAll(); // Double-remove okay: - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_CANCELLED, result); EXPECT_EQ(1u, context); // Cancel before after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); - waiter_list.CancelAllWaiters(); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); + awakable_list.CancelAll(); thread.Start(); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_CANCELLED, result); @@ -51,46 +51,46 @@ TEST(WaiterListTest, BasicCancel) { // Cancel some time after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.CancelAllWaiters(); + awakable_list.CancelAll(); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_CANCELLED, result); EXPECT_EQ(3u, context); } -TEST(WaiterListTest, BasicAwakeSatisfied) { +TEST(AwakableListTest, BasicAwakeSatisfied) { MojoResult result; uint32_t context; // Awake immediately after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); EXPECT_EQ(1u, context); // Awake before after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); // Double-remove okay: - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); thread.Start(); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); @@ -98,45 +98,45 @@ TEST(WaiterListTest, BasicAwakeSatisfied) { // Awake some time after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); EXPECT_EQ(3u, context); } -TEST(WaiterListTest, BasicAwakeUnsatisfiable) { +TEST(AwakableListTest, BasicAwakeUnsatisfiable) { MojoResult result; uint32_t context; // Awake (for unsatisfiability) immediately after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(1u, context); // Awake (for unsatisfiability) before after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); thread.Start(); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); @@ -144,22 +144,22 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) { // Awake (for unsatisfiability) some time after thread start. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread(&result, &context); - waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); + awakable_list.Add(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); // Double-remove okay: - waiter_list.RemoveWaiter(thread.waiter()); + awakable_list.Remove(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(3u, context); } -TEST(WaiterListTest, MultipleWaiters) { +TEST(AwakableListTest, MultipleAwakables) { MojoResult result1; MojoResult result2; MojoResult result3; @@ -169,110 +169,110 @@ TEST(WaiterListTest, MultipleWaiters) { uint32_t context3; uint32_t context4; - // Cancel two waiters. + // Cancel two awakables. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread1(&result1, &context1); - waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); + awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread1.Start(); test::SimpleWaiterThread thread2(&result2, &context2); - waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); + awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); thread2.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.CancelAllWaiters(); + awakable_list.CancelAll(); } // Join threads. EXPECT_EQ(MOJO_RESULT_CANCELLED, result1); EXPECT_EQ(1u, context1); EXPECT_EQ(MOJO_RESULT_CANCELLED, result2); EXPECT_EQ(2u, context2); - // Awake one waiter, cancel other. + // Awake one awakable, cancel other. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread1(&result1, &context1); - waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); + awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread1.Start(); test::SimpleWaiterThread thread2(&result2, &context2); - waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 4); + awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 4); thread2.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread1.waiter()); - waiter_list.CancelAllWaiters(); + awakable_list.Remove(thread1.waiter()); + awakable_list.CancelAll(); } // Join threads. EXPECT_EQ(MOJO_RESULT_OK, result1); EXPECT_EQ(3u, context1); EXPECT_EQ(MOJO_RESULT_CANCELLED, result2); EXPECT_EQ(4u, context2); - // Cancel one waiter, awake other for unsatisfiability. + // Cancel one awakable, awake other for unsatisfiability. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread1(&result1, &context1); - waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 5); + awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 5); thread1.Start(); test::SimpleWaiterThread thread2(&result2, &context2); - waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 6); + awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 6); thread2.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE)); - waiter_list.RemoveWaiter(thread2.waiter()); - waiter_list.CancelAllWaiters(); + awakable_list.Remove(thread2.waiter()); + awakable_list.CancelAll(); } // Join threads. EXPECT_EQ(MOJO_RESULT_CANCELLED, result1); EXPECT_EQ(5u, context1); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result2); EXPECT_EQ(6u, context2); - // Cancel one waiter, awake other for unsatisfiability. + // Cancel one awakable, awake other for unsatisfiability. { - WaiterList waiter_list; + AwakableList awakable_list; test::SimpleWaiterThread thread1(&result1, &context1); - waiter_list.AddWaiter(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 7); + awakable_list.Add(thread1.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 7); thread1.Start(); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Should do nothing. - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); test::SimpleWaiterThread thread2(&result2, &context2); - waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8); + awakable_list.Add(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8); thread2.Start(); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Awake #1. - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); - waiter_list.RemoveWaiter(thread1.waiter()); + awakable_list.Remove(thread1.waiter()); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); test::SimpleWaiterThread thread3(&result3, &context3); - waiter_list.AddWaiter(thread3.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 9); + awakable_list.Add(thread3.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 9); thread3.Start(); test::SimpleWaiterThread thread4(&result4, &context4); - waiter_list.AddWaiter(thread4.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 10); + awakable_list.Add(thread4.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 10); thread4.Start(); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Awake #2 and #3 for unsatisfiability. - waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + awakable_list.AwakeForStateChange(HandleSignalsState( MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE)); - waiter_list.RemoveWaiter(thread2.waiter()); - waiter_list.RemoveWaiter(thread3.waiter()); + awakable_list.Remove(thread2.waiter()); + awakable_list.Remove(thread3.waiter()); // Cancel #4. - waiter_list.CancelAllWaiters(); + awakable_list.CancelAll(); } // Join threads. EXPECT_EQ(MOJO_RESULT_OK, result1); EXPECT_EQ(7u, context1); diff --git a/mojo/edk/system/channel.cc b/mojo/edk/system/channel.cc index 3d6c54f..1e26145 100644 --- a/mojo/edk/system/channel.cc +++ b/mojo/edk/system/channel.cc @@ -72,7 +72,7 @@ void Channel::Shutdown() { size_t num_zombies = 0; for (IdToEndpointMap::iterator it = to_destroy.begin(); it != to_destroy.end(); ++it) { - if (it->second.get()) { + if (it->second) { num_live++; it->second->DetachFromChannel(); } else { @@ -97,7 +97,7 @@ void Channel::WillShutdownSoon() { ChannelEndpointId Channel::AttachAndRunEndpoint( scoped_refptr<ChannelEndpoint> endpoint, bool is_bootstrap) { - DCHECK(endpoint.get()); + DCHECK(endpoint); ChannelEndpointId local_id; ChannelEndpointId remote_id; @@ -185,7 +185,7 @@ void Channel::DetachEndpoint(ChannelEndpoint* endpoint, if (it == local_id_to_endpoint_map_.end() || it->second.get() != endpoint) return; - DCHECK(it->second.get()); + DCHECK(it->second); it->second = nullptr; // Send a remove message outside the lock. @@ -306,7 +306,7 @@ void Channel::OnReadMessageForEndpoint( local_id_to_endpoint_map_.find(local_id); if (it != local_id_to_endpoint_map_.end()) { // Ignore messages for zombie endpoints (not an error). - if (!it->second.get()) { + if (!it->second) { DVLOG(2) << "Ignoring downstream message for zombie endpoint (local ID " "= " << local_id << ", remote ID = " << message_view.source_id() << ")"; @@ -316,7 +316,7 @@ void Channel::OnReadMessageForEndpoint( endpoint = it->second; } } - if (!endpoint.get()) { + if (!endpoint) { HandleRemoteError(base::StringPrintf( "Received a message for nonexistent local destination ID %u", static_cast<unsigned>(local_id.value()))); @@ -453,7 +453,7 @@ bool Channel::OnRemoveMessagePipeEndpoint(ChannelEndpointId local_id, return false; } - if (!it->second.get()) { + if (!it->second) { // Remove messages "crossed"; we have to wait for the ack. return true; } @@ -489,7 +489,7 @@ bool Channel::OnRemoveMessagePipeEndpointAck(ChannelEndpointId local_id) { return false; } - if (it->second.get()) { + if (it->second) { DVLOG(2) << "Remove message pipe endpoint ack error: wrong state"; return false; } diff --git a/mojo/edk/system/channel_endpoint.cc b/mojo/edk/system/channel_endpoint.cc index a8bbbb2..8ef1f40 100644 --- a/mojo/edk/system/channel_endpoint.cc +++ b/mojo/edk/system/channel_endpoint.cc @@ -5,6 +5,7 @@ #include "mojo/edk/system/channel_endpoint.h" #include "base/logging.h" +#include "base/threading/platform_thread.h" #include "mojo/edk/system/channel.h" #include "mojo/edk/system/channel_endpoint_client.h" @@ -14,8 +15,11 @@ namespace system { ChannelEndpoint::ChannelEndpoint(ChannelEndpointClient* client, unsigned client_port, MessageInTransitQueue* message_queue) - : client_(client), client_port_(client_port), channel_(nullptr) { - DCHECK(client_.get() || message_queue); + : client_(client), + client_port_(client_port), + channel_(nullptr), + is_detached_from_channel_(false) { + DCHECK(client_ || message_queue); if (message_queue) channel_message_queue_.Swap(message_queue); @@ -39,21 +43,27 @@ bool ChannelEndpoint::EnqueueMessage(scoped_ptr<MessageInTransit> message) { return WriteMessageNoLock(message.Pass()); } +bool ChannelEndpoint::ReplaceClient(ChannelEndpointClient* client, + unsigned client_port) { + DCHECK(client); + + base::AutoLock locker(lock_); + DCHECK(client_); + DCHECK(client != client_.get() || client_port != client_port_); + client_ = client; + client_port_ = client_port; + return !is_detached_from_channel_; +} + void ChannelEndpoint::DetachFromClient() { - { - base::AutoLock locker(lock_); - DCHECK(client_.get()); - client_ = nullptr; + base::AutoLock locker(lock_); + DCHECK(client_); + client_ = nullptr; - if (!channel_) - return; - DCHECK(local_id_.is_valid()); - DCHECK(remote_id_.is_valid()); - channel_->DetachEndpoint(this, local_id_, remote_id_); - channel_ = nullptr; - local_id_ = ChannelEndpointId(); - remote_id_ = ChannelEndpointId(); - } + if (!channel_) + return; + channel_->DetachEndpoint(this, local_id_, remote_id_); + ResetChannelNoLock(); } void ChannelEndpoint::AttachAndRun(Channel* channel, @@ -76,32 +86,52 @@ void ChannelEndpoint::AttachAndRun(Channel* channel, << "Failed to write enqueue message to channel"; } - if (!client_.get()) { + if (!client_) { channel_->DetachEndpoint(this, local_id_, remote_id_); - channel_ = nullptr; - local_id_ = ChannelEndpointId(); - remote_id_ = ChannelEndpointId(); + ResetChannelNoLock(); } } void ChannelEndpoint::OnReadMessage(scoped_ptr<MessageInTransit> message) { scoped_refptr<ChannelEndpointClient> client; - unsigned client_port; - { - base::AutoLock locker(lock_); - DCHECK(channel_); - if (!client_.get()) { - // This isn't a failure per se. (It just means that, e.g., the other end - // of the message point closed first.) - return; + unsigned client_port = 0; + + // This loop is to make |ReplaceClient()| work. We can't call the client's + // |OnReadMessage()| under our lock, so by the time we do that, |client| may + // no longer be our client. + // + // In that case, |client| must return false. We'll then yield, and retry with + // the new client. (Theoretically, the client could be replaced again.) + // + // This solution isn't terribly elegant, but it's the least costly way of + // handling/avoiding this (very unlikely) race. (Other solutions -- e.g., + // adding a client message queue, which the client only fetches messages from + // -- impose significant cost in the common case.) + for (;;) { + { + base::AutoLock locker(lock_); + if (!channel_ || !client_) { + // This isn't a failure per se. (It just means that, e.g., the other end + // of the message point closed first.) + return; + } + + // If we get here in a second (third, etc.) iteration of the loop, it's + // because |ReplaceClient()| was called. + DCHECK(client_ != client || client_port_ != client_port); + + // Take a ref, and call |OnReadMessage()| outside the lock. + client = client_; + client_port = client_port_; } - // Take a ref, and call |OnReadMessage()| outside the lock. - client = client_; - client_port = client_port_; - } + if (client->OnReadMessage(client_port, message.get())) { + ignore_result(message.release()); + break; + } - client->OnReadMessage(client_port, message.Pass()); + base::PlatformThread::YieldCurrentThread(); + } } void ChannelEndpoint::DetachFromChannel() { @@ -110,7 +140,7 @@ void ChannelEndpoint::DetachFromChannel() { { base::AutoLock locker(lock_); - if (client_.get()) { + if (client_) { // Take a ref, and call |OnDetachFromChannel()| outside the lock. client = client_; client_port = client_port_; @@ -119,21 +149,23 @@ void ChannelEndpoint::DetachFromChannel() { // |channel_| may already be null if we already detached from the channel in // |DetachFromClient()| by calling |Channel::DetachEndpoint()| (and there // are racing detaches). - if (channel_) { - DCHECK(local_id_.is_valid()); - DCHECK(remote_id_.is_valid()); - channel_ = nullptr; - local_id_ = ChannelEndpointId(); - remote_id_ = ChannelEndpointId(); - } + if (channel_) + ResetChannelNoLock(); + else + DCHECK(is_detached_from_channel_); } - if (client.get()) + // If |ReplaceClient()| is called (from another thread) after the above locked + // section but before we call |OnDetachFromChannel()|, |ReplaceClient()| + // return false to notify the caller that the channel was already detached. + // (The old client has to accept the arguably-spurious call to + // |OnDetachFromChannel()|.) + if (client) client->OnDetachFromChannel(client_port); } ChannelEndpoint::~ChannelEndpoint() { - DCHECK(!client_.get()); + DCHECK(!client_); DCHECK(!channel_); DCHECK(!local_id_.is_valid()); DCHECK(!remote_id_.is_valid()); @@ -154,5 +186,17 @@ bool ChannelEndpoint::WriteMessageNoLock(scoped_ptr<MessageInTransit> message) { return channel_->WriteMessage(message.Pass()); } +void ChannelEndpoint::ResetChannelNoLock() { + DCHECK(channel_); + DCHECK(local_id_.is_valid()); + DCHECK(remote_id_.is_valid()); + DCHECK(!is_detached_from_channel_); + + channel_ = nullptr; + local_id_ = ChannelEndpointId(); + remote_id_ = ChannelEndpointId(); + is_detached_from_channel_ = true; +} + } // namespace system } // namespace mojo diff --git a/mojo/edk/system/channel_endpoint.h b/mojo/edk/system/channel_endpoint.h index 71b6f9b..90ee86b 100644 --- a/mojo/edk/system/channel_endpoint.h +++ b/mojo/edk/system/channel_endpoint.h @@ -130,6 +130,15 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpoint // called.) bool EnqueueMessage(scoped_ptr<MessageInTransit> message); + // Called to *replace* current client with a new client (which must differ + // from the existing client). This must not be called after + // |DetachFromClient()| has been called. + // + // This returns true in the typical case, and false if this endpoint has been + // detached from the channel, in which case the caller should probably call + // its (new) client's |OnDetachFromChannel()|. + bool ReplaceClient(ChannelEndpointClient* client, unsigned client_port); + // Called before the |ChannelEndpointClient| gives up its reference to this // object. void DetachFromClient(); @@ -156,6 +165,10 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpoint // Must be called with |lock_| held. bool WriteMessageNoLock(scoped_ptr<MessageInTransit> message); + // Resets |channel_| to null (and sets |is_detached_from_channel_|). This may + // only be called if |channel_| is non-null. Must be called with |lock_| held. + void ResetChannelNoLock(); + // Protects the members below. base::Lock lock_; @@ -168,6 +181,9 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpoint // WARNING: |ChannelEndpointClient| methods must not be called under |lock_|. // Thus to make such a call, a reference must first be taken under |lock_| and // the lock released. + // WARNING: Beware of interactions with |ReplaceClient()|. By the time the + // call is made, the client may have changed. This must be detected and dealt + // with. scoped_refptr<ChannelEndpointClient> client_; unsigned client_port_; @@ -177,6 +193,9 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpoint Channel* channel_; ChannelEndpointId local_id_; ChannelEndpointId remote_id_; + // This distinguishes the two cases of |channel| being null: not yet attached + // versus detached. + bool is_detached_from_channel_; // This queue is used before we're running on a channel and ready to send // messages to the channel. diff --git a/mojo/edk/system/channel_endpoint_client.h b/mojo/edk/system/channel_endpoint_client.h index 7a7d5b8..c758e9c 100644 --- a/mojo/edk/system/channel_endpoint_client.h +++ b/mojo/edk/system/channel_endpoint_client.h @@ -38,8 +38,9 @@ class MOJO_SYSTEM_IMPL_EXPORT ChannelEndpointClient // called by |Channel| when it receives a message for the |ChannelEndpoint|. // (|port| is the value passed to |ChannelEndpoint|'s constructor as // |client_port|.) - virtual void OnReadMessage(unsigned port, - scoped_ptr<MessageInTransit> message) = 0; + // + // This should return true if it accepted (and took ownership of) |message|. + virtual bool OnReadMessage(unsigned port, MessageInTransit* message) = 0; // Called by |ChannelEndpoint| when the |Channel| is relinquishing its pointer // to the |ChannelEndpoint| (and vice versa). After this is called, diff --git a/mojo/edk/system/channel_unittest.cc b/mojo/edk/system/channel_unittest.cc index e84ab5b..ce4eefe 100644 --- a/mojo/edk/system/channel_unittest.cc +++ b/mojo/edk/system/channel_unittest.cc @@ -50,7 +50,7 @@ class ChannelTest : public testing::Test { CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop()); CHECK(raw_channel_); - CHECK(channel_.get()); + CHECK(channel_); CHECK_EQ(init_result_, TRISTATE_UNKNOWN); init_result_ = BoolToTristate(channel_->Init(raw_channel_.Pass())); @@ -59,7 +59,7 @@ class ChannelTest : public testing::Test { void ShutdownChannelOnIOThread() { CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop()); - CHECK(channel_.get()); + CHECK(channel_); channel_->Shutdown(); } @@ -231,7 +231,7 @@ TEST_F(ChannelTest, ShutdownAfterAttach) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Don't wait for the shutdown to run ... io_thread()->PostTask(FROM_HERE, @@ -242,7 +242,7 @@ TEST_F(ChannelTest, ShutdownAfterAttach) { EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(MOJO_DEADLINE_INDEFINITE, nullptr)); HandleSignalsState hss; - mp->RemoveWaiter(0, &waiter, &hss); + mp->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -277,8 +277,9 @@ TEST_F(ChannelTest, WaitAfterAttachRunAndShutdown) { Waiter waiter; waiter.Init(); HandleSignalsState hss; - EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, &hss)); + EXPECT_EQ( + MOJO_RESULT_FAILED_PRECONDITION, + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc index 27d33b2..3843d97 100644 --- a/mojo/edk/system/core.cc +++ b/mojo/edk/system/core.cc @@ -47,10 +47,11 @@ namespace system { // |Dispatcher|s for the handles that it wants to wait on with a |Waiter| // object; this |Waiter| object may be created on the stack of that thread or be // kept in thread local storage for that thread (TODO(vtl): future improvement). -// The |Dispatcher| then adds the |Waiter| to a |WaiterList| that's either owned -// by that |Dispatcher| (see |SimpleDispatcher|) or by a secondary object (e.g., -// |MessagePipe|). To signal/wake a |Waiter|, the object in question -- either a -// |SimpleDispatcher| or a secondary object -- talks to its |WaiterList|. +// The |Dispatcher| then adds the |Waiter| to an |AwakableList| that's either +// owned by that |Dispatcher| (see |SimpleDispatcher|) or by a secondary object +// (e.g., |MessagePipe|). To signal/wake a |Waiter|, the object in question -- +// either a |SimpleDispatcher| or a secondary object -- talks to its +// |AwakableList|. // Thread-safety notes // @@ -221,7 +222,7 @@ MojoResult Core::WriteMessage(MojoHandle message_pipe_handle, uint32_t num_handles, MojoWriteMessageFlags flags) { scoped_refptr<Dispatcher> dispatcher(GetDispatcher(message_pipe_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; // Easy case: not sending any handles. @@ -288,7 +289,7 @@ MojoResult Core::ReadMessage(MojoHandle message_pipe_handle, UserPointer<uint32_t> num_handles, MojoReadMessageFlags flags) { scoped_refptr<Dispatcher> dispatcher(GetDispatcher(message_pipe_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; uint32_t num_handles_value = num_handles.IsNull() ? 0 : num_handles.Get(); @@ -322,7 +323,7 @@ MojoResult Core::ReadMessage(MojoHandle message_pipe_handle, << " handles, but handle table full"; // Close dispatchers (outside the lock). for (size_t i = 0; i < dispatchers.size(); i++) { - if (dispatchers[i].get()) + if (dispatchers[i]) dispatchers[i]->Close(); } if (rv == MOJO_RESULT_OK) @@ -381,7 +382,7 @@ MojoResult Core::WriteData(MojoHandle data_pipe_producer_handle, MojoWriteDataFlags flags) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_producer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->WriteData(elements, num_bytes, flags); @@ -393,7 +394,7 @@ MojoResult Core::BeginWriteData(MojoHandle data_pipe_producer_handle, MojoWriteDataFlags flags) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_producer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->BeginWriteData(buffer, buffer_num_bytes, flags); @@ -403,7 +404,7 @@ MojoResult Core::EndWriteData(MojoHandle data_pipe_producer_handle, uint32_t num_bytes_written) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_producer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->EndWriteData(num_bytes_written); @@ -415,7 +416,7 @@ MojoResult Core::ReadData(MojoHandle data_pipe_consumer_handle, MojoReadDataFlags flags) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_consumer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->ReadData(elements, num_bytes, flags); @@ -427,7 +428,7 @@ MojoResult Core::BeginReadData(MojoHandle data_pipe_consumer_handle, MojoReadDataFlags flags) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_consumer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->BeginReadData(buffer, buffer_num_bytes, flags); @@ -437,7 +438,7 @@ MojoResult Core::EndReadData(MojoHandle data_pipe_consumer_handle, uint32_t num_bytes_read) { scoped_refptr<Dispatcher> dispatcher( GetDispatcher(data_pipe_consumer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; return dispatcher->EndReadData(num_bytes_read); @@ -457,7 +458,7 @@ MojoResult Core::CreateSharedBuffer( result = SharedBufferDispatcher::Create(platform_support(), validated_options, num_bytes, &dispatcher); if (result != MOJO_RESULT_OK) { - DCHECK(!dispatcher.get()); + DCHECK(!dispatcher); return result; } @@ -477,7 +478,7 @@ MojoResult Core::DuplicateBufferHandle( UserPointer<const MojoDuplicateBufferHandleOptions> options, UserPointer<MojoHandle> new_buffer_handle) { scoped_refptr<Dispatcher> dispatcher(GetDispatcher(buffer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; // Don't verify |options| here; that's the dispatcher's job. @@ -504,7 +505,7 @@ MojoResult Core::MapBuffer(MojoHandle buffer_handle, UserPointer<void*> buffer, MojoMapBufferFlags flags) { scoped_refptr<Dispatcher> dispatcher(GetDispatcher(buffer_handle)); - if (!dispatcher.get()) + if (!dispatcher) return MOJO_RESULT_INVALID_ARGUMENT; scoped_ptr<embedder::PlatformSharedBufferMapping> mapping; @@ -532,7 +533,7 @@ MojoResult Core::UnmapBuffer(UserPointer<void> buffer) { // Note: We allow |handles| to repeat the same handle multiple times, since // different flags may be specified. -// TODO(vtl): This incurs a performance cost in |RemoveWaiter()|. Analyze this +// TODO(vtl): This incurs a performance cost in |Remove()|. Analyze this // more carefully and address it if necessary. MojoResult Core::WaitManyInternal(const MojoHandle* handles, const MojoHandleSignals* signals, @@ -547,7 +548,7 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles, dispatchers.reserve(num_handles); for (uint32_t i = 0; i < num_handles; i++) { scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handles[i]); - if (!dispatcher.get()) { + if (!dispatcher) { *result_index = i; return MOJO_RESULT_INVALID_ARGUMENT; } @@ -561,7 +562,7 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles, uint32_t i; MojoResult rv = MOJO_RESULT_OK; for (i = 0; i < num_handles; i++) { - rv = dispatchers[i]->AddWaiter( + rv = dispatchers[i]->AddAwakable( &waiter, signals[i], i, signals_states ? &signals_states[i] : nullptr); if (rv != MOJO_RESULT_OK) { *result_index = i; @@ -579,8 +580,8 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles, // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be // destroyed, but this would still be required if the waiter were in TLS.) for (i = 0; i < num_added; i++) { - dispatchers[i]->RemoveWaiter(&waiter, - signals_states ? &signals_states[i] : nullptr); + dispatchers[i]->RemoveAwakable( + &waiter, signals_states ? &signals_states[i] : nullptr); } if (signals_states) { for (; i < num_handles; i++) diff --git a/mojo/edk/system/core_test_base.cc b/mojo/edk/system/core_test_base.cc index ea06c29..76e70e2 100644 --- a/mojo/edk/system/core_test_base.cc +++ b/mojo/edk/system/core_test_base.cc @@ -123,27 +123,27 @@ class MockDispatcher : public Dispatcher { return MOJO_RESULT_UNIMPLEMENTED; } - MojoResult AddWaiterImplNoLock(Waiter* /*waiter*/, - MojoHandleSignals /*signals*/, - uint32_t /*context*/, - HandleSignalsState* signals_state) override { - info_->IncrementAddWaiterCallCount(); + MojoResult AddAwakableImplNoLock(Awakable* /*awakable*/, + MojoHandleSignals /*signals*/, + uint32_t /*context*/, + HandleSignalsState* signals_state) override { + info_->IncrementAddAwakableCallCount(); lock().AssertAcquired(); if (signals_state) *signals_state = HandleSignalsState(); return MOJO_RESULT_FAILED_PRECONDITION; } - void RemoveWaiterImplNoLock(Waiter* /*waiter*/, - HandleSignalsState* signals_state) override { - info_->IncrementRemoveWaiterCallCount(); + void RemoveAwakableImplNoLock(Awakable* /*awakable*/, + HandleSignalsState* signals_state) override { + info_->IncrementRemoveAwakableCallCount(); lock().AssertAcquired(); if (signals_state) *signals_state = HandleSignalsState(); } - void CancelAllWaitersNoLock() override { - info_->IncrementCancelAllWaitersCallCount(); + void CancelAllAwakablesNoLock() override { + info_->IncrementCancelAllAwakablesCallCount(); lock().AssertAcquired(); } @@ -196,9 +196,9 @@ CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo() read_data_call_count_(0), begin_read_data_call_count_(0), end_read_data_call_count_(0), - add_waiter_call_count_(0), - remove_waiter_call_count_(0), - cancel_all_waiters_call_count_(0) { + add_awakable_call_count_(0), + remove_awakable_call_count_(0), + cancel_all_awakables_call_count_(0) { } CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() { @@ -259,19 +259,19 @@ unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const { return end_read_data_call_count_; } -unsigned CoreTestBase_MockHandleInfo::GetAddWaiterCallCount() const { +unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const { base::AutoLock locker(lock_); - return add_waiter_call_count_; + return add_awakable_call_count_; } -unsigned CoreTestBase_MockHandleInfo::GetRemoveWaiterCallCount() const { +unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const { base::AutoLock locker(lock_); - return remove_waiter_call_count_; + return remove_awakable_call_count_; } -unsigned CoreTestBase_MockHandleInfo::GetCancelAllWaitersCallCount() const { +unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const { base::AutoLock locker(lock_); - return cancel_all_waiters_call_count_; + return cancel_all_awakables_call_count_; } void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() { @@ -329,19 +329,19 @@ void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() { end_read_data_call_count_++; } -void CoreTestBase_MockHandleInfo::IncrementAddWaiterCallCount() { +void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() { base::AutoLock locker(lock_); - add_waiter_call_count_++; + add_awakable_call_count_++; } -void CoreTestBase_MockHandleInfo::IncrementRemoveWaiterCallCount() { +void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() { base::AutoLock locker(lock_); - remove_waiter_call_count_++; + remove_awakable_call_count_++; } -void CoreTestBase_MockHandleInfo::IncrementCancelAllWaitersCallCount() { +void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() { base::AutoLock locker(lock_); - cancel_all_waiters_call_count_++; + cancel_all_awakables_call_count_++; } } // namespace test diff --git a/mojo/edk/system/core_test_base.h b/mojo/edk/system/core_test_base.h index 2881176..80a926b 100644 --- a/mojo/edk/system/core_test_base.h +++ b/mojo/edk/system/core_test_base.h @@ -58,9 +58,9 @@ class CoreTestBase_MockHandleInfo { unsigned GetReadDataCallCount() const; unsigned GetBeginReadDataCallCount() const; unsigned GetEndReadDataCallCount() const; - unsigned GetAddWaiterCallCount() const; - unsigned GetRemoveWaiterCallCount() const; - unsigned GetCancelAllWaitersCallCount() const; + unsigned GetAddAwakableCallCount() const; + unsigned GetRemoveAwakableCallCount() const; + unsigned GetCancelAllAwakablesCallCount() const; // For use by |MockDispatcher|: void IncrementCtorCallCount(); @@ -74,9 +74,9 @@ class CoreTestBase_MockHandleInfo { void IncrementReadDataCallCount(); void IncrementBeginReadDataCallCount(); void IncrementEndReadDataCallCount(); - void IncrementAddWaiterCallCount(); - void IncrementRemoveWaiterCallCount(); - void IncrementCancelAllWaitersCallCount(); + void IncrementAddAwakableCallCount(); + void IncrementRemoveAwakableCallCount(); + void IncrementCancelAllAwakablesCallCount(); private: mutable base::Lock lock_; // Protects the following members. @@ -91,9 +91,9 @@ class CoreTestBase_MockHandleInfo { unsigned read_data_call_count_; unsigned begin_read_data_call_count_; unsigned end_read_data_call_count_; - unsigned add_waiter_call_count_; - unsigned remove_waiter_call_count_; - unsigned cancel_all_waiters_call_count_; + unsigned add_awakable_call_count_; + unsigned remove_awakable_call_count_; + unsigned cancel_all_awakables_call_count_; DISALLOW_COPY_AND_ASSIGN(CoreTestBase_MockHandleInfo); }; diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc index 51a4022..d7976a3 100644 --- a/mojo/edk/system/core_unittest.cc +++ b/mojo/edk/system/core_unittest.cc @@ -95,30 +95,30 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0)); EXPECT_EQ(1u, info.GetEndReadDataCallCount()); - EXPECT_EQ(0u, info.GetAddWaiterCallCount()); + EXPECT_EQ(0u, info.GetAddAwakableCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, NullUserPointer())); - EXPECT_EQ(1u, info.GetAddWaiterCallCount()); + EXPECT_EQ(1u, info.GetAddAwakableCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0, NullUserPointer())); - EXPECT_EQ(2u, info.GetAddWaiterCallCount()); + EXPECT_EQ(2u, info.GetAddAwakableCallCount()); MojoHandleSignalsState hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); - EXPECT_EQ(3u, info.GetAddWaiterCallCount()); + EXPECT_EQ(3u, info.GetAddAwakableCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); EXPECT_EQ( MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, NullUserPointer())); - EXPECT_EQ(4u, info.GetAddWaiterCallCount()); + EXPECT_EQ(4u, info.GetAddAwakableCallCount()); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, MakeUserPointer(&hss))); - EXPECT_EQ(5u, info.GetAddWaiterCallCount()); + EXPECT_EQ(5u, info.GetAddAwakableCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); @@ -128,14 +128,14 @@ TEST_F(CoreTest, Basic) { core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, MOJO_DEADLINE_INDEFINITE, NullUserPointer(), NullUserPointer())); - EXPECT_EQ(6u, info.GetAddWaiterCallCount()); + EXPECT_EQ(6u, info.GetAddAwakableCallCount()); uint32_t result_index = static_cast<uint32_t>(-1); EXPECT_EQ( MOJO_RESULT_FAILED_PRECONDITION, core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), NullUserPointer())); - EXPECT_EQ(7u, info.GetAddWaiterCallCount()); + EXPECT_EQ(7u, info.GetAddAwakableCallCount()); EXPECT_EQ(0u, result_index); hss = kFullMojoHandleSignalsState; EXPECT_EQ( @@ -143,7 +143,7 @@ TEST_F(CoreTest, Basic) { core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, MOJO_DEADLINE_INDEFINITE, NullUserPointer(), MakeUserPointer(&hss))); - EXPECT_EQ(8u, info.GetAddWaiterCallCount()); + EXPECT_EQ(8u, info.GetAddAwakableCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); result_index = static_cast<uint32_t>(-1); @@ -153,21 +153,21 @@ TEST_F(CoreTest, Basic) { core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), MakeUserPointer(&hss))); - EXPECT_EQ(9u, info.GetAddWaiterCallCount()); + EXPECT_EQ(9u, info.GetAddAwakableCallCount()); EXPECT_EQ(0u, result_index); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); EXPECT_EQ(0u, info.GetDtorCallCount()); EXPECT_EQ(0u, info.GetCloseCallCount()); - EXPECT_EQ(0u, info.GetCancelAllWaitersCallCount()); + EXPECT_EQ(0u, info.GetCancelAllAwakablesCallCount()); EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); - EXPECT_EQ(1u, info.GetCancelAllWaitersCallCount()); + EXPECT_EQ(1u, info.GetCancelAllAwakablesCallCount()); EXPECT_EQ(1u, info.GetCloseCallCount()); EXPECT_EQ(1u, info.GetDtorCallCount()); - // No waiters should ever have ever been added. - EXPECT_EQ(0u, info.GetRemoveWaiterCallCount()); + // No awakables should ever have ever been added. + EXPECT_EQ(0u, info.GetRemoveAwakableCallCount()); } TEST_F(CoreTest, InvalidArguments) { diff --git a/mojo/edk/system/data_pipe.cc b/mojo/edk/system/data_pipe.cc index cbacb89..2f433bd 100644 --- a/mojo/edk/system/data_pipe.cc +++ b/mojo/edk/system/data_pipe.cc @@ -10,10 +10,10 @@ #include <limits> #include "base/logging.h" +#include "mojo/edk/system/awakable_list.h" #include "mojo/edk/system/configuration.h" #include "mojo/edk/system/memory.h" #include "mojo/edk/system/options_validation.h" -#include "mojo/edk/system/waiter_list.h" namespace mojo { namespace system { @@ -83,10 +83,10 @@ MojoResult DataPipe::ValidateCreateOptions( return MOJO_RESULT_OK; } -void DataPipe::ProducerCancelAllWaiters() { +void DataPipe::ProducerCancelAllAwakables() { base::AutoLock locker(lock_); DCHECK(has_local_producer_no_lock()); - producer_waiter_list_->CancelAllWaiters(); + producer_awakable_list_->CancelAll(); } void DataPipe::ProducerClose() { @@ -94,13 +94,13 @@ void DataPipe::ProducerClose() { DCHECK(producer_open_); producer_open_ = false; DCHECK(has_local_producer_no_lock()); - producer_waiter_list_.reset(); + producer_awakable_list_.reset(); // Not a bug, except possibly in "user" code. DVLOG_IF(2, producer_in_two_phase_write_no_lock()) << "Producer closed with active two-phase write"; producer_two_phase_max_num_bytes_written_ = 0; ProducerCloseImplNoLock(); - AwakeConsumerWaitersForStateChangeNoLock( + AwakeConsumerAwakablesForStateChangeNoLock( ConsumerGetHandleSignalsStateImplNoLock()); } @@ -132,7 +132,7 @@ MojoResult DataPipe::ProducerWriteData(UserPointer<const void> elements, HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateImplNoLock(); if (!new_consumer_state.equals(old_consumer_state)) - AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state); + AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state); return rv; } @@ -159,10 +159,10 @@ MojoResult DataPipe::ProducerBeginWriteData( min_num_bytes_to_write); if (rv != MOJO_RESULT_OK) return rv; - // Note: No need to awake producer waiters, even though we're going from + // Note: No need to awake producer awakables, even though we're going from // writable to non-writable (since you can't wait on non-writability). // Similarly, though this may have discarded data (in "may discard" mode), - // making it non-readable, there's still no need to awake consumer waiters. + // making it non-readable, there's still no need to awake consumer awakables. DCHECK(producer_in_two_phase_write_no_lock()); return MOJO_RESULT_OK; } @@ -189,15 +189,15 @@ MojoResult DataPipe::ProducerEndWriteData(uint32_t num_bytes_written) { // Two-phase write ended even on failure. DCHECK(!producer_in_two_phase_write_no_lock()); // If we're now writable, we *became* writable (since we weren't writable - // during the two-phase write), so awake producer waiters. + // during the two-phase write), so awake producer awakables. HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateImplNoLock(); if (new_producer_state.satisfies(MOJO_HANDLE_SIGNAL_WRITABLE)) - AwakeProducerWaitersForStateChangeNoLock(new_producer_state); + AwakeProducerAwakablesForStateChangeNoLock(new_producer_state); HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateImplNoLock(); if (!new_consumer_state.equals(old_consumer_state)) - AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state); + AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state); return rv; } @@ -207,10 +207,10 @@ HandleSignalsState DataPipe::ProducerGetHandleSignalsState() { return ProducerGetHandleSignalsStateImplNoLock(); } -MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) { +MojoResult DataPipe::ProducerAddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) { base::AutoLock locker(lock_); DCHECK(has_local_producer_no_lock()); @@ -226,15 +226,15 @@ MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter, return MOJO_RESULT_FAILED_PRECONDITION; } - producer_waiter_list_->AddWaiter(waiter, signals, context); + producer_awakable_list_->Add(awakable, signals, context); return MOJO_RESULT_OK; } -void DataPipe::ProducerRemoveWaiter(Waiter* waiter, - HandleSignalsState* signals_state) { +void DataPipe::ProducerRemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state) { base::AutoLock locker(lock_); DCHECK(has_local_producer_no_lock()); - producer_waiter_list_->RemoveWaiter(waiter); + producer_awakable_list_->Remove(awakable); if (signals_state) *signals_state = ProducerGetHandleSignalsStateImplNoLock(); } @@ -244,10 +244,10 @@ bool DataPipe::ProducerIsBusy() const { return producer_in_two_phase_write_no_lock(); } -void DataPipe::ConsumerCancelAllWaiters() { +void DataPipe::ConsumerCancelAllAwakables() { base::AutoLock locker(lock_); DCHECK(has_local_consumer_no_lock()); - consumer_waiter_list_->CancelAllWaiters(); + consumer_awakable_list_->CancelAll(); } void DataPipe::ConsumerClose() { @@ -255,13 +255,13 @@ void DataPipe::ConsumerClose() { DCHECK(consumer_open_); consumer_open_ = false; DCHECK(has_local_consumer_no_lock()); - consumer_waiter_list_.reset(); + consumer_awakable_list_.reset(); // Not a bug, except possibly in "user" code. DVLOG_IF(2, consumer_in_two_phase_read_no_lock()) << "Consumer closed with active two-phase read"; consumer_two_phase_max_num_bytes_read_ = 0; ConsumerCloseImplNoLock(); - AwakeProducerWaitersForStateChangeNoLock( + AwakeProducerAwakablesForStateChangeNoLock( ProducerGetHandleSignalsStateImplNoLock()); } @@ -291,7 +291,7 @@ MojoResult DataPipe::ConsumerReadData(UserPointer<void> elements, HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateImplNoLock(); if (!new_producer_state.equals(old_producer_state)) - AwakeProducerWaitersForStateChangeNoLock(new_producer_state); + AwakeProducerAwakablesForStateChangeNoLock(new_producer_state); return rv; } @@ -320,7 +320,7 @@ MojoResult DataPipe::ConsumerDiscardData(UserPointer<uint32_t> num_bytes, HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateImplNoLock(); if (!new_producer_state.equals(old_producer_state)) - AwakeProducerWaitersForStateChangeNoLock(new_producer_state); + AwakeProducerAwakablesForStateChangeNoLock(new_producer_state); return rv; } @@ -380,15 +380,15 @@ MojoResult DataPipe::ConsumerEndReadData(uint32_t num_bytes_read) { // Two-phase read ended even on failure. DCHECK(!consumer_in_two_phase_read_no_lock()); // If we're now readable, we *became* readable (since we weren't readable - // during the two-phase read), so awake consumer waiters. + // during the two-phase read), so awake consumer awakables. HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateImplNoLock(); if (new_consumer_state.satisfies(MOJO_HANDLE_SIGNAL_READABLE)) - AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state); + AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state); HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateImplNoLock(); if (!new_producer_state.equals(old_producer_state)) - AwakeProducerWaitersForStateChangeNoLock(new_producer_state); + AwakeProducerAwakablesForStateChangeNoLock(new_producer_state); return rv; } @@ -398,10 +398,10 @@ HandleSignalsState DataPipe::ConsumerGetHandleSignalsState() { return ConsumerGetHandleSignalsStateImplNoLock(); } -MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) { +MojoResult DataPipe::ConsumerAddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) { base::AutoLock locker(lock_); DCHECK(has_local_consumer_no_lock()); @@ -417,15 +417,15 @@ MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter, return MOJO_RESULT_FAILED_PRECONDITION; } - consumer_waiter_list_->AddWaiter(waiter, signals, context); + consumer_awakable_list_->Add(awakable, signals, context); return MOJO_RESULT_OK; } -void DataPipe::ConsumerRemoveWaiter(Waiter* waiter, - HandleSignalsState* signals_state) { +void DataPipe::ConsumerRemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state) { base::AutoLock locker(lock_); DCHECK(has_local_consumer_no_lock()); - consumer_waiter_list_->RemoveWaiter(waiter); + consumer_awakable_list_->Remove(awakable); if (signals_state) *signals_state = ConsumerGetHandleSignalsStateImplNoLock(); } @@ -444,8 +444,10 @@ DataPipe::DataPipe(bool has_local_producer, capacity_num_bytes_(validated_options.capacity_num_bytes), producer_open_(true), consumer_open_(true), - producer_waiter_list_(has_local_producer ? new WaiterList() : nullptr), - consumer_waiter_list_(has_local_consumer ? new WaiterList() : nullptr), + producer_awakable_list_(has_local_producer ? new AwakableList() + : nullptr), + consumer_awakable_list_(has_local_consumer ? new AwakableList() + : nullptr), producer_two_phase_max_num_bytes_written_(0), consumer_two_phase_max_num_bytes_read_(0) { // Check that the passed in options actually are validated. @@ -457,24 +459,24 @@ DataPipe::DataPipe(bool has_local_producer, DataPipe::~DataPipe() { DCHECK(!producer_open_); DCHECK(!consumer_open_); - DCHECK(!producer_waiter_list_); - DCHECK(!consumer_waiter_list_); + DCHECK(!producer_awakable_list_); + DCHECK(!consumer_awakable_list_); } -void DataPipe::AwakeProducerWaitersForStateChangeNoLock( +void DataPipe::AwakeProducerAwakablesForStateChangeNoLock( const HandleSignalsState& new_producer_state) { lock_.AssertAcquired(); if (!has_local_producer_no_lock()) return; - producer_waiter_list_->AwakeWaitersForStateChange(new_producer_state); + producer_awakable_list_->AwakeForStateChange(new_producer_state); } -void DataPipe::AwakeConsumerWaitersForStateChangeNoLock( +void DataPipe::AwakeConsumerAwakablesForStateChangeNoLock( const HandleSignalsState& new_consumer_state) { lock_.AssertAcquired(); if (!has_local_consumer_no_lock()) return; - consumer_waiter_list_->AwakeWaitersForStateChange(new_consumer_state); + consumer_awakable_list_->AwakeForStateChange(new_consumer_state); } } // namespace system diff --git a/mojo/edk/system/data_pipe.h b/mojo/edk/system/data_pipe.h index 767d405..d893465 100644 --- a/mojo/edk/system/data_pipe.h +++ b/mojo/edk/system/data_pipe.h @@ -20,8 +20,8 @@ namespace mojo { namespace system { -class Waiter; -class WaiterList; +class Awakable; +class AwakableList; // |DataPipe| is a base class for secondary objects implementing data pipes, // similar to |MessagePipe| (see the explanatory comment in core.cc). It is @@ -48,7 +48,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe // These are called by the producer dispatcher to implement its methods of // corresponding names. - void ProducerCancelAllWaiters(); + void ProducerCancelAllAwakables(); void ProducerClose(); MojoResult ProducerWriteData(UserPointer<const void> elements, UserPointer<uint32_t> num_bytes, @@ -58,16 +58,17 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe bool all_or_none); MojoResult ProducerEndWriteData(uint32_t num_bytes_written); HandleSignalsState ProducerGetHandleSignalsState(); - MojoResult ProducerAddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - void ProducerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state); + MojoResult ProducerAddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + void ProducerRemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state); bool ProducerIsBusy() const; // These are called by the consumer dispatcher to implement its methods of // corresponding names. - void ConsumerCancelAllWaiters(); + void ConsumerCancelAllAwakables(); void ConsumerClose(); // This does not validate its arguments, except to check that |*num_bytes| is // a multiple of |element_num_bytes_|. @@ -83,11 +84,12 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe bool all_or_none); MojoResult ConsumerEndReadData(uint32_t num_bytes_read); HandleSignalsState ConsumerGetHandleSignalsState(); - MojoResult ConsumerAddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - void ConsumerRemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state); + MojoResult ConsumerAddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + void ConsumerRemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state); bool ConsumerIsBusy() const; protected: @@ -179,18 +181,18 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe } private: - void AwakeProducerWaitersForStateChangeNoLock( + void AwakeProducerAwakablesForStateChangeNoLock( const HandleSignalsState& new_producer_state); - void AwakeConsumerWaitersForStateChangeNoLock( + void AwakeConsumerAwakablesForStateChangeNoLock( const HandleSignalsState& new_consumer_state); bool has_local_producer_no_lock() const { lock_.AssertAcquired(); - return !!producer_waiter_list_; + return !!producer_awakable_list_; } bool has_local_consumer_no_lock() const { lock_.AssertAcquired(); - return !!consumer_waiter_list_; + return !!consumer_awakable_list_; } const bool may_discard_; @@ -202,8 +204,8 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe bool producer_open_; bool consumer_open_; // Non-null only if the producer or consumer, respectively, is local. - scoped_ptr<WaiterList> producer_waiter_list_; - scoped_ptr<WaiterList> consumer_waiter_list_; + scoped_ptr<AwakableList> producer_awakable_list_; + scoped_ptr<AwakableList> consumer_awakable_list_; // These are nonzero if and only if a two-phase write/read is in progress. uint32_t producer_two_phase_max_num_bytes_written_; uint32_t consumer_two_phase_max_num_bytes_read_; diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.cc b/mojo/edk/system/data_pipe_consumer_dispatcher.cc index 3c14f35..21127c6 100644 --- a/mojo/edk/system/data_pipe_consumer_dispatcher.cc +++ b/mojo/edk/system/data_pipe_consumer_dispatcher.cc @@ -15,7 +15,7 @@ DataPipeConsumerDispatcher::DataPipeConsumerDispatcher() { } void DataPipeConsumerDispatcher::Init(scoped_refptr<DataPipe> data_pipe) { - DCHECK(data_pipe.get()); + DCHECK(data_pipe); data_pipe_ = data_pipe; } @@ -25,12 +25,12 @@ Dispatcher::Type DataPipeConsumerDispatcher::GetType() const { DataPipeConsumerDispatcher::~DataPipeConsumerDispatcher() { // |Close()|/|CloseImplNoLock()| should have taken care of the pipe. - DCHECK(!data_pipe_.get()); + DCHECK(!data_pipe_); } -void DataPipeConsumerDispatcher::CancelAllWaitersNoLock() { +void DataPipeConsumerDispatcher::CancelAllAwakablesNoLock() { lock().AssertAcquired(); - data_pipe_->ConsumerCancelAllWaiters(); + data_pipe_->ConsumerCancelAllAwakables(); } void DataPipeConsumerDispatcher::CloseImplNoLock() { @@ -109,20 +109,21 @@ HandleSignalsState DataPipeConsumerDispatcher::GetHandleSignalsStateImplNoLock() return data_pipe_->ConsumerGetHandleSignalsState(); } -MojoResult DataPipeConsumerDispatcher::AddWaiterImplNoLock( - Waiter* waiter, +MojoResult DataPipeConsumerDispatcher::AddAwakableImplNoLock( + Awakable* awakable, MojoHandleSignals signals, uint32_t context, HandleSignalsState* signals_state) { lock().AssertAcquired(); - return data_pipe_->ConsumerAddWaiter(waiter, signals, context, signals_state); + return data_pipe_->ConsumerAddAwakable(awakable, signals, context, + signals_state); } -void DataPipeConsumerDispatcher::RemoveWaiterImplNoLock( - Waiter* waiter, +void DataPipeConsumerDispatcher::RemoveAwakableImplNoLock( + Awakable* awakable, HandleSignalsState* signals_state) { lock().AssertAcquired(); - data_pipe_->ConsumerRemoveWaiter(waiter, signals_state); + data_pipe_->ConsumerRemoveAwakable(awakable, signals_state); } bool DataPipeConsumerDispatcher::IsBusyNoLock() const { diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.h b/mojo/edk/system/data_pipe_consumer_dispatcher.h index 6555fb5..10a3d94 100644 --- a/mojo/edk/system/data_pipe_consumer_dispatcher.h +++ b/mojo/edk/system/data_pipe_consumer_dispatcher.h @@ -32,7 +32,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipeConsumerDispatcher : public Dispatcher { ~DataPipeConsumerDispatcher() override; // |Dispatcher| protected methods: - void CancelAllWaitersNoLock() override; + void CancelAllAwakablesNoLock() override; void CloseImplNoLock() override; scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() override; @@ -44,12 +44,12 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipeConsumerDispatcher : public Dispatcher { MojoReadDataFlags flags) override; MojoResult EndReadDataImplNoLock(uint32_t num_bytes_read) override; HandleSignalsState GetHandleSignalsStateImplNoLock() const override; - MojoResult AddWaiterImplNoLock(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) override; - void RemoveWaiterImplNoLock(Waiter* waiter, - HandleSignalsState* signals_state) override; + MojoResult AddAwakableImplNoLock(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) override; + void RemoveAwakableImplNoLock(Awakable* awakable, + HandleSignalsState* signals_state) override; bool IsBusyNoLock() const override; // Protected by |lock()|: diff --git a/mojo/edk/system/data_pipe_producer_dispatcher.cc b/mojo/edk/system/data_pipe_producer_dispatcher.cc index 0a82c9a..0531126 100644 --- a/mojo/edk/system/data_pipe_producer_dispatcher.cc +++ b/mojo/edk/system/data_pipe_producer_dispatcher.cc @@ -15,7 +15,7 @@ DataPipeProducerDispatcher::DataPipeProducerDispatcher() { } void DataPipeProducerDispatcher::Init(scoped_refptr<DataPipe> data_pipe) { - DCHECK(data_pipe.get()); + DCHECK(data_pipe); data_pipe_ = data_pipe; } @@ -25,12 +25,12 @@ Dispatcher::Type DataPipeProducerDispatcher::GetType() const { DataPipeProducerDispatcher::~DataPipeProducerDispatcher() { // |Close()|/|CloseImplNoLock()| should have taken care of the pipe. - DCHECK(!data_pipe_.get()); + DCHECK(!data_pipe_); } -void DataPipeProducerDispatcher::CancelAllWaitersNoLock() { +void DataPipeProducerDispatcher::CancelAllAwakablesNoLock() { lock().AssertAcquired(); - data_pipe_->ProducerCancelAllWaiters(); + data_pipe_->ProducerCancelAllAwakables(); } void DataPipeProducerDispatcher::CloseImplNoLock() { @@ -82,20 +82,21 @@ HandleSignalsState DataPipeProducerDispatcher::GetHandleSignalsStateImplNoLock() return data_pipe_->ProducerGetHandleSignalsState(); } -MojoResult DataPipeProducerDispatcher::AddWaiterImplNoLock( - Waiter* waiter, +MojoResult DataPipeProducerDispatcher::AddAwakableImplNoLock( + Awakable* awakable, MojoHandleSignals signals, uint32_t context, HandleSignalsState* signals_state) { lock().AssertAcquired(); - return data_pipe_->ProducerAddWaiter(waiter, signals, context, signals_state); + return data_pipe_->ProducerAddAwakable(awakable, signals, context, + signals_state); } -void DataPipeProducerDispatcher::RemoveWaiterImplNoLock( - Waiter* waiter, +void DataPipeProducerDispatcher::RemoveAwakableImplNoLock( + Awakable* awakable, HandleSignalsState* signals_state) { lock().AssertAcquired(); - data_pipe_->ProducerRemoveWaiter(waiter, signals_state); + data_pipe_->ProducerRemoveAwakable(awakable, signals_state); } bool DataPipeProducerDispatcher::IsBusyNoLock() const { diff --git a/mojo/edk/system/data_pipe_producer_dispatcher.h b/mojo/edk/system/data_pipe_producer_dispatcher.h index bf13148..39c070c 100644 --- a/mojo/edk/system/data_pipe_producer_dispatcher.h +++ b/mojo/edk/system/data_pipe_producer_dispatcher.h @@ -32,7 +32,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipeProducerDispatcher : public Dispatcher { ~DataPipeProducerDispatcher() override; // |Dispatcher| protected methods: - void CancelAllWaitersNoLock() override; + void CancelAllAwakablesNoLock() override; void CloseImplNoLock() override; scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() override; @@ -44,12 +44,12 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipeProducerDispatcher : public Dispatcher { MojoWriteDataFlags flags) override; MojoResult EndWriteDataImplNoLock(uint32_t num_bytes_written) override; HandleSignalsState GetHandleSignalsStateImplNoLock() const override; - MojoResult AddWaiterImplNoLock(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) override; - void RemoveWaiterImplNoLock(Waiter* waiter, - HandleSignalsState* signals_state) override; + MojoResult AddAwakableImplNoLock(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) override; + void RemoveAwakableImplNoLock(Awakable* awakable, + HandleSignalsState* signals_state) override; bool IsBusyNoLock() const override; // Protected by |lock()|: diff --git a/mojo/edk/system/dispatcher.cc b/mojo/edk/system/dispatcher.cc index bed5f9e..e2f2b87 100644 --- a/mojo/edk/system/dispatcher.cc +++ b/mojo/edk/system/dispatcher.cc @@ -220,10 +220,10 @@ HandleSignalsState Dispatcher::GetHandleSignalsState() const { return GetHandleSignalsStateImplNoLock(); } -MojoResult Dispatcher::AddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) { +MojoResult Dispatcher::AddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) { base::AutoLock locker(lock_); if (is_closed_) { if (signals_state) @@ -231,18 +231,19 @@ MojoResult Dispatcher::AddWaiter(Waiter* waiter, return MOJO_RESULT_INVALID_ARGUMENT; } - return AddWaiterImplNoLock(waiter, signals, context, signals_state); + return AddAwakableImplNoLock(awakable, signals, context, signals_state); } -void Dispatcher::RemoveWaiter(Waiter* waiter, - HandleSignalsState* handle_signals_state) { +void Dispatcher::RemoveAwakable(Awakable* awakable, + HandleSignalsState* handle_signals_state) { base::AutoLock locker(lock_); if (is_closed_) { if (handle_signals_state) *handle_signals_state = HandleSignalsState(); return; } - RemoveWaiterImplNoLock(waiter, handle_signals_state); + + RemoveAwakableImplNoLock(awakable, handle_signals_state); } Dispatcher::Dispatcher() : is_closed_(false) { @@ -253,7 +254,7 @@ Dispatcher::~Dispatcher() { DCHECK(is_closed_); } -void Dispatcher::CancelAllWaitersNoLock() { +void Dispatcher::CancelAllAwakablesNoLock() { lock_.AssertAcquired(); DCHECK(is_closed_); // By default, waiting isn't supported. Only dispatchers that can be waited on @@ -370,10 +371,11 @@ HandleSignalsState Dispatcher::GetHandleSignalsStateImplNoLock() const { return HandleSignalsState(); } -MojoResult Dispatcher::AddWaiterImplNoLock(Waiter* /*waiter*/, - MojoHandleSignals /*signals*/, - uint32_t /*context*/, - HandleSignalsState* signals_state) { +MojoResult Dispatcher::AddAwakableImplNoLock( + Awakable* /*awakable*/, + MojoHandleSignals /*signals*/, + uint32_t /*context*/, + HandleSignalsState* signals_state) { lock_.AssertAcquired(); DCHECK(!is_closed_); // By default, waiting isn't supported. Only dispatchers that can be waited on @@ -383,8 +385,8 @@ MojoResult Dispatcher::AddWaiterImplNoLock(Waiter* /*waiter*/, return MOJO_RESULT_FAILED_PRECONDITION; } -void Dispatcher::RemoveWaiterImplNoLock(Waiter* /*waiter*/, - HandleSignalsState* signals_state) { +void Dispatcher::RemoveAwakableImplNoLock(Awakable* /*awakable*/, + HandleSignalsState* signals_state) { lock_.AssertAcquired(); DCHECK(!is_closed_); // By default, waiting isn't supported. Only dispatchers that can be waited on @@ -427,7 +429,7 @@ void Dispatcher::CloseNoLock() { DCHECK(!is_closed_); is_closed_ = true; - CancelAllWaitersNoLock(); + CancelAllAwakablesNoLock(); CloseImplNoLock(); } @@ -437,7 +439,7 @@ Dispatcher::CreateEquivalentDispatcherAndCloseNoLock() { DCHECK(!is_closed_); is_closed_ = true; - CancelAllWaitersNoLock(); + CancelAllAwakablesNoLock(); return CreateEquivalentDispatcherAndCloseImplNoLock(); } diff --git a/mojo/edk/system/dispatcher.h b/mojo/edk/system/dispatcher.h index b17bfae..c069269 100644 --- a/mojo/edk/system/dispatcher.h +++ b/mojo/edk/system/dispatcher.h @@ -39,7 +39,7 @@ class HandleTable; class LocalMessagePipeEndpoint; class ProxyMessagePipeEndpoint; class TransportData; -class Waiter; +class Awakable; typedef std::vector<scoped_refptr<Dispatcher>> DispatcherVector; @@ -128,7 +128,7 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher // threads. HandleSignalsState GetHandleSignalsState() const; - // Adds a waiter to this dispatcher. The waiter will be woken up when this + // Adds an awakable to this dispatcher, which will be woken up when this // object changes state to satisfy |signals| with context |context|. It will // also be woken up when it becomes impossible for the object to ever satisfy // |signals| with a suitable error status. @@ -137,20 +137,20 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher // to the current handle signals state (on success, it is left untouched). // // Returns: - // - |MOJO_RESULT_OK| if the waiter was added; + // - |MOJO_RESULT_OK| if the awakable was added; // - |MOJO_RESULT_ALREADY_EXISTS| if |signals| is already satisfied; // - |MOJO_RESULT_INVALID_ARGUMENT| if the dispatcher has been closed; and // - |MOJO_RESULT_FAILED_PRECONDITION| if it is not (or no longer) possible // that |signals| will ever be satisfied. - MojoResult AddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - // Removes a waiter from this dispatcher. (It is valid to call this multiple - // times for the same |waiter| on the same object, so long as |AddWaiter()| - // was called at most once.) If |signals_state| is non-null, |*signals_state| - // will be set to the current handle signals state. - void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state); + MojoResult AddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + // Removes an awakable from this dispatcher. (It is valid to call this + // multiple times for the same |awakable| on the same object, so long as + // |AddAwakable()| was called at most once.) If |signals_state| is non-null, + // |*signals_state| will be set to the current handle signals state. + void RemoveAwakable(Awakable* awakable, HandleSignalsState* signals_state); // A dispatcher must be put into a special state in order to be sent across a // message pipe. Outside of tests, only |HandleTableAccess| is allowed to do @@ -220,9 +220,10 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher virtual ~Dispatcher(); // These are to be overridden by subclasses (if necessary). They are called - // exactly once -- first |CancelAllWaitersNoLock()|, then |CloseImplNoLock()|, + // exactly once -- first |CancelAllAwakablesNoLock()|, then + // |CloseImplNoLock()|, // when the dispatcher is being closed. They are called under |lock_|. - virtual void CancelAllWaitersNoLock(); + virtual void CancelAllAwakablesNoLock(); virtual void CloseImplNoLock(); virtual scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() = 0; @@ -266,12 +267,12 @@ class MOJO_SYSTEM_IMPL_EXPORT Dispatcher MojoMapBufferFlags flags, scoped_ptr<embedder::PlatformSharedBufferMapping>* mapping); virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const; - virtual MojoResult AddWaiterImplNoLock(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - virtual void RemoveWaiterImplNoLock(Waiter* waiter, - HandleSignalsState* signals_state); + virtual MojoResult AddAwakableImplNoLock(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + virtual void RemoveAwakableImplNoLock(Awakable* awakable, + HandleSignalsState* signals_state); // These implement the API used to serialize dispatchers to a |Channel| // (described below). They will only be called on a dispatcher that's attached diff --git a/mojo/edk/system/dispatcher_unittest.cc b/mojo/edk/system/dispatcher_unittest.cc index 0b15436..97e2eed 100644 --- a/mojo/edk/system/dispatcher_unittest.cc +++ b/mojo/edk/system/dispatcher_unittest.cc @@ -67,16 +67,16 @@ TEST(DispatcherTest, Basic) { w.Init(); HandleSignalsState hss; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss)); + d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); // Okay to remove even if it wasn't added (or was already removed). hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); @@ -104,11 +104,11 @@ TEST(DispatcherTest, Basic) { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0)); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss)); + d->AddAwakable(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); } @@ -212,8 +212,8 @@ class ThreadSafetyStressThread : public base::SimpleThread { } case ADD_WAITER: { HandleSignalsState hss; - MojoResult r = - dispatcher_->AddWaiter(&waiter_, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss); + MojoResult r = dispatcher_->AddAwakable( + &waiter_, ~MOJO_HANDLE_SIGNAL_NONE, 0, &hss); EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION || r == MOJO_RESULT_INVALID_ARGUMENT); EXPECT_EQ(0u, hss.satisfied_signals); @@ -222,7 +222,7 @@ class ThreadSafetyStressThread : public base::SimpleThread { } case REMOVE_WAITER: { HandleSignalsState hss; - dispatcher_->RemoveWaiter(&waiter_, &hss); + dispatcher_->RemoveAwakable(&waiter_, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); break; @@ -234,7 +234,7 @@ class ThreadSafetyStressThread : public base::SimpleThread { // Always try to remove the waiter, in case we added it. HandleSignalsState hss; - dispatcher_->RemoveWaiter(&waiter_, &hss); + dispatcher_->RemoveAwakable(&waiter_, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); } diff --git a/mojo/edk/system/endpoint_relayer.cc b/mojo/edk/system/endpoint_relayer.cc new file mode 100644 index 0000000..52faefa --- /dev/null +++ b/mojo/edk/system/endpoint_relayer.cc @@ -0,0 +1,70 @@ +// Copyright 2014 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/endpoint_relayer.h" + +#include "base/logging.h" +#include "mojo/edk/system/channel_endpoint.h" +#include "mojo/edk/system/message_in_transit.h" + +namespace mojo { +namespace system { + +EndpointRelayer::EndpointRelayer() { +} + +// static +unsigned EndpointRelayer::GetPeerPort(unsigned port) { + DCHECK(port == 0 || port == 1); + return port ^ 1; +} + +void EndpointRelayer::Init(ChannelEndpoint* endpoint0, + ChannelEndpoint* endpoint1) { + DCHECK(endpoint0); + DCHECK(endpoint1); + DCHECK(!endpoints_[0]); + DCHECK(!endpoints_[1]); + endpoints_[0] = endpoint0; + endpoints_[1] = endpoint1; +} + +bool EndpointRelayer::OnReadMessage(unsigned port, MessageInTransit* message) { + DCHECK(message); + + base::AutoLock locker(lock_); + + // If we're no longer the client, then reject the message. + if (!endpoints_[port]) + return false; + + // Otherwise, consume it even if the peer port is closed. + unsigned peer_port = GetPeerPort(port); + if (endpoints_[peer_port]) + endpoints_[peer_port]->EnqueueMessage(make_scoped_ptr(message)); + return true; +} + +void EndpointRelayer::OnDetachFromChannel(unsigned port) { + base::AutoLock locker(lock_); + + if (endpoints_[port]) { + endpoints_[port]->DetachFromClient(); + endpoints_[port] = nullptr; + } + + unsigned peer_port = GetPeerPort(port); + if (endpoints_[peer_port]) { + endpoints_[peer_port]->DetachFromClient(); + endpoints_[peer_port] = nullptr; + } +} + +EndpointRelayer::~EndpointRelayer() { + DCHECK(!endpoints_[0]); + DCHECK(!endpoints_[1]); +} + +} // namespace system +} // namespace mojo diff --git a/mojo/edk/system/endpoint_relayer.h b/mojo/edk/system/endpoint_relayer.h new file mode 100644 index 0000000..4084452 --- /dev/null +++ b/mojo/edk/system/endpoint_relayer.h @@ -0,0 +1,49 @@ +// Copyright 2014 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. + +#ifndef MOJO_EDK_SYSTEM_ENDPOINT_RELAYER_H_ +#define MOJO_EDK_SYSTEM_ENDPOINT_RELAYER_H_ + +#include "base/macros.h" +#include "base/memory/ref_counted.h" +#include "base/synchronization/lock.h" +#include "mojo/edk/system/channel_endpoint_client.h" +#include "mojo/edk/system/system_impl_export.h" + +namespace mojo { +namespace system { + +class ChannelEndpoint; + +// This is a simple |ChannelEndpointClient| that just relays messages between +// two |ChannelEndpoint|s (without the overhead of |MessagePipe|). +class MOJO_SYSTEM_IMPL_EXPORT EndpointRelayer : public ChannelEndpointClient { + public: + EndpointRelayer(); + + // Gets the other port number (i.e., 0 -> 1, 1 -> 0). + static unsigned GetPeerPort(unsigned port); + + // Initialize this object. This must be called before any other method. + void Init(ChannelEndpoint* endpoint0, ChannelEndpoint* endpoint1); + + // |ChannelEndpointClient| methods: + bool OnReadMessage(unsigned port, MessageInTransit* message) override; + void OnDetachFromChannel(unsigned port) override; + + private: + virtual ~EndpointRelayer(); + + // TODO(vtl): We could probably get away without the lock if we had a + // thread-safe |scoped_refptr|. + base::Lock lock_; // Protects the following members. + scoped_refptr<ChannelEndpoint> endpoints_[2]; + + DISALLOW_COPY_AND_ASSIGN(EndpointRelayer); +}; + +} // namespace system +} // namespace mojo + +#endif // MOJO_EDK_SYSTEM_ENDPOINT_RELAYER_H_ diff --git a/mojo/edk/system/handle_table.cc b/mojo/edk/system/handle_table.cc index 05d5260..e054919 100644 --- a/mojo/edk/system/handle_table.cc +++ b/mojo/edk/system/handle_table.cc @@ -91,7 +91,7 @@ bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers, return false; for (size_t i = 0; i < dispatchers.size(); i++) { - if (dispatchers[i].get()) { + if (dispatchers[i]) { handles[i] = AddDispatcherNoSizeCheck(dispatchers[i]); } else { LOG(WARNING) << "Invalid dispatcher at index " << i; @@ -188,7 +188,7 @@ MojoResult HandleTable::MarkBusyAndStartTransport( MojoHandle HandleTable::AddDispatcherNoSizeCheck( const scoped_refptr<Dispatcher>& dispatcher) { - DCHECK(dispatcher.get()); + DCHECK(dispatcher); DCHECK_LT(handle_to_entry_map_.size(), GetConfiguration().max_handle_table_size); DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID); diff --git a/mojo/edk/system/local_data_pipe_unittest.cc b/mojo/edk/system/local_data_pipe_unittest.cc index cea50a0..1223a2ba 100644 --- a/mojo/edk/system/local_data_pipe_unittest.cc +++ b/mojo/edk/system/local_data_pipe_unittest.cc @@ -237,7 +237,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_FAILED_PRECONDITION, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -247,7 +247,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34, &hss)); // Write two elements. int32_t elements[2] = {123, 456}; @@ -259,13 +259,13 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Adding a waiter should now succeed. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, + nullptr)); // And it shouldn't be writable yet. EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -283,22 +283,22 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Add a waiter. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 56, + nullptr)); // And it still shouldn't be writable yet. EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); // Do it again. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 78, + nullptr)); // Read one element. elements[0] = -1; @@ -315,7 +315,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); EXPECT_EQ(78u, context); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -335,9 +335,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Add a waiter. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 90, + nullptr)); // Read one element, using a two-phase read. const void* read_buffer = nullptr; @@ -359,7 +359,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); EXPECT_EQ(90u, context); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -374,9 +374,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Add a waiter. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, + nullptr)); // Close the consumer. dp->ConsumerClose(); @@ -385,7 +385,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context)); EXPECT_EQ(12u, context); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -412,8 +412,8 @@ TEST(LocalDataPipeTest, PeerClosedWaiting) { // Add a waiter. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, - nullptr)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, + 12, nullptr)); // Close the consumer. dp->ConsumerClose(); @@ -423,7 +423,7 @@ TEST(LocalDataPipeTest, PeerClosedWaiting) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); EXPECT_EQ(12u, context); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -436,8 +436,8 @@ TEST(LocalDataPipeTest, PeerClosedWaiting) { // Add a waiter. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, - nullptr)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, + 12, nullptr)); // Close the producer. dp->ProducerClose(); @@ -447,7 +447,7 @@ TEST(LocalDataPipeTest, PeerClosedWaiting) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); EXPECT_EQ(12u, context); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -475,9 +475,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Never writable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, &hss)); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 12, + &hss)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -485,11 +485,11 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Not yet readable. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, - nullptr)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -504,9 +504,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should already be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -520,9 +520,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should still be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -541,9 +541,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should still be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 78, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -562,8 +562,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Adding a waiter should now succeed. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, - nullptr)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, + nullptr)); // Write one element. elements[0] = 789; @@ -577,7 +577,7 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); EXPECT_EQ(90u, context); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -588,9 +588,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should still be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -610,9 +610,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should be never-readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss)); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -646,9 +646,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should already be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 12, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -670,9 +670,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Should still be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ( - MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, &hss)); + EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -694,8 +694,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Adding a waiter should now succeed. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, - nullptr)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, + nullptr)); // Close the producer. dp->ProducerClose(); @@ -704,7 +704,7 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(1000, &context)); EXPECT_EQ(56u, context); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -733,7 +733,7 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -748,24 +748,24 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // At this point, it shouldn't be writable. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 1, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ProducerRemoveWaiter(&waiter, &hss); + dp->ProducerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); // It shouldn't be readable yet either. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 2, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -779,7 +779,7 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 3, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -789,7 +789,7 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 4, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -809,7 +809,7 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -831,19 +831,19 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); // But not readable. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -856,7 +856,7 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -886,19 +886,19 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); // Not readable. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -915,7 +915,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 2, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -925,7 +925,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -943,7 +943,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -953,7 +953,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss)); + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 5, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -972,19 +972,19 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { hss = HandleSignalsState(); EXPECT_EQ( MOJO_RESULT_ALREADY_EXISTS, - dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); + dp->ProducerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); // No longer readable. waiter.Init(); - ASSERT_EQ( - MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, nullptr)); + ASSERT_EQ(MOJO_RESULT_OK, + dp->ConsumerAddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, + nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - dp->ConsumerRemoveWaiter(&waiter, &hss); + dp->ConsumerRemoveAwakable(&waiter, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); diff --git a/mojo/edk/system/local_message_pipe_endpoint.cc b/mojo/edk/system/local_message_pipe_endpoint.cc index 86d241c..576ad50 100644 --- a/mojo/edk/system/local_message_pipe_endpoint.cc +++ b/mojo/edk/system/local_message_pipe_endpoint.cc @@ -35,7 +35,7 @@ bool LocalMessagePipeEndpoint::OnPeerClose() { HandleSignalsState new_state = GetHandleSignalsState(); if (!new_state.equals(old_state)) - waiter_list_.AwakeWaitersForStateChange(new_state); + awakable_list_.AwakeForStateChange(new_state); return true; } @@ -48,7 +48,7 @@ void LocalMessagePipeEndpoint::EnqueueMessage( bool was_empty = message_queue_.IsEmpty(); message_queue_.AddMessage(message.Pass()); if (was_empty) - waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState()); + awakable_list_.AwakeForStateChange(GetHandleSignalsState()); } void LocalMessagePipeEndpoint::Close() { @@ -57,9 +57,9 @@ void LocalMessagePipeEndpoint::Close() { message_queue_.Clear(); } -void LocalMessagePipeEndpoint::CancelAllWaiters() { +void LocalMessagePipeEndpoint::CancelAllAwakables() { DCHECK(is_open_); - waiter_list_.CancelAllWaiters(); + awakable_list_.CancelAll(); } MojoResult LocalMessagePipeEndpoint::ReadMessage( @@ -117,7 +117,7 @@ MojoResult LocalMessagePipeEndpoint::ReadMessage( if (message_queue_.IsEmpty()) { // It's currently not possible to wait for non-readability, but we should // do the state change anyway. - waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsState()); + awakable_list_.AwakeForStateChange(GetHandleSignalsState()); } } @@ -144,8 +144,8 @@ HandleSignalsState LocalMessagePipeEndpoint::GetHandleSignalsState() const { return rv; } -MojoResult LocalMessagePipeEndpoint::AddWaiter( - Waiter* waiter, +MojoResult LocalMessagePipeEndpoint::AddAwakable( + Awakable* awakable, MojoHandleSignals signals, uint32_t context, HandleSignalsState* signals_state) { @@ -163,14 +163,15 @@ MojoResult LocalMessagePipeEndpoint::AddWaiter( return MOJO_RESULT_FAILED_PRECONDITION; } - waiter_list_.AddWaiter(waiter, signals, context); + awakable_list_.Add(awakable, signals, context); return MOJO_RESULT_OK; } -void LocalMessagePipeEndpoint::RemoveWaiter(Waiter* waiter, - HandleSignalsState* signals_state) { +void LocalMessagePipeEndpoint::RemoveAwakable( + Awakable* awakable, + HandleSignalsState* signals_state) { DCHECK(is_open_); - waiter_list_.RemoveWaiter(waiter); + awakable_list_.Remove(awakable); if (signals_state) *signals_state = GetHandleSignalsState(); } diff --git a/mojo/edk/system/local_message_pipe_endpoint.h b/mojo/edk/system/local_message_pipe_endpoint.h index 7eb3949..eb1c6ee 100644 --- a/mojo/edk/system/local_message_pipe_endpoint.h +++ b/mojo/edk/system/local_message_pipe_endpoint.h @@ -7,11 +7,11 @@ #include "base/compiler_specific.h" #include "base/macros.h" +#include "mojo/edk/system/awakable_list.h" #include "mojo/edk/system/handle_signals_state.h" #include "mojo/edk/system/message_in_transit_queue.h" #include "mojo/edk/system/message_pipe_endpoint.h" #include "mojo/edk/system/system_impl_export.h" -#include "mojo/edk/system/waiter_list.h" namespace mojo { namespace system { @@ -30,18 +30,19 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalMessagePipeEndpoint // There's a dispatcher for |LocalMessagePipeEndpoint|s, so we have to // implement/override these: void Close() override; - void CancelAllWaiters() override; + void CancelAllAwakables() override; MojoResult ReadMessage(UserPointer<void> bytes, UserPointer<uint32_t> num_bytes, DispatcherVector* dispatchers, uint32_t* num_dispatchers, MojoReadMessageFlags flags) override; HandleSignalsState GetHandleSignalsState() const override; - MojoResult AddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) override; - void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state) override; + MojoResult AddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) override; + void RemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state) override; // This is only to be used by |MessagePipe|: MessageInTransitQueue* message_queue() { return &message_queue_; } @@ -52,7 +53,7 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalMessagePipeEndpoint // Queue of incoming messages. MessageInTransitQueue message_queue_; - WaiterList waiter_list_; + AwakableList awakable_list_; DISALLOW_COPY_AND_ASSIGN(LocalMessagePipeEndpoint); }; diff --git a/mojo/edk/system/message_in_transit.cc b/mojo/edk/system/message_in_transit.cc index 624a546..1387dd82 100644 --- a/mojo/edk/system/message_in_transit.cc +++ b/mojo/edk/system/message_in_transit.cc @@ -127,7 +127,7 @@ MessageInTransit::MessageInTransit(const View& message_view) MessageInTransit::~MessageInTransit() { if (dispatchers_) { for (size_t i = 0; i < dispatchers_->size(); i++) { - if (!(*dispatchers_)[i].get()) + if (!(*dispatchers_)[i]) continue; DCHECK((*dispatchers_)[i]->HasOneRef()); @@ -166,7 +166,7 @@ void MessageInTransit::SetDispatchers( dispatchers_ = dispatchers.Pass(); #ifndef NDEBUG for (size_t i = 0; i < dispatchers_->size(); i++) - DCHECK(!(*dispatchers_)[i].get() || (*dispatchers_)[i]->HasOneRef()); + DCHECK(!(*dispatchers_)[i] || (*dispatchers_)[i]->HasOneRef()); #endif } diff --git a/mojo/edk/system/message_pipe.cc b/mojo/edk/system/message_pipe.cc index ee5036f..3e243b6 100644 --- a/mojo/edk/system/message_pipe.cc +++ b/mojo/edk/system/message_pipe.cc @@ -8,6 +8,7 @@ #include "mojo/edk/system/channel.h" #include "mojo/edk/system/channel_endpoint.h" #include "mojo/edk/system/channel_endpoint_id.h" +#include "mojo/edk/system/endpoint_relayer.h" #include "mojo/edk/system/local_message_pipe_endpoint.h" #include "mojo/edk/system/message_in_transit.h" #include "mojo/edk/system/message_pipe_dispatcher.h" @@ -41,7 +42,7 @@ MessagePipe* MessagePipe::CreateLocalLocal() { // static MessagePipe* MessagePipe::CreateLocalProxy( scoped_refptr<ChannelEndpoint>* channel_endpoint) { - DCHECK(!channel_endpoint->get()); // Not technically wrong, but unlikely. + DCHECK(!*channel_endpoint); // Not technically wrong, but unlikely. MessagePipe* message_pipe = new MessagePipe(); message_pipe->endpoints_[0].reset(new LocalMessagePipeEndpoint()); *channel_endpoint = new ChannelEndpoint(message_pipe, 1); @@ -53,7 +54,7 @@ MessagePipe* MessagePipe::CreateLocalProxy( // static MessagePipe* MessagePipe::CreateProxyLocal( scoped_refptr<ChannelEndpoint>* channel_endpoint) { - DCHECK(!channel_endpoint->get()); // Not technically wrong, but unlikely. + DCHECK(!*channel_endpoint); // Not technically wrong, but unlikely. MessagePipe* message_pipe = new MessagePipe(); *channel_endpoint = new ChannelEndpoint(message_pipe, 0); message_pipe->endpoints_[0].reset( @@ -74,7 +75,7 @@ bool MessagePipe::Deserialize(Channel* channel, size_t size, scoped_refptr<MessagePipe>* message_pipe, unsigned* port) { - DCHECK(!message_pipe->get()); // Not technically wrong, but unlikely. + DCHECK(!*message_pipe); // Not technically wrong, but unlikely. if (size != sizeof(SerializedMessagePipe)) { LOG(ERROR) << "Invalid serialized message pipe"; @@ -84,7 +85,7 @@ bool MessagePipe::Deserialize(Channel* channel, const SerializedMessagePipe* s = static_cast<const SerializedMessagePipe*>(source); *message_pipe = channel->PassIncomingMessagePipe(s->receiver_endpoint_id); - if (!message_pipe->get()) { + if (!*message_pipe) { LOG(ERROR) << "Failed to deserialize message pipe (ID = " << s->receiver_endpoint_id << ")"; return false; @@ -104,18 +105,18 @@ MessagePipeEndpoint::Type MessagePipe::GetType(unsigned port) { return endpoints_[port]->GetType(); } -void MessagePipe::CancelAllWaiters(unsigned port) { +void MessagePipe::CancelAllAwakables(unsigned port) { DCHECK(port == 0 || port == 1); base::AutoLock locker(lock_); DCHECK(endpoints_[port]); - endpoints_[port]->CancelAllWaiters(); + endpoints_[port]->CancelAllAwakables(); } void MessagePipe::Close(unsigned port) { DCHECK(port == 0 || port == 1); - unsigned destination_port = GetPeerPort(port); + unsigned peer_port = GetPeerPort(port); base::AutoLock locker(lock_); // The endpoint's |OnPeerClose()| may have been called first and returned @@ -124,9 +125,9 @@ void MessagePipe::Close(unsigned port) { return; endpoints_[port]->Close(); - if (endpoints_[destination_port]) { - if (!endpoints_[destination_port]->OnPeerClose()) - endpoints_[destination_port].reset(); + if (endpoints_[peer_port]) { + if (!endpoints_[peer_port]->OnPeerClose()) + endpoints_[peer_port].reset(); } endpoints_[port].reset(); } @@ -139,7 +140,9 @@ MojoResult MessagePipe::WriteMessage( std::vector<DispatcherTransport>* transports, MojoWriteMessageFlags flags) { DCHECK(port == 0 || port == 1); - return EnqueueMessage( + + base::AutoLock locker(lock_); + return EnqueueMessageNoLock( GetPeerPort(port), make_scoped_ptr(new MessageInTransit( MessageInTransit::kTypeEndpoint, @@ -171,28 +174,29 @@ HandleSignalsState MessagePipe::GetHandleSignalsState(unsigned port) const { return endpoints_[port]->GetHandleSignalsState(); } -MojoResult MessagePipe::AddWaiter(unsigned port, - Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) { +MojoResult MessagePipe::AddAwakable(unsigned port, + Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) { DCHECK(port == 0 || port == 1); base::AutoLock locker(lock_); DCHECK(endpoints_[port]); - return endpoints_[port]->AddWaiter(waiter, signals, context, signals_state); + return endpoints_[port]->AddAwakable(awakable, signals, context, + signals_state); } -void MessagePipe::RemoveWaiter(unsigned port, - Waiter* waiter, - HandleSignalsState* signals_state) { +void MessagePipe::RemoveAwakable(unsigned port, + Awakable* awakable, + HandleSignalsState* signals_state) { DCHECK(port == 0 || port == 1); base::AutoLock locker(lock_); DCHECK(endpoints_[port]); - endpoints_[port]->RemoveWaiter(waiter, signals_state); + endpoints_[port]->RemoveAwakable(awakable, signals_state); } void MessagePipe::StartSerialize(unsigned /*port*/, @@ -243,16 +247,17 @@ bool MessagePipe::EndSerialize( // We also pass its |ChannelEndpoint| to the channel, which then decides // what to do. We have no reason to continue to exist. // - // TODO(vtl): Factor some of this out to |ChannelEndpoint|. + // TODO(vtl): Factor some of this out to |ChannelEndpoint| (or |Channel|). - if (!endpoints_[GetPeerPort(port)]) { + unsigned peer_port = GetPeerPort(port); + if (!endpoints_[peer_port]) { // Case 1. channel_endpoint = new ChannelEndpoint( nullptr, 0, static_cast<LocalMessagePipeEndpoint*>( endpoints_[port].get())->message_queue()); endpoints_[port]->Close(); endpoints_[port].reset(); - } else if (endpoints_[GetPeerPort(port)]->GetType() == + } else if (endpoints_[peer_port]->GetType() == MessagePipeEndpoint::kTypeLocal) { // Case 2. channel_endpoint = new ChannelEndpoint( @@ -263,15 +268,44 @@ bool MessagePipe::EndSerialize( new ProxyMessagePipeEndpoint(channel_endpoint.get())); } else { // Case 3. - // TODO(vtl): Temporarily the same as case 2. DLOG(WARNING) << "Direct message pipe passing across multiple channels " "not yet implemented; will proxy"; + + // Create an |EndpointRelayer| to replace ourselves (rather than having a + // |MessagePipe| object that exists solely to relay messages between two + // |ChannelEndpoint|s, owned by the |Channel| through them. + // + // This reduces overhead somewhat, and more importantly restores some + // invariants, e.g., that |MessagePipe|s are owned by dispatchers. + // + // TODO(vtl): If we get the |Channel| to own/track the relayer directly, + // then possibly we could make |ChannelEndpoint|'s |client_| pointer a raw + // pointer (and not have the |Channel| owning the relayer via its + // |ChannelEndpoint|s. + // + // TODO(vtl): This is not obviously the right place for (all of) this + // logic, nor is it obviously factored correctly. + + DCHECK_EQ(endpoints_[peer_port]->GetType(), + MessagePipeEndpoint::kTypeProxy); + ProxyMessagePipeEndpoint* peer_endpoint = + static_cast<ProxyMessagePipeEndpoint*>(endpoints_[peer_port].get()); + scoped_refptr<ChannelEndpoint> peer_channel_endpoint = + peer_endpoint->ReleaseChannelEndpoint(); + + scoped_refptr<EndpointRelayer> relayer(new EndpointRelayer()); + // We'll assign our peer port's endpoint to the relayer's port 1, and this + // port's endpoint to the relayer's port 0. channel_endpoint = new ChannelEndpoint( - this, port, static_cast<LocalMessagePipeEndpoint*>( - endpoints_[port].get())->message_queue()); + relayer.get(), 0, static_cast<LocalMessagePipeEndpoint*>( + endpoints_[port].get())->message_queue()); + relayer->Init(channel_endpoint.get(), peer_channel_endpoint.get()); + peer_channel_endpoint->ReplaceClient(relayer.get(), 1); + endpoints_[port]->Close(); - endpoints_[port].reset( - new ProxyMessagePipeEndpoint(channel_endpoint.get())); + endpoints_[port].reset(); + // No need to call |Close()| after |ReleaseChannelEndpoint()|. + endpoints_[peer_port].reset(); } } @@ -287,16 +321,27 @@ bool MessagePipe::EndSerialize( return true; } -void MessagePipe::OnReadMessage(unsigned port, - scoped_ptr<MessageInTransit> message) { +bool MessagePipe::OnReadMessage(unsigned port, MessageInTransit* message) { + base::AutoLock locker(lock_); + + if (!endpoints_[port]) { + // This will happen only on the rare occasion that the call to + // |OnReadMessage()| is racing with us calling + // |ChannelEndpoint::ReplaceClient()|, in which case we reject the message, + // and the |ChannelEndpoint| can retry (calling the new client's + // |OnReadMessage()|). + return false; + } + // This is called when the |ChannelEndpoint| for the // |ProxyMessagePipeEndpoint| |port| receives a message (from the |Channel|). // We need to pass this message on to its peer port (typically a // |LocalMessagePipeEndpoint|). - MojoResult result = - EnqueueMessage(GetPeerPort(port), message.Pass(), nullptr); + MojoResult result = EnqueueMessageNoLock(GetPeerPort(port), + make_scoped_ptr(message), nullptr); DLOG_IF(WARNING, result != MOJO_RESULT_OK) - << "EnqueueMessage() failed (result = " << result << ")"; + << "EnqueueMessageNoLock() failed (result = " << result << ")"; + return true; } void MessagePipe::OnDetachFromChannel(unsigned port) { @@ -314,7 +359,7 @@ MessagePipe::~MessagePipe() { DCHECK(!endpoints_[1]); } -MojoResult MessagePipe::EnqueueMessage( +MojoResult MessagePipe::EnqueueMessageNoLock( unsigned port, scoped_ptr<MessageInTransit> message, std::vector<DispatcherTransport>* transports) { @@ -322,8 +367,6 @@ MojoResult MessagePipe::EnqueueMessage( DCHECK(message); DCHECK_EQ(message->type(), MessageInTransit::kTypeEndpoint); - - base::AutoLock locker(lock_); DCHECK(endpoints_[GetPeerPort(port)]); // The destination port need not be open, unlike the source port. diff --git a/mojo/edk/system/message_pipe.h b/mojo/edk/system/message_pipe.h index e8f97d0..431b5a6 100644 --- a/mojo/edk/system/message_pipe.h +++ b/mojo/edk/system/message_pipe.h @@ -28,9 +28,9 @@ namespace mojo { namespace system { +class Awakable; class Channel; class ChannelEndpoint; -class Waiter; // |MessagePipe| is the secondary object implementing a message pipe (see the // explanatory comment in core.cc). It is typically owned by the dispatcher(s) @@ -72,7 +72,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe : public ChannelEndpointClient { // These are called by the dispatcher to implement its methods of // corresponding names. In all cases, the port |port| must be open. - void CancelAllWaiters(unsigned port); + void CancelAllAwakables(unsigned port); void Close(unsigned port); // Unlike |MessagePipeDispatcher::WriteMessage()|, this does not validate its // arguments. @@ -88,14 +88,14 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe : public ChannelEndpointClient { uint32_t* num_dispatchers, MojoReadMessageFlags flags); HandleSignalsState GetHandleSignalsState(unsigned port) const; - MojoResult AddWaiter(unsigned port, - Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - void RemoveWaiter(unsigned port, - Waiter* waiter, - HandleSignalsState* signals_state); + MojoResult AddAwakable(unsigned port, + Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + void RemoveAwakable(unsigned port, + Awakable* awakable, + HandleSignalsState* signals_state); void StartSerialize(unsigned port, Channel* channel, size_t* max_size, @@ -107,8 +107,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe : public ChannelEndpointClient { embedder::PlatformHandleVector* platform_handles); // |ChannelEndpointClient| methods: - void OnReadMessage(unsigned port, - scoped_ptr<MessageInTransit> message) override; + bool OnReadMessage(unsigned port, MessageInTransit* message) override; void OnDetachFromChannel(unsigned port) override; private: @@ -117,12 +116,12 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe : public ChannelEndpointClient { // This is used internally by |WriteMessage()| and by |OnReadMessage()|. // |transports| may be non-null only if it's nonempty and |message| has no - // dispatchers attached. - MojoResult EnqueueMessage(unsigned port, - scoped_ptr<MessageInTransit> message, - std::vector<DispatcherTransport>* transports); + // dispatchers attached. Must be called with |lock_| held. + MojoResult EnqueueMessageNoLock(unsigned port, + scoped_ptr<MessageInTransit> message, + std::vector<DispatcherTransport>* transports); - // Helper for |EnqueueMessage()|. Must be called with |lock_| held. + // Helper for |EnqueueMessageNoLock()|. Must be called with |lock_| held. MojoResult AttachTransportsNoLock( unsigned port, MessageInTransit* message, diff --git a/mojo/edk/system/message_pipe_dispatcher.cc b/mojo/edk/system/message_pipe_dispatcher.cc index df861df..a6733dbe 100644 --- a/mojo/edk/system/message_pipe_dispatcher.cc +++ b/mojo/edk/system/message_pipe_dispatcher.cc @@ -60,7 +60,7 @@ MojoResult MessagePipeDispatcher::ValidateCreateOptions( void MessagePipeDispatcher::Init(scoped_refptr<MessagePipe> message_pipe, unsigned port) { - DCHECK(message_pipe.get()); + DCHECK(message_pipe); DCHECK(port == 0 || port == 1); message_pipe_ = message_pipe; @@ -92,7 +92,7 @@ scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize( scoped_refptr<MessagePipe> message_pipe; if (!MessagePipe::Deserialize(channel, source, size, &message_pipe, &port)) return nullptr; - DCHECK(message_pipe.get()); + DCHECK(message_pipe); DCHECK(port == 0 || port == 1); scoped_refptr<MessagePipeDispatcher> dispatcher( @@ -103,7 +103,7 @@ scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize( MessagePipeDispatcher::~MessagePipeDispatcher() { // |Close()|/|CloseImplNoLock()| should have taken care of the pipe. - DCHECK(!message_pipe_.get()); + DCHECK(!message_pipe_); } MessagePipe* MessagePipeDispatcher::GetMessagePipeNoLock() const { @@ -116,9 +116,9 @@ unsigned MessagePipeDispatcher::GetPortNoLock() const { return port_; } -void MessagePipeDispatcher::CancelAllWaitersNoLock() { +void MessagePipeDispatcher::CancelAllAwakablesNoLock() { lock().AssertAcquired(); - message_pipe_->CancelAllWaiters(port_); + message_pipe_->CancelAllAwakables(port_); } void MessagePipeDispatcher::CloseImplNoLock() { @@ -178,21 +178,21 @@ HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock() return message_pipe_->GetHandleSignalsState(port_); } -MojoResult MessagePipeDispatcher::AddWaiterImplNoLock( - Waiter* waiter, +MojoResult MessagePipeDispatcher::AddAwakableImplNoLock( + Awakable* awakable, MojoHandleSignals signals, uint32_t context, HandleSignalsState* signals_state) { lock().AssertAcquired(); - return message_pipe_->AddWaiter(port_, waiter, signals, context, - signals_state); + return message_pipe_->AddAwakable(port_, awakable, signals, context, + signals_state); } -void MessagePipeDispatcher::RemoveWaiterImplNoLock( - Waiter* waiter, +void MessagePipeDispatcher::RemoveAwakableImplNoLock( + Awakable* awakable, HandleSignalsState* signals_state) { lock().AssertAcquired(); - message_pipe_->RemoveWaiter(port_, waiter, signals_state); + message_pipe_->RemoveAwakable(port_, awakable, signals_state); } void MessagePipeDispatcher::StartSerializeImplNoLock( diff --git a/mojo/edk/system/message_pipe_dispatcher.h b/mojo/edk/system/message_pipe_dispatcher.h index 9afdb70..fb16dd3 100644 --- a/mojo/edk/system/message_pipe_dispatcher.h +++ b/mojo/edk/system/message_pipe_dispatcher.h @@ -73,7 +73,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipeDispatcher : public Dispatcher { unsigned GetPortNoLock() const; // |Dispatcher| protected methods: - void CancelAllWaitersNoLock() override; + void CancelAllAwakablesNoLock() override; void CloseImplNoLock() override; scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock() override; @@ -88,12 +88,12 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipeDispatcher : public Dispatcher { uint32_t* num_dispatchers, MojoReadMessageFlags flags) override; HandleSignalsState GetHandleSignalsStateImplNoLock() const override; - MojoResult AddWaiterImplNoLock(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) override; - void RemoveWaiterImplNoLock(Waiter* waiter, - HandleSignalsState* signals_state) override; + MojoResult AddAwakableImplNoLock(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) override; + void RemoveAwakableImplNoLock(Awakable* awakable, + HandleSignalsState* signals_state) override; void StartSerializeImplNoLock(Channel* channel, size_t* max_size, size_t* max_platform_handles) override; diff --git a/mojo/edk/system/message_pipe_dispatcher_unittest.cc b/mojo/edk/system/message_pipe_dispatcher_unittest.cc index 303ae6a..b5562b0 100644 --- a/mojo/edk/system/message_pipe_dispatcher_unittest.cc +++ b/mojo/edk/system/message_pipe_dispatcher_unittest.cc @@ -59,7 +59,7 @@ TEST(MessagePipeDispatcherTest, Basic) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); // Shouldn't need to remove the waiter (it was not added). @@ -68,7 +68,7 @@ TEST(MessagePipeDispatcherTest, Basic) { // |d1|), then wait. w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, @@ -78,7 +78,7 @@ TEST(MessagePipeDispatcherTest, Basic) { EXPECT_EQ(1u, context); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); hss = HandleSignalsState(); - d0->RemoveWaiter(&w, &hss); + d0->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -87,7 +87,7 @@ TEST(MessagePipeDispatcherTest, Basic) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -106,19 +106,19 @@ TEST(MessagePipeDispatcherTest, Basic) { // Wait for zero time for readability on |d0| (will time out). w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr)); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); hss = HandleSignalsState(); - d0->RemoveWaiter(&w, &hss); + d0->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); // Wait for non-zero, finite time for readability on |d0| (will time out). w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), nullptr)); @@ -126,14 +126,14 @@ TEST(MessagePipeDispatcherTest, Basic) { EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); hss = HandleSignalsState(); - d0->RemoveWaiter(&w, &hss); + d0->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); // Check the peer closed signal. w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, nullptr)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 12, nullptr)); // Close the peer. EXPECT_EQ(MOJO_RESULT_OK, d1->Close()); @@ -142,7 +142,7 @@ TEST(MessagePipeDispatcherTest, Basic) { EXPECT_EQ(MOJO_RESULT_OK, w.Wait(1000, &context)); EXPECT_EQ(12u, context); hss = HandleSignalsState(); - d0->RemoveWaiter(&w, &hss); + d0->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -249,7 +249,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -269,7 +269,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -289,7 +289,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 2, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -309,7 +309,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -317,7 +317,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { w.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); + d0->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -559,15 +559,15 @@ class ReaderThread : public base::SimpleThread { // Wait for it to be readable. w.Init(); hss = HandleSignalsState(); - result = - read_dispatcher_->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss); + result = read_dispatcher_->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, + &hss); EXPECT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_ALREADY_EXISTS) << "result: " << result; if (result == MOJO_RESULT_OK) { // Actually need to wait. EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, nullptr)); - read_dispatcher_->RemoveWaiter(&w, &hss); + read_dispatcher_->RemoveAwakable(&w, &hss); } // We may not actually be readable, since we're racing with other threads. EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); diff --git a/mojo/edk/system/message_pipe_endpoint.cc b/mojo/edk/system/message_pipe_endpoint.cc index df623d4..4b8bc5e 100644 --- a/mojo/edk/system/message_pipe_endpoint.cc +++ b/mojo/edk/system/message_pipe_endpoint.cc @@ -9,7 +9,7 @@ namespace mojo { namespace system { -void MessagePipeEndpoint::CancelAllWaiters() { +void MessagePipeEndpoint::CancelAllAwakables() { NOTREACHED(); } @@ -27,18 +27,18 @@ HandleSignalsState MessagePipeEndpoint::GetHandleSignalsState() const { return HandleSignalsState(); } -MojoResult MessagePipeEndpoint::AddWaiter(Waiter* /*waiter*/, - MojoHandleSignals /*signals*/, - uint32_t /*context*/, - HandleSignalsState* signals_state) { +MojoResult MessagePipeEndpoint::AddAwakable(Awakable* /*awakable*/, + MojoHandleSignals /*signals*/, + uint32_t /*context*/, + HandleSignalsState* signals_state) { NOTREACHED(); if (signals_state) *signals_state = HandleSignalsState(); return MOJO_RESULT_INTERNAL; } -void MessagePipeEndpoint::RemoveWaiter(Waiter* /*waiter*/, - HandleSignalsState* signals_state) { +void MessagePipeEndpoint::RemoveAwakable(Awakable* /*awakable*/, + HandleSignalsState* signals_state) { NOTREACHED(); if (signals_state) *signals_state = HandleSignalsState(); diff --git a/mojo/edk/system/message_pipe_endpoint.h b/mojo/edk/system/message_pipe_endpoint.h index 7bc0a0d..0b5f12e 100644 --- a/mojo/edk/system/message_pipe_endpoint.h +++ b/mojo/edk/system/message_pipe_endpoint.h @@ -23,7 +23,7 @@ namespace mojo { namespace system { class ChannelEndpoint; -class Waiter; +class Awakable; // This is an interface to one of the ends of a message pipe, and is used by // |MessagePipe|. Its most important role is to provide a sink for messages @@ -58,18 +58,19 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipeEndpoint { // These methods implement the methods of the same name in |MessagePipe|, // though |MessagePipe|'s implementation may have to do a little more if the // operation involves both endpoints. - virtual void CancelAllWaiters(); + virtual void CancelAllAwakables(); virtual MojoResult ReadMessage(UserPointer<void> bytes, UserPointer<uint32_t> num_bytes, DispatcherVector* dispatchers, uint32_t* num_dispatchers, MojoReadMessageFlags flags); virtual HandleSignalsState GetHandleSignalsState() const; - virtual MojoResult AddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state); - virtual void RemoveWaiter(Waiter* waiter, HandleSignalsState* signals_state); + virtual MojoResult AddAwakable(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state); + virtual void RemoveAwakable(Awakable* awakable, + HandleSignalsState* signals_state); // Implementations must override these if they represent a proxy endpoint. An // implementation for a local endpoint needs not override these methods, since diff --git a/mojo/edk/system/message_pipe_test_utils.cc b/mojo/edk/system/message_pipe_test_utils.cc index e5df26d..38fc899 100644 --- a/mojo/edk/system/message_pipe_test_utils.cc +++ b/mojo/edk/system/message_pipe_test_utils.cc @@ -21,14 +21,15 @@ MojoResult WaitIfNecessary(scoped_refptr<MessagePipe> mp, Waiter waiter; waiter.Init(); - MojoResult add_result = mp->AddWaiter(0, &waiter, signals, 0, signals_state); + MojoResult add_result = + mp->AddAwakable(0, &waiter, signals, 0, signals_state); if (add_result != MOJO_RESULT_OK) { return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK : add_result; } MojoResult wait_result = waiter.Wait(MOJO_DEADLINE_INDEFINITE, nullptr); - mp->RemoveWaiter(0, &waiter, signals_state); + mp->RemoveAwakable(0, &waiter, signals_state); return wait_result; } @@ -51,7 +52,7 @@ void ChannelThread::Start(embedder::ScopedPlatformHandle platform_handle, } void ChannelThread::Stop() { - if (channel_.get()) { + if (channel_) { // Hack to flush write buffers before quitting. // TODO(vtl): Remove this once |Channel| has a // |FlushWriteBufferAndShutdown()| (or whatever). @@ -85,7 +86,7 @@ void ChannelThread::InitChannelOnIOThread( } void ChannelThread::ShutdownChannelOnIOThread() { - CHECK(channel_.get()); + CHECK(channel_); channel_->Shutdown(); channel_ = nullptr; } diff --git a/mojo/edk/system/message_pipe_unittest.cc b/mojo/edk/system/message_pipe_unittest.cc index c700891..a30b636 100644 --- a/mojo/edk/system/message_pipe_unittest.cc +++ b/mojo/edk/system/message_pipe_unittest.cc @@ -337,25 +337,26 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE, - 0, &hss)); + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE, + 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); // Not yet readable. waiter.Init(); - ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); + ASSERT_EQ( + MOJO_RESULT_OK, + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - mp->RemoveWaiter(0, &waiter, &hss); + mp->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -363,10 +364,10 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 2, nullptr)); + mp->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 2, nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); - mp->RemoveWaiter(0, &waiter, &hss); + mp->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -380,16 +381,16 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 3, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE, - 0, &hss)); + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE, + 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -397,7 +398,7 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 4, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -408,8 +409,9 @@ TEST(MessagePipeTest, BasicWaiting) { // Port 1 should be signaled with peer closed. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 5, &hss)); + EXPECT_EQ( + MOJO_RESULT_ALREADY_EXISTS, + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 5, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -419,7 +421,7 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 6, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -429,7 +431,7 @@ TEST(MessagePipeTest, BasicWaiting) { waiter.Init(); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, &hss)); + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 7, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -447,8 +449,9 @@ TEST(MessagePipeTest, BasicWaiting) { // Now port 1 should no longer be readable. waiter.Init(); hss = HandleSignalsState(); - EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, nullptr)); + EXPECT_EQ( + MOJO_RESULT_FAILED_PRECONDITION, + mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 8, nullptr)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); @@ -469,8 +472,8 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, - nullptr)); + mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, + 1, nullptr)); thread.Start(); buffer[0] = 123456789; @@ -480,7 +483,7 @@ TEST(MessagePipeTest, ThreadedWaiting) { nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); HandleSignalsState hss; - mp->RemoveWaiter(1, thread.waiter(), &hss); + mp->RemoveAwakable(1, thread.waiter(), &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -499,16 +502,16 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, - nullptr)); + mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, + 2, nullptr)); thread.Start(); // Close port 1 first -- this should result in the waiter being cancelled. - mp->CancelAllWaiters(1); + mp->CancelAllAwakables(1); mp->Close(1); - // Port 1 is closed, so |Dispatcher::RemoveWaiter()| wouldn't call into the - // |MessagePipe| to remove any waiter. + // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into + // the |MessagePipe| to remove any waiter. mp->Close(0); } // Joins |thread|. @@ -522,16 +525,16 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_PEER_CLOSED, - 3, nullptr)); + mp->AddAwakable(1, thread.waiter(), + MOJO_HANDLE_SIGNAL_PEER_CLOSED, 3, nullptr)); thread.Start(); // Close port 1 first -- this should result in the waiter being cancelled. - mp->CancelAllWaiters(1); + mp->CancelAllAwakables(1); mp->Close(1); - // Port 1 is closed, so |Dispatcher::RemoveWaiter()| wouldn't call into the - // |MessagePipe| to remove any waiter. + // Port 1 is closed, so |Dispatcher::RemoveAwakable()| wouldn't call into + // the |MessagePipe| to remove any waiter. mp->Close(0); } // Joins |thread|. @@ -545,21 +548,21 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 4, - nullptr)); + mp->AddAwakable(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, + 4, nullptr)); thread.Start(); // Close port 0 first -- this should wake the waiter up, since port 1 will // never be readable. - mp->CancelAllWaiters(0); + mp->CancelAllAwakables(0); mp->Close(0); HandleSignalsState hss; - mp->RemoveWaiter(1, thread.waiter(), &hss); + mp->RemoveAwakable(1, thread.waiter(), &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); - mp->CancelAllWaiters(1); + mp->CancelAllAwakables(1); mp->Close(1); } // Joins |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); diff --git a/mojo/edk/system/multiprocess_message_pipe_unittest.cc b/mojo/edk/system/multiprocess_message_pipe_unittest.cc index f486152..4d8380b 100644 --- a/mojo/edk/system/multiprocess_message_pipe_unittest.cc +++ b/mojo/edk/system/multiprocess_message_pipe_unittest.cc @@ -316,7 +316,7 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); - ASSERT_TRUE(dispatcher.get()); + ASSERT_TRUE(dispatcher); // Make a mapping. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping; diff --git a/mojo/edk/system/platform_handle_dispatcher_unittest.cc b/mojo/edk/system/platform_handle_dispatcher_unittest.cc index 1d784a6..dae53b4 100644 --- a/mojo/edk/system/platform_handle_dispatcher_unittest.cc +++ b/mojo/edk/system/platform_handle_dispatcher_unittest.cc @@ -84,7 +84,7 @@ TEST(PlatformHandleDispatcherTest, CreateEquivalentDispatcherAndClose) { scoped_refptr<Dispatcher> generic_dispatcher = transport.CreateEquivalentDispatcherAndClose(); - ASSERT_TRUE(generic_dispatcher.get()); + ASSERT_TRUE(generic_dispatcher); transport.End(); EXPECT_TRUE(dispatcher->HasOneRef()); diff --git a/mojo/edk/system/proxy_message_pipe_endpoint.cc b/mojo/edk/system/proxy_message_pipe_endpoint.cc index 4a954d9..5f0f2e9 100644 --- a/mojo/edk/system/proxy_message_pipe_endpoint.cc +++ b/mojo/edk/system/proxy_message_pipe_endpoint.cc @@ -20,7 +20,15 @@ ProxyMessagePipeEndpoint::ProxyMessagePipeEndpoint( } ProxyMessagePipeEndpoint::~ProxyMessagePipeEndpoint() { - DCHECK(!channel_endpoint_.get()); + DCHECK(!channel_endpoint_); +} + +scoped_refptr<ChannelEndpoint> +ProxyMessagePipeEndpoint::ReleaseChannelEndpoint() { + DCHECK(channel_endpoint_); + scoped_refptr<ChannelEndpoint> rv; + rv.swap(channel_endpoint_); + return rv; } MessagePipeEndpoint::Type ProxyMessagePipeEndpoint::GetType() const { @@ -37,7 +45,7 @@ bool ProxyMessagePipeEndpoint::OnPeerClose() { // This case is handled in |Run()| (which will call us). void ProxyMessagePipeEndpoint::EnqueueMessage( scoped_ptr<MessageInTransit> message) { - DCHECK(channel_endpoint_.get()); + DCHECK(channel_endpoint_); LOG_IF(WARNING, !channel_endpoint_->EnqueueMessage(message.Pass())) << "Failed to write enqueue message to channel"; } @@ -47,7 +55,7 @@ void ProxyMessagePipeEndpoint::Close() { } void ProxyMessagePipeEndpoint::DetachIfNecessary() { - if (channel_endpoint_.get()) { + if (channel_endpoint_) { channel_endpoint_->DetachFromClient(); channel_endpoint_ = nullptr; } diff --git a/mojo/edk/system/proxy_message_pipe_endpoint.h b/mojo/edk/system/proxy_message_pipe_endpoint.h index 3426869..6e10699 100644 --- a/mojo/edk/system/proxy_message_pipe_endpoint.h +++ b/mojo/edk/system/proxy_message_pipe_endpoint.h @@ -33,6 +33,14 @@ class MOJO_SYSTEM_IMPL_EXPORT ProxyMessagePipeEndpoint explicit ProxyMessagePipeEndpoint(ChannelEndpoint* channel_endpoint); ~ProxyMessagePipeEndpoint() override; + // Returns |channel_endpoint_| and resets |channel_endpoint_| to null. This + // may be called at most once, after which |Close()| need not be called. + // + // Note: The returned |ChannelEndpoint| must have its client changed while + // still under |MessagePipe|'s lock (which this must have also been called + // under). + scoped_refptr<ChannelEndpoint> ReleaseChannelEndpoint(); + // |MessagePipeEndpoint| implementation: Type GetType() const override; bool OnPeerClose() override; diff --git a/mojo/edk/system/remote_message_pipe_unittest.cc b/mojo/edk/system/remote_message_pipe_unittest.cc index 926ca0b..d34602c 100644 --- a/mojo/edk/system/remote_message_pipe_unittest.cc +++ b/mojo/edk/system/remote_message_pipe_unittest.cc @@ -110,11 +110,11 @@ class RemoteMessagePipeTest : public testing::Test { void TearDownOnIOThread() { CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop()); - if (channels_[0].get()) { + if (channels_[0]) { channels_[0]->Shutdown(); channels_[0] = nullptr; } - if (channels_[1].get()) { + if (channels_[1]) { channels_[1]->Shutdown(); channels_[1] = nullptr; } @@ -123,7 +123,7 @@ class RemoteMessagePipeTest : public testing::Test { void CreateAndInitChannel(unsigned channel_index) { CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop()); CHECK(channel_index == 0 || channel_index == 1); - CHECK(!channels_[channel_index].get()); + CHECK(!channels_[channel_index]); channels_[channel_index] = new Channel(&platform_support_); CHECK(channels_[channel_index]->Init( @@ -134,9 +134,9 @@ class RemoteMessagePipeTest : public testing::Test { scoped_refptr<ChannelEndpoint> ep1) { CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop()); - if (!channels_[0].get()) + if (!channels_[0]) CreateAndInitChannel(0); - if (!channels_[1].get()) + if (!channels_[1]) CreateAndInitChannel(1); channels_[0]->AttachAndRunEndpoint(ep0, true); @@ -193,7 +193,7 @@ TEST_F(RemoteMessagePipeTest, Basic) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. EXPECT_EQ( @@ -205,7 +205,7 @@ TEST_F(RemoteMessagePipeTest, Basic) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -223,7 +223,7 @@ TEST_F(RemoteMessagePipeTest, Basic) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); + mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); EXPECT_EQ( MOJO_RESULT_OK, @@ -233,7 +233,7 @@ TEST_F(RemoteMessagePipeTest, Basic) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(456u, context); hss = HandleSignalsState(); - mp0->RemoveWaiter(0, &waiter, &hss); + mp0->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -255,13 +255,13 @@ TEST_F(RemoteMessagePipeTest, Basic) { waiter.Init(); hss = HandleSignalsState(); MojoResult result = - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, &hss); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, &hss); if (result == MOJO_RESULT_OK) { EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); } EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -292,12 +292,12 @@ TEST_F(RemoteMessagePipeTest, PeerClosed) { waiter.Init(); hss = HandleSignalsState(); MojoResult result = - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 101, &hss); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_PEER_CLOSED, 101, &hss); if (result == MOJO_RESULT_OK) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(101u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); } EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, hss.satisfiable_signals); @@ -339,7 +339,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); EXPECT_EQ(MOJO_RESULT_OK, mp0->WriteMessage(0, UserPointer<const void>(&remote_id), @@ -349,7 +349,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -366,14 +366,14 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { // Warning: The local side of mp3 is port 0, not port 1. scoped_refptr<MessagePipe> mp3 = channels(1)->PassIncomingMessagePipe(received_id); - ASSERT_TRUE(mp3.get()); + ASSERT_TRUE(mp3); // Write: MP 2, port 0 -> MP 3, port 1. waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); + mp3->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); EXPECT_EQ( MOJO_RESULT_OK, @@ -383,7 +383,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); hss = HandleSignalsState(); - mp3->RemoveWaiter(0, &waiter, &hss); + mp3->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -419,7 +419,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); EXPECT_EQ( MOJO_RESULT_OK, @@ -429,7 +429,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals | MOJO_HANDLE_SIGNAL_PEER_CLOSED, @@ -500,7 +500,7 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); BootstrapChannelEndpointNoWait(1, ep1); @@ -512,7 +512,7 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) { // not appear as writable (there's a race, and it may not have noticed that // the other side was closed yet -- e.g., inserting a sleep here would make it // much more likely to notice that it's no longer writable). - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); @@ -562,7 +562,7 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); BootstrapChannelEndpointNoWait(1, ep1); @@ -574,7 +574,7 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { // not appear as writable (there's a race, and it may not have noticed that // the other side was closed yet -- e.g., inserting a sleep here would make it // much more likely to notice that it's no longer writable). - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_TRUE((hss.satisfied_signals & MOJO_HANDLE_SIGNAL_READABLE)); EXPECT_TRUE((hss.satisfiable_signals & MOJO_HANDLE_SIGNAL_READABLE)); @@ -613,7 +613,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. { @@ -639,7 +639,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -658,7 +658,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType()); @@ -667,8 +667,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { // Add the waiter now, before it becomes readable to avoid a race. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, - nullptr)); + dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, + nullptr)); // Write to "local_mp", port 1. EXPECT_EQ( @@ -683,7 +683,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(456u, context); hss = HandleSignalsState(); - dispatcher->RemoveWaiter(&waiter, &hss); + dispatcher->RemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -701,8 +701,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { // Prepare to wait on "local_mp", port 1. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, - nullptr)); + local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, + nullptr)); // Write to the dispatcher. EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage( @@ -713,7 +713,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); hss = HandleSignalsState(); - local_mp->RemoveWaiter(1, &waiter, &hss); + local_mp->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -787,7 +787,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. { @@ -813,7 +813,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -832,7 +832,7 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType()); @@ -903,7 +903,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); - ASSERT_TRUE(dispatcher.get()); + ASSERT_TRUE(dispatcher); // Make a mapping. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0; @@ -921,7 +921,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. { @@ -947,7 +947,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -966,7 +966,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, read_dispatchers[0]->GetType()); @@ -1040,7 +1040,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. { @@ -1066,7 +1066,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -1085,7 +1085,7 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { EXPECT_STREQ(kWorld, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypePlatformHandle, read_dispatchers[0]->GetType()); @@ -1177,7 +1177,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); + mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. { @@ -1203,7 +1203,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); hss = HandleSignalsState(); - mp1->RemoveWaiter(1, &waiter, &hss); + mp1->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -1222,7 +1222,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType()); @@ -1236,7 +1236,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { waiter.Init(); ASSERT_EQ( MOJO_RESULT_OK, - mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); + mp0->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); // Write to MP 1, port 1. { @@ -1262,7 +1262,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(456u, context); hss = HandleSignalsState(); - mp0->RemoveWaiter(0, &waiter, &hss); + mp0->RemoveAwakable(0, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -1279,7 +1279,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_STREQ(kWorld, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); EXPECT_EQ(1u, read_num_dispatchers); - ASSERT_TRUE(read_dispatchers[0].get()); + ASSERT_TRUE(read_dispatchers[0]); EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeMessagePipe, read_dispatchers[0]->GetType()); @@ -1289,8 +1289,8 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { // Add the waiter now, before it becomes readable to avoid a race. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, - nullptr)); + dispatcher->AddAwakable(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, + nullptr)); // Write to "local_mp", port 1. EXPECT_EQ( @@ -1302,7 +1302,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); hss = HandleSignalsState(); - dispatcher->RemoveWaiter(&waiter, &hss); + dispatcher->RemoveAwakable(&waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); @@ -1320,8 +1320,8 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { // Prepare to wait on "local_mp", port 1. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, - nullptr)); + local_mp->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, + nullptr)); // Write to the dispatcher. EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage( @@ -1332,7 +1332,7 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); hss = HandleSignalsState(); - local_mp->RemoveWaiter(1, &waiter, &hss); + local_mp->RemoveAwakable(1, &waiter, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(kAllSignals, hss.satisfiable_signals); diff --git a/mojo/edk/system/shared_buffer_dispatcher.cc b/mojo/edk/system/shared_buffer_dispatcher.cc index 698ef4e..db823d5 100644 --- a/mojo/edk/system/shared_buffer_dispatcher.cc +++ b/mojo/edk/system/shared_buffer_dispatcher.cc @@ -74,7 +74,7 @@ MojoResult SharedBufferDispatcher::Create( scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer( platform_support->CreateSharedBuffer(static_cast<size_t>(num_bytes))); - if (!shared_buffer.get()) + if (!shared_buffer) return MOJO_RESULT_RESOURCE_EXHAUSTED; *result = new SharedBufferDispatcher(shared_buffer); @@ -126,7 +126,7 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize( scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer( channel->platform_support()->CreateSharedBufferFromHandle( num_bytes, embedder::ScopedPlatformHandle(platform_handle))); - if (!shared_buffer.get()) { + if (!shared_buffer) { LOG(ERROR) << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)"; return nullptr; @@ -139,7 +139,7 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize( SharedBufferDispatcher::SharedBufferDispatcher( scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer) : shared_buffer_(shared_buffer) { - DCHECK(shared_buffer_.get()); + DCHECK(shared_buffer_); } SharedBufferDispatcher::~SharedBufferDispatcher() { @@ -179,14 +179,14 @@ MojoResult SharedBufferDispatcher::ValidateDuplicateOptions( void SharedBufferDispatcher::CloseImplNoLock() { lock().AssertAcquired(); - DCHECK(shared_buffer_.get()); + DCHECK(shared_buffer_); shared_buffer_ = nullptr; } scoped_refptr<Dispatcher> SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { lock().AssertAcquired(); - DCHECK(shared_buffer_.get()); + DCHECK(shared_buffer_); scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer; shared_buffer.swap(shared_buffer_); return scoped_refptr<Dispatcher>(new SharedBufferDispatcher(shared_buffer)); @@ -212,7 +212,7 @@ MojoResult SharedBufferDispatcher::MapBufferImplNoLock( MojoMapBufferFlags flags, scoped_ptr<embedder::PlatformSharedBufferMapping>* mapping) { lock().AssertAcquired(); - DCHECK(shared_buffer_.get()); + DCHECK(shared_buffer_); if (offset > static_cast<uint64_t>(std::numeric_limits<size_t>::max())) return MOJO_RESULT_INVALID_ARGUMENT; @@ -247,7 +247,7 @@ bool SharedBufferDispatcher::EndSerializeAndCloseImplNoLock( size_t* actual_size, embedder::PlatformHandleVector* platform_handles) { DCHECK(HasOneRef()); // Only one ref => no need to take the lock. - DCHECK(shared_buffer_.get()); + DCHECK(shared_buffer_); SerializedSharedBufferDispatcher* serialization = static_cast<SerializedSharedBufferDispatcher*>(destination); diff --git a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc index 5866089..29dcb57 100644 --- a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc +++ b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc @@ -118,7 +118,7 @@ TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) { platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); - ASSERT_TRUE(dispatcher.get()); + ASSERT_TRUE(dispatcher); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); // Make a couple of mappings. @@ -165,7 +165,7 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) { scoped_refptr<Dispatcher> dispatcher2; EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle( NullUserPointer(), &dispatcher2)); - ASSERT_TRUE(dispatcher2.get()); + ASSERT_TRUE(dispatcher2); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); @@ -193,7 +193,7 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { scoped_refptr<Dispatcher> dispatcher2; EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle( MakeUserPointer(&options[i]), &dispatcher2)); - ASSERT_TRUE(dispatcher2.get()); + ASSERT_TRUE(dispatcher2); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); } @@ -216,7 +216,7 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), &dispatcher2)); - EXPECT_FALSE(dispatcher2.get()); + EXPECT_FALSE(dispatcher2); } // Unknown |flags|. @@ -227,7 +227,7 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), &dispatcher2)); - EXPECT_FALSE(dispatcher2.get()); + EXPECT_FALSE(dispatcher2); } EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); @@ -241,14 +241,14 @@ TEST_F(SharedBufferDispatcherTest, CreateInvalidNumBytes) { SharedBufferDispatcher::Create( platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, std::numeric_limits<uint64_t>::max(), &dispatcher)); - EXPECT_FALSE(dispatcher.get()); + EXPECT_FALSE(dispatcher); // Zero size. EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, SharedBufferDispatcher::Create( platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher)); - EXPECT_FALSE(dispatcher.get()); + EXPECT_FALSE(dispatcher); } TEST_F(SharedBufferDispatcherTest, MapBufferInvalidArguments) { diff --git a/mojo/edk/system/simple_dispatcher.cc b/mojo/edk/system/simple_dispatcher.cc index 3eb7a4f..f7db875 100644 --- a/mojo/edk/system/simple_dispatcher.cc +++ b/mojo/edk/system/simple_dispatcher.cc @@ -17,16 +17,16 @@ SimpleDispatcher::~SimpleDispatcher() { void SimpleDispatcher::HandleSignalsStateChangedNoLock() { lock().AssertAcquired(); - waiter_list_.AwakeWaitersForStateChange(GetHandleSignalsStateImplNoLock()); + awakable_list_.AwakeForStateChange(GetHandleSignalsStateImplNoLock()); } -void SimpleDispatcher::CancelAllWaitersNoLock() { +void SimpleDispatcher::CancelAllAwakablesNoLock() { lock().AssertAcquired(); - waiter_list_.CancelAllWaiters(); + awakable_list_.CancelAll(); } -MojoResult SimpleDispatcher::AddWaiterImplNoLock( - Waiter* waiter, +MojoResult SimpleDispatcher::AddAwakableImplNoLock( + Awakable* awakable, MojoHandleSignals signals, uint32_t context, HandleSignalsState* signals_state) { @@ -44,15 +44,15 @@ MojoResult SimpleDispatcher::AddWaiterImplNoLock( return MOJO_RESULT_FAILED_PRECONDITION; } - waiter_list_.AddWaiter(waiter, signals, context); + awakable_list_.Add(awakable, signals, context); return MOJO_RESULT_OK; } -void SimpleDispatcher::RemoveWaiterImplNoLock( - Waiter* waiter, +void SimpleDispatcher::RemoveAwakableImplNoLock( + Awakable* awakable, HandleSignalsState* signals_state) { lock().AssertAcquired(); - waiter_list_.RemoveWaiter(waiter); + awakable_list_.Remove(awakable); if (signals_state) *signals_state = GetHandleSignalsStateImplNoLock(); } diff --git a/mojo/edk/system/simple_dispatcher.h b/mojo/edk/system/simple_dispatcher.h index b1260ef..eddf614 100644 --- a/mojo/edk/system/simple_dispatcher.h +++ b/mojo/edk/system/simple_dispatcher.h @@ -8,9 +8,9 @@ #include <list> #include "base/macros.h" +#include "mojo/edk/system/awakable_list.h" #include "mojo/edk/system/dispatcher.h" #include "mojo/edk/system/system_impl_export.h" -#include "mojo/edk/system/waiter_list.h" namespace mojo { namespace system { @@ -30,17 +30,17 @@ class MOJO_SYSTEM_IMPL_EXPORT SimpleDispatcher : public Dispatcher { void HandleSignalsStateChangedNoLock(); // |Dispatcher| protected methods: - void CancelAllWaitersNoLock() override; - MojoResult AddWaiterImplNoLock(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context, - HandleSignalsState* signals_state) override; - void RemoveWaiterImplNoLock(Waiter* waiter, - HandleSignalsState* signals_state) override; + void CancelAllAwakablesNoLock() override; + MojoResult AddAwakableImplNoLock(Awakable* awakable, + MojoHandleSignals signals, + uint32_t context, + HandleSignalsState* signals_state) override; + void RemoveAwakableImplNoLock(Awakable* awakable, + HandleSignalsState* signals_state) override; private: // Protected by |lock()|: - WaiterList waiter_list_; + AwakableList awakable_list_; DISALLOW_COPY_AND_ASSIGN(SimpleDispatcher); }; diff --git a/mojo/edk/system/simple_dispatcher_unittest.cc b/mojo/edk/system/simple_dispatcher_unittest.cc index f23ff68..b8e57e9 100644 --- a/mojo/edk/system/simple_dispatcher_unittest.cc +++ b/mojo/edk/system/simple_dispatcher_unittest.cc @@ -104,7 +104,7 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_READABLE, 0, &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -114,14 +114,14 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { w.Init(); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, nullptr)); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(1u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -130,14 +130,14 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { w.Init(); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_OK, w.Wait(0, &context)); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(2u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -146,7 +146,7 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { w.Init(); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_WRITABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_OK, @@ -154,7 +154,7 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(3u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -163,12 +163,12 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { w.Init(); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(0, nullptr)); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -178,7 +178,7 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { w.Init(); d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 5, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 5, nullptr)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), nullptr)); @@ -186,7 +186,7 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -208,7 +208,7 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { d->SetSatisfiedSignals(0); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); // Shouldn't need to remove the waiter (it was not added). @@ -218,7 +218,7 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, @@ -226,7 +226,7 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(2u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); @@ -235,14 +235,14 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, w.Wait(0, &context)); EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(3u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); @@ -252,7 +252,7 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, @@ -260,7 +260,7 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { EXPECT_LT(stopwatch.Elapsed(), test::EpsilonTimeout()); EXPECT_EQ(4u, context); hss = HandleSignalsState(); - d->RemoveWaiter(&w, &hss); + d->RemoveAwakable(&w, &hss); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); @@ -281,7 +281,7 @@ TEST(SimpleDispatcherTest, BasicClosed) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 1, &hss)); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); // Shouldn't need to remove the waiter (it was not added). @@ -290,7 +290,7 @@ TEST(SimpleDispatcherTest, BasicClosed) { d = new MockSimpleDispatcher(); w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2, nullptr)); EXPECT_EQ(MOJO_RESULT_OK, d->Close()); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -302,7 +302,7 @@ TEST(SimpleDispatcherTest, BasicClosed) { d = new MockSimpleDispatcher(); w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3, nullptr)); EXPECT_EQ(MOJO_RESULT_OK, d->Close()); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_CANCELLED, w.Wait(0, &context)); @@ -315,7 +315,7 @@ TEST(SimpleDispatcherTest, BasicClosed) { d = new MockSimpleDispatcher(); w.Init(); ASSERT_EQ(MOJO_RESULT_OK, - d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); + d->AddAwakable(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4, nullptr)); EXPECT_EQ(MOJO_RESULT_OK, d->Close()); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_CANCELLED, diff --git a/mojo/edk/system/test_utils.cc b/mojo/edk/system/test_utils.cc index 3217c00..420b084 100644 --- a/mojo/edk/system/test_utils.cc +++ b/mojo/edk/system/test_utils.cc @@ -42,7 +42,7 @@ base::TimeDelta EpsilonTimeout() { // Currently, |tiny_timeout()| is usually 100 ms (possibly scaled under ASAN, // etc.). Based on this, set it to (usually be) 30 ms on Windows and 20 ms // elsewhere. -#if defined(OS_WIN) +#if defined(OS_WIN) || defined(OS_ANDROID) return (TestTimeouts::tiny_timeout() * 3) / 10; #else return (TestTimeouts::tiny_timeout() * 2) / 10; diff --git a/mojo/edk/system/waiter.cc b/mojo/edk/system/waiter.cc index 6dcd713..f9047cb 100644 --- a/mojo/edk/system/waiter.cc +++ b/mojo/edk/system/waiter.cc @@ -49,7 +49,7 @@ MojoResult Waiter::Wait(MojoDeadline deadline, uint32_t* context) { if (awoken_) { DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL); if (context) - *context = awake_context_; + *context = static_cast<uint32_t>(awake_context_); return awake_result_; } @@ -78,11 +78,11 @@ MojoResult Waiter::Wait(MojoDeadline deadline, uint32_t* context) { DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL); if (context) - *context = awake_context_; + *context = static_cast<uint32_t>(awake_context_); return awake_result_; } -void Waiter::Awake(MojoResult result, uint32_t context) { +void Waiter::Awake(MojoResult result, uintptr_t context) { base::AutoLock locker(lock_); if (awoken_) diff --git a/mojo/edk/system/waiter.h b/mojo/edk/system/waiter.h index 03ada16..999f286 100644 --- a/mojo/edk/system/waiter.h +++ b/mojo/edk/system/waiter.h @@ -10,6 +10,7 @@ #include "base/macros.h" #include "base/synchronization/condition_variable.h" #include "base/synchronization/lock.h" +#include "mojo/edk/system/awakable.h" #include "mojo/edk/system/system_impl_export.h" #include "mojo/public/c/system/types.h" @@ -20,7 +21,7 @@ namespace system { // under other locks, in particular, |Dispatcher::lock_|s, so |Waiter| methods // must never call out to other objects (in particular, |Dispatcher|s). This // class is thread-safe. -class MOJO_SYSTEM_IMPL_EXPORT Waiter { +class MOJO_SYSTEM_IMPL_EXPORT Waiter : public Awakable { public: Waiter(); ~Waiter(); @@ -39,12 +40,12 @@ class MOJO_SYSTEM_IMPL_EXPORT Waiter { // case |*context| is not modified. // // Usually, the context passed to |Awake()| will be the value passed to - // |Dispatcher::AddWaiter()|, which is usually the index to the array of + // |Dispatcher::AddAwakable()|, which is usually the index to the array of // handles passed to |MojoWaitMany()| (or 0 for |MojoWait()|). // // Typical |Awake()| results are: // - |MOJO_RESULT_OK| if one of the flags passed to - // |MojoWait()|/|MojoWaitMany()| (hence |Dispatcher::AddWaiter()|) was + // |MojoWait()|/|MojoWaitMany()| (hence |Dispatcher::AddAwakable()|) was // satisfied; // - |MOJO_RESULT_CANCELLED| if a handle (on which // |MojoWait()|/|MojoWaitMany()| was called) was closed (hence the @@ -57,7 +58,7 @@ class MOJO_SYSTEM_IMPL_EXPORT Waiter { // Wake the waiter up with the given result and context (or no-op if it's been // woken up already). - void Awake(MojoResult result, uint32_t context); + void Awake(MojoResult result, uintptr_t context) override; private: base::ConditionVariable cv_; // Associated to |lock_|. @@ -67,10 +68,7 @@ class MOJO_SYSTEM_IMPL_EXPORT Waiter { #endif bool awoken_; MojoResult awake_result_; - // This is a |uint32_t| because we really only need to store an index (for - // |MojoWaitMany()|). But in tests, it's convenient to use this for other - // purposes (e.g., to distinguish between different wake-up reasons). - uint32_t awake_context_; + uintptr_t awake_context_; DISALLOW_COPY_AND_ASSIGN(Waiter); }; diff --git a/mojo/edk/system/waiter_list.cc b/mojo/edk/system/waiter_list.cc deleted file mode 100644 index 42dfe15..0000000 --- a/mojo/edk/system/waiter_list.cc +++ /dev/null @@ -1,57 +0,0 @@ -// Copyright 2013 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/waiter_list.h" - -#include "base/logging.h" -#include "mojo/edk/system/handle_signals_state.h" -#include "mojo/edk/system/waiter.h" - -namespace mojo { -namespace system { - -WaiterList::WaiterList() { -} - -WaiterList::~WaiterList() { - DCHECK(waiters_.empty()); -} - -void WaiterList::AwakeWaitersForStateChange(const HandleSignalsState& state) { - for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end(); - ++it) { - if (state.satisfies(it->signals)) - it->waiter->Awake(MOJO_RESULT_OK, it->context); - else if (!state.can_satisfy(it->signals)) - it->waiter->Awake(MOJO_RESULT_FAILED_PRECONDITION, it->context); - } -} - -void WaiterList::CancelAllWaiters() { - for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end(); - ++it) { - it->waiter->Awake(MOJO_RESULT_CANCELLED, it->context); - } - waiters_.clear(); -} - -void WaiterList::AddWaiter(Waiter* waiter, - MojoHandleSignals signals, - uint32_t context) { - waiters_.push_back(WaiterInfo(waiter, signals, context)); -} - -void WaiterList::RemoveWaiter(Waiter* waiter) { - // We allow a thread to wait on the same handle multiple times simultaneously, - // so we need to scan the entire list and remove all occurrences of |waiter|. - for (WaiterInfoList::iterator it = waiters_.begin(); it != waiters_.end();) { - WaiterInfoList::iterator maybe_delete = it; - ++it; - if (maybe_delete->waiter == waiter) - waiters_.erase(maybe_delete); - } -} - -} // namespace system -} // namespace mojo diff --git a/mojo/edk/system/waiter_list.h b/mojo/edk/system/waiter_list.h deleted file mode 100644 index 6bbc799..0000000 --- a/mojo/edk/system/waiter_list.h +++ /dev/null @@ -1,58 +0,0 @@ -// Copyright 2013 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. - -#ifndef MOJO_EDK_SYSTEM_WAITER_LIST_H_ -#define MOJO_EDK_SYSTEM_WAITER_LIST_H_ - -#include <stdint.h> - -#include <list> - -#include "base/macros.h" -#include "mojo/edk/system/system_impl_export.h" -#include "mojo/public/c/system/types.h" - -namespace mojo { -namespace system { - -class Waiter; -struct HandleSignalsState; - -// |WaiterList| tracks all the |Waiter|s that are waiting on a given -// handle/|Dispatcher|. There should be a |WaiterList| for each handle that can -// be waited on (in any way). In the simple case, the |WaiterList| is owned by -// the |Dispatcher|, whereas in more complex cases it is owned by the secondary -// object (see simple_dispatcher.* and the explanatory comment in core.cc). This -// class is thread-unsafe (all concurrent access must be protected by some -// lock). -class MOJO_SYSTEM_IMPL_EXPORT WaiterList { - public: - WaiterList(); - ~WaiterList(); - - void AwakeWaitersForStateChange(const HandleSignalsState& state); - void CancelAllWaiters(); - void AddWaiter(Waiter* waiter, MojoHandleSignals signals, uint32_t context); - void RemoveWaiter(Waiter* waiter); - - private: - struct WaiterInfo { - WaiterInfo(Waiter* waiter, MojoHandleSignals signals, uint32_t context) - : waiter(waiter), signals(signals), context(context) {} - - Waiter* waiter; - MojoHandleSignals signals; - uint32_t context; - }; - typedef std::list<WaiterInfo> WaiterInfoList; - - WaiterInfoList waiters_; - - DISALLOW_COPY_AND_ASSIGN(WaiterList); -}; - -} // namespace system -} // namespace mojo - -#endif // MOJO_EDK_SYSTEM_WAITER_LIST_H_ diff --git a/mojo/edk/system/waiter_test_utils.cc b/mojo/edk/system/waiter_test_utils.cc index 39cb14e..ea243ed1 100644 --- a/mojo/edk/system/waiter_test_utils.cc +++ b/mojo/edk/system/waiter_test_utils.cc @@ -55,14 +55,14 @@ WaiterThread::~WaiterThread() { void WaiterThread::Run() { waiter_.Init(); - *result_out_ = dispatcher_->AddWaiter(&waiter_, handle_signals_, context_, - signals_state_out_); + *result_out_ = dispatcher_->AddAwakable(&waiter_, handle_signals_, context_, + signals_state_out_); if (*result_out_ != MOJO_RESULT_OK) return; *did_wait_out_ = true; *result_out_ = waiter_.Wait(deadline_, context_out_); - dispatcher_->RemoveWaiter(&waiter_, signals_state_out_); + dispatcher_->RemoveAwakable(&waiter_, signals_state_out_); } } // namespace test diff --git a/mojo/edk/system/waiter_test_utils.h b/mojo/edk/system/waiter_test_utils.h index cec0f3e..b11d78d 100644 --- a/mojo/edk/system/waiter_test_utils.h +++ b/mojo/edk/system/waiter_test_utils.h @@ -29,19 +29,19 @@ namespace test { // // MojoResult result; // { -// WaiterList waiter_list; +// AwakableList awakable_list; // test::SimpleWaiterThread thread(&result); -// waiter_list.AddWaiter(thread.waiter(), ...); +// awakable_list.Add(thread.waiter(), ...); // thread.Start(); // ... some stuff to wake the waiter ... -// waiter_list.RemoveWaiter(thread.waiter()); +// awakable_list.Remove(thread.waiter()); // } // Join |thread|. // EXPECT_EQ(..., result); // // There's a bit of unrealism in its use: In this sort of usage, calls such as -// |Waiter::Init()|, |AddWaiter()|, and |RemoveWaiter()| are done in the main -// (test) thread, not the waiter thread (as would actually happen in real code). -// (We accept this unrealism for simplicity, since |WaiterList| is +// |Waiter::Init()|, |AddAwakable()|, and |RemoveAwakable()| are done in the +// main (test) thread, not the waiter thread (as would actually happen in real +// code). (We accept this unrealism for simplicity, since |AwakableList| is // thread-unsafe so making it more realistic would require adding nontrivial // synchronization machinery.) class SimpleWaiterThread : public base::SimpleThread { diff --git a/mojo/edk/test/BUILD.gn b/mojo/edk/test/BUILD.gn index 42e8c03..3cf8ae8 100644 --- a/mojo/edk/test/BUILD.gn +++ b/mojo/edk/test/BUILD.gn @@ -2,8 +2,10 @@ # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. +import("../mojo_edk.gni") + # GYP version: mojo/edk/mojo_edk.gyp:mojo_common_test_support -source_set("test_support") { +mojo_edk_source_set("test_support") { testonly = true sources = [ "multiprocess_test_helper.cc", @@ -16,37 +18,52 @@ source_set("test_support") { deps = [ "//base", "//base/test:test_support", - "//mojo/edk/system", "//testing/gtest", ] + + mojo_edk_deps = [ + "mojo/edk/system", + ] } # GYP version: mojo/edk/mojo_edk.gyp:mojo_run_all_unittests -source_set("run_all_unittests") { +mojo_edk_source_set("run_all_unittests") { testonly = true + sources = [ + "run_all_unittests.cc" + ] + deps = [ ":test_support_impl", "//base", "//base/test:test_support", - "//mojo/edk/system", - "//mojo/public/c/test_support", "//testing/gtest", ] - sources = [ - "run_all_unittests.cc", + mojo_edk_deps = [ + "mojo/edk/system", + ] + + mojo_sdk_deps = [ + "mojo/public/c/test_support", ] } # GYP version: mojo/edk/mojo_edk.gyp:mojo_run_all_perftests -source_set("run_all_perftests") { +mojo_edk_source_set("run_all_perftests") { testonly = true deps = [ ":test_support_impl", "//base", "//base/test:test_support", - "//mojo/edk/system", - "//mojo/public/c/test_support", + ] + + mojo_edk_deps = [ + "mojo/edk/system", + ] + + mojo_sdk_deps = [ + "mojo/public/c/test_support", ] sources = [ @@ -55,12 +72,15 @@ source_set("run_all_perftests") { } # GYP version: mojo/edk/mojo_edk.gyp:mojo_test_support_impl -source_set("test_support_impl") { +mojo_edk_source_set("test_support_impl") { testonly = true deps = [ "//base", "//base/test:test_support", - "//mojo/public/c/test_support", + ] + + mojo_sdk_deps = [ + "mojo/public/c/test_support", ] sources = [ diff --git a/mojo/edk/test/multiprocess_test_helper.cc b/mojo/edk/test/multiprocess_test_helper.cc index 30aa0be..758520a 100644 --- a/mojo/edk/test/multiprocess_test_helper.cc +++ b/mojo/edk/test/multiprocess_test_helper.cc @@ -27,7 +27,7 @@ MultiprocessTestHelper::~MultiprocessTestHelper() { } void MultiprocessTestHelper::StartChild(const std::string& test_child_name) { - CHECK(platform_channel_pair_.get()); + CHECK(platform_channel_pair_); CHECK(!test_child_name.empty()); CHECK_EQ(test_child_handle_, base::kNullProcessHandle); |