diff options
| author | thakis <thakis@chromium.org> | 2014-11-14 16:04:25 -0800 |
|---|---|---|
| committer | Commit bot <commit-bot@chromium.org> | 2014-11-15 00:04:49 +0000 |
| commit | 671db43a735bd2297225b9d74129402e66fdc549 (patch) | |
| tree | eeeb2735f56d964bcdd6a6bf8aa206d41a744b6c /mojo/edk/system | |
| parent | 3ec1799a199d75eda8bfe2040252df4e05e10735 (diff) | |
| download | chromium_src-671db43a735bd2297225b9d74129402e66fdc549.zip chromium_src-671db43a735bd2297225b9d74129402e66fdc549.tar.gz chromium_src-671db43a735bd2297225b9d74129402e66fdc549.tar.bz2 | |
Revert of Update mojo sdk to rev afb4440fd5a10cba980878c326180b7ad7960480 (patchset #3 id:40001 of https://codereview.chromium.org/728553002/)
Reason for revert:
Breaks incremental builds, crbug.com/433524
Original issue's description:
> Update mojo sdk to rev afb4440fd5a10cba980878c326180b7ad7960480
>
> TBR=jam@chromium.org
>
> Committed: https://crrev.com/184f354ddeff66784515ddbbee9c46355cadab6a
> Cr-Commit-Position: refs/heads/master@{#304114}
TBR=jam@chromium.org,jamesr@chromium.org
NOTREECHECKS=true
NOTRY=true
Review URL: https://codereview.chromium.org/728043002
Cr-Commit-Position: refs/heads/master@{#304305}
Diffstat (limited to 'mojo/edk/system')
54 files changed, 2442 insertions, 1540 deletions
diff --git a/mojo/edk/system/BUILD.gn b/mojo/edk/system/BUILD.gn index d0bfda7..791a192 100644 --- a/mojo/edk/system/BUILD.gn +++ b/mojo/edk/system/BUILD.gn @@ -12,6 +12,19 @@ config("system_config") { component("system") { output_name = "mojo_system_impl" + deps = [ + "//base", + "//base/third_party/dynamic_annotations", + "//mojo/edk/embedder", + ] + + defines = [ + "MOJO_SYSTEM_IMPL_IMPLEMENTATION", + "MOJO_SYSTEM_IMPLEMENTATION", + ] + + all_dependent_configs = [ ":system_config" ] + sources = [ "channel.cc", "channel.h", @@ -21,10 +34,7 @@ component("system") { "channel_endpoint_id.h", "channel_info.cc", "channel_info.h", - "channel_manager.cc", - "channel_manager.h", - "configuration.cc", - "configuration.h", + "constants.h", "core.cc", "core.h", "data_pipe.cc", @@ -35,6 +45,7 @@ component("system") { "data_pipe_producer_dispatcher.h", "dispatcher.cc", "dispatcher.h", + "entrypoints.cc", "handle_signals_state.h", "handle_table.cc", "handle_table.h", @@ -76,30 +87,18 @@ component("system") { "waiter_list.cc", "waiter_list.h", ] +} - defines = [ - "MOJO_SYSTEM_IMPL_IMPLEMENTATION", - "MOJO_SYSTEM_IMPLEMENTATION", - ] - - all_dependent_configs = [ ":system_config" ] - - public_deps = [ - "//mojo/edk/embedder", - "//mojo/edk/embedder:platform", - "//mojo/public/c/system", - ] - +# GYP version: mojo/edk/mojo_edk.gyp:mojo_system_unittests +test("mojo_system_unittests") { deps = [ + ":system", "//base", - "//base/third_party/dynamic_annotations", + "//mojo/edk/embedder:embedder_unittests", + "//mojo/edk/test:test_support", + "//testing/gtest", ] - allow_circular_includes_from = [ "//mojo/edk/embedder" ] -} - -# GYP version: mojo/edk/mojo_edk.gyp:mojo_system_unittests -test("mojo_system_unittests") { sources = [ "../test/multiprocess_test_helper_unittest.cc", "channel_endpoint_id_unittest.cc", @@ -123,7 +122,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", @@ -131,21 +129,19 @@ test("mojo_system_unittests") { "waiter_test_utils.h", "waiter_unittest.cc", ] +} +# GYP version: mojo/edk/mojo_edk.gyp:mojo_message_pipe_perftests +test("mojo_message_pipe_perftests") { deps = [ ":system", "//base", "//base/test:test_support", - "//mojo/edk/embedder:embedder_unittests", + "//base/test:test_support_perf", "//mojo/edk/test:test_support", "//testing/gtest", ] - allow_circular_includes_from = [ "//mojo/edk/embedder:embedder_unittests" ] -} - -# GYP version: mojo/edk/mojo_edk.gyp:mojo_message_pipe_perftests -test("mojo_message_pipe_perftests") { sources = [ "message_pipe_perftest.cc", "message_pipe_test_utils.h", @@ -153,13 +149,4 @@ test("mojo_message_pipe_perftests") { "test_utils.cc", "test_utils.h", ] - - deps = [ - ":system", - "//base", - "//base/test:test_support", - "//base/test:test_support_perf", - "//mojo/edk/test:test_support", - "//testing/gtest", - ] } diff --git a/mojo/edk/system/channel.cc b/mojo/edk/system/channel.cc index 0205312..b63aaeb 100644 --- a/mojo/edk/system/channel.cc +++ b/mojo/edk/system/channel.cc @@ -20,8 +20,7 @@ namespace system { Channel::Channel(embedder::PlatformSupport* platform_support) : platform_support_(platform_support), is_running_(false), - is_shutting_down_(false), - channel_manager_(nullptr) { + is_shutting_down_(false) { } bool Channel::Init(scoped_ptr<RawChannel> raw_channel) { @@ -42,15 +41,6 @@ bool Channel::Init(scoped_ptr<RawChannel> raw_channel) { return true; } -void Channel::SetChannelManager(ChannelManager* channel_manager) { - DCHECK(channel_manager); - - base::AutoLock locker(lock_); - DCHECK(!is_shutting_down_); - DCHECK(!channel_manager_); - channel_manager_ = channel_manager; -} - void Channel::Shutdown() { DCHECK(creation_thread_checker_.CalledOnValidThread()); @@ -72,7 +62,8 @@ void Channel::Shutdown() { size_t num_live = 0; size_t num_zombies = 0; for (IdToEndpointMap::iterator it = to_destroy.begin(); - it != to_destroy.end(); ++it) { + it != to_destroy.end(); + ++it) { if (it->second.get()) { num_live++; it->second->OnDisconnect(); @@ -89,7 +80,6 @@ void Channel::Shutdown() { void Channel::WillShutdownSoon() { base::AutoLock locker(lock_); is_shutting_down_ = true; - channel_manager_ = nullptr; } // Note: |endpoint| being a |scoped_refptr| makes this function safe, since it @@ -130,7 +120,8 @@ ChannelEndpointId Channel::AttachAndRunEndpoint( if (!is_bootstrap) { if (!SendControlMessage( - MessageInTransit::kSubtypeChannelAttachAndRunEndpoint, local_id, + MessageInTransit::kSubtypeChannelAttachAndRunEndpoint, + local_id, remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to run remote message pipe endpoint (local " @@ -194,7 +185,8 @@ void Channel::DetachEndpoint(ChannelEndpoint* endpoint, } if (!SendControlMessage( - MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, local_id, + MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, + local_id, remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to remove remote message pipe endpoint (local " @@ -467,7 +459,8 @@ bool Channel::OnRemoveMessagePipeEndpoint(ChannelEndpointId local_id, if (!SendControlMessage( MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck, - local_id, remote_id)) { + local_id, + remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to remove remote message pipe endpoint ack " "(local ID %u, remote ID %u)", diff --git a/mojo/edk/system/channel.h b/mojo/edk/system/channel.h index 715d1f2..6697965 100644 --- a/mojo/edk/system/channel.h +++ b/mojo/edk/system/channel.h @@ -32,7 +32,6 @@ class PlatformSupport; namespace system { class ChannelEndpoint; -class ChannelManager; // This class is mostly thread-safe. It must be created on an I/O thread. // |Init()| must be called on that same thread before it becomes thread-safe (in @@ -62,11 +61,6 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel // failure, no other methods should be called (including |Shutdown()|). bool Init(scoped_ptr<RawChannel> raw_channel); - // Sets the channel manager associated with this channel. This should be set - // at most once and only called before |WillShutdownSoon()| (and - // |Shutdown()|). - void SetChannelManager(ChannelManager* channel_manager); - // This must be called on the creation thread before destruction (which can // happen on any thread). void Shutdown(); @@ -75,8 +69,6 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel // thread, unlike |Shutdown()|). Warnings will be issued if, e.g., messages // are written after this is called; other warnings may be suppressed. (This // may be called multiple times, or not at all.) - // - // If set, the channel manager associated with this channel will be reset. void WillShutdownSoon(); // Attaches the given endpoint to this channel and runs it. |is_bootstrap| @@ -183,9 +175,6 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel // Set when |WillShutdownSoon()| is called. bool is_shutting_down_; - // Has a reference to us. - ChannelManager* channel_manager_; - typedef base::hash_map<ChannelEndpointId, scoped_refptr<ChannelEndpoint>> IdToEndpointMap; // Map from local IDs to endpoints. If the endpoint is null, this means that diff --git a/mojo/edk/system/channel_endpoint.cc b/mojo/edk/system/channel_endpoint.cc index dd7cd5b..8b64643 100644 --- a/mojo/edk/system/channel_endpoint.cc +++ b/mojo/edk/system/channel_endpoint.cc @@ -109,7 +109,8 @@ bool ChannelEndpoint::OnReadMessage( DCHECK(message_view.transport_data_buffer()); message->SetDispatchers(TransportData::DeserializeDispatchers( message_view.transport_data_buffer(), - message_view.transport_data_buffer_size(), platform_handles.Pass(), + message_view.transport_data_buffer_size(), + platform_handles.Pass(), channel_)); } diff --git a/mojo/edk/system/channel_info.cc b/mojo/edk/system/channel_info.cc index 6d23215..efc5f04 100644 --- a/mojo/edk/system/channel_info.cc +++ b/mojo/edk/system/channel_info.cc @@ -4,8 +4,6 @@ #include "mojo/edk/system/channel_info.h" -#include <algorithm> - namespace mojo { namespace system { @@ -21,11 +19,5 @@ ChannelInfo::ChannelInfo( ChannelInfo::~ChannelInfo() { } -void ChannelInfo::Swap(ChannelInfo* other) { - // Note: Swapping avoids refcount churn. - std::swap(channel, other->channel); - std::swap(channel_thread_task_runner, other->channel_thread_task_runner); -} - } // namespace system } // namespace mojo diff --git a/mojo/edk/system/channel_info.h b/mojo/edk/system/channel_info.h index 5167cca..bd84e16 100644 --- a/mojo/edk/system/channel_info.h +++ b/mojo/edk/system/channel_info.h @@ -19,8 +19,6 @@ struct MOJO_SYSTEM_IMPL_EXPORT ChannelInfo { scoped_refptr<base::TaskRunner> channel_thread_task_runner); ~ChannelInfo(); - void Swap(ChannelInfo* other); - scoped_refptr<Channel> channel; // The task runner for |channel|'s creation thread (a.k.a. its I/O thread), on // which it must, e.g., be shut down. diff --git a/mojo/edk/system/channel_manager.cc b/mojo/edk/system/channel_manager.cc deleted file mode 100644 index e673299..0000000 --- a/mojo/edk/system/channel_manager.cc +++ /dev/null @@ -1,62 +0,0 @@ -// 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/channel_manager.h" - -#include "base/bind.h" -#include "base/location.h" - -namespace mojo { -namespace system { - -namespace { - -void ShutdownChannelHelper(const ChannelInfo& channel_info) { - channel_info.channel->WillShutdownSoon(); - channel_info.channel_thread_task_runner->PostTask( - FROM_HERE, base::Bind(&Channel::Shutdown, channel_info.channel)); -} - -} // namespace - -ChannelManager::ChannelManager() { -} - -ChannelManager::~ChannelManager() { - // No need to take the lock. - for (const auto& map_elem : channel_infos_) - ShutdownChannelHelper(map_elem.second); -} - -ChannelId ChannelManager::AddChannel( - scoped_refptr<Channel> channel, - scoped_refptr<base::TaskRunner> channel_thread_task_runner) { - ChannelId channel_id = GetChannelId(channel.get()); - - { - base::AutoLock locker(lock_); - DCHECK(channel_infos_.find(channel_id) == channel_infos_.end()); - channel_infos_[channel_id] = - ChannelInfo(channel, channel_thread_task_runner); - } - channel->SetChannelManager(this); - - return channel_id; -} - -void ChannelManager::ShutdownChannel(ChannelId channel_id) { - ChannelInfo channel_info; - { - base::AutoLock locker(lock_); - - auto it = channel_infos_.find(channel_id); - DCHECK(it != channel_infos_.end()); - channel_info.Swap(&it->second); - channel_infos_.erase(it); - } - ShutdownChannelHelper(channel_info); -} - -} // namespace system -} // namespace mojo diff --git a/mojo/edk/system/channel_manager.h b/mojo/edk/system/channel_manager.h deleted file mode 100644 index 244f8ad..0000000 --- a/mojo/edk/system/channel_manager.h +++ /dev/null @@ -1,74 +0,0 @@ -// 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_CHANNEL_MANAGER_H_ -#define MOJO_EDK_SYSTEM_CHANNEL_MANAGER_H_ - -#include <stdint.h> - -#include "base/containers/hash_tables.h" -#include "base/macros.h" -#include "base/memory/ref_counted.h" -#include "base/synchronization/lock.h" -#include "base/task_runner.h" -#include "mojo/edk/system/channel.h" -#include "mojo/edk/system/channel_info.h" - -namespace mojo { -namespace system { - -// IDs for |Channel|s managed by a |ChannelManager|. (IDs should be thought of -// as specific to a given |ChannelManager|.) 0 is never a valid ID. -// -// Note: We currently just use the pointer of the |Channel| casted to a -// |uintptr_t|, but we reserve the right to change this. -typedef uintptr_t ChannelId; - -// This class manages and "owns" |Channel|s (which typically connect to other -// processes) for a given process. This class is thread-safe. -class MOJO_SYSTEM_IMPL_EXPORT ChannelManager { - public: - ChannelManager(); - ~ChannelManager(); - - // Gets the ID for a given channel. - // - // Note: This is currently a static method and thus may be called under - // |lock_|. If this is ever made non-static (i.e., made specific to a given - // |ChannelManager|), those call sites may have to changed. - static ChannelId GetChannelId(const Channel* channel) { - return reinterpret_cast<ChannelId>(channel); - } - - // Adds |channel| to the set of |Channel|s managed by this |ChannelManager|; - // |channel_thread_task_runner| should be the task runner for |channel|'s - // creation (a.k.a. I/O) thread. - // - // |channel| should either already be initialized or at least already have a - // task posted to |channel_thread_task_runner| to initialize it. It should not - // be managed by any |ChannelManager| yet. - // - // Returns the ID for the added channel. - ChannelId AddChannel( - scoped_refptr<Channel> channel, - scoped_refptr<base::TaskRunner> channel_thread_task_runner); - - // Shuts down the channel specified by the given ID. It is up to the caller to - // guarantee that this is only called once per channel (that was added using - // |AddChannel()|). - void ShutdownChannel(ChannelId channel_id); - - private: - // Note: |Channel| methods should not be called under |lock_|. - base::Lock lock_; // Protects the members below. - - base::hash_map<ChannelId, ChannelInfo> channel_infos_; - - DISALLOW_COPY_AND_ASSIGN(ChannelManager); -}; - -} // namespace system -} // namespace mojo - -#endif // MOJO_EDK_SYSTEM_CHANNEL_MANAGER_H_ diff --git a/mojo/edk/system/channel_unittest.cc b/mojo/edk/system/channel_unittest.cc index 68b1315..f6cf896 100644 --- a/mojo/edk/system/channel_unittest.cc +++ b/mojo/edk/system/channel_unittest.cc @@ -104,8 +104,9 @@ TEST_F(ChannelTest, InitShutdown) { EXPECT_EQ(TRISTATE_TRUE, init_result()); io_thread()->PostTaskAndWait( - FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&ChannelTest::ShutdownChannelOnIOThread, + base::Unretained(this))); // Okay to destroy |Channel| on not-the-I/O-thread. EXPECT_TRUE(channel()->HasOneRef()); @@ -202,8 +203,9 @@ TEST_F(ChannelTest, CloseBeforeRun) { channel()->AttachAndRunEndpoint(channel_endpoint, true); io_thread()->PostTaskAndWait( - FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&ChannelTest::ShutdownChannelOnIOThread, + base::Unretained(this))); EXPECT_TRUE(channel()->HasOneRef()); } @@ -271,8 +273,9 @@ TEST_F(ChannelTest, WaitAfterAttachRunAndShutdown) { channel()->AttachAndRunEndpoint(channel_endpoint, true); io_thread()->PostTaskAndWait( - FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&ChannelTest::ShutdownChannelOnIOThread, + base::Unretained(this))); Waiter waiter; waiter.Init(); diff --git a/mojo/edk/system/configuration.cc b/mojo/edk/system/configuration.cc deleted file mode 100644 index 4756c99..0000000 --- a/mojo/edk/system/configuration.cc +++ /dev/null @@ -1,26 +0,0 @@ -// 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/configuration.h" - -namespace mojo { -namespace system { -namespace internal { - -// These default values should be synced with the documentation in -// mojo/edk/embedder/configuration.h. -embedder::Configuration g_configuration = { - 1000000, // max_handle_table_size - 1000000, // max_mapping_table_sze - 1000000, // max_wait_many_num_handles - 4 * 1024 * 1024, // max_message_num_bytes - 10000, // max_message_num_handles - 256 * 1024 * 1024, // max_data_pipe_capacity_bytes - 1024 * 1024, // default_data_pipe_capacity_bytes - 16, // data_pipe_buffer_alignment_bytes - 1024 * 1024 * 1024}; // max_shared_memory_num_bytes - -} // namespace internal -} // namespace system -} // namespace mojo diff --git a/mojo/edk/system/configuration.h b/mojo/edk/system/configuration.h deleted file mode 100644 index 007277a..0000000 --- a/mojo/edk/system/configuration.h +++ /dev/null @@ -1,31 +0,0 @@ -// 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_CONFIGURATION_H_ -#define MOJO_EDK_SYSTEM_CONFIGURATION_H_ - -#include "mojo/edk/embedder/configuration.h" -#include "mojo/edk/system/system_impl_export.h" - -namespace mojo { -namespace system { - -namespace internal { -MOJO_SYSTEM_IMPL_EXPORT extern embedder::Configuration g_configuration; -} // namespace internal - -MOJO_SYSTEM_IMPL_EXPORT inline const embedder::Configuration& -GetConfiguration() { - return internal::g_configuration; -} - -MOJO_SYSTEM_IMPL_EXPORT inline embedder::Configuration* -GetMutableConfiguration() { - return &internal::g_configuration; -} - -} // namespace system -} // namespace mojo - -#endif // MOJO_EDK_SYSTEM_CONFIGURATION_H_ diff --git a/mojo/edk/system/constants.h b/mojo/edk/system/constants.h new file mode 100644 index 0000000..23f35d8 --- /dev/null +++ b/mojo/edk/system/constants.h @@ -0,0 +1,48 @@ +// 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_CONSTANTS_H_ +#define MOJO_EDK_SYSTEM_CONSTANTS_H_ + +#include <stddef.h> + +namespace mojo { +namespace system { + +// Maximum number of open (Mojo) handles. +// TODO(vtl): This doesn't count "live" handles, some of which may live in +// messages. +const size_t kMaxHandleTableSize = 1000000; + +// Maximum number of active memory mappings. +const size_t kMaxMappingTableSize = 1000000; + +const size_t kMaxWaitManyNumHandles = kMaxHandleTableSize; + +const size_t kMaxMessageNumBytes = 4 * 1024 * 1024; + +const size_t kMaxMessageNumHandles = 10000; + +// Maximum capacity of a data pipe, in bytes. This value must fit into a +// |uint32_t|. +// WARNING: If you bump it closer to 2^32, you must audit all the code to check +// that we don't overflow (2^31 would definitely be risky; up to 2^30 is +// probably okay). +const size_t kMaxDataPipeCapacityBytes = 256 * 1024 * 1024; // 256 MB. + +const size_t kDefaultDataPipeCapacityBytes = 1024 * 1024; // 1 MB. + +// Alignment for the "start" of the data buffer used by data pipes. (The +// alignment of elements will depend on this and the element size.) +const size_t kDataPipeBufferAlignmentBytes = 16; + +// TODO(vtl): Set this hard limit appropriately (e.g., higher on 64-bit). (This +// will also entail some auditing to make sure I'm not messing up my checks +// anywhere.) +const size_t kMaxSharedMemoryNumBytes = 1024 * 1024 * 1024; // 1 GB. + +} // namespace system +} // namespace mojo + +#endif // MOJO_EDK_SYSTEM_CONSTANTS_H_ diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc index 27d33b2..c67a626 100644 --- a/mojo/edk/system/core.cc +++ b/mojo/edk/system/core.cc @@ -10,7 +10,7 @@ #include "base/time/time.h" #include "mojo/edk/embedder/platform_shared_buffer.h" #include "mojo/edk/embedder/platform_support.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/data_pipe.h" #include "mojo/edk/system/data_pipe_consumer_dispatcher.h" #include "mojo/edk/system/data_pipe_producer_dispatcher.h" @@ -126,7 +126,11 @@ MojoResult Core::Wait(MojoHandle handle, UserPointer<MojoHandleSignalsState> signals_state) { uint32_t unused = static_cast<uint32_t>(-1); HandleSignalsState hss; - MojoResult rv = WaitManyInternal(&handle, &signals, 1, deadline, &unused, + MojoResult rv = WaitManyInternal(&handle, + &signals, + 1, + deadline, + &unused, signals_state.IsNull() ? nullptr : &hss); if (rv != MOJO_RESULT_INVALID_ARGUMENT && !signals_state.IsNull()) signals_state.Put(hss); @@ -141,7 +145,7 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles, UserPointer<MojoHandleSignalsState> signals_states) { if (num_handles < 1) return MOJO_RESULT_INVALID_ARGUMENT; - if (num_handles > GetConfiguration().max_wait_many_num_handles) + if (num_handles > kMaxWaitManyNumHandles) return MOJO_RESULT_RESOURCE_EXHAUSTED; UserPointer<const MojoHandle>::Reader handles_reader(handles, num_handles); @@ -151,17 +155,23 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles, MojoResult rv; if (signals_states.IsNull()) { rv = WaitManyInternal(handles_reader.GetPointer(), - signals_reader.GetPointer(), num_handles, deadline, - &index, nullptr); + signals_reader.GetPointer(), + num_handles, + deadline, + &index, + nullptr); } else { UserPointer<MojoHandleSignalsState>::Writer signals_states_writer( signals_states, num_handles); // Note: The |reinterpret_cast| is safe, since |HandleSignalsState| is a // subclass of |MojoHandleSignalsState| that doesn't add any data members. rv = WaitManyInternal(handles_reader.GetPointer(), - signals_reader.GetPointer(), num_handles, deadline, - &index, reinterpret_cast<HandleSignalsState*>( - signals_states_writer.GetPointer())); + signals_reader.GetPointer(), + num_handles, + deadline, + &index, + reinterpret_cast<HandleSignalsState*>( + signals_states_writer.GetPointer())); if (rv != MOJO_RESULT_INVALID_ARGUMENT) signals_states_writer.Commit(); } @@ -236,7 +246,7 @@ MojoResult Core::WriteMessage(MojoHandle message_pipe_handle, // validity, even for dispatchers that don't support |WriteMessage()| and will // simply return failure unconditionally. It also breaks the usual // left-to-right verification order of arguments.) - if (num_handles > GetConfiguration().max_message_num_handles) + if (num_handles > kMaxMessageNumHandles) return MOJO_RESULT_RESOURCE_EXHAUSTED; UserPointer<const MojoHandle>::Reader handles_reader(handles, num_handles); @@ -253,9 +263,11 @@ MojoResult Core::WriteMessage(MojoHandle message_pipe_handle, // handles from the handle table. { base::AutoLock locker(handle_table_lock_); - MojoResult result = handle_table_.MarkBusyAndStartTransport( - message_pipe_handle, handles_reader.GetPointer(), num_handles, - &transports); + MojoResult result = + handle_table_.MarkBusyAndStartTransport(message_pipe_handle, + handles_reader.GetPointer(), + num_handles, + &transports); if (result != MOJO_RESULT_OK) return result; } @@ -296,12 +308,12 @@ MojoResult Core::ReadMessage(MojoHandle message_pipe_handle, MojoResult rv; if (num_handles_value == 0) { // Easy case: won't receive any handles. - rv = dispatcher->ReadMessage(bytes, num_bytes, nullptr, &num_handles_value, - flags); + rv = dispatcher->ReadMessage( + bytes, num_bytes, nullptr, &num_handles_value, flags); } else { DispatcherVector dispatchers; - rv = dispatcher->ReadMessage(bytes, num_bytes, &dispatchers, - &num_handles_value, flags); + rv = dispatcher->ReadMessage( + bytes, num_bytes, &dispatchers, &num_handles_value, flags); if (!dispatchers.empty()) { DCHECK_EQ(rv, MOJO_RESULT_OK); DCHECK(!num_handles.IsNull()); @@ -454,8 +466,8 @@ MojoResult Core::CreateSharedBuffer( return result; scoped_refptr<SharedBufferDispatcher> dispatcher; - result = SharedBufferDispatcher::Create(platform_support(), validated_options, - num_bytes, &dispatcher); + result = SharedBufferDispatcher::Create( + platform_support(), validated_options, num_bytes, &dispatcher); if (result != MOJO_RESULT_OK) { DCHECK(!dispatcher.get()); return result; diff --git a/mojo/edk/system/core_test_base.cc b/mojo/edk/system/core_test_base.cc index ea06c29..d1a1a24 100644 --- a/mojo/edk/system/core_test_base.cc +++ b/mojo/edk/system/core_test_base.cc @@ -10,7 +10,7 @@ #include "base/logging.h" #include "base/memory/ref_counted.h" #include "mojo/edk/embedder/simple_platform_support.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/core.h" #include "mojo/edk/system/dispatcher.h" #include "mojo/edk/system/memory.h" @@ -50,7 +50,7 @@ class MockDispatcher : public Dispatcher { info_->IncrementWriteMessageCallCount(); lock().AssertAcquired(); - if (num_bytes > GetConfiguration().max_message_num_bytes) + if (num_bytes > kMaxMessageNumBytes) return MOJO_RESULT_RESOURCE_EXHAUSTED; if (transports) diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc index 96780f7..e6607df 100644 --- a/mojo/edk/system/core_unittest.cc +++ b/mojo/edk/system/core_unittest.cc @@ -42,34 +42,45 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(0u, info.GetWriteMessageCallCount()); EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0, + core()->WriteMessage(h, + NullUserPointer(), + 0, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); EXPECT_EQ(0u, info.GetReadMessageCallCount()); uint32_t num_bytes = 0; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->ReadMessage(h, NullUserPointer(), MakeUserPointer(&num_bytes), - NullUserPointer(), NullUserPointer(), - MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + core()->ReadMessage(h, + NullUserPointer(), + MakeUserPointer(&num_bytes), + NullUserPointer(), + NullUserPointer(), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetReadMessageCallCount()); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), - NullUserPointer(), NullUserPointer(), + core()->ReadMessage(h, + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(2u, info.GetReadMessageCallCount()); EXPECT_EQ(0u, info.GetWriteDataCallCount()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->WriteData(h, NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->WriteData( + h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteDataCallCount()); EXPECT_EQ(0u, info.GetBeginWriteDataCallCount()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->BeginWriteData(h, NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->BeginWriteData( + h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); EXPECT_EQ(1u, info.GetBeginWriteDataCallCount()); EXPECT_EQ(0u, info.GetEndWriteDataCallCount()); @@ -77,15 +88,17 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(1u, info.GetEndWriteDataCallCount()); EXPECT_EQ(0u, info.GetReadDataCallCount()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->ReadData(h, NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->ReadData( + h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ(1u, info.GetReadDataCallCount()); EXPECT_EQ(0u, info.GetBeginReadDataCallCount()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->BeginReadData(h, NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->BeginReadData( + h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ(1u, info.GetBeginReadDataCallCount()); EXPECT_EQ(0u, info.GetEndReadDataCallCount()); @@ -94,7 +107,9 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(0u, info.GetAddWaiterCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, + core()->Wait(h, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, NullUserPointer())); EXPECT_EQ(1u, info.GetAddWaiterCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, @@ -102,7 +117,9 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(2u, info.GetAddWaiterCallCount()); MojoHandleSignalsState hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, + core()->Wait(h, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); EXPECT_EQ(3u, info.GetAddWaiterCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); @@ -113,43 +130,51 @@ TEST_F(CoreTest, Basic) { EXPECT_EQ(4u, info.GetAddWaiterCallCount()); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, - MakeUserPointer(&hss))); + core()->Wait( + h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, MakeUserPointer(&hss))); EXPECT_EQ(5u, info.GetAddWaiterCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE; - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer())); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + core()->WaitMany(MakeUserPointer(&h), + MakeUserPointer(&handle_signals), + 1, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer())); EXPECT_EQ(6u, info.GetAddWaiterCallCount()); 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(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(0u, result_index); hss = kFullMojoHandleSignalsState; - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - MakeUserPointer(&hss))); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + core()->WaitMany(MakeUserPointer(&h), + MakeUserPointer(&handle_signals), + 1, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + MakeUserPointer(&hss))); EXPECT_EQ(8u, info.GetAddWaiterCallCount()); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); result_index = static_cast<uint32_t>(-1); hss = kFullMojoHandleSignalsState; - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(&hss))); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + core()->WaitMany(MakeUserPointer(&h), + MakeUserPointer(&handle_signals), + 1, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(&hss))); EXPECT_EQ(9u, info.GetAddWaiterCallCount()); EXPECT_EQ(0u, result_index); EXPECT_EQ(0u, hss.satisfied_signals); @@ -186,16 +211,22 @@ TEST_F(CoreTest, InvalidArguments) { // |Wait()|: { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE, NullUserPointer())); + core()->Wait(MOJO_HANDLE_INVALID, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer())); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE, NullUserPointer())); + core()->Wait(10, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer())); MojoHandleSignalsState hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); + core()->Wait(MOJO_HANDLE_INVALID, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&hss))); // On invalid argument, it shouldn't modify the handle signals state. EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, hss.satisfied_signals); @@ -203,8 +234,10 @@ TEST_F(CoreTest, InvalidArguments) { hss.satisfiable_signals); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss))); + core()->Wait(10, + ~MOJO_HANDLE_SIGNAL_NONE, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&hss))); // On invalid argument, it shouldn't modify the handle signals state. EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, hss.satisfied_signals); @@ -217,14 +250,19 @@ TEST_F(CoreTest, InvalidArguments) { MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID}; MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE, ~MOJO_HANDLE_SIGNAL_NONE}; - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 0, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer())); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 0, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer())); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WaitMany(NullUserPointer(), + MakeUserPointer(signals), + 0, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), NullUserPointer())); // If |num_handles| is invalid, it should leave |result_index| and // |signals_states| alone. @@ -232,7 +270,9 @@ TEST_F(CoreTest, InvalidArguments) { uint32_t result_index = 123; MojoHandleSignalsState hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0, + core()->WaitMany(NullUserPointer(), + MakeUserPointer(signals), + 0, MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), MakeUserPointer(&hss))); @@ -243,23 +283,30 @@ TEST_F(CoreTest, InvalidArguments) { hss.satisfiable_signals); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), + core()->WaitMany(MakeUserPointer(handles), + NullUserPointer(), + 0, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer())); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 1, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), NullUserPointer())); - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 1, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer())); // But if a handle is bad, then it should set |result_index| but still leave // |signals_states| alone. result_index = static_cast<uint32_t>(-1); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany( - MakeUserPointer(handles), MakeUserPointer(signals), 1, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(&hss))); + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 1, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(&hss))); EXPECT_EQ(0u, result_index); EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, hss.satisfied_signals); @@ -272,10 +319,12 @@ TEST_F(CoreTest, InvalidArguments) { result_index = static_cast<uint32_t>(-1); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->WaitMany( - MakeUserPointer(handles), MakeUserPointer(signals), 1, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(&hss))); + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 1, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(&hss))); EXPECT_EQ(0u, result_index); EXPECT_EQ(0u, hss.satisfied_signals); EXPECT_EQ(0u, hss.satisfiable_signals); @@ -284,27 +333,33 @@ TEST_F(CoreTest, InvalidArguments) { result_index = static_cast<uint32_t>(-1); hss = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany( - MakeUserPointer(handles), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(&hss))); + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(&hss))); EXPECT_EQ(1u, result_index); EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals, hss.satisfied_signals); EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals, hss.satisfiable_signals); handles[1] = handles[0] + 1; // Invalid handle. - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer())); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer())); handles[1] = CreateMockHandle(&info[1]); - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer())); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + core()->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer())); // TODO(vtl): Test one where we get "failed precondition" only for the // second handle (and the first one is valid to wait on). @@ -321,8 +376,11 @@ TEST_F(CoreTest, InvalidArguments) { // |num_handles|. { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WriteMessage(MOJO_HANDLE_INVALID, NullUserPointer(), 0, - NullUserPointer(), 0, + core()->WriteMessage(MOJO_HANDLE_INVALID, + NullUserPointer(), + 0, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); MockHandleInfo info; @@ -334,41 +392,55 @@ TEST_F(CoreTest, InvalidArguments) { // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or // not. - EXPECT_NE( - MOJO_RESULT_OK, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - std::numeric_limits<uint32_t>::max(), - MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_NE(MOJO_RESULT_OK, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + std::numeric_limits<uint32_t>::max(), + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); // Huge handle count (plausibly big). EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, core()->WriteMessage( - h, NullUserPointer(), 0, MakeUserPointer(handles), + h, + NullUserPointer(), + 0, + MakeUserPointer(handles), std::numeric_limits<uint32_t>::max() / sizeof(handles[0]), MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); // Invalid handle in |handles|. - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 1, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); // Two invalid handles in |handles|. - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 2, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); // Can't send a handle over itself. handles[0] = h; - EXPECT_EQ( - MOJO_RESULT_BUSY, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_BUSY, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 1, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); MockHandleInfo info2; @@ -376,33 +448,45 @@ TEST_F(CoreTest, InvalidArguments) { // This is "okay", but |MockDispatcher| doesn't implement it. handles[0] = h2; - EXPECT_EQ( - MOJO_RESULT_UNIMPLEMENTED, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 1, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); // One of the |handles| is still invalid. - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 2, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); // One of the |handles| is the same as |handle|. handles[1] = h; - EXPECT_EQ( - MOJO_RESULT_BUSY, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_BUSY, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 2, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); // Can't send a handle twice in the same message. handles[1] = h2; - EXPECT_EQ( - MOJO_RESULT_BUSY, - core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles), - 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_BUSY, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 2, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); // Note: Since we never successfully sent anything with it, |h2| should @@ -416,11 +500,13 @@ TEST_F(CoreTest, InvalidArguments) { // Only check arguments checked by |Core|, namely |handle|, |handles|, and // |num_handles|. { - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(), - NullUserPointer(), NullUserPointer(), - NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->ReadMessage(MOJO_HANDLE_INVALID, + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + MOJO_READ_MESSAGE_FLAG_NONE)); MockHandleInfo info; MojoHandle h = CreateMockHandle(&info); @@ -428,9 +514,12 @@ TEST_F(CoreTest, InvalidArguments) { // Okay. uint32_t handle_count = 0; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h, NullUserPointer(), NullUserPointer(), NullUserPointer(), - MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h, + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + MakeUserPointer(&handle_count), + MOJO_READ_MESSAGE_FLAG_NONE)); // Checked by |Core|, shouldn't go through to the dispatcher. EXPECT_EQ(1u, info.GetReadMessageCallCount()); @@ -451,16 +540,20 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { { MojoHandle handle = MOJO_HANDLE_INVALID; MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE; - EXPECT_DEATH_IF_SUPPORTED( - core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer()), - kMemoryCheckFailedRegex); - EXPECT_DEATH_IF_SUPPORTED( - core()->WaitMany(MakeUserPointer(&handle), NullUserPointer(), 1, - MOJO_DEADLINE_INDEFINITE, NullUserPointer(), - NullUserPointer()), - kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(NullUserPointer(), + MakeUserPointer(&signals), + 1, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer()), + kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(MakeUserPointer(&handle), + NullUserPointer(), + 1, + MOJO_DEADLINE_INDEFINITE, + NullUserPointer(), + NullUserPointer()), + kMemoryCheckFailedRegex); // TODO(vtl): |result_index| and |signals_states| are optional. Test them // with non-null invalid pointers? } @@ -469,16 +562,16 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { { MojoHandle h; EXPECT_DEATH_IF_SUPPORTED( - core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(), - NullUserPointer()), + core()->CreateMessagePipe( + NullUserPointer(), NullUserPointer(), NullUserPointer()), kMemoryCheckFailedRegex); EXPECT_DEATH_IF_SUPPORTED( - core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h), - NullUserPointer()), + core()->CreateMessagePipe( + NullUserPointer(), MakeUserPointer(&h), NullUserPointer()), kMemoryCheckFailedRegex); EXPECT_DEATH_IF_SUPPORTED( - core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(), - MakeUserPointer(&h)), + core()->CreateMessagePipe( + NullUserPointer(), NullUserPointer(), MakeUserPointer(&h)), kMemoryCheckFailedRegex); } @@ -491,7 +584,11 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { // Null |handles| with nonzero |num_handles|. EXPECT_DEATH_IF_SUPPORTED( - core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 1, + core()->WriteMessage(h, + NullUserPointer(), + 0, + NullUserPointer(), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE), kMemoryCheckFailedRegex); @@ -507,8 +604,11 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { uint32_t handle_count = 1; EXPECT_DEATH_IF_SUPPORTED( - core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), - NullUserPointer(), MakeUserPointer(&handle_count), + core()->ReadMessage(h, + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE), kMemoryCheckFailedRegex); @@ -525,9 +625,10 @@ TEST_F(CoreTest, MessagePipe) { MojoHandleSignalsState hss[2]; uint32_t result_index; - EXPECT_EQ(MOJO_RESULT_OK, - core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]), - MakeUserPointer(&h[1]))); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->CreateMessagePipe( + NullUserPointer(), MakeUserPointer(&h[0]), MakeUserPointer(&h[1]))); // Should get two distinct, valid handles. EXPECT_NE(h[0], MOJO_HANDLE_INVALID); EXPECT_NE(h[1], MOJO_HANDLE_INVALID); @@ -539,10 +640,13 @@ TEST_F(CoreTest, MessagePipe) { result_index = static_cast<uint32_t>(-1); hss[0] = kEmptyMojoHandleSignalsState; hss[1] = kEmptyMojoHandleSignalsState; - EXPECT_EQ( - MOJO_RESULT_DEADLINE_EXCEEDED, - core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0, - MakeUserPointer(&result_index), MakeUserPointer(hss))); + EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, + core()->WaitMany(MakeUserPointer(h), + MakeUserPointer(signals), + 2, + 0, + MakeUserPointer(&result_index), + MakeUserPointer(hss))); EXPECT_EQ(static_cast<uint32_t>(-1), result_index); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, @@ -554,25 +658,33 @@ TEST_F(CoreTest, MessagePipe) { // Try to read anyway. char buffer[1] = {'a'}; uint32_t buffer_size = 1; - EXPECT_EQ( - MOJO_RESULT_SHOULD_WAIT, - core()->ReadMessage(h[0], UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), NullUserPointer(), - NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, + core()->ReadMessage(h[0], + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NullUserPointer(), + NullUserPointer(), + MOJO_READ_MESSAGE_FLAG_NONE)); // Check that it left its inputs alone. EXPECT_EQ('a', buffer[0]); EXPECT_EQ(1u, buffer_size); // Both should be writable. hss[0] = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE, - 1000000000, MakeUserPointer(&hss[0]))); + EXPECT_EQ(MOJO_RESULT_OK, + core()->Wait(h[0], + MOJO_HANDLE_SIGNAL_WRITABLE, + 1000000000, + MakeUserPointer(&hss[0]))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfiable_signals); hss[0] = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, - 1000000000, MakeUserPointer(&hss[0]))); + EXPECT_EQ(MOJO_RESULT_OK, + core()->Wait(h[1], + MOJO_HANDLE_SIGNAL_WRITABLE, + 1000000000, + MakeUserPointer(&hss[0]))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfiable_signals); @@ -583,11 +695,13 @@ TEST_F(CoreTest, MessagePipe) { result_index = static_cast<uint32_t>(-1); hss[0] = kEmptyMojoHandleSignalsState; hss[1] = kEmptyMojoHandleSignalsState; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(hss))); + EXPECT_EQ(MOJO_RESULT_OK, + core()->WaitMany(MakeUserPointer(h), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(hss))); EXPECT_EQ(1u, result_index); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, @@ -598,10 +712,13 @@ TEST_F(CoreTest, MessagePipe) { // Write to |h[1]|. buffer[0] = 'b'; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1, - NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + core()->WriteMessage(h[1], + UserPointer<const void>(buffer), + 1, + NullUserPointer(), + 0, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Check that |h[0]| is now readable. signals[0] = MOJO_HANDLE_SIGNAL_READABLE; @@ -609,11 +726,13 @@ TEST_F(CoreTest, MessagePipe) { result_index = static_cast<uint32_t>(-1); hss[0] = kEmptyMojoHandleSignalsState; hss[1] = kEmptyMojoHandleSignalsState; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index), - MakeUserPointer(hss))); + EXPECT_EQ(MOJO_RESULT_OK, + core()->WaitMany(MakeUserPointer(h), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE, + MakeUserPointer(&result_index), + MakeUserPointer(hss))); EXPECT_EQ(0u, result_index); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); @@ -626,38 +745,46 @@ TEST_F(CoreTest, MessagePipe) { // Read from |h[0]|. // First, get only the size. buffer_size = 0; - EXPECT_EQ( - MOJO_RESULT_RESOURCE_EXHAUSTED, - core()->ReadMessage(h[0], NullUserPointer(), - MakeUserPointer(&buffer_size), NullUserPointer(), - NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, + core()->ReadMessage(h[0], + NullUserPointer(), + MakeUserPointer(&buffer_size), + NullUserPointer(), + NullUserPointer(), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, buffer_size); // Then actually read it. buffer[0] = 'c'; buffer_size = 1; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->ReadMessage(h[0], UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), NullUserPointer(), - NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + core()->ReadMessage(h[0], + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NullUserPointer(), + NullUserPointer(), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ('b', buffer[0]); EXPECT_EQ(1u, buffer_size); // |h[0]| should no longer be readable. hss[0] = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, - core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, - MakeUserPointer(&hss[0]))); + EXPECT_EQ( + MOJO_RESULT_DEADLINE_EXCEEDED, + core()->Wait( + h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss[0]))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfiable_signals); // Write to |h[0]|. buffer[0] = 'd'; - EXPECT_EQ( - MOJO_RESULT_OK, - core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1, - NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + core()->WriteMessage(h[0], + UserPointer<const void>(buffer), + 1, + NullUserPointer(), + 0, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Close |h[0]|. EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0])); @@ -665,38 +792,51 @@ TEST_F(CoreTest, MessagePipe) { // Check that |h[1]| is no longer writable (and will never be). hss[0] = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000, + core()->Wait(h[1], + MOJO_HANDLE_SIGNAL_WRITABLE, + 1000000000, MakeUserPointer(&hss[0]))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals); // Check that |h[1]| is still readable (for the moment). hss[0] = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000, MakeUserPointer(&hss[0]))); + EXPECT_EQ(MOJO_RESULT_OK, + core()->Wait(h[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, + MakeUserPointer(&hss[0]))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals); // Discard a message from |h[1]|. EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - core()->ReadMessage(h[1], NullUserPointer(), NullUserPointer(), - NullUserPointer(), NullUserPointer(), + core()->ReadMessage(h[1], + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); // |h[1]| is no longer readable (and will never be). hss[0] = kFullMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss[0]))); EXPECT_EQ(0u, hss[0].satisfied_signals); EXPECT_EQ(0u, hss[0].satisfiable_signals); // Try writing to |h[1]|. buffer[0] = 'e'; - EXPECT_EQ( - MOJO_RESULT_FAILED_PRECONDITION, - core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1, - NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, + core()->WriteMessage(h[1], + UserPointer<const void>(buffer), + 1, + NullUserPointer(), + 0, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1])); } @@ -723,12 +863,17 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { // Make sure that |h_passing[]| work properly. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, NullUserPointer(), 0, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -737,10 +882,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); EXPECT_STREQ(kHello, buffer); EXPECT_EQ(0u, num_handles); @@ -748,12 +895,18 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { // Make sure that you can't pass either of the message pipe's handles over // itself. EXPECT_EQ(MOJO_RESULT_BUSY, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&h_passing[0]), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&h_passing[0]), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&h_passing[1]), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&h_passing[1]), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); MojoHandle h_passed[2]; @@ -764,12 +917,17 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { // Make sure that |h_passed[]| work properly. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello), - kHelloSize, NullUserPointer(), 0, + core()->WriteMessage(h_passed[0], + UserPointer<const void>(kHello), + kHelloSize, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passed[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -778,22 +936,29 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passed[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passed[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); EXPECT_STREQ(kHello, buffer); EXPECT_EQ(0u, num_handles); // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), - kWorldSize, MakeUserPointer(&h_passed[1]), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kWorld), + kWorldSize, + MakeUserPointer(&h_passed[1]), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -802,10 +967,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kWorldSize, num_bytes); EXPECT_STREQ(kWorld, buffer); EXPECT_EQ(1u, num_handles); @@ -824,12 +991,17 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { // Write to |h_passed[0]|. Should receive on |h_received|. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello), - kHelloSize, NullUserPointer(), 0, + core()->WriteMessage(h_passed[0], + UserPointer<const void>(kHello), + kHelloSize, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_received, + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -838,10 +1010,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_received, UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_received, + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); EXPECT_STREQ(kHello, buffer); EXPECT_EQ(0u, num_handles); @@ -857,8 +1031,8 @@ TEST_F(CoreTest, DataPipe) { MojoHandleSignalsState hss; EXPECT_EQ(MOJO_RESULT_OK, - core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph), - MakeUserPointer(&ch))); + core()->CreateDataPipe( + NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch))); // Should get two distinct, valid handles. EXPECT_NE(ph, MOJO_HANDLE_INVALID); EXPECT_NE(ch, MOJO_HANDLE_INVALID); @@ -872,8 +1046,9 @@ TEST_F(CoreTest, DataPipe) { EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); hss = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, - MakeUserPointer(&hss))); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -895,15 +1070,17 @@ TEST_F(CoreTest, DataPipe) { char elements[2] = {'A', 'B'}; uint32_t num_bytes = 2u; EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteData(ph, UserPointer<const void>(elements), + core()->WriteData(ph, + UserPointer<const void>(elements), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_NONE)); EXPECT_EQ(2u, num_bytes); // Consumer should now be readable. hss = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, - MakeUserPointer(&hss))); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); @@ -913,7 +1090,9 @@ TEST_F(CoreTest, DataPipe) { num_bytes = 1u; EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData( - ch, UserPointer<void>(elements), MakeUserPointer(&num_bytes), + ch, + UserPointer<void>(elements), + MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK)); EXPECT_EQ('A', elements[0]); EXPECT_EQ(-1, elements[1]); @@ -922,9 +1101,11 @@ TEST_F(CoreTest, DataPipe) { elements[0] = -1; elements[1] = -1; num_bytes = 1u; - EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, UserPointer<void>(elements), - MakeUserPointer(&num_bytes), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + core()->ReadData(ch, + UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ('A', elements[0]); EXPECT_EQ(-1, elements[1]); @@ -932,7 +1113,8 @@ TEST_F(CoreTest, DataPipe) { void* write_ptr = nullptr; num_bytes = 0u; ASSERT_EQ(MOJO_RESULT_OK, - core()->BeginWriteData(ph, MakeUserPointer(&write_ptr), + core()->BeginWriteData(ph, + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_NONE)); // We count on the default options providing a decent buffer size. @@ -942,7 +1124,8 @@ TEST_F(CoreTest, DataPipe) { elements[0] = 'X'; num_bytes = 1u; EXPECT_EQ(MOJO_RESULT_BUSY, - core()->WriteData(ph, UserPointer<const void>(elements), + core()->WriteData(ph, + UserPointer<const void>(elements), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_NONE)); @@ -955,51 +1138,63 @@ TEST_F(CoreTest, DataPipe) { // Query how much data we have. num_bytes = 0; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), + core()->ReadData(ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_QUERY)); EXPECT_EQ(4u, num_bytes); // Try to query with peek. Should fail. num_bytes = 0; - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), - MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->ReadData( + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), + MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK)); EXPECT_EQ(0u, num_bytes); // Try to discard ten characters, in all-or-none mode. Should fail. num_bytes = 10; EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, core()->ReadData( - ch, NullUserPointer(), MakeUserPointer(&num_bytes), + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); // Try to discard two characters, in peek mode. Should fail. num_bytes = 2; - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), - MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->ReadData( + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), + MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK)); // Discard two characters. num_bytes = 2; EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData( - ch, NullUserPointer(), MakeUserPointer(&num_bytes), + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); // Try a two-phase read of the remaining two bytes with peek. Should fail. const void* read_ptr = nullptr; num_bytes = 2; ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->BeginReadData(ch, MakeUserPointer(&read_ptr), + core()->BeginReadData(ch, + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_PEEK)); // Read the remaining two characters, in two-phase mode (all-or-none). num_bytes = 2; ASSERT_EQ(MOJO_RESULT_OK, - core()->BeginReadData(ch, MakeUserPointer(&read_ptr), + core()->BeginReadData(ch, + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_ALL_OR_NONE)); // Note: Count on still being able to do the contiguous read here. @@ -1008,7 +1203,9 @@ TEST_F(CoreTest, DataPipe) { // Discarding right now should fail. num_bytes = 1; EXPECT_EQ(MOJO_RESULT_BUSY, - core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), + core()->ReadData(ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_DISCARD)); // Actually check our data and end the two-phase read. @@ -1061,17 +1258,22 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { MojoHandle ph, ch; EXPECT_EQ(MOJO_RESULT_OK, - core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph), - MakeUserPointer(&ch))); + core()->CreateDataPipe( + NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch))); // Send |ch| from |h_passing[0]| to |h_passing[1]|. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&ch), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&ch), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -1080,10 +1282,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); EXPECT_STREQ(kHello, buffer); EXPECT_EQ(1u, num_handles); @@ -1103,18 +1307,22 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { // Write to |ph|. Should receive on |ch_received|. num_bytes = kWorldSize; EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteData(ph, UserPointer<const void>(kWorld), + core()->WriteData(ph, + UserPointer<const void>(kWorld), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(ch_received, + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); num_bytes = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadData(ch_received, UserPointer<void>(buffer), + core()->ReadData(ch_received, + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kWorldSize, num_bytes); @@ -1122,12 +1330,17 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { // Now pass |ph| in the same direction. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), - kWorldSize, MakeUserPointer(&ph), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kWorld), + kWorldSize, + MakeUserPointer(&ph), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -1136,10 +1349,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kWorldSize, num_bytes); EXPECT_STREQ(kWorld, buffer); EXPECT_EQ(1u, num_handles); @@ -1159,18 +1374,22 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { // Write to |ph_received|. Should receive on |ch_received|. num_bytes = kHelloSize; EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteData(ph_received, UserPointer<const void>(kHello), + core()->WriteData(ph_received, + UserPointer<const void>(kHello), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)); hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(ch_received, + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); num_bytes = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadData(ch_received, UserPointer<void>(buffer), + core()->ReadData(ch_received, + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); @@ -1185,31 +1404,42 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { void* write_ptr = nullptr; num_bytes = 0; ASSERT_EQ(MOJO_RESULT_OK, - core()->BeginWriteData(ph, MakeUserPointer(&write_ptr), + core()->BeginWriteData(ph, + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), MOJO_WRITE_DATA_FLAG_NONE)); ASSERT_GE(num_bytes, 1u); EXPECT_EQ(MOJO_RESULT_BUSY, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&ph), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&ph), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); // But |ch| can, even if |ph| is in a two-phase write. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&ch), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&ch), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); ch = MOJO_HANDLE_INVALID; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, NullUserPointer())); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kHelloSize, num_bytes); EXPECT_STREQ(kHello, buffer); EXPECT_EQ(1u, num_handles); @@ -1222,8 +1452,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { // Wait for |ch| to be readable. hss = kEmptyMojoHandleSignalsState; - EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, - 1000000000, MakeUserPointer(&hss))); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait( + ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); @@ -1231,23 +1463,32 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { const void* read_ptr = nullptr; num_bytes = 1; ASSERT_EQ(MOJO_RESULT_OK, - core()->BeginReadData(ch, MakeUserPointer(&read_ptr), + core()->BeginReadData(ch, + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_ALL_OR_NONE)); EXPECT_EQ(MOJO_RESULT_BUSY, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello), - kHelloSize, MakeUserPointer(&ch), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kHello), + kHelloSize, + MakeUserPointer(&ch), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); // But |ph| can, even if |ch| is in a two-phase read. EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld), - kWorldSize, MakeUserPointer(&ph), 1, + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kWorld), + kWorldSize, + MakeUserPointer(&ph), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); ph = MOJO_HANDLE_INVALID; hss = kEmptyMojoHandleSignalsState; EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000, + core()->Wait(h_passing[1], + MOJO_HANDLE_SIGNAL_READABLE, + 1000000000, MakeUserPointer(&hss))); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -1256,10 +1497,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage( - h_passing[1], UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), MakeUserPointer(handles), - MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE)); + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + MakeUserPointer(handles), + MakeUserPointer(&num_handles), + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kWorldSize, num_bytes); EXPECT_STREQ(kWorld, buffer); EXPECT_EQ(1u, num_handles); diff --git a/mojo/edk/system/data_pipe.cc b/mojo/edk/system/data_pipe.cc index cbacb89..e9525bc 100644 --- a/mojo/edk/system/data_pipe.cc +++ b/mojo/edk/system/data_pipe.cc @@ -10,7 +10,7 @@ #include <limits> #include "base/logging.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/memory.h" #include "mojo/edk/system/options_validation.h" #include "mojo/edk/system/waiter_list.h" @@ -19,15 +19,11 @@ namespace mojo { namespace system { // static -MojoCreateDataPipeOptions DataPipe::GetDefaultCreateOptions() { - MojoCreateDataPipeOptions result = { - static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)), - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, - 1u, - static_cast<uint32_t>( - GetConfiguration().default_data_pipe_capacity_bytes)}; - return result; -} +const MojoCreateDataPipeOptions DataPipe::kDefaultCreateOptions = { + static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)), + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, + 1u, + static_cast<uint32_t>(kDefaultDataPipeCapacityBytes)}; // static MojoResult DataPipe::ValidateCreateOptions( @@ -36,7 +32,7 @@ MojoResult DataPipe::ValidateCreateOptions( const MojoCreateDataPipeOptionsFlags kKnownFlags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD; - *out_options = GetDefaultCreateOptions(); + *out_options = kDefaultCreateOptions; if (in_options.IsNull()) return MOJO_RESULT_OK; @@ -52,31 +48,28 @@ MojoResult DataPipe::ValidateCreateOptions( // Checks for fields beyond |flags|: - if (!OPTIONS_STRUCT_HAS_MEMBER(MojoCreateDataPipeOptions, element_num_bytes, - reader)) + if (!OPTIONS_STRUCT_HAS_MEMBER( + MojoCreateDataPipeOptions, element_num_bytes, reader)) return MOJO_RESULT_OK; if (reader.options().element_num_bytes == 0) return MOJO_RESULT_INVALID_ARGUMENT; out_options->element_num_bytes = reader.options().element_num_bytes; - if (!OPTIONS_STRUCT_HAS_MEMBER(MojoCreateDataPipeOptions, capacity_num_bytes, - reader) || + if (!OPTIONS_STRUCT_HAS_MEMBER( + MojoCreateDataPipeOptions, capacity_num_bytes, reader) || reader.options().capacity_num_bytes == 0) { // Round the default capacity down to a multiple of the element size (but at // least one element). - size_t default_data_pipe_capacity_bytes = - GetConfiguration().default_data_pipe_capacity_bytes; out_options->capacity_num_bytes = - std::max(static_cast<uint32_t>(default_data_pipe_capacity_bytes - - (default_data_pipe_capacity_bytes % + std::max(static_cast<uint32_t>(kDefaultDataPipeCapacityBytes - + (kDefaultDataPipeCapacityBytes % out_options->element_num_bytes)), out_options->element_num_bytes); return MOJO_RESULT_OK; } if (reader.options().capacity_num_bytes % out_options->element_num_bytes != 0) return MOJO_RESULT_INVALID_ARGUMENT; - if (reader.options().capacity_num_bytes > - GetConfiguration().max_data_pipe_capacity_bytes) + if (reader.options().capacity_num_bytes > kMaxDataPipeCapacityBytes) return MOJO_RESULT_RESOURCE_EXHAUSTED; out_options->capacity_num_bytes = reader.options().capacity_num_bytes; @@ -155,8 +148,8 @@ MojoResult DataPipe::ProducerBeginWriteData( return MOJO_RESULT_INVALID_ARGUMENT; } - MojoResult rv = ProducerBeginWriteDataImplNoLock(buffer, buffer_num_bytes, - min_num_bytes_to_write); + MojoResult rv = ProducerBeginWriteDataImplNoLock( + buffer, buffer_num_bytes, 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 @@ -352,8 +345,8 @@ MojoResult DataPipe::ConsumerBeginReadData( return MOJO_RESULT_INVALID_ARGUMENT; } - MojoResult rv = ConsumerBeginReadDataImplNoLock(buffer, buffer_num_bytes, - min_num_bytes_to_read); + MojoResult rv = ConsumerBeginReadDataImplNoLock( + buffer, buffer_num_bytes, min_num_bytes_to_read); if (rv != MOJO_RESULT_OK) return rv; DCHECK(consumer_in_two_phase_read_no_lock()); diff --git a/mojo/edk/system/data_pipe.h b/mojo/edk/system/data_pipe.h index 767d405..d4afdda 100644 --- a/mojo/edk/system/data_pipe.h +++ b/mojo/edk/system/data_pipe.h @@ -35,7 +35,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe // The default options for |MojoCreateDataPipe()|. (Real uses should obtain // this via |ValidateCreateOptions()| with a null |in_options|; this is // exposed directly for testing convenience.) - static MojoCreateDataPipeOptions GetDefaultCreateOptions(); + static const MojoCreateDataPipeOptions kDefaultCreateOptions; // Validates and/or sets default options for |MojoCreateDataPipeOptions|. If // non-null, |in_options| must point to a struct of at least @@ -117,11 +117,12 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe virtual void ConsumerCloseImplNoLock() = 0; // |*num_bytes| will be a nonzero multiple of |element_num_bytes_|. - virtual MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements, - UserPointer<uint32_t> num_bytes, - uint32_t max_num_bytes_to_read, - uint32_t min_num_bytes_to_read, - bool peek) = 0; + virtual MojoResult ConsumerReadDataImplNoLock( + UserPointer<void> elements, + UserPointer<uint32_t> num_bytes, + uint32_t max_num_bytes_to_read, + uint32_t min_num_bytes_to_read, + bool peek) = 0; virtual MojoResult ConsumerDiscardDataImplNoLock( UserPointer<uint32_t> num_bytes, uint32_t max_num_bytes_to_discard, diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.cc b/mojo/edk/system/data_pipe_consumer_dispatcher.cc index 3c14f35..fa103c3 100644 --- a/mojo/edk/system/data_pipe_consumer_dispatcher.cc +++ b/mojo/edk/system/data_pipe_consumer_dispatcher.cc @@ -77,7 +77,9 @@ MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock( } return data_pipe_->ConsumerReadData( - elements, num_bytes, !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE), + elements, + num_bytes, + !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE), !!(flags & MOJO_READ_DATA_FLAG_PEEK)); } @@ -89,7 +91,8 @@ MojoResult DataPipeConsumerDispatcher::BeginReadDataImplNoLock( // These flags may not be used in two-phase mode. if ((flags & MOJO_READ_DATA_FLAG_DISCARD) || - (flags & MOJO_READ_DATA_FLAG_QUERY) || (flags & MOJO_READ_DATA_FLAG_PEEK)) + (flags & MOJO_READ_DATA_FLAG_QUERY) || + (flags & MOJO_READ_DATA_FLAG_PEEK)) return MOJO_RESULT_INVALID_ARGUMENT; return data_pipe_->ConsumerBeginReadData( diff --git a/mojo/edk/system/data_pipe_unittest.cc b/mojo/edk/system/data_pipe_unittest.cc index ad02222..8d2e4eb 100644 --- a/mojo/edk/system/data_pipe_unittest.cc +++ b/mojo/edk/system/data_pipe_unittest.cc @@ -9,7 +9,7 @@ #include <limits> -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "testing/gtest/include/gtest/gtest.h" namespace mojo { @@ -28,8 +28,9 @@ void RevalidateCreateOptions( // Nothing to check for flags. EXPECT_GT(validated_options.element_num_bytes, 0u); EXPECT_GT(validated_options.capacity_num_bytes, 0u); - EXPECT_EQ(0u, validated_options.capacity_num_bytes % - validated_options.element_num_bytes); + EXPECT_EQ(0u, + validated_options.capacity_num_bytes % + validated_options.element_num_bytes); MojoCreateDataPipeOptions revalidated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -47,10 +48,10 @@ void RevalidateCreateOptions( // checks done by |RevalidateCreateOptions()|.) void CheckDefaultCapacity(const MojoCreateDataPipeOptions& validated_options) { EXPECT_LE(validated_options.capacity_num_bytes, - GetConfiguration().default_data_pipe_capacity_bytes); + kDefaultDataPipeCapacityBytes); EXPECT_GT(validated_options.capacity_num_bytes + validated_options.element_num_bytes, - GetConfiguration().default_data_pipe_capacity_bytes); + kDefaultDataPipeCapacityBytes); } // Tests valid inputs to |ValidateCreateOptions()|. @@ -58,8 +59,9 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Default options. { MojoCreateDataPipeOptions validated_options = {}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - NullUserPointer(), &validated_options)); + EXPECT_EQ( + MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(NullUserPointer(), &validated_options)); RevalidateCreateOptions(validated_options); CheckDefaultCapacity(validated_options); } diff --git a/mojo/edk/system/dispatcher.cc b/mojo/edk/system/dispatcher.cc index c58da9f..5607125 100644 --- a/mojo/edk/system/dispatcher.cc +++ b/mojo/edk/system/dispatcher.cc @@ -5,7 +5,7 @@ #include "mojo/edk/system/dispatcher.h" #include "base/logging.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/message_pipe_dispatcher.h" #include "mojo/edk/system/platform_handle_dispatcher.h" #include "mojo/edk/system/shared_buffer_dispatcher.h" @@ -58,8 +58,8 @@ bool Dispatcher::TransportDataAccess::EndSerializeAndClose( size_t* actual_size, embedder::PlatformHandleVector* platform_handles) { DCHECK(dispatcher); - return dispatcher->EndSerializeAndClose(channel, destination, actual_size, - platform_handles); + return dispatcher->EndSerializeAndClose( + channel, destination, actual_size, platform_handles); } // static @@ -107,9 +107,8 @@ MojoResult Dispatcher::WriteMessage( uint32_t num_bytes, std::vector<DispatcherTransport>* transports, MojoWriteMessageFlags flags) { - DCHECK(!transports || - (transports->size() > 0 && - transports->size() < GetConfiguration().max_message_num_handles)); + DCHECK(!transports || (transports->size() > 0 && + transports->size() < kMaxMessageNumHandles)); base::AutoLock locker(lock_); if (is_closed_) @@ -130,8 +129,8 @@ MojoResult Dispatcher::ReadMessage(UserPointer<void> bytes, if (is_closed_) return MOJO_RESULT_INVALID_ARGUMENT; - return ReadMessageImplNoLock(bytes, num_bytes, dispatchers, num_dispatchers, - flags); + return ReadMessageImplNoLock( + bytes, num_bytes, dispatchers, num_dispatchers, flags); } MojoResult Dispatcher::WriteData(UserPointer<const void> elements, @@ -474,8 +473,8 @@ bool Dispatcher::EndSerializeAndClose( base::AutoLock locker(lock_); #endif - return EndSerializeAndCloseImplNoLock(channel, destination, actual_size, - platform_handles); + return EndSerializeAndCloseImplNoLock( + channel, destination, actual_size, platform_handles); } // DispatcherTransport --------------------------------------------------------- diff --git a/mojo/edk/system/dispatcher.h b/mojo/edk/system/dispatcher.h index d4db54b..8d3edd4 100644 --- a/mojo/edk/system/dispatcher.h +++ b/mojo/edk/system/dispatcher.h @@ -48,7 +48,7 @@ namespace test { // Test helper. We need to declare it here so we can friend it. MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport -DispatcherTryStartTransport(Dispatcher* dispatcher); + DispatcherTryStartTransport(Dispatcher* dispatcher); } // namespace test diff --git a/mojo/edk/system/dispatcher_unittest.cc b/mojo/edk/system/dispatcher_unittest.cc index 0b15436..b5a05d4 100644 --- a/mojo/edk/system/dispatcher_unittest.cc +++ b/mojo/edk/system/dispatcher_unittest.cc @@ -44,24 +44,31 @@ TEST(DispatcherTest, Basic) { EXPECT_EQ(Dispatcher::kTypeUnknown, d->GetType()); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteMessage(NullUserPointer(), 0, nullptr, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + d->WriteMessage( + NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteData(NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->BeginWriteData(NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); + d->ReadMessage(NullUserPointer(), + NullUserPointer(), + nullptr, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->WriteData( + NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->BeginWriteData( + NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadData(NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->BeginReadData(NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->ReadData( + NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->BeginReadData( + NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0)); Waiter w; w.Init(); @@ -83,24 +90,31 @@ TEST(DispatcherTest, Basic) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteMessage(NullUserPointer(), 0, nullptr, - MOJO_WRITE_MESSAGE_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d->WriteMessage( + NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteData(NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->BeginWriteData(NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); + d->ReadMessage(NullUserPointer(), + NullUserPointer(), + nullptr, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->WriteData( + NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->BeginWriteData( + NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadData(NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->BeginReadData(NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->ReadData( + NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + d->BeginReadData( + NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0)); hss = HandleSignalsState(); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, @@ -158,40 +172,45 @@ class ThreadSafetyStressThread : public base::SimpleThread { break; } case WRITE_MESSAGE: - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->WriteMessage(NullUserPointer(), 0, nullptr, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->WriteMessage( + NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); break; case READ_MESSAGE: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->ReadMessage(NullUserPointer(), NullUserPointer(), - nullptr, nullptr, + dispatcher_->ReadMessage(NullUserPointer(), + NullUserPointer(), + nullptr, + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); break; case WRITE_DATA: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->WriteData(NullUserPointer(), NullUserPointer(), + dispatcher_->WriteData(NullUserPointer(), + NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); break; case BEGIN_WRITE_DATA: - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->BeginWriteData(NullUserPointer(), NullUserPointer(), - MOJO_WRITE_DATA_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->BeginWriteData(NullUserPointer(), + NullUserPointer(), + MOJO_WRITE_DATA_FLAG_NONE)); break; case END_WRITE_DATA: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndWriteData(0)); break; case READ_DATA: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->ReadData(NullUserPointer(), NullUserPointer(), + dispatcher_->ReadData(NullUserPointer(), + NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); break; case BEGIN_READ_DATA: - EXPECT_EQ( - MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->BeginReadData(NullUserPointer(), NullUserPointer(), - MOJO_READ_DATA_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->BeginReadData(NullUserPointer(), + NullUserPointer(), + MOJO_READ_DATA_FLAG_NONE)); break; case END_READ_DATA: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndReadData(0)); diff --git a/mojo/edk/system/entrypoints.cc b/mojo/edk/system/entrypoints.cc new file mode 100644 index 0000000..7ec5bb4 --- /dev/null +++ b/mojo/edk/system/entrypoints.cc @@ -0,0 +1,191 @@ +// 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/entrypoints.h" + +#include "base/logging.h" +#include "mojo/edk/system/core.h" +#include "mojo/public/c/system/buffer.h" +#include "mojo/public/c/system/data_pipe.h" +#include "mojo/public/c/system/functions.h" +#include "mojo/public/c/system/message_pipe.h" + +static mojo::system::Core* g_core = nullptr; + +using mojo::system::MakeUserPointer; + +namespace mojo { +namespace system { +namespace entrypoints { + +void SetCore(Core* core) { + g_core = core; +} + +Core* GetCore() { + return g_core; +} + +} // namespace entrypoints +} // namepace system +} // namespace mojo + +// Definitions of the system functions. +extern "C" { +MojoTimeTicks MojoGetTimeTicksNow() { + return g_core->GetTimeTicksNow(); +} + +MojoResult MojoClose(MojoHandle handle) { + return g_core->Close(handle); +} + +MojoResult MojoWait(MojoHandle handle, + MojoHandleSignals signals, + MojoDeadline deadline) { + return g_core->Wait( + handle, signals, deadline, mojo::system::NullUserPointer()); +} + +MojoResult MojoWaitMany(const MojoHandle* handles, + const MojoHandleSignals* signals, + uint32_t num_handles, + MojoDeadline deadline) { + uint32_t result_index = static_cast<uint32_t>(-1); + MojoResult result = g_core->WaitMany(MakeUserPointer(handles), + MakeUserPointer(signals), + num_handles, + deadline, + MakeUserPointer(&result_index), + mojo::system::NullUserPointer()); + return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index) + : result; +} + +MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options, + MojoHandle* message_pipe_handle0, + MojoHandle* message_pipe_handle1) { + return g_core->CreateMessagePipe(MakeUserPointer(options), + MakeUserPointer(message_pipe_handle0), + MakeUserPointer(message_pipe_handle1)); +} + +MojoResult MojoWriteMessage(MojoHandle message_pipe_handle, + const void* bytes, + uint32_t num_bytes, + const MojoHandle* handles, + uint32_t num_handles, + MojoWriteMessageFlags flags) { + return g_core->WriteMessage(message_pipe_handle, + MakeUserPointer(bytes), + num_bytes, + MakeUserPointer(handles), + num_handles, + flags); +} + +MojoResult MojoReadMessage(MojoHandle message_pipe_handle, + void* bytes, + uint32_t* num_bytes, + MojoHandle* handles, + uint32_t* num_handles, + MojoReadMessageFlags flags) { + return g_core->ReadMessage(message_pipe_handle, + MakeUserPointer(bytes), + MakeUserPointer(num_bytes), + MakeUserPointer(handles), + MakeUserPointer(num_handles), + flags); +} + +MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options, + MojoHandle* data_pipe_producer_handle, + MojoHandle* data_pipe_consumer_handle) { + return g_core->CreateDataPipe(MakeUserPointer(options), + MakeUserPointer(data_pipe_producer_handle), + MakeUserPointer(data_pipe_consumer_handle)); +} + +MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle, + const void* elements, + uint32_t* num_elements, + MojoWriteDataFlags flags) { + return g_core->WriteData(data_pipe_producer_handle, + MakeUserPointer(elements), + MakeUserPointer(num_elements), + flags); +} + +MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle, + void** buffer, + uint32_t* buffer_num_elements, + MojoWriteDataFlags flags) { + return g_core->BeginWriteData(data_pipe_producer_handle, + MakeUserPointer(buffer), + MakeUserPointer(buffer_num_elements), + flags); +} + +MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle, + uint32_t num_elements_written) { + return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written); +} + +MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle, + void* elements, + uint32_t* num_elements, + MojoReadDataFlags flags) { + return g_core->ReadData(data_pipe_consumer_handle, + MakeUserPointer(elements), + MakeUserPointer(num_elements), + flags); +} + +MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle, + const void** buffer, + uint32_t* buffer_num_elements, + MojoReadDataFlags flags) { + return g_core->BeginReadData(data_pipe_consumer_handle, + MakeUserPointer(buffer), + MakeUserPointer(buffer_num_elements), + flags); +} + +MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle, + uint32_t num_elements_read) { + return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read); +} + +MojoResult MojoCreateSharedBuffer( + const struct MojoCreateSharedBufferOptions* options, + uint64_t num_bytes, + MojoHandle* shared_buffer_handle) { + return g_core->CreateSharedBuffer(MakeUserPointer(options), + num_bytes, + MakeUserPointer(shared_buffer_handle)); +} + +MojoResult MojoDuplicateBufferHandle( + MojoHandle buffer_handle, + const struct MojoDuplicateBufferHandleOptions* options, + MojoHandle* new_buffer_handle) { + return g_core->DuplicateBufferHandle(buffer_handle, + MakeUserPointer(options), + MakeUserPointer(new_buffer_handle)); +} + +MojoResult MojoMapBuffer(MojoHandle buffer_handle, + uint64_t offset, + uint64_t num_bytes, + void** buffer, + MojoMapBufferFlags flags) { + return g_core->MapBuffer( + buffer_handle, offset, num_bytes, MakeUserPointer(buffer), flags); +} + +MojoResult MojoUnmapBuffer(void* buffer) { + return g_core->UnmapBuffer(MakeUserPointer(buffer)); +} + +} // extern "C" diff --git a/mojo/edk/system/entrypoints.h b/mojo/edk/system/entrypoints.h new file mode 100644 index 0000000..46c41b4 --- /dev/null +++ b/mojo/edk/system/entrypoints.h @@ -0,0 +1,24 @@ +// 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_ENTRYPOINTS_H_ +#define MOJO_EDK_SYSTEM_ENTRYPOINTS_H_ + +namespace mojo { +namespace system { + +class Core; + +namespace entrypoints { + +// Sets the instance of Core to be used by system functions. +void SetCore(Core* core); +// Gets the instance of Core to be used by system functions. +Core* GetCore(); + +} // namespace entrypoints +} // namepace system +} // namespace mojo + +#endif // MOJO_EDK_SYSTEM_ENTRYPOINTS_H_ diff --git a/mojo/edk/system/handle_table.cc b/mojo/edk/system/handle_table.cc index 05d5260..9c01230 100644 --- a/mojo/edk/system/handle_table.cc +++ b/mojo/edk/system/handle_table.cc @@ -4,10 +4,9 @@ #include "mojo/edk/system/handle_table.h" -#include <limits> #include "base/logging.h" #include "base/macros.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/dispatcher.h" namespace mojo { @@ -60,7 +59,7 @@ MojoResult HandleTable::GetAndRemoveDispatcher( MojoHandle HandleTable::AddDispatcher( const scoped_refptr<Dispatcher>& dispatcher) { - if (handle_to_entry_map_.size() >= GetConfiguration().max_handle_table_size) + if (handle_to_entry_map_.size() >= kMaxHandleTableSize) return MOJO_HANDLE_INVALID; return AddDispatcherNoSizeCheck(dispatcher); } @@ -68,8 +67,7 @@ MojoHandle HandleTable::AddDispatcher( std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair( const scoped_refptr<Dispatcher>& dispatcher0, const scoped_refptr<Dispatcher>& dispatcher1) { - if (handle_to_entry_map_.size() + 1 >= - GetConfiguration().max_handle_table_size) + if (handle_to_entry_map_.size() + 1 >= kMaxHandleTableSize) return std::make_pair(MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID); return std::make_pair(AddDispatcherNoSizeCheck(dispatcher0), AddDispatcherNoSizeCheck(dispatcher1)); @@ -77,17 +75,17 @@ std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair( bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers, MojoHandle* handles) { - size_t max_message_num_handles = GetConfiguration().max_message_num_handles; - size_t max_handle_table_size = GetConfiguration().max_handle_table_size; - - DCHECK_LE(dispatchers.size(), max_message_num_handles); + DCHECK_LE(dispatchers.size(), kMaxMessageNumHandles); DCHECK(handles); - DCHECK_LT( - static_cast<uint64_t>(max_handle_table_size) + max_message_num_handles, - std::numeric_limits<size_t>::max()) - << "Addition may overflow"; - - if (handle_to_entry_map_.size() + dispatchers.size() > max_handle_table_size) + // TODO(vtl): |std::numeric_limits<size_t>::max()| isn't a compile-time + // expression in C++03. + static_assert( + static_cast<uint64_t>(kMaxHandleTableSize) + kMaxMessageNumHandles < + (sizeof(size_t) == 8 ? kuint64max + : static_cast<uint64_t>(kuint32max)), + "Addition may overflow"); + + if (handle_to_entry_map_.size() + dispatchers.size() > kMaxHandleTableSize) return false; for (size_t i = 0; i < dispatchers.size(); i++) { @@ -108,7 +106,7 @@ MojoResult HandleTable::MarkBusyAndStartTransport( std::vector<DispatcherTransport>* transports) { DCHECK_NE(disallowed_handle, MOJO_HANDLE_INVALID); DCHECK(handles); - DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles); + DCHECK_LE(num_handles, kMaxMessageNumHandles); DCHECK(transports); DCHECK_EQ(transports->size(), num_handles); @@ -189,8 +187,7 @@ MojoResult HandleTable::MarkBusyAndStartTransport( MojoHandle HandleTable::AddDispatcherNoSizeCheck( const scoped_refptr<Dispatcher>& dispatcher) { DCHECK(dispatcher.get()); - DCHECK_LT(handle_to_entry_map_.size(), - GetConfiguration().max_handle_table_size); + DCHECK_LT(handle_to_entry_map_.size(), kMaxHandleTableSize); DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID); // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try @@ -215,7 +212,7 @@ MojoHandle HandleTable::AddDispatcherNoSizeCheck( void HandleTable::RemoveBusyHandles(const MojoHandle* handles, uint32_t num_handles) { DCHECK(handles); - DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles); + DCHECK_LE(num_handles, kMaxMessageNumHandles); for (uint32_t i = 0; i < num_handles; i++) { HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]); @@ -229,7 +226,7 @@ void HandleTable::RemoveBusyHandles(const MojoHandle* handles, void HandleTable::RestoreBusyHandles(const MojoHandle* handles, uint32_t num_handles) { DCHECK(handles); - DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles); + DCHECK_LE(num_handles, kMaxMessageNumHandles); for (uint32_t i = 0; i < num_handles; i++) { HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]); diff --git a/mojo/edk/system/local_data_pipe.cc b/mojo/edk/system/local_data_pipe.cc index 177b238..fdfaf28 100644 --- a/mojo/edk/system/local_data_pipe.cc +++ b/mojo/edk/system/local_data_pipe.cc @@ -15,7 +15,7 @@ #include <algorithm> #include "base/logging.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" namespace mojo { namespace system { @@ -301,8 +301,7 @@ void LocalDataPipe::EnsureBufferNoLock() { if (buffer_) return; buffer_.reset(static_cast<char*>( - base::AlignedAlloc(capacity_num_bytes(), - GetConfiguration().data_pipe_buffer_alignment_bytes))); + base::AlignedAlloc(capacity_num_bytes(), kDataPipeBufferAlignmentBytes))); } void LocalDataPipe::DestroyBufferNoLock() { diff --git a/mojo/edk/system/local_data_pipe.h b/mojo/edk/system/local_data_pipe.h index abe3a46..c98cb7e 100644 --- a/mojo/edk/system/local_data_pipe.h +++ b/mojo/edk/system/local_data_pipe.h @@ -44,11 +44,12 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe { uint32_t num_bytes_written) override; HandleSignalsState ProducerGetHandleSignalsStateImplNoLock() const override; void ConsumerCloseImplNoLock() override; - MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements, - UserPointer<uint32_t> num_bytes, - uint32_t max_num_bytes_to_read, - uint32_t min_num_bytes_to_read, - bool peek) override; + MojoResult ConsumerReadDataImplNoLock( + UserPointer<void> elements, + UserPointer<uint32_t> num_bytes, + uint32_t max_num_bytes_to_read, + uint32_t min_num_bytes_to_read, + bool peek) override; MojoResult ConsumerDiscardDataImplNoLock( UserPointer<uint32_t> num_bytes, uint32_t max_num_bytes_to_discard, diff --git a/mojo/edk/system/local_data_pipe_unittest.cc b/mojo/edk/system/local_data_pipe_unittest.cc index 9ba6b21..e8bc716 100644 --- a/mojo/edk/system/local_data_pipe_unittest.cc +++ b/mojo/edk/system/local_data_pipe_unittest.cc @@ -25,8 +25,9 @@ TEST(LocalDataPipeTest, Creation) { { // Get default options. MojoCreateDataPipeOptions default_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - NullUserPointer(), &default_options)); + EXPECT_EQ( + MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options)); dp->ProducerClose(); dp->ConsumerClose(); @@ -104,8 +105,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -114,9 +116,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { // Try reading; nothing there yet. num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_SHOULD_WAIT, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + false, + false)); // Query; nothing there yet. num_bytes = 0; @@ -130,9 +135,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { // Read with invalid |num_bytes|. num_bytes = sizeof(elements[0]) + 1; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + false, + false)); // Write two elements. elements[0] = 123; @@ -140,7 +148,8 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // It should have written everything (even without "all or none"). EXPECT_EQ(2u * sizeof(elements[0]), num_bytes); @@ -153,9 +162,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(1u * sizeof(elements[0]), num_bytes); EXPECT_EQ(123, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -169,9 +181,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), false, true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + false, + true)); EXPECT_EQ(1u * sizeof(elements[0]), num_bytes); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -185,9 +200,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, false)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(-1, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -195,9 +213,12 @@ TEST(LocalDataPipeTest, SimpleReadWrite) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -224,8 +245,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { 2 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); Waiter waiter; @@ -253,7 +275,8 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), true)); + MakeUserPointer(&num_bytes), + true)); EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); // Adding a waiter should now succeed. @@ -272,9 +295,12 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + true)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(123, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -301,9 +327,12 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(123, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -320,14 +349,15 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { void* buffer = nullptr; num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&buffer), - MakeUserPointer(&num_bytes), false)); + dp->ProducerBeginWriteData( + MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(buffer); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); static_cast<int32_t*>(buffer)[0] = 789; - EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>( - 1u * sizeof(elements[0])))); + EXPECT_EQ(MOJO_RESULT_OK, + dp->ProducerEndWriteData( + static_cast<uint32_t>(1u * sizeof(elements[0])))); // Add a waiter. waiter.Init(); @@ -338,9 +368,10 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Read one element, using a two-phase read. const void* read_buffer = nullptr; num_bytes = 0u; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(read_buffer); // Since we only read one element (after having written three in all), the // two-phase read should only allow us to read one. This checks an @@ -364,7 +395,8 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); // Add a waiter. @@ -395,8 +427,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); { scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -416,8 +449,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Not yet readable. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, - nullptr)); + dp->ConsumerAddWaiter( + &waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, nullptr)); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr)); hss = HandleSignalsState(); dp->ConsumerRemoveWaiter(&waiter, &hss); @@ -429,7 +462,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), true)); + MakeUserPointer(&num_bytes), + true)); // Should already be readable. waiter.Init(); @@ -459,9 +493,12 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + true)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -479,9 +516,12 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -489,8 +529,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->ConsumerAddWaiter( + &waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, nullptr)); // Write one element. elements[0] = 789; @@ -498,7 +538,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), true)); + MakeUserPointer(&num_bytes), + true)); // Waiting should now succeed. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); @@ -524,9 +565,12 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { elements[0] = -1; elements[1] = -1; num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(elements), - MakeUserPointer(&num_bytes), true, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(elements), + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(789, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -557,15 +601,16 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Request room for three (but we'll only write two). uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0])); EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&buffer), - MakeUserPointer(&num_bytes), true)); + dp->ProducerBeginWriteData( + MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), true)); EXPECT_TRUE(buffer); EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0]))); elements = static_cast<int32_t*>(buffer); elements[0] = 123; elements[1] = 456; - EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>( - 2u * sizeof(elements[0])))); + EXPECT_EQ(MOJO_RESULT_OK, + dp->ProducerEndWriteData( + static_cast<uint32_t>(2u * sizeof(elements[0])))); // Should already be readable. waiter.Init(); @@ -580,15 +625,17 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Request two in all-or-none mode, but only read one. const void* read_buffer = nullptr; num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), true)); EXPECT_TRUE(read_buffer); EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); const int32_t* read_elements = static_cast<const int32_t*>(read_buffer); EXPECT_EQ(123, read_elements[0]); - EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>( - 1u * sizeof(elements[0])))); + EXPECT_EQ(MOJO_RESULT_OK, + dp->ConsumerEndReadData( + static_cast<uint32_t>(1u * sizeof(elements[0])))); // Should still be readable. waiter.Init(); @@ -603,21 +650,23 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Request three, but not in all-or-none mode. read_buffer = nullptr; num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0])); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(read_buffer); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); read_elements = static_cast<const int32_t*>(read_buffer); EXPECT_EQ(456, read_elements[0]); - EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>( - 1u * sizeof(elements[0])))); + EXPECT_EQ(MOJO_RESULT_OK, + dp->ConsumerEndReadData( + static_cast<uint32_t>(1u * sizeof(elements[0])))); // Adding a waiter should now succeed. waiter.Init(); ASSERT_EQ(MOJO_RESULT_OK, - dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, - nullptr)); + dp->ConsumerAddWaiter( + &waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, nullptr)); // Close the producer. dp->ProducerClose(); @@ -643,8 +692,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); Waiter waiter; @@ -661,9 +711,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); void* write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(write_ptr); EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); @@ -690,8 +741,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals); static_cast<int32_t*>(write_ptr)[0] = 123; - EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData( - static_cast<uint32_t>(1u * sizeof(int32_t)))); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerEndWriteData(static_cast<uint32_t>(1u * sizeof(int32_t)))); // It should be writable again. waiter.Init(); @@ -715,9 +767,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // middle of it. num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(write_ptr); EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); @@ -736,9 +789,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // Start a two-phase read. num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); const void* read_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(read_ptr); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes); @@ -787,8 +841,9 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { 1 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); Waiter waiter; @@ -818,7 +873,8 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { int32_t element = 123; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(&element), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes); // Still writable (even though it's full). @@ -844,7 +900,8 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { element = 456; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(&element), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes); // Still writable. @@ -868,9 +925,12 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { // Read that element. num_bytes = static_cast<uint32_t>(sizeof(int32_t)); element = 0; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(&element), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(&element), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes); EXPECT_EQ(456, element); @@ -911,8 +971,9 @@ TEST(LocalDataPipeTest, MayDiscard) { 10 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -923,9 +984,10 @@ TEST(LocalDataPipeTest, MayDiscard) { Seq(0, arraysize(buffer), buffer); // Try writing more than capacity. (This test relies on the implementation // enforcing the capacity strictly.) - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); // Read half of what we wrote. @@ -933,7 +995,9 @@ TEST(LocalDataPipeTest, MayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); @@ -945,9 +1009,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // Write a bit more than the space that's available. num_bytes = 8u * sizeof(int32_t); Seq(100, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(8u * sizeof(int32_t), num_bytes); // Internally, a circular buffer would now look like: // 100, 101, 102, 103, 104, 105, 106, 107, 8, 9 @@ -957,7 +1022,9 @@ TEST(LocalDataPipeTest, MayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 8; @@ -972,9 +1039,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // Write one integer. num_bytes = 1u * sizeof(int32_t); Seq(200, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(1u * sizeof(int32_t), num_bytes); // Internally, a circular buffer would now look like: // -, -, -, 103, 104, 105, 106, 107, 200, - @@ -982,9 +1050,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // Write five more. num_bytes = 5u * sizeof(int32_t); Seq(300, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); // Internally, a circular buffer would now look like: // 301, 302, 303, 304, 104, 105, 106, 107, 200, 300 @@ -994,7 +1063,9 @@ TEST(LocalDataPipeTest, MayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 104; @@ -1016,9 +1087,10 @@ TEST(LocalDataPipeTest, MayDiscard) { num_bytes = 0u; void* write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_TRUE(write_ptr); EXPECT_EQ(6u * sizeof(int32_t), num_bytes); Seq(400, 6, static_cast<int32_t*>(write_ptr)); @@ -1030,9 +1102,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // mode. num_bytes = 6u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(4u * sizeof(int32_t), num_bytes); static_cast<int32_t*>(write_ptr)[0] = 500; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t))); @@ -1042,17 +1115,19 @@ TEST(LocalDataPipeTest, MayDiscard) { // Requesting a 10-element buffer in all-or-none mode fails at this point. num_bytes = 10u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); // But requesting, say, a 5-element (up to 9, really) buffer should be okay. // It will discard two elements. num_bytes = 5u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); // Only write 4 elements though. Seq(600, 4, static_cast<int32_t*>(write_ptr)); @@ -1064,9 +1139,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // the internal buffer. num_bytes = 5u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); // Only write 3 elements though. Seq(700, 3, static_cast<int32_t*>(write_ptr)); @@ -1079,7 +1155,9 @@ TEST(LocalDataPipeTest, MayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(8u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 500; @@ -1104,8 +1182,9 @@ TEST(LocalDataPipeTest, AllOrNone) { 10 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -1113,9 +1192,10 @@ TEST(LocalDataPipeTest, AllOrNone) { uint32_t num_bytes = 20u * sizeof(int32_t); int32_t buffer[100]; Seq(0, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); // Should still be empty. num_bytes = ~0u; @@ -1125,9 +1205,10 @@ TEST(LocalDataPipeTest, AllOrNone) { // Write some data. num_bytes = 5u * sizeof(int32_t); Seq(100, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); // Half full. @@ -1138,16 +1219,19 @@ TEST(LocalDataPipeTest, AllOrNone) { // Too much. num_bytes = 6u * sizeof(int32_t); Seq(200, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); // Try reading too much. num_bytes = 11u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1160,17 +1244,19 @@ TEST(LocalDataPipeTest, AllOrNone) { // Just a little. num_bytes = 2u * sizeof(int32_t); Seq(300, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(2u * sizeof(int32_t), num_bytes); // Just right. num_bytes = 3u * sizeof(int32_t); Seq(400, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(3u * sizeof(int32_t), num_bytes); // Exactly full. @@ -1183,7 +1269,9 @@ TEST(LocalDataPipeTest, AllOrNone) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); Seq(100, 5, expected_buffer); @@ -1194,7 +1282,9 @@ TEST(LocalDataPipeTest, AllOrNone) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1222,7 +1312,9 @@ TEST(LocalDataPipeTest, AllOrNone) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1236,7 +1328,9 @@ TEST(LocalDataPipeTest, AllOrNone) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(2u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); Seq(400, 2, expected_buffer); @@ -1264,8 +1358,9 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { 10 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -1273,24 +1368,27 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { uint32_t num_bytes = 20u * sizeof(int32_t); int32_t buffer[100]; Seq(0, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); // Write some stuff. num_bytes = 5u * sizeof(int32_t); Seq(100, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); // Write lots of stuff (discarding all but "104"). num_bytes = 9u * sizeof(int32_t); Seq(200, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(9u * sizeof(int32_t), num_bytes); // Read one. @@ -1298,7 +1396,9 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); EXPECT_EQ(1u * sizeof(int32_t), num_bytes); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); @@ -1310,7 +1410,9 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1332,9 +1434,10 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { // Write as much as possible. num_bytes = 10u * sizeof(int32_t); Seq(300, arraysize(buffer), buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); // Read everything. @@ -1342,7 +1445,9 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true, false)); + MakeUserPointer(&num_bytes), + true, + false)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); Seq(300, 10, expected_buffer); @@ -1363,40 +1468,44 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { 10 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); // Try writing way too much (two-phase). uint32_t num_bytes = 20u * sizeof(int32_t); void* write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); // Try writing an amount which isn't a multiple of the element size // (two-phase). static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1"); num_bytes = 1u; write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); // Try reading way too much (two-phase). num_bytes = 20u * sizeof(int32_t); const void* read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); // Write half (two-phase). num_bytes = 5u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); // May provide more space than requested. EXPECT_GE(num_bytes, 5u * sizeof(int32_t)); EXPECT_TRUE(write_ptr); @@ -1408,15 +1517,15 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 1u; read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); // Read one (two-phase). num_bytes = 1u * sizeof(int32_t); read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); EXPECT_GE(num_bytes, 1u * sizeof(int32_t)); EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(1u * sizeof(int32_t))); @@ -1430,17 +1539,19 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { // two-phase write of six now. num_bytes = 6u * sizeof(int32_t); write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true)); // Write six elements (simple), filling the buffer. num_bytes = 6u * sizeof(int32_t); int32_t buffer[100]; Seq(100, 6, buffer); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerWriteData(UserPointer<const void>(buffer), - MakeUserPointer(&num_bytes), true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerWriteData( + UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(6u * sizeof(int32_t), num_bytes); // We have ten. @@ -1452,8 +1563,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 10u * sizeof(int32_t); read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); // Close the producer. dp->ProducerClose(); @@ -1462,8 +1573,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 9u * sizeof(int32_t); read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); EXPECT_GE(num_bytes, 9u * sizeof(int32_t)); EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]); EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]); @@ -1480,8 +1591,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 2u * sizeof(int32_t); read_ptr = nullptr; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true)); dp->ConsumerClose(); } @@ -1502,8 +1613,9 @@ TEST(LocalDataPipeTest, WrapAround) { 100u // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); // This test won't be valid if |ValidateCreateOptions()| decides to give the // pipe more space. ASSERT_EQ(100u, validated_options.capacity_num_bytes); @@ -1514,15 +1626,19 @@ TEST(LocalDataPipeTest, WrapAround) { uint32_t num_bytes = 20u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(&test_data[0]), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(20u, num_bytes); // Read 10 bytes. unsigned char read_buffer[1000] = {0}; num_bytes = 10u; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(read_buffer), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(read_buffer), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(10u, num_bytes); EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u)); @@ -1533,7 +1649,8 @@ TEST(LocalDataPipeTest, WrapAround) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(write_buffer_ptr); EXPECT_EQ(80u, num_bytes); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u)); @@ -1543,7 +1660,8 @@ TEST(LocalDataPipeTest, WrapAround) { num_bytes = 200u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(&test_data[20]), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(90u, num_bytes); // Check that a two-phase read can now only read (at most) 90 bytes. (This @@ -1553,7 +1671,8 @@ TEST(LocalDataPipeTest, WrapAround) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(read_buffer_ptr); EXPECT_EQ(90u, num_bytes); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u)); @@ -1563,9 +1682,12 @@ TEST(LocalDataPipeTest, WrapAround) { num_bytes = static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0])); memset(read_buffer, 0, num_bytes); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(read_buffer), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(read_buffer), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(100u, num_bytes); EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u)); @@ -1586,8 +1708,9 @@ TEST(LocalDataPipeTest, CloseWriteRead) { 1000u // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); // Close producer first, then consumer. { @@ -1597,14 +1720,16 @@ TEST(LocalDataPipeTest, CloseWriteRead) { uint32_t num_bytes = kTestDataSize; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(kTestData), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(kTestDataSize, num_bytes); // Write it again, so we'll have something left over. num_bytes = kTestDataSize; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(kTestData), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(kTestDataSize, num_bytes); // Start two-phase write. @@ -1612,7 +1737,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(write_buffer_ptr); EXPECT_GT(num_bytes, 0u); @@ -1621,7 +1747,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(read_buffer_ptr); EXPECT_EQ(2u * kTestDataSize, num_bytes); @@ -1637,7 +1764,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(read_buffer_ptr); EXPECT_EQ(kTestDataSize, num_bytes); @@ -1653,7 +1781,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { uint32_t num_bytes = kTestDataSize; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(kTestData), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(kTestDataSize, num_bytes); // Start two-phase write. @@ -1661,7 +1790,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(write_buffer_ptr); ASSERT_GT(num_bytes, kTestDataSize); @@ -1670,7 +1800,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(read_buffer_ptr); EXPECT_EQ(kTestDataSize, num_bytes); @@ -1688,14 +1819,16 @@ TEST(LocalDataPipeTest, CloseWriteRead) { num_bytes = kTestDataSize; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerWriteData(UserPointer<const void>(kTestData), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // As will trying to start another two-phase write. write_buffer_ptr = nullptr; num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); dp->ProducerClose(); } @@ -1710,7 +1843,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { uint32_t num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_TRUE(write_buffer_ptr); ASSERT_GT(num_bytes, kTestDataSize); @@ -1726,7 +1860,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) { uint32_t num_bytes = kTestDataSize; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(kTestData), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(kTestDataSize, num_bytes); // Close the producer. @@ -1735,33 +1870,43 @@ TEST(LocalDataPipeTest, CloseWriteRead) { // Peek that data. char buffer[1000]; num_bytes = static_cast<uint32_t>(sizeof(buffer)); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, true)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + false, + true)); EXPECT_EQ(kTestDataSize, num_bytes); EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize)); // Read that data. memset(buffer, 0, 1000); num_bytes = static_cast<uint32_t>(sizeof(buffer)); - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData(UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + false, + false)); EXPECT_EQ(kTestDataSize, num_bytes); EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize)); // A second read should fail. num_bytes = static_cast<uint32_t>(sizeof(buffer)); - EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false, false)); + EXPECT_EQ( + MOJO_RESULT_FAILED_PRECONDITION, + dp->ConsumerReadData(UserPointer<void>(buffer), + MakeUserPointer(&num_bytes), + false, + false)); // A two-phase read should also fail. const void* read_buffer_ptr = nullptr; num_bytes = 0u; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // Ditto for discard. num_bytes = 10u; @@ -1780,8 +1925,9 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { 10 * sizeof(int32_t) // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -1802,9 +1948,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // Try ending a two-phase write with an invalid amount (too much). num_bytes = 0u; void* write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(num_bytes + static_cast<uint32_t>(sizeof(int32_t)))); @@ -1821,9 +1968,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // element size). num_bytes = 0u; write_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ProducerBeginWriteData( + MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_GE(num_bytes, 1u); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u)); @@ -1840,7 +1988,8 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { num_bytes = 1u * sizeof(int32_t); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(&element), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // One element available. num_bytes = 0u; @@ -1859,9 +2008,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // Try ending a two-phase read with an invalid amount (too much). num_bytes = 0u; const void* read_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(num_bytes + static_cast<uint32_t>(sizeof(int32_t)))); @@ -1875,9 +2025,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // element size). num_bytes = 0u; read_ptr = nullptr; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(1u * sizeof(int32_t), num_bytes); EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(1u)); @@ -1906,8 +2057,9 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { 2 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {0}; - EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions( - MakeUserPointer(&options), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), + &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); @@ -1916,15 +2068,17 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { uint32_t num_bytes = 2u; EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); EXPECT_EQ(2u, num_bytes); // Begin reading. const void* read_ptr = nullptr; num_bytes = 2u; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(2u, num_bytes); EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]); EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]); @@ -1940,7 +2094,8 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { // this through reveals the significant consequence. EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // Check that our read buffer hasn't changed underneath us. EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]); @@ -1952,14 +2107,16 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { // Now writing should succeed. EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerWriteData(UserPointer<const void>(elements), - MakeUserPointer(&num_bytes), false)); + MakeUserPointer(&num_bytes), + false)); // And if we read, we should get the new values. read_ptr = nullptr; num_bytes = 2u; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerBeginReadData( + MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(2u, num_bytes); EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]); EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]); diff --git a/mojo/edk/system/mapping_table.cc b/mojo/edk/system/mapping_table.cc index 693e8d7..0a28a1d 100644 --- a/mojo/edk/system/mapping_table.cc +++ b/mojo/edk/system/mapping_table.cc @@ -6,7 +6,7 @@ #include "base/logging.h" #include "mojo/edk/embedder/platform_shared_buffer.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" namespace mojo { namespace system { @@ -23,8 +23,7 @@ MojoResult MappingTable::AddMapping( scoped_ptr<embedder::PlatformSharedBufferMapping> mapping) { DCHECK(mapping); - if (address_to_mapping_map_.size() >= - GetConfiguration().max_mapping_table_sze) + if (address_to_mapping_map_.size() >= kMaxMappingTableSize) return MOJO_RESULT_RESOURCE_EXHAUSTED; uintptr_t address = reinterpret_cast<uintptr_t>(mapping->GetBase()); diff --git a/mojo/edk/system/memory.cc b/mojo/edk/system/memory.cc index 0e3d9a9..1d7f792 100644 --- a/mojo/edk/system/memory.cc +++ b/mojo/edk/system/memory.cc @@ -40,20 +40,20 @@ template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<8, 8>(const void*); template <size_t size, size_t alignment> void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount(const void* pointer, size_t count) { + CheckUserPointerWithCount(const void* pointer, size_t count) { CHECK_LE(count, std::numeric_limits<size_t>::max() / size); CHECK(count == 0 || (pointer && IsAligned<alignment>(pointer))); } // Explicitly instantiate the sizes we need. Add instantiations as needed. template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount<1, 1>(const void*, size_t); + CheckUserPointerWithCount<1, 1>(const void*, size_t); template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount<4, 4>(const void*, size_t); + CheckUserPointerWithCount<4, 4>(const void*, size_t); template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount<8, 4>(const void*, size_t); + CheckUserPointerWithCount<8, 4>(const void*, size_t); template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount<8, 8>(const void*, size_t); + CheckUserPointerWithCount<8, 8>(const void*, size_t); template <size_t alignment> void CheckUserPointerWithSize(const void* pointer, size_t size) { @@ -65,9 +65,9 @@ void CheckUserPointerWithSize(const void* pointer, size_t size) { // Explicitly instantiate the sizes we need. Add instantiations as needed. template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithSize<1>(const void*, size_t); + CheckUserPointerWithSize<1>(const void*, size_t); template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithSize<4>(const void*, size_t); + CheckUserPointerWithSize<4>(const void*, size_t); // Whereas the other |Check...()| functions are usually used with integral typs // or arrays of integral types, this one is used with Options structs for which // alignment has been explicitly been specified (using |MOJO_ALIGNAS()|), which @@ -75,13 +75,13 @@ CheckUserPointerWithSize<4>(const void*, size_t); #if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS) template <> void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithSize<8>(const void* pointer, size_t size) { + CheckUserPointerWithSize<8>(const void* pointer, size_t size) { CHECK(size == 0 || (!!pointer && reinterpret_cast<uintptr_t>(pointer) % 8 == 0)); } #else template void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithSize<8>(const void*, size_t); + CheckUserPointerWithSize<8>(const void*, size_t); #endif } // namespace internal diff --git a/mojo/edk/system/memory.h b/mojo/edk/system/memory.h index 96cf219..7b5b724 100644 --- a/mojo/edk/system/memory.h +++ b/mojo/edk/system/memory.h @@ -53,13 +53,13 @@ void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer); // a buffer of |count| elements of the given size and alignment (both in bytes). template <size_t size, size_t alignment> void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithCount(const void* pointer, size_t count); + CheckUserPointerWithCount(const void* pointer, size_t count); // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to // a buffer of the given size and alignment (both in bytes). template <size_t alignment> void MOJO_SYSTEM_IMPL_EXPORT -CheckUserPointerWithSize(const void* pointer, size_t size); + CheckUserPointerWithSize(const void* pointer, size_t size); } // namespace internal diff --git a/mojo/edk/system/message_in_transit.cc b/mojo/edk/system/message_in_transit.cc index 0f2ff5e..95a7d23 100644 --- a/mojo/edk/system/message_in_transit.cc +++ b/mojo/edk/system/message_in_transit.cc @@ -8,7 +8,7 @@ #include "base/compiler_specific.h" #include "base/logging.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/transport_data.h" namespace mojo { @@ -38,13 +38,23 @@ struct MessageInTransit::PrivateStructForCompileAsserts { // The size of |Header| must be a multiple of the alignment. static_assert(sizeof(Header) % kMessageAlignment == 0, "sizeof(MessageInTransit::Header) invalid"); + // Avoid dangerous situations, but making sure that the size of the "header" + + // the size of the data fits into a 31-bit number. + static_assert(static_cast<uint64_t>(sizeof(Header)) + kMaxMessageNumBytes <= + 0x7fffffffULL, + "kMaxMessageNumBytes too big"); + + // We assume (to avoid extra rounding code) that the maximum message (data) + // size is a multiple of the alignment. + static_assert(kMaxMessageNumBytes % kMessageAlignment == 0, + "kMessageAlignment not a multiple of alignment"); }; MessageInTransit::View::View(size_t message_size, const void* buffer) : buffer_(buffer) { size_t next_message_size = 0; - DCHECK(MessageInTransit::GetNextMessageSize(buffer_, message_size, - &next_message_size)); + DCHECK(MessageInTransit::GetNextMessageSize( + buffer_, message_size, &next_message_size)); DCHECK_EQ(message_size, next_message_size); // This should be equivalent. DCHECK_EQ(message_size, total_size()); @@ -52,29 +62,18 @@ MessageInTransit::View::View(size_t message_size, const void* buffer) bool MessageInTransit::View::IsValid(size_t serialized_platform_handle_size, const char** error_message) const { - size_t max_message_num_bytes = GetConfiguration().max_message_num_bytes; - // Avoid dangerous situations, but making sure that the size of the "header" + - // the size of the data fits into a 31-bit number. - DCHECK_LE(static_cast<uint64_t>(sizeof(Header)) + max_message_num_bytes, - 0x7fffffffULL) - << "GetConfiguration().max_message_num_bytes too big"; - - // We assume (to avoid extra rounding code) that the maximum message (data) - // size is a multiple of the alignment. - DCHECK_EQ(max_message_num_bytes % kMessageAlignment, 0U) - << "GetConfiguration().max_message_num_bytes not a multiple of alignment"; - // Note: This also implies a check on the |main_buffer_size()|, which is just // |RoundUpMessageAlignment(sizeof(Header) + num_bytes())|. - if (num_bytes() > max_message_num_bytes) { + if (num_bytes() > kMaxMessageNumBytes) { *error_message = "Message data payload too large"; return false; } if (transport_data_buffer_size() > 0) { - const char* e = TransportData::ValidateBuffer( - serialized_platform_handle_size, transport_data_buffer(), - transport_data_buffer_size()); + const char* e = + TransportData::ValidateBuffer(serialized_platform_handle_size, + transport_data_buffer(), + transport_data_buffer_size()); if (e) { *error_message = e; return false; @@ -94,7 +93,8 @@ MessageInTransit::MessageInTransit(Type type, ConstructorHelper(type, subtype, num_bytes); if (bytes) { memcpy(MessageInTransit::bytes(), bytes, num_bytes); - memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes, 0, + memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes, + 0, main_buffer_size_ - sizeof(Header) - num_bytes); } else { memset(MessageInTransit::bytes(), 0, main_buffer_size_ - sizeof(Header)); @@ -195,7 +195,7 @@ void MessageInTransit::SerializeAndCloseDispatchers(Channel* channel) { void MessageInTransit::ConstructorHelper(Type type, Subtype subtype, uint32_t num_bytes) { - DCHECK_LE(num_bytes, GetConfiguration().max_message_num_bytes); + DCHECK_LE(num_bytes, kMaxMessageNumBytes); // |total_size| is updated below, from the other values. header()->type = type; diff --git a/mojo/edk/system/message_pipe.cc b/mojo/edk/system/message_pipe.cc index ce529ed..e215730 100644 --- a/mojo/edk/system/message_pipe.cc +++ b/mojo/edk/system/message_pipe.cc @@ -100,7 +100,9 @@ MojoResult MessagePipe::WriteMessage( GetPeerPort(port), make_scoped_ptr(new MessageInTransit( MessageInTransit::kTypeMessagePipeEndpoint, - MessageInTransit::kSubtypeMessagePipeEndpointData, num_bytes, bytes)), + MessageInTransit::kSubtypeMessagePipeEndpointData, + num_bytes, + bytes)), transports); } @@ -115,8 +117,8 @@ MojoResult MessagePipe::ReadMessage(unsigned port, base::AutoLock locker(lock_); DCHECK(endpoints_[port]); - return endpoints_[port]->ReadMessage(bytes, num_bytes, dispatchers, - num_dispatchers, flags); + return endpoints_[port]->ReadMessage( + bytes, num_bytes, dispatchers, num_dispatchers, flags); } HandleSignalsState MessagePipe::GetHandleSignalsState(unsigned port) const { @@ -163,8 +165,10 @@ scoped_refptr<ChannelEndpoint> MessagePipe::ConvertLocalToProxy(unsigned port) { // send the already-queued messages. if (!endpoints_[GetPeerPort(port)]) { scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint( - nullptr, 0, static_cast<LocalMessagePipeEndpoint*>( - endpoints_[port].get())->message_queue())); + nullptr, + 0, + static_cast<LocalMessagePipeEndpoint*>(endpoints_[port].get()) + ->message_queue())); endpoints_[port]->Close(); endpoints_[port].reset(); return channel_endpoint; @@ -173,15 +177,18 @@ scoped_refptr<ChannelEndpoint> MessagePipe::ConvertLocalToProxy(unsigned port) { // TODO(vtl): Allowing this case is a temporary hack. It'll set up a // |MessagePipe| with two proxy endpoints, which will then act as a proxy // (rather than trying to connect the two ends directly). - DLOG_IF(WARNING, endpoints_[GetPeerPort(port)]->GetType() != - MessagePipeEndpoint::kTypeLocal) + DLOG_IF(WARNING, + endpoints_[GetPeerPort(port)]->GetType() != + MessagePipeEndpoint::kTypeLocal) << "Direct message pipe passing across multiple channels not yet " "implemented; will proxy"; scoped_ptr<MessagePipeEndpoint> old_endpoint(endpoints_[port].Pass()); scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint( - this, port, static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get()) - ->message_queue())); + this, + port, + static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get()) + ->message_queue())); endpoints_[port].reset(new ProxyMessagePipeEndpoint(channel_endpoint.get())); old_endpoint->Close(); diff --git a/mojo/edk/system/message_pipe_dispatcher.cc b/mojo/edk/system/message_pipe_dispatcher.cc index 826cf26..7db16e8 100644 --- a/mojo/edk/system/message_pipe_dispatcher.cc +++ b/mojo/edk/system/message_pipe_dispatcher.cc @@ -8,7 +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/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/local_message_pipe_endpoint.h" #include "mojo/edk/system/memory.h" #include "mojo/edk/system/message_pipe.h" @@ -173,17 +173,16 @@ MojoResult MessagePipeDispatcher::WriteMessageImplNoLock( uint32_t num_bytes, std::vector<DispatcherTransport>* transports, MojoWriteMessageFlags flags) { - DCHECK(!transports || - (transports->size() > 0 && - transports->size() <= GetConfiguration().max_message_num_handles)); + DCHECK(!transports || (transports->size() > 0 && + transports->size() <= kMaxMessageNumHandles)); lock().AssertAcquired(); - if (num_bytes > GetConfiguration().max_message_num_bytes) + if (num_bytes > kMaxMessageNumBytes) return MOJO_RESULT_RESOURCE_EXHAUSTED; - return message_pipe_->WriteMessage(port_, bytes, num_bytes, transports, - flags); + return message_pipe_->WriteMessage( + port_, bytes, num_bytes, transports, flags); } MojoResult MessagePipeDispatcher::ReadMessageImplNoLock( @@ -193,8 +192,8 @@ MojoResult MessagePipeDispatcher::ReadMessageImplNoLock( uint32_t* num_dispatchers, MojoReadMessageFlags flags) { lock().AssertAcquired(); - return message_pipe_->ReadMessage(port_, bytes, num_bytes, dispatchers, - num_dispatchers, flags); + return message_pipe_->ReadMessage( + port_, bytes, num_bytes, dispatchers, num_dispatchers, flags); } HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock() @@ -209,8 +208,8 @@ MojoResult MessagePipeDispatcher::AddWaiterImplNoLock( uint32_t context, HandleSignalsState* signals_state) { lock().AssertAcquired(); - return message_pipe_->AddWaiter(port_, waiter, signals, context, - signals_state); + return message_pipe_->AddWaiter( + port_, waiter, signals, context, signals_state); } void MessagePipeDispatcher::RemoveWaiterImplNoLock( diff --git a/mojo/edk/system/message_pipe_dispatcher_unittest.cc b/mojo/edk/system/message_pipe_dispatcher_unittest.cc index 8076a99..ae651fa 100644 --- a/mojo/edk/system/message_pipe_dispatcher_unittest.cc +++ b/mojo/edk/system/message_pipe_dispatcher_unittest.cc @@ -68,8 +68,10 @@ TEST(MessagePipeDispatcherTest, Basic) { d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(1u, context); @@ -97,7 +99,9 @@ TEST(MessagePipeDispatcherTest, Basic) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -153,7 +157,8 @@ TEST(MessagePipeDispatcherTest, InvalidParams) { // Huge buffer size. EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, d0->WriteMessage(UserPointer<const void>(buffer), - std::numeric_limits<uint32_t>::max(), nullptr, + std::numeric_limits<uint32_t>::max(), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); @@ -181,21 +186,26 @@ TEST(MessagePipeDispatcherTest, InvalidParamsDeath) { // |WriteMessage|: // Null buffer with nonzero buffer size. - EXPECT_DEATH_IF_SUPPORTED(d0->WriteMessage(NullUserPointer(), 1, nullptr, - MOJO_WRITE_MESSAGE_FLAG_NONE), - kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED( + d0->WriteMessage( + NullUserPointer(), 1, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), + kMemoryCheckFailedRegex); // |ReadMessage|: // Null buffer with nonzero buffer size. // First write something so that we actually have something to read. EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>("x"), 1, nullptr, + d1->WriteMessage(UserPointer<const void>("x"), + 1, + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); uint32_t buffer_size = 1; - EXPECT_DEATH_IF_SUPPORTED( - d0->ReadMessage(NullUserPointer(), MakeUserPointer(&buffer_size), 0, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE), - kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(d0->ReadMessage(NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE), + kMemoryCheckFailedRegex); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); EXPECT_EQ(MOJO_RESULT_OK, d1->Close()); @@ -224,12 +234,16 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { // Write (twice) to |d1|. buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); buffer[0] = 234567890; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Try waiting for readable on |d0|; should fail (already satisfied). w.Init(); @@ -246,7 +260,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, d1->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Close |d1|. @@ -265,7 +281,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -283,7 +301,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(234567890, buffer[0]); @@ -310,14 +330,18 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Try writing to |d0|; should fail (other end closed). buffer[0] = 345678901; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d0->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); } @@ -354,17 +378,24 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { // Wait for readable on |d1|, which will become readable after some time. { - test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d1, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 1, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); // Wake it up by writing to |d0|. buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d0->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); } // Joins the thread. elapsed = stopwatch.Elapsed(); EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); @@ -379,9 +410,14 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { // Now |d1| is already readable. Try waiting for it again. { - test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d1, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 2, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); } // Joins the thread. @@ -398,7 +434,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d1->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -406,9 +444,14 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { // Wait for readable on |d1| and close |d0| after some time, which should // cancel that wait. { - test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d1, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 3, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -440,9 +483,14 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { // Wait for readable on |d1| and close |d1| after some time, which should // cancel that wait. { - test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d1, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 4, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -498,15 +546,18 @@ class WriterThread : public base::SimpleThread { base::RandInt(1, static_cast<int>(kMaxMessageSize))); EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage(UserPointer<const void>(buffer), - bytes_to_write, nullptr, + bytes_to_write, + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); *bytes_written_ += bytes_to_write; } // Write one last "quit" message. - EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage( - UserPointer<const void>("quit"), 4, nullptr, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + write_dispatcher_->WriteMessage(UserPointer<const void>("quit"), + 4, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); } const scoped_refptr<Dispatcher> write_dispatcher_; @@ -561,9 +612,11 @@ class ReaderThread : public base::SimpleThread { // Clear the buffer so that we can check the result. memset(buffer, 0, sizeof(buffer)); uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); - result = read_dispatcher_->ReadMessage( - UserPointer<void>(buffer), MakeUserPointer(&buffer_size), 0, nullptr, - MOJO_READ_MESSAGE_FLAG_NONE); + result = read_dispatcher_->ReadMessage(UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE); EXPECT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_SHOULD_WAIT) << "result: " << result; // We're racing with others to read, so maybe we failed. diff --git a/mojo/edk/system/message_pipe_perftest.cc b/mojo/edk/system/message_pipe_perftest.cc index 9f1ac5d..9861e0b 100644 --- a/mojo/edk/system/message_pipe_perftest.cc +++ b/mojo/edk/system/message_pipe_perftest.cc @@ -47,23 +47,31 @@ class MultiprocessMessagePipePerfTest protected: void WriteWaitThenRead(scoped_refptr<MessagePipe> mp) { - CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(payload_.data()), - static_cast<uint32_t>(payload_.size()), nullptr, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(payload_.data()), + static_cast<uint32_t>(payload_.size()), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); HandleSignalsState hss; CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss), MOJO_RESULT_OK); uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer_.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer_[0]), - MakeUserPointer(&read_buffer_size), nullptr, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE), + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer_[0]), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); CHECK_EQ(read_buffer_size, static_cast<uint32_t>(payload_.size())); } void SendQuitMessage(scoped_refptr<MessagePipe> mp) { - CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(""), 0, nullptr, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(""), + 0, + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); } @@ -73,7 +81,8 @@ class MultiprocessMessagePipePerfTest WriteWaitThenRead(mp); std::string test_name = - base::StringPrintf("IPC_Perf_%dx_%u", message_count_, + base::StringPrintf("IPC_Perf_%dx_%u", + message_count_, static_cast<unsigned>(message_size_)); base::PerfTimeLogger logger(test_name.c_str()); @@ -118,8 +127,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(PingPongClient) { } uint32_t read_size = static_cast<uint32_t>(buffer.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&buffer[0]), - MakeUserPointer(&read_size), nullptr, nullptr, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&buffer[0]), + MakeUserPointer(&read_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); @@ -127,8 +139,10 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(PingPongClient) { if (0 == read_size) break; - CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&buffer[0]), - static_cast<uint32_t>(read_size), nullptr, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(&buffer[0]), + static_cast<uint32_t>(read_size), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); } diff --git a/mojo/edk/system/message_pipe_test_utils.cc b/mojo/edk/system/message_pipe_test_utils.cc index e5df26d..8f217ca 100644 --- a/mojo/edk/system/message_pipe_test_utils.cc +++ b/mojo/edk/system/message_pipe_test_utils.cc @@ -46,8 +46,10 @@ void ChannelThread::Start(embedder::ScopedPlatformHandle platform_handle, test_io_thread_.Start(); test_io_thread_.PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelThread::InitChannelOnIOThread, base::Unretained(this), - base::Passed(&platform_handle), channel_endpoint)); + base::Bind(&ChannelThread::InitChannelOnIOThread, + base::Unretained(this), + base::Passed(&platform_handle), + channel_endpoint)); } void ChannelThread::Stop() { @@ -59,8 +61,9 @@ void ChannelThread::Stop() { base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20)); test_io_thread_.PostTaskAndWait( - FROM_HERE, base::Bind(&ChannelThread::ShutdownChannelOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&ChannelThread::ShutdownChannelOnIOThread, + base::Unretained(this))); } test_io_thread_.Stop(); } diff --git a/mojo/edk/system/message_pipe_unittest.cc b/mojo/edk/system/message_pipe_unittest.cc index 030084b..dbffb4c 100644 --- a/mojo/edk/system/message_pipe_unittest.cc +++ b/mojo/edk/system/message_pipe_unittest.cc @@ -39,8 +39,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123, buffer[0]); @@ -51,16 +54,21 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Write from port 1 (to port 0). buffer[0] = 789012345; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 0. @@ -68,8 +76,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(789012345, buffer[0]); @@ -78,30 +89,41 @@ TEST(MessagePipeTest, Basic) { // Read again from port 0 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Write two messages from port 0 (to port 1). buffer[0] = 123456789; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); buffer[0] = 234567890; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 1 with buffer size 0 (should get the size of next message). // Also test that giving a null buffer is okay when the buffer size is 0. buffer_size = 0; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(1, NullUserPointer(), MakeUserPointer(&buffer_size), - 0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + mp->ReadMessage(1, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); // Read from port 1 with buffer size 1 (too small; should get the size of next @@ -110,8 +132,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = 1; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(123, buffer[0]); @@ -122,8 +147,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -134,8 +162,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(234567890, buffer[0]); @@ -144,16 +175,21 @@ TEST(MessagePipeTest, Basic) { // Read again from port 1 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Write from port 0 (to port 1). buffer[0] = 345678901; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Close port 0. @@ -163,8 +199,10 @@ TEST(MessagePipeTest, Basic) { buffer[0] = 456789012; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 1; should still get message (even though port 0 was closed). @@ -172,8 +210,11 @@ TEST(MessagePipeTest, Basic) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(345678901, buffer[0]); @@ -182,8 +223,11 @@ TEST(MessagePipeTest, Basic) { // Read again from port 1 -- it should be empty (and port 0 is closed). buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); mp->Close(1); @@ -200,15 +244,22 @@ TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) { for (int32_t i = 0; i < 5; i++) { buffer[0] = i; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(1, + UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); } // Port 0 shouldn't be empty. buffer_size = 0; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size), - 0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + mp->ReadMessage(0, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); // Close port 0 first, which should have outstanding (incoming) messages. @@ -227,30 +278,41 @@ TEST(MessagePipeTest, DiscardMode) { buffer[0] = 789012345; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read/discard from port 0 (no buffer); get size. buffer_size = 0; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size), - 0, nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); + mp->ReadMessage(0, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); // Read again from port 0 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); // Write from port 1 (to port 0). buffer[0] = 890123456; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 0 (buffer big enough). @@ -258,8 +320,11 @@ TEST(MessagePipeTest, DiscardMode) { buffer[1] = 456; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(890123456, buffer[0]); @@ -268,52 +333,72 @@ TEST(MessagePipeTest, DiscardMode) { // Read again from port 0 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); // Write from port 1 (to port 0). buffer[0] = 901234567; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read/discard from port 0 (buffer too small); get size. buffer_size = 1; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); // Read again from port 0 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); // Write from port 1 (to port 0). buffer[0] = 123456789; buffer[1] = 0; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(1, UserPointer<const void>(buffer), - static_cast<uint32_t>(sizeof(buffer[0])), nullptr, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Discard from port 0. buffer_size = 1; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(0, NullUserPointer(), NullUserPointer(), 0, nullptr, + mp->ReadMessage(0, + NullUserPointer(), + NullUserPointer(), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); // Read again from port 0 -- it should be empty. buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); mp->Close(0); @@ -339,10 +424,13 @@ TEST(MessagePipeTest, BasicWaiting) { 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)); + EXPECT_EQ( + MOJO_RESULT_ALREADY_EXISTS, + mp->AddWaiter(0, + &waiter, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, + 0, + &hss)); EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); @@ -361,8 +449,11 @@ TEST(MessagePipeTest, BasicWaiting) { // Write from port 0 (to port 1), to make port 1 readable. buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(0, + UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Port 1 should already be readable now. waiter.Init(); @@ -375,10 +466,13 @@ TEST(MessagePipeTest, BasicWaiting) { 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)); + EXPECT_EQ( + MOJO_RESULT_ALREADY_EXISTS, + mp->AddWaiter(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(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, @@ -416,8 +510,11 @@ TEST(MessagePipeTest, BasicWaiting) { buffer[0] = 0; buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, nullptr, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(123456789, buffer[0]); @@ -446,15 +543,18 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, - nullptr)); + mp->AddWaiter( + 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr)); thread.Start(); buffer[0] = 123456789; // Write from port 0 (to port 1), which should wake up the waiter. EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize, - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(0, + UserPointer<const void>(buffer), + kBufferSize, + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); HandleSignalsState hss; mp->RemoveWaiter(1, thread.waiter(), &hss); @@ -477,8 +577,8 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, - nullptr)); + mp->AddWaiter( + 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr)); thread.Start(); // Close port 1 first -- this should result in the waiter being cancelled. @@ -500,8 +600,8 @@ TEST(MessagePipeTest, ThreadedWaiting) { thread.waiter()->Init(); ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, - nullptr)); + mp->AddWaiter( + 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr)); thread.Start(); // Close port 0 first -- this should wake the waiter up, since port 1 will diff --git a/mojo/edk/system/multiprocess_message_pipe_unittest.cc b/mojo/edk/system/multiprocess_message_pipe_unittest.cc index ab2e75c..2f22d67 100644 --- a/mojo/edk/system/multiprocess_message_pipe_unittest.cc +++ b/mojo/edk/system/multiprocess_message_pipe_unittest.cc @@ -72,9 +72,12 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) { std::string read_buffer(1000, '\0'); uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&read_buffer_size), nullptr, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE), + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); VLOG(2) << "Child got: " << read_buffer; @@ -85,9 +88,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) { } std::string write_buffer = read_buffer + read_buffer; - CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()), + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(write_buffer.data()), static_cast<uint32_t>(write_buffer.size()), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); } @@ -105,8 +110,10 @@ TEST_F(MultiprocessMessagePipeTest, Basic) { std::string hello("hello"); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(hello.data()), - static_cast<uint32_t>(hello.size()), nullptr, + mp->WriteMessage(0, + UserPointer<const void>(hello.data()), + static_cast<uint32_t>(hello.size()), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); HandleSignalsState hss; @@ -120,8 +127,11 @@ TEST_F(MultiprocessMessagePipeTest, Basic) { std::string read_buffer(1000, '\0'); uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&read_buffer_size), nullptr, nullptr, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); @@ -147,16 +157,20 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) { for (size_t i = 0; i < kNumMessages; i++) { std::string write_buffer(i, 'A' + (i % 26)); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()), + mp->WriteMessage(0, + UserPointer<const void>(write_buffer.data()), static_cast<uint32_t>(write_buffer.size()), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); } const std::string quitquitquit("quitquitquit"); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(quitquitquit.data()), + mp->WriteMessage(0, + UserPointer<const void>(quitquitquit.data()), static_cast<uint32_t>(quitquitquit.size()), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); for (size_t i = 0; i < kNumMessages; i++) { HandleSignalsState hss; @@ -170,9 +184,12 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) { std::string read_buffer(kNumMessages * 2, '\0'); uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&read_buffer_size), nullptr, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE), + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); @@ -219,9 +236,12 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) { uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); DispatcherVector dispatchers; uint32_t num_dispatchers = 10; // Maximum number to receive. - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&num_bytes), &dispatchers, - &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE), + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + &dispatchers, + &num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(num_bytes); CHECK_EQ(read_buffer, std::string("go 1")); @@ -249,8 +269,10 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) { // And send a message to signal that we've written stuff. const std::string go2("go 2"); - CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&go2[0]), - static_cast<uint32_t>(go2.size()), nullptr, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(&go2[0]), + static_cast<uint32_t>(go2.size()), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); @@ -265,8 +287,11 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) { read_buffer = std::string(100, '\0'); num_bytes = static_cast<uint32_t>(read_buffer.size()); - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&num_bytes), nullptr, nullptr, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(num_bytes); @@ -297,10 +322,12 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { // Make a shared buffer. scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher)); ASSERT_TRUE(dispatcher.get()); // Make a mapping. @@ -320,8 +347,10 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { std::vector<DispatcherTransport> transports; transports.push_back(transport); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(&go1[0]), - static_cast<uint32_t>(go1.size()), &transports, + mp->WriteMessage(0, + UserPointer<const void>(&go1[0]), + static_cast<uint32_t>(go1.size()), + &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); @@ -338,8 +367,11 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { std::string read_buffer(100, '\0'); uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); EXPECT_EQ(MOJO_RESULT_OK, - mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&num_bytes), nullptr, nullptr, + mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); read_buffer.resize(num_bytes); EXPECT_EQ(std::string("go 2"), read_buffer); @@ -356,8 +388,10 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { // And send a message to signal that we've written stuff. const std::string go3("go 3"); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(&go3[0]), - static_cast<uint32_t>(go3.size()), nullptr, + mp->WriteMessage(0, + UserPointer<const void>(&go3[0]), + static_cast<uint32_t>(go3.size()), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait for |mp| to become readable, which should fail. @@ -394,9 +428,12 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) { uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size()); DispatcherVector dispatchers; uint32_t num_dispatchers = 10; // Maximum number to receive. - CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]), - MakeUserPointer(&num_bytes), &dispatchers, - &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE), + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + &dispatchers, + &num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); mp->Close(0); @@ -459,8 +496,10 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) { std::vector<DispatcherTransport> transports; transports.push_back(transport); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(&hello[0]), - static_cast<uint32_t>(hello.size()), &transports, + mp->WriteMessage(0, + UserPointer<const void>(&hello[0]), + static_cast<uint32_t>(hello.size()), + &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); diff --git a/mojo/edk/system/options_validation.h b/mojo/edk/system/options_validation.h index 9724e38..4772508 100644 --- a/mojo/edk/system/options_validation.h +++ b/mojo/edk/system/options_validation.h @@ -18,6 +18,7 @@ #include "base/logging.h" #include "base/macros.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/memory.h" #include "mojo/edk/system/system_impl_export.h" #include "mojo/public/c/system/types.h" diff --git a/mojo/edk/system/raw_channel.cc b/mojo/edk/system/raw_channel.cc index 4331166..0bfe104 100644 --- a/mojo/edk/system/raw_channel.cc +++ b/mojo/edk/system/raw_channel.cc @@ -133,8 +133,9 @@ void RawChannel::WriteBuffer::GetBuffers(std::vector<Buffer>* buffers) const { // attached. // Write from both buffers. - DCHECK_EQ(bytes_to_write, message->main_buffer_size() - data_offset_ + - transport_data_buffer_size); + DCHECK_EQ( + bytes_to_write, + message->main_buffer_size() - data_offset_ + transport_data_buffer_size); Buffer buffer1 = { static_cast<const char*>(message->main_buffer()) + data_offset_, message->main_buffer_size() - data_offset_}; @@ -194,9 +195,11 @@ bool RawChannel::Init(Delegate* delegate) { if (io_result != IO_PENDING) { // This will notify the delegate about the read failure. Although we're on // the I/O thread, don't call it in the nested context. - message_loop_for_io_->PostTask( - FROM_HERE, base::Bind(&RawChannel::OnReadCompleted, - weak_ptr_factory_.GetWeakPtr(), io_result, 0)); + message_loop_for_io_->PostTask(FROM_HERE, + base::Bind(&RawChannel::OnReadCompleted, + weak_ptr_factory_.GetWeakPtr(), + io_result, + 0)); } // ScheduleRead() failure is treated as a read failure (by notifying the @@ -243,15 +246,15 @@ bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) { if (io_result == IO_PENDING) return true; - bool result = OnWriteCompletedNoLock(io_result, platform_handles_written, - bytes_written); + bool result = OnWriteCompletedNoLock( + io_result, platform_handles_written, bytes_written); if (!result) { // Even if we're on the I/O thread, don't call |OnError()| in the nested // context. - message_loop_for_io_->PostTask( - FROM_HERE, - base::Bind(&RawChannel::CallOnError, weak_ptr_factory_.GetWeakPtr(), - Delegate::ERROR_WRITE)); + message_loop_for_io_->PostTask(FROM_HERE, + base::Bind(&RawChannel::CallOnError, + weak_ptr_factory_.GetWeakPtr(), + Delegate::ERROR_WRITE)); } return result; @@ -309,7 +312,8 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) { // TODO(vtl): Validate that |message_size| is sane. while (remaining_bytes > 0 && MessageInTransit::GetNextMessageSize( &read_buffer_->buffer_[read_buffer_start], - remaining_bytes, &message_size) && + remaining_bytes, + &message_size) && remaining_bytes >= message_size) { MessageInTransit::View message_view( message_size, &read_buffer_->buffer_[read_buffer_start]); @@ -337,7 +341,8 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) { size_t num_platform_handles; const void* platform_handle_table; TransportData::GetPlatformHandleTable( - message_view.transport_data_buffer(), &num_platform_handles, + message_view.transport_data_buffer(), + &num_platform_handles, &platform_handle_table); if (num_platform_handles > 0) { @@ -378,7 +383,8 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) { read_buffer_->num_valid_bytes_ = remaining_bytes; if (read_buffer_->num_valid_bytes_ > 0) { memmove(&read_buffer_->buffer_[0], - &read_buffer_->buffer_[read_buffer_start], remaining_bytes); + &read_buffer_->buffer_[read_buffer_start], + remaining_bytes); } read_buffer_start = 0; } @@ -427,8 +433,8 @@ void RawChannel::OnWriteCompleted(IOResult io_result, return; } - did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written, - bytes_written); + did_fail = !OnWriteCompletedNoLock( + io_result, platform_handles_written, bytes_written); } if (did_fail) diff --git a/mojo/edk/system/raw_channel.h b/mojo/edk/system/raw_channel.h index 62e13ff..1a077ef 100644 --- a/mojo/edk/system/raw_channel.h +++ b/mojo/edk/system/raw_channel.h @@ -14,6 +14,7 @@ #include "base/synchronization/lock.h" #include "mojo/edk/embedder/platform_handle_vector.h" #include "mojo/edk/embedder/scoped_platform_handle.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/message_in_transit.h" #include "mojo/edk/system/system_impl_export.h" diff --git a/mojo/edk/system/raw_channel_posix.cc b/mojo/edk/system/raw_channel_posix.cc index 71ec02f..45d93e86 100644 --- a/mojo/edk/system/raw_channel_posix.cc +++ b/mojo/edk/system/raw_channel_posix.cc @@ -135,7 +135,8 @@ void RawChannelPosix::EnqueueMessageNoLock( i += embedder::kPlatformChannelMaxNumHandles) { scoped_ptr<MessageInTransit> fd_message(new MessageInTransit( MessageInTransit::kTypeRawChannel, - MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, 0, + MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, + 0, nullptr)); embedder::ScopedPlatformHandleVectorPtr fds( new embedder::PlatformHandleVector( @@ -252,8 +253,8 @@ RawChannel::IOResult RawChannelPosix::WriteNoLock( DCHECK(!buffers.empty()); if (buffers.size() == 1) { - write_result = embedder::PlatformChannelWrite(fd_.get(), buffers[0].addr, - buffers[0].size); + write_result = embedder::PlatformChannelWrite( + fd_.get(), buffers[0].addr, buffers[0].size); } else { const size_t kMaxBufferCount = 10; iovec iov[kMaxBufferCount]; @@ -301,8 +302,11 @@ RawChannel::IOResult RawChannelPosix::ScheduleWriteNoLock() { } if (message_loop_for_io()->WatchFileDescriptor( - fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE, - write_watcher_.get(), this)) { + fd_.get().fd, + false, + base::MessageLoopForIO::WATCH_WRITE, + write_watcher_.get(), + this)) { pending_write_ = true; return IO_PENDING; } @@ -319,8 +323,11 @@ bool RawChannelPosix::OnInit() { write_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher()); if (!message_loop_for_io()->WatchFileDescriptor( - fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ, - read_watcher_.get(), this)) { + fd_.get().fd, + true, + base::MessageLoopForIO::WATCH_READ, + read_watcher_.get(), + this)) { // TODO(vtl): I'm not sure |WatchFileDescriptor()| actually fails cleanly // (in the sense of returning the message loop's state to what it was before // it was called). @@ -414,7 +421,7 @@ RawChannel::IOResult RawChannelPosix::ReadImpl(size_t* bytes_read) { // then received the message data plus the first set of handles for the next // message in the subsequent |recvmsg()|.) if (read_platform_handles_.size() > - (TransportData::GetMaxPlatformHandles() + + (TransportData::kMaxPlatformHandles + embedder::kPlatformChannelMaxNumHandles)) { LOG(ERROR) << "Received too many platform handles"; embedder::CloseAllPlatformHandles(&read_platform_handles_); @@ -448,8 +455,11 @@ void RawChannelPosix::WaitToWrite() { DCHECK(write_watcher_); if (!message_loop_for_io()->WatchFileDescriptor( - fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE, - write_watcher_.get(), this)) { + fd_.get().fd, + false, + base::MessageLoopForIO::WATCH_WRITE, + write_watcher_.get(), + this)) { { base::AutoLock locker(write_lock()); diff --git a/mojo/edk/system/raw_channel_unittest.cc b/mojo/edk/system/raw_channel_unittest.cc index 7717f49..9ee937d 100644 --- a/mojo/edk/system/raw_channel_unittest.cc +++ b/mojo/edk/system/raw_channel_unittest.cc @@ -41,7 +41,8 @@ scoped_ptr<MessageInTransit> MakeTestMessage(uint32_t num_bytes) { return make_scoped_ptr( new MessageInTransit(MessageInTransit::kTypeMessagePipeEndpoint, MessageInTransit::kSubtypeMessagePipeEndpointData, - num_bytes, bytes.empty() ? nullptr : &bytes[0])); + num_bytes, + bytes.empty() ? nullptr : &bytes[0])); } bool CheckMessageData(const void* bytes, uint32_t num_bytes) { @@ -62,8 +63,8 @@ bool WriteTestMessageToHandle(const embedder::PlatformHandle& handle, scoped_ptr<MessageInTransit> message(MakeTestMessage(num_bytes)); size_t write_size = 0; - mojo::test::BlockingWrite(handle, message->main_buffer(), - message->main_buffer_size(), &write_size); + mojo::test::BlockingWrite( + handle, message->main_buffer(), message->main_buffer_size(), &write_size); return write_size == message->main_buffer_size(); } @@ -134,8 +135,8 @@ class TestMessageReaderAndChecker { for (size_t i = 0; i < kMessageReaderMaxPollIterations;) { size_t read_size = 0; - CHECK(mojo::test::NonBlockingRead(handle_, buffer, sizeof(buffer), - &read_size)); + CHECK(mojo::test::NonBlockingRead( + handle_, buffer, sizeof(buffer), &read_size)); // Append newly-read data to |bytes_|. bytes_.insert(bytes_.end(), buffer, buffer + read_size); @@ -143,7 +144,8 @@ class TestMessageReaderAndChecker { // If we have the header.... size_t message_size; if (MessageInTransit::GetNextMessageSize( - bytes_.empty() ? nullptr : &bytes_[0], bytes_.size(), + bytes_.empty() ? nullptr : &bytes_[0], + bytes_.size(), &message_size)) { // If we've read the whole message.... if (bytes_.size() >= message_size) { @@ -376,14 +378,16 @@ TEST_F(RawChannelTest, WriteMessageAndOnReadMessage) { WriteOnlyRawChannelDelegate writer_delegate; scoped_ptr<RawChannel> writer_rc(RawChannel::Create(handles[0].Pass())); io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, writer_rc.get(), + base::Bind(&InitOnIOThread, + writer_rc.get(), base::Unretained(&writer_delegate))); ReadCountdownRawChannelDelegate reader_delegate(kNumWriterThreads * kNumWriteMessagesPerThread); scoped_ptr<RawChannel> reader_rc(RawChannel::Create(handles[1].Pass())); io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, reader_rc.get(), + base::Bind(&InitOnIOThread, + reader_rc.get(), base::Unretained(&reader_delegate))); { diff --git a/mojo/edk/system/raw_channel_win.cc b/mojo/edk/system/raw_channel_win.cc index 27b9ccf..98380a9 100644 --- a/mojo/edk/system/raw_channel_win.cc +++ b/mojo/edk/system/raw_channel_win.cc @@ -371,9 +371,11 @@ RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) { size_t bytes_to_read = 0; read_buffer()->GetBuffer(&buffer, &bytes_to_read); - BOOL result = - ReadFile(io_handler_->handle(), buffer, static_cast<DWORD>(bytes_to_read), - nullptr, &io_handler_->read_context()->overlapped); + BOOL result = ReadFile(io_handler_->handle(), + buffer, + static_cast<DWORD>(bytes_to_read), + nullptr, + &io_handler_->read_context()->overlapped); if (!result) { DWORD error = GetLastError(); if (error == ERROR_BROKEN_PIPE) @@ -386,9 +388,11 @@ RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) { if (result && skip_completion_port_on_success_) { DWORD bytes_read_dword = 0; - BOOL get_size_result = GetOverlappedResult( - io_handler_->handle(), &io_handler_->read_context()->overlapped, - &bytes_read_dword, FALSE); + BOOL get_size_result = + GetOverlappedResult(io_handler_->handle(), + &io_handler_->read_context()->overlapped, + &bytes_read_dword, + FALSE); DPCHECK(get_size_result); *bytes_read = bytes_read_dword; return IO_SUCCEEDED; @@ -422,10 +426,12 @@ RawChannel::IOResult RawChannelWin::ScheduleRead() { // |io_handler_| won't go away before the task is run, so it is safe to use // |base::Unretained()|. message_loop_for_io()->PostTask( - FROM_HERE, base::Bind(&RawChannelIOHandler::OnIOCompleted, - base::Unretained(io_handler_), - base::Unretained(io_handler_->read_context()), - static_cast<DWORD>(bytes_read), ERROR_SUCCESS)); + FROM_HERE, + base::Bind(&RawChannelIOHandler::OnIOCompleted, + base::Unretained(io_handler_), + base::Unretained(io_handler_->read_context()), + static_cast<DWORD>(bytes_read), + ERROR_SUCCESS)); return IO_PENDING; } @@ -459,10 +465,11 @@ RawChannel::IOResult RawChannelWin::WriteNoLock( // TODO(yzshen): Handle multi-segment writes more efficiently. DWORD bytes_written_dword = 0; - BOOL result = - WriteFile(io_handler_->handle(), buffers[0].addr, - static_cast<DWORD>(buffers[0].size), &bytes_written_dword, - &io_handler_->write_context_no_lock()->overlapped); + BOOL result = WriteFile(io_handler_->handle(), + buffers[0].addr, + static_cast<DWORD>(buffers[0].size), + &bytes_written_dword, + &io_handler_->write_context_no_lock()->overlapped); if (!result) { DWORD error = GetLastError(); if (error == ERROR_BROKEN_PIPE) @@ -514,7 +521,8 @@ RawChannel::IOResult RawChannelWin::ScheduleWriteNoLock() { base::Bind(&RawChannelIOHandler::OnIOCompleted, base::Unretained(io_handler_), base::Unretained(io_handler_->write_context_no_lock()), - static_cast<DWORD>(bytes_written), ERROR_SUCCESS)); + static_cast<DWORD>(bytes_written), + ERROR_SUCCESS)); return IO_PENDING; } diff --git a/mojo/edk/system/remote_message_pipe_unittest.cc b/mojo/edk/system/remote_message_pipe_unittest.cc index e3a320e..d3a95df 100644 --- a/mojo/edk/system/remote_message_pipe_unittest.cc +++ b/mojo/edk/system/remote_message_pipe_unittest.cc @@ -48,14 +48,16 @@ class RemoteMessagePipeTest : public testing::Test { void SetUp() override { io_thread_.PostTaskAndWait( - FROM_HERE, base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread, + base::Unretained(this))); } void TearDown() override { io_thread_.PostTaskAndWait( - FROM_HERE, base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread, - base::Unretained(this))); + FROM_HERE, + base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread, + base::Unretained(this))); } protected: @@ -67,7 +69,9 @@ class RemoteMessagePipeTest : public testing::Test { io_thread_.PostTaskAndWait( FROM_HERE, base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointsOnIOThread, - base::Unretained(this), ep0, ep1)); + base::Unretained(this), + ep0, + ep1)); } // This bootstraps |ep| on |channels_[channel_index]|. It assumes/requires @@ -78,7 +82,9 @@ class RemoteMessagePipeTest : public testing::Test { io_thread_.PostTask( FROM_HERE, base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointOnIOThread, - base::Unretained(this), channel_index, ep)); + base::Unretained(this), + channel_index, + ep)); } void RestoreInitialState() { @@ -192,10 +198,12 @@ TEST_F(RemoteMessagePipeTest, Basic) { mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); // Write to MP 0, port 0. - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -209,8 +217,11 @@ TEST_F(RemoteMessagePipeTest, Basic) { // Read from MP 1, port 1. EXPECT_EQ(MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -222,10 +233,12 @@ TEST_F(RemoteMessagePipeTest, Basic) { MOJO_RESULT_OK, mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->WriteMessage(1, + UserPointer<const void>(kWorld), + sizeof(kWorld), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(456u, context); @@ -238,8 +251,11 @@ TEST_F(RemoteMessagePipeTest, Basic) { buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - mp0->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kWorld, buffer); @@ -304,8 +320,10 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(&remote_id), - sizeof(remote_id), nullptr, + mp0->WriteMessage(0, + UserPointer<const void>(&remote_id), + sizeof(remote_id), + nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -320,8 +338,11 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { ChannelEndpointId received_id; buffer_size = static_cast<uint32_t>(sizeof(received_id)); EXPECT_EQ(MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(&received_id), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(&received_id), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(received_id), static_cast<size_t>(buffer_size)); EXPECT_EQ(remote_id, received_id); @@ -338,10 +359,12 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { MOJO_RESULT_OK, mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); - EXPECT_EQ( - MOJO_RESULT_OK, - mp2->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp2->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(789u, context); @@ -355,25 +378,37 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { // Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0. buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp0->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp1->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp2->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp2->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); // Read from MP 3, port 1. buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - mp3->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp3->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -385,10 +420,12 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { MOJO_RESULT_OK, mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr)); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kWorld), + sizeof(kWorld), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(123u, context); @@ -402,24 +439,36 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { // Make sure there's nothing on the other ports. buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp0->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp2->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp2->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp3->ReadMessage(0, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp3->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kWorld, buffer); @@ -446,10 +495,12 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) { scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0)); // Write to MP 0, port 0. - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Close MP 0, port 0 before it's even been attached to the channel and run. mp0->Close(0); @@ -482,8 +533,11 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) { // Read from MP 1, port 1. EXPECT_EQ(MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -508,10 +562,12 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0)); // Write to MP 0, port 0. - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); BootstrapChannelEndpointNoWait(0, ep0); @@ -544,8 +600,11 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { // Read from MP 1, port 1. EXPECT_EQ(MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), nullptr, nullptr, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + nullptr, + nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -587,10 +646,12 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -614,11 +675,13 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); DispatcherVector read_dispatchers; uint32_t read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -632,14 +695,16 @@ 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->AddWaiter( + &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr)); // Write to "local_mp", port 1. - EXPECT_EQ( - MOJO_RESULT_OK, - local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + local_mp->WriteMessage(1, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately // here. (We don't crash if I sleep and then close.) @@ -659,21 +724,25 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, dispatcher->ReadMessage(UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), 0, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + MakeUserPointer(&read_buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); // 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->AddWaiter( + 1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); // Write to the dispatcher. - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage( - UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + dispatcher->WriteMessage(UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -689,9 +758,12 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { memset(read_buffer, 0, sizeof(read_buffer)); read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, - local_mp->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), nullptr, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + local_mp->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); @@ -724,20 +796,24 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); // Write to the other end (|local_mp|, port 1), and then close it. - EXPECT_EQ( - MOJO_RESULT_OK, - local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + local_mp->WriteMessage(1, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = local_mp->GetHandleSignalsState(0); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals); // Then the second message.... - EXPECT_EQ( - MOJO_RESULT_OK, - local_mp->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + local_mp->WriteMessage(1, + UserPointer<const void>(kWorld), + sizeof(kWorld), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); hss = local_mp->GetHandleSignalsState(0); EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals); @@ -767,10 +843,12 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -794,11 +872,13 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); DispatcherVector read_dispatchers; uint32_t read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -818,8 +898,10 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, dispatcher->ReadMessage(UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), 0, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + MakeUserPointer(&read_buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); // It should still be readable. @@ -831,8 +913,10 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) { read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, dispatcher->ReadMessage(UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), 0, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + MakeUserPointer(&read_buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kWorld, read_buffer); // Now it should no longer be readable. @@ -866,16 +950,19 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { // We'll try to pass this dispatcher. scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher)); ASSERT_TRUE(dispatcher.get()); // Make a mapping. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer( - 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0)); ASSERT_TRUE(mapping0); ASSERT_TRUE(mapping0->GetBase()); ASSERT_EQ(100u, mapping0->GetLength()); @@ -898,10 +985,12 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -925,11 +1014,13 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); DispatcherVector read_dispatchers; uint32_t read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -942,8 +1033,9 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { // Make another mapping. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer( - 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1)); ASSERT_TRUE(mapping1); ASSERT_TRUE(mapping1->GetBase()); ASSERT_EQ(100u, mapping1->GetLength()); @@ -1018,10 +1110,12 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kWorld), + sizeof(kWorld), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -1045,11 +1139,13 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); DispatcherVector read_dispatchers; uint32_t read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kWorld, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -1156,10 +1252,12 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -1183,11 +1281,13 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); DispatcherVector read_dispatchers; uint32_t read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -1216,10 +1316,12 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { std::vector<DispatcherTransport> transports; transports.push_back(transport); - EXPECT_EQ( - MOJO_RESULT_OK, - mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld), - &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp1->WriteMessage(1, + UserPointer<const void>(kWorld), + sizeof(kWorld), + &transports, + MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); // |dispatcher| should have been closed. This is |DCHECK()|ed when the @@ -1241,11 +1343,13 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { // Read from MP 0, port 0. read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); read_num_dispatchers = 10; // Maximum to get. - EXPECT_EQ( - MOJO_RESULT_OK, - mp0->ReadMessage(0, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), &read_dispatchers, - &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + mp0->ReadMessage(0, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + &read_dispatchers, + &read_num_dispatchers, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kWorld, read_buffer); EXPECT_EQ(1u, read_dispatchers.size()); @@ -1260,14 +1364,16 @@ 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->AddWaiter( + &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); // Write to "local_mp", port 1. - EXPECT_EQ( - MOJO_RESULT_OK, - local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + local_mp->WriteMessage(1, + UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait for the dispatcher to become readable. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -1284,21 +1390,25 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, dispatcher->ReadMessage(UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), 0, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + MakeUserPointer(&read_buffer_size), + 0, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); // 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->AddWaiter( + 1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr)); // Write to the dispatcher. - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage( - UserPointer<const void>(kHello), sizeof(kHello), - nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ(MOJO_RESULT_OK, + dispatcher->WriteMessage(UserPointer<const void>(kHello), + sizeof(kHello), + nullptr, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -1314,9 +1424,12 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) { memset(read_buffer, 0, sizeof(read_buffer)); read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer)); EXPECT_EQ(MOJO_RESULT_OK, - local_mp->ReadMessage(1, UserPointer<void>(read_buffer), - MakeUserPointer(&read_buffer_size), nullptr, - nullptr, MOJO_READ_MESSAGE_FLAG_NONE)); + local_mp->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + nullptr, + nullptr, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); diff --git a/mojo/edk/system/run_all_unittests.cc b/mojo/edk/system/run_all_unittests.cc index 3ea1682..2855e96 100644 --- a/mojo/edk/system/run_all_unittests.cc +++ b/mojo/edk/system/run_all_unittests.cc @@ -15,6 +15,7 @@ int main(int argc, char** argv) { base::TestSuite test_suite(argc, argv); return base::LaunchUnitTests( - argc, argv, + argc, + argv, base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite))); } diff --git a/mojo/edk/system/shared_buffer_dispatcher.cc b/mojo/edk/system/shared_buffer_dispatcher.cc index 38ac390..7e345d9 100644 --- a/mojo/edk/system/shared_buffer_dispatcher.cc +++ b/mojo/edk/system/shared_buffer_dispatcher.cc @@ -10,7 +10,7 @@ #include "base/memory/scoped_ptr.h" #include "mojo/edk/embedder/platform_support.h" #include "mojo/edk/system/channel.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/memory.h" #include "mojo/edk/system/options_validation.h" #include "mojo/public/c/system/macros.h" @@ -69,7 +69,7 @@ MojoResult SharedBufferDispatcher::Create( scoped_refptr<SharedBufferDispatcher>* result) { if (!num_bytes) return MOJO_RESULT_INVALID_ARGUMENT; - if (num_bytes > GetConfiguration().max_shared_memory_num_bytes) + if (num_bytes > kMaxSharedMemoryNumBytes) return MOJO_RESULT_RESOURCE_EXHAUSTED; scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer( @@ -163,8 +163,8 @@ MojoResult SharedBufferDispatcher::ValidateDuplicateOptions( if (!reader.is_valid()) return MOJO_RESULT_INVALID_ARGUMENT; - if (!OPTIONS_STRUCT_HAS_MEMBER(MojoDuplicateBufferHandleOptions, flags, - reader)) + if (!OPTIONS_STRUCT_HAS_MEMBER( + MojoDuplicateBufferHandleOptions, flags, reader)) return MOJO_RESULT_OK; if ((reader.options().flags & ~kKnownFlags)) return MOJO_RESULT_UNIMPLEMENTED; diff --git a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc index 5866089..a80f71d 100644 --- a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc +++ b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc @@ -58,8 +58,9 @@ TEST_F(SharedBufferDispatcherTest, ValidateCreateOptionsValid) { // Default options. { MojoCreateSharedBufferOptions validated_options = {}; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::ValidateCreateOptions( - NullUserPointer(), &validated_options)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::ValidateCreateOptions( + NullUserPointer(), &validated_options)); RevalidateCreateOptions(validated_options); } @@ -114,17 +115,20 @@ TEST_F(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) { scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher)); ASSERT_TRUE(dispatcher.get()); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); // Make a couple of mappings. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer( - 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1)); ASSERT_TRUE(mapping1); ASSERT_TRUE(mapping1->GetBase()); EXPECT_EQ(100u, mapping1->GetLength()); @@ -132,8 +136,9 @@ TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) { static_cast<char*>(mapping1->GetBase())[50] = 'x'; scoped_ptr<embedder::PlatformSharedBufferMapping> mapping2; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer( - 50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher->MapBuffer(50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2)); ASSERT_TRUE(mapping2); ASSERT_TRUE(mapping2->GetBase()); EXPECT_EQ(50u, mapping2->GetLength()); @@ -149,30 +154,35 @@ TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) { TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher1)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher1)); // Map and write something. scoped_ptr<embedder::PlatformSharedBufferMapping> mapping; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->MapBuffer( - 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); static_cast<char*>(mapping->GetBase())[0] = 'x'; mapping.reset(); // Duplicate |dispatcher1| and then close it. scoped_refptr<Dispatcher> dispatcher2; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle( - NullUserPointer(), &dispatcher2)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher1->DuplicateBufferHandle(NullUserPointer(), &dispatcher2)); ASSERT_TRUE(dispatcher2.get()); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close()); // Map |dispatcher2| and read something. - EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->MapBuffer( - 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); + EXPECT_EQ( + MOJO_RESULT_OK, + dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping)); EXPECT_EQ('x', static_cast<char*>(mapping->GetBase())[0]); EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); @@ -180,10 +190,12 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) { TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher1)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher1)); MojoDuplicateBufferHandleOptions options[] = { {sizeof(MojoDuplicateBufferHandleOptions), @@ -191,8 +203,9 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u}}; for (size_t i = 0; i < arraysize(options); i++) { scoped_refptr<Dispatcher> dispatcher2; - EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle( - MakeUserPointer(&options[i]), &dispatcher2)); + EXPECT_EQ(MOJO_RESULT_OK, + dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options[i]), + &dispatcher2)); ASSERT_TRUE(dispatcher2.get()); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType()); EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); @@ -203,10 +216,12 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher1)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher1)); // Invalid |struct_size|. { @@ -236,27 +251,32 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { TEST_F(SharedBufferDispatcherTest, CreateInvalidNumBytes) { // Size too big. scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ( - MOJO_RESULT_RESOURCE_EXHAUSTED, - SharedBufferDispatcher::Create( - platform_support(), SharedBufferDispatcher::kDefaultCreateOptions, - std::numeric_limits<uint64_t>::max(), &dispatcher)); + EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + std::numeric_limits<uint64_t>::max(), + &dispatcher)); EXPECT_FALSE(dispatcher.get()); // Zero size. EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, SharedBufferDispatcher::Create( platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher)); + SharedBufferDispatcher::kDefaultCreateOptions, + 0, + &dispatcher)); EXPECT_FALSE(dispatcher.get()); } TEST_F(SharedBufferDispatcherTest, MapBufferInvalidArguments) { scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create( - platform_support(), - SharedBufferDispatcher::kDefaultCreateOptions, - 100, &dispatcher)); + EXPECT_EQ(MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + platform_support(), + SharedBufferDispatcher::kDefaultCreateOptions, + 100, + &dispatcher)); scoped_ptr<embedder::PlatformSharedBufferMapping> mapping; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, diff --git a/mojo/edk/system/simple_dispatcher_unittest.cc b/mojo/edk/system/simple_dispatcher_unittest.cc index f23ff68..502e34b 100644 --- a/mojo/edk/system/simple_dispatcher_unittest.cc +++ b/mojo/edk/system/simple_dispatcher_unittest.cc @@ -343,9 +343,14 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); { d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE); - test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 1, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); } // Joins the thread. @@ -363,9 +368,14 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); { - test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 2, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -387,9 +397,14 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); { - test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 3, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -409,9 +424,14 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { // Wait for readable and dispatcher gets closed. { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); - test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE, - MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result, - &context, &hss); + test::WaiterThread thread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 4, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -430,9 +450,14 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); { - test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE, - 2 * test::EpsilonTimeout().InMicroseconds(), 5, - &did_wait, &result, &context, &hss); + test::WaiterThread thread(d, + MOJO_HANDLE_SIGNAL_READABLE, + 2 * test::EpsilonTimeout().InMicroseconds(), + 5, + &did_wait, + &result, + &context, + &hss); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); @@ -471,9 +496,14 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); ScopedVector<test::WaiterThread> threads; for (uint32_t i = 0; i < kNumWaiters; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i, - &did_wait[i], &result[i], &context[i], &hss[i])); + threads.push_back(new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -494,15 +524,25 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); ScopedVector<test::WaiterThread> threads; for (uint32_t i = 0; i < kNumWaiters / 2; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i, - &did_wait[i], &result[i], &context[i], &hss[i])); + threads.push_back(new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i, - &did_wait[i], &result[i], &context[i], &hss[i])); + threads.push_back(new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_WRITABLE, + MOJO_DEADLINE_INDEFINITE, + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -531,15 +571,25 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); ScopedVector<test::WaiterThread> threads; for (uint32_t i = 0; i < kNumWaiters / 2; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i, - &did_wait[i], &result[i], &context[i], &hss[i])); + threads.push_back(new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i, - &did_wait[i], &result[i], &context[i], &hss[i])); + threads.push_back(new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_WRITABLE, + MOJO_DEADLINE_INDEFINITE, + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); @@ -569,17 +619,27 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher()); ScopedVector<test::WaiterThread> threads; for (uint32_t i = 0; i < kNumWaiters / 2; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_READABLE, - 3 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i], - &result[i], &context[i], &hss[i])); + threads.push_back( + new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_READABLE, + 3 * test::EpsilonTimeout().InMicroseconds(), + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) { - threads.push_back(new test::WaiterThread( - d, MOJO_HANDLE_SIGNAL_WRITABLE, - 1 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i], - &result[i], &context[i], &hss[i])); + threads.push_back( + new test::WaiterThread(d, + MOJO_HANDLE_SIGNAL_WRITABLE, + 1 * test::EpsilonTimeout().InMicroseconds(), + i, + &did_wait[i], + &result[i], + &context[i], + &hss[i])); threads.back()->Start(); } base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); diff --git a/mojo/edk/system/test_utils.h b/mojo/edk/system/test_utils.h index b8dee66..3ab1907 100644 --- a/mojo/edk/system/test_utils.h +++ b/mojo/edk/system/test_utils.h @@ -5,7 +5,10 @@ #ifndef MOJO_EDK_SYSTEM_TEST_UTILS_H_ #define MOJO_EDK_SYSTEM_TEST_UTILS_H_ +#include <stdint.h> + #include "base/callback_forward.h" +#include "base/compiler_specific.h" #include "base/macros.h" #include "base/memory/ref_counted.h" #include "base/task_runner.h" diff --git a/mojo/edk/system/transport_data.cc b/mojo/edk/system/transport_data.cc index 300b731..774b744 100644 --- a/mojo/edk/system/transport_data.cc +++ b/mojo/edk/system/transport_data.cc @@ -9,7 +9,7 @@ #include "base/compiler_specific.h" #include "base/logging.h" #include "mojo/edk/system/channel.h" -#include "mojo/edk/system/configuration.h" +#include "mojo/edk/system/constants.h" #include "mojo/edk/system/message_in_transit.h" namespace mojo { @@ -32,20 +32,19 @@ STATIC_CONST_MEMBER_DEFINITION const size_t TransportData::kMaxSerializedDispatcherPlatformHandles; // static -size_t TransportData::GetMaxBufferSize() { - // In additional to the header, for each attached (Mojo) handle there'll be a - // handle table entry and serialized dispatcher data. - return sizeof(Header) + - GetConfiguration().max_message_num_handles * - (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) + - GetMaxPlatformHandles() * kMaxSizePerPlatformHandle; -} +const size_t TransportData::kMaxPlatformHandles = + kMaxMessageNumHandles * kMaxSerializedDispatcherPlatformHandles; +// In additional to the header, for each attached (Mojo) handle there'll be a +// handle table entry and serialized dispatcher data. +// Note: This definition must follow the one for |kMaxPlatformHandles|; +// otherwise, we get a static initializer with gcc (but not clang). // static -size_t TransportData::GetMaxPlatformHandles() { - return GetConfiguration().max_message_num_handles * - kMaxSerializedDispatcherPlatformHandles; -} +const size_t TransportData::kMaxBufferSize = + sizeof(Header) + + kMaxMessageNumHandles * + (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) + + kMaxPlatformHandles * kMaxSizePerPlatformHandle; struct TransportData::PrivateStructForCompileAsserts { static_assert(sizeof(Header) % MessageInTransit::kMessageAlignment == 0, @@ -91,11 +90,11 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers, DCHECK_LE(max_size, kMaxSerializedDispatcherSize); estimated_size += MessageInTransit::RoundUpMessageAlignment(max_size); - DCHECK_LE(estimated_size, GetMaxBufferSize()); + DCHECK_LE(estimated_size, kMaxBufferSize); DCHECK_LE(max_platform_handles, kMaxSerializedDispatcherPlatformHandles); estimated_num_platform_handles += max_platform_handles; - DCHECK_LE(estimated_num_platform_handles, GetMaxPlatformHandles()); + DCHECK_LE(estimated_num_platform_handles, kMaxPlatformHandles); #if DCHECK_IS_ON all_max_sizes[i] = max_size; @@ -110,7 +109,7 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers, DCHECK_LE(size_per_platform_handle, kMaxSizePerPlatformHandle); estimated_size += estimated_num_platform_handles * size_per_platform_handle; estimated_size = MessageInTransit::RoundUpMessageAlignment(estimated_size); - DCHECK_LE(estimated_size, GetMaxBufferSize()); + DCHECK_LE(estimated_size, kMaxBufferSize); } buffer_.reset(static_cast<char*>( @@ -149,7 +148,10 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers, void* destination = buffer_.get() + current_offset; size_t actual_size = 0; if (Dispatcher::TransportDataAccess::EndSerializeAndClose( - dispatcher, channel, destination, &actual_size, + dispatcher, + channel, + destination, + &actual_size, platform_handles_.get())) { handle_table[i].type = static_cast<int32_t>(dispatcher->GetType()); handle_table[i].offset = static_cast<uint32_t>(current_offset); @@ -214,7 +216,7 @@ const char* TransportData::ValidateBuffer( // Always make sure that the buffer size is sane; if it's not, someone's // messing with us. - if (buffer_size < sizeof(Header) || buffer_size > GetMaxBufferSize() || + if (buffer_size < sizeof(Header) || buffer_size > kMaxBufferSize || buffer_size % MessageInTransit::kMessageAlignment != 0) return "Invalid message secondary buffer size"; @@ -231,7 +233,7 @@ const char* TransportData::ValidateBuffer( #endif // Sanity-check |num_handles| (before multiplying it against anything). - if (num_handles > GetConfiguration().max_message_num_handles) + if (num_handles > kMaxMessageNumHandles) return "Message handle payload too large"; if (buffer_size < sizeof(Header) + num_handles * sizeof(HandleTableEntry)) diff --git a/mojo/edk/system/transport_data.h b/mojo/edk/system/transport_data.h index d54ad2a..395bc73 100644 --- a/mojo/edk/system/transport_data.h +++ b/mojo/edk/system/transport_data.h @@ -84,10 +84,10 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData { static const size_t kMaxSerializedDispatcherPlatformHandles = 2; // The maximum possible size of a valid transport data buffer. - static size_t GetMaxBufferSize(); + static const size_t kMaxBufferSize; // The maximum total number of platform handles that may be attached. - static size_t GetMaxPlatformHandles(); + static const size_t kMaxPlatformHandles; TransportData(scoped_ptr<DispatcherVector> dispatchers, Channel* channel); diff --git a/mojo/edk/system/waiter_test_utils.cc b/mojo/edk/system/waiter_test_utils.cc index 39cb14e..06a4033 100644 --- a/mojo/edk/system/waiter_test_utils.cc +++ b/mojo/edk/system/waiter_test_utils.cc @@ -55,8 +55,8 @@ WaiterThread::~WaiterThread() { void WaiterThread::Run() { waiter_.Init(); - *result_out_ = dispatcher_->AddWaiter(&waiter_, handle_signals_, context_, - signals_state_out_); + *result_out_ = dispatcher_->AddWaiter( + &waiter_, handle_signals_, context_, signals_state_out_); if (*result_out_ != MOJO_RESULT_OK) return; |