diff options
Diffstat (limited to 'mojo')
58 files changed, 2097 insertions, 1667 deletions
diff --git a/mojo/system/PRESUBMIT.py b/mojo/system/PRESUBMIT.py new file mode 100644 index 0000000..97f67c0 --- /dev/null +++ b/mojo/system/PRESUBMIT.py @@ -0,0 +1,16 @@ +# 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. + +"""Presubmit script for mojo/embedder. + +See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts +for more details about the presubmit API built into depot_tools. +""" + +def CheckChangeOnUpload(input_api, output_api): + results = [] + results += input_api.canned_checks.CheckChangeHasOnlyOneEol(input_api, + output_api) + results += input_api.canned_checks.CheckPatchFormatted(input_api, output_api) + return results diff --git a/mojo/system/channel.cc b/mojo/system/channel.cc index 47d06f2..aeb24c3 100644 --- a/mojo/system/channel.cc +++ b/mojo/system/channel.cc @@ -25,24 +25,18 @@ COMPILE_ASSERT(Channel::kBootstrapEndpointId != STATIC_CONST_MEMBER_DEFINITION const MessageInTransit::EndpointId Channel::kBootstrapEndpointId; -Channel::EndpointInfo::EndpointInfo() - : state(STATE_NORMAL), - port() { +Channel::EndpointInfo::EndpointInfo() : state(STATE_NORMAL), port() { } Channel::EndpointInfo::EndpointInfo(scoped_refptr<MessagePipe> message_pipe, unsigned port) - : state(STATE_NORMAL), - message_pipe(message_pipe), - port(port) { + : state(STATE_NORMAL), message_pipe(message_pipe), port(port) { } Channel::EndpointInfo::~EndpointInfo() { } -Channel::Channel() - : is_running_(false), - next_local_id_(kBootstrapEndpointId) { +Channel::Channel() : is_running_(false), next_local_id_(kBootstrapEndpointId) { } bool Channel::Init(scoped_ptr<RawChannel> raw_channel) { @@ -94,9 +88,9 @@ void Channel::Shutdown() { num_zombies++; } } - DVLOG_IF(2, num_live || num_zombies) - << "Shut down Channel with " << num_live << " live endpoints and " - << num_zombies << " zombies"; + DVLOG_IF(2, num_live || num_zombies) << "Shut down Channel with " << num_live + << " live endpoints and " << num_zombies + << " zombies"; } MessageInTransit::EndpointId Channel::AttachMessagePipeEndpoint( @@ -185,17 +179,19 @@ void Channel::RunRemoteMessagePipeEndpoint( { base::AutoLock locker(lock_); DCHECK(local_id_to_endpoint_info_map_.find(local_id) != - local_id_to_endpoint_info_map_.end()); + local_id_to_endpoint_info_map_.end()); } #endif if (!SendControlMessage( - MessageInTransit::kSubtypeChannelRunMessagePipeEndpoint, - local_id, remote_id)) { + MessageInTransit::kSubtypeChannelRunMessagePipeEndpoint, + local_id, + remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to run remote message pipe endpoint (local ID " "%u, remote ID %u)", - static_cast<unsigned>(local_id), static_cast<unsigned>(remote_id))); + static_cast<unsigned>(local_id), + static_cast<unsigned>(remote_id))); } } @@ -255,12 +251,14 @@ void Channel::DetachMessagePipeEndpoint( return; if (!SendControlMessage( - MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, - local_id, remote_id)) { + MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, + local_id, + remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to remove remote message pipe endpoint (local " "ID %u, remote ID %u)", - static_cast<unsigned>(local_id), static_cast<unsigned>(remote_id))); + static_cast<unsigned>(local_id), + static_cast<unsigned>(remote_id))); } } @@ -285,9 +283,9 @@ void Channel::OnReadMessage( OnReadMessageForChannel(message_view, platform_handles.Pass()); break; default: - HandleRemoteError(base::StringPrintf( - "Received message of invalid type %u", - static_cast<unsigned>(message_view.type()))); + HandleRemoteError( + base::StringPrintf("Received message of invalid type %u", + static_cast<unsigned>(message_view.type()))); break; } } @@ -357,12 +355,11 @@ void Channel::OnReadMessageForDownstream( scoped_ptr<MessageInTransit> message(new MessageInTransit(message_view)); if (message_view.transport_data_buffer_size() > 0) { DCHECK(message_view.transport_data_buffer()); - message->SetDispatchers( - TransportData::DeserializeDispatchers( - message_view.transport_data_buffer(), - message_view.transport_data_buffer_size(), - platform_handles.Pass(), - this)); + message->SetDispatchers(TransportData::DeserializeDispatchers( + message_view.transport_data_buffer(), + message_view.transport_data_buffer_size(), + platform_handles.Pass(), + this)); } MojoResult result = endpoint_info.message_pipe->EnqueueMessage( MessagePipe::GetPeerPort(endpoint_info.port), message.Pass()); @@ -373,7 +370,8 @@ void Channel::OnReadMessageForDownstream( // the message pipe). HandleLocalError(base::StringPrintf( "Failed to enqueue message to local ID %u (result %d)", - static_cast<unsigned>(local_id), static_cast<int>(result))); + static_cast<unsigned>(local_id), + static_cast<int>(result))); return; } } @@ -414,8 +412,7 @@ void Channel::OnReadMessageForChannel( break; case MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck: DVLOG(2) << "Handling channel message to ack remove message pipe (local " - "ID " - << message_view.destination_id() << ", remote ID " + "ID " << message_view.destination_id() << ", remote ID " << message_view.source_id() << ")"; if (!RemoveMessagePipeEndpoint(message_view.destination_id(), message_view.source_id())) { @@ -461,12 +458,14 @@ bool Channel::RemoveMessagePipeEndpoint( } if (!SendControlMessage( - MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck, - local_id, remote_id)) { + MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck, + local_id, + remote_id)) { HandleLocalError(base::StringPrintf( "Failed to send message to remove remote message pipe endpoint ack " "(local ID %u, remote ID %u)", - static_cast<unsigned>(local_id), static_cast<unsigned>(remote_id))); + static_cast<unsigned>(local_id), + static_cast<unsigned>(remote_id))); } endpoint_info.message_pipe->OnRemove(endpoint_info.port); @@ -479,8 +478,8 @@ bool Channel::SendControlMessage(MessageInTransit::Subtype subtype, MessageInTransit::EndpointId remote_id) { DVLOG(2) << "Sending channel control message: subtype " << subtype << ", local ID " << local_id << ", remote ID " << remote_id; - scoped_ptr<MessageInTransit> message(new MessageInTransit( - MessageInTransit::kTypeChannel, subtype, 0, NULL)); + scoped_ptr<MessageInTransit> message( + new MessageInTransit(MessageInTransit::kTypeChannel, subtype, 0, NULL)); message->set_source_id(local_id); message->set_destination_id(remote_id); return WriteMessage(message.Pass()); diff --git a/mojo/system/channel_unittest.cc b/mojo/system/channel_unittest.cc index 70cfe83..e16089e 100644 --- a/mojo/system/channel_unittest.cc +++ b/mojo/system/channel_unittest.cc @@ -21,11 +21,7 @@ namespace mojo { namespace system { namespace { -enum Tristate { - TRISTATE_UNKNOWN = -1, - TRISTATE_FALSE = 0, - TRISTATE_TRUE = 1 -}; +enum Tristate { TRISTATE_UNKNOWN = -1, TRISTATE_FALSE = 0, TRISTATE_TRUE = 1 }; Tristate BoolToTristate(bool b) { return b ? TRISTATE_TRUE : TRISTATE_FALSE; @@ -95,16 +91,14 @@ class ChannelTest : public testing::Test { // ChannelTest.InitShutdown ---------------------------------------------------- TEST_F(ChannelTest, InitShutdown) { - io_thread()->PostTaskAndWait( - FROM_HERE, - base::Bind(&ChannelTest::CreateChannelOnIOThread, - base::Unretained(this))); + io_thread()->PostTaskAndWait(FROM_HERE, + base::Bind(&ChannelTest::CreateChannelOnIOThread, + base::Unretained(this))); ASSERT_TRUE(channel()); io_thread()->PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelTest::InitChannelOnIOThread, - base::Unretained(this))); + base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this))); EXPECT_EQ(TRISTATE_TRUE, init_result()); io_thread()->PostTaskAndWait( @@ -125,9 +119,7 @@ class MockRawChannelOnInitFails : public RawChannel { virtual ~MockRawChannelOnInitFails() {} // |RawChannel| public methods: - virtual size_t GetSerializedPlatformHandleSize() const OVERRIDE { - return 0; - } + virtual size_t GetSerializedPlatformHandleSize() const OVERRIDE { return 0; } private: // |RawChannel| protected methods: @@ -140,7 +132,8 @@ class MockRawChannelOnInitFails : public RawChannel { return IO_FAILED; } virtual embedder::ScopedPlatformHandleVectorPtr GetReadPlatformHandles( - size_t, const void*) OVERRIDE { + size_t, + const void*) OVERRIDE { CHECK(false); return embedder::ScopedPlatformHandleVectorPtr(); } @@ -168,10 +161,9 @@ class MockRawChannelOnInitFails : public RawChannel { }; TEST_F(ChannelTest, InitFails) { - io_thread()->PostTaskAndWait( - FROM_HERE, - base::Bind(&ChannelTest::CreateChannelOnIOThread, - base::Unretained(this))); + io_thread()->PostTaskAndWait(FROM_HERE, + base::Bind(&ChannelTest::CreateChannelOnIOThread, + base::Unretained(this))); ASSERT_TRUE(channel()); ASSERT_TRUE(raw_channel()); @@ -179,8 +171,7 @@ TEST_F(ChannelTest, InitFails) { io_thread()->PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelTest::InitChannelOnIOThread, - base::Unretained(this))); + base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this))); EXPECT_EQ(TRISTATE_FALSE, init_result()); // Should destroy |Channel| with no |Shutdown()| (on not-the-I/O-thread). @@ -191,16 +182,14 @@ TEST_F(ChannelTest, InitFails) { // ChannelTest.CloseBeforeRun -------------------------------------------------- TEST_F(ChannelTest, CloseBeforeRun) { - io_thread()->PostTaskAndWait( - FROM_HERE, - base::Bind(&ChannelTest::CreateChannelOnIOThread, - base::Unretained(this))); + io_thread()->PostTaskAndWait(FROM_HERE, + base::Bind(&ChannelTest::CreateChannelOnIOThread, + base::Unretained(this))); ASSERT_TRUE(channel()); io_thread()->PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelTest::InitChannelOnIOThread, - base::Unretained(this))); + base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this))); EXPECT_EQ(TRISTATE_TRUE, init_result()); scoped_refptr<MessagePipe> mp(new MessagePipe( @@ -233,16 +222,14 @@ TEST_F(ChannelTest, CloseBeforeRun) { // ChannelTest.ShutdownAfterAttachAndRun --------------------------------------- TEST_F(ChannelTest, ShutdownAfterAttach) { - io_thread()->PostTaskAndWait( - FROM_HERE, - base::Bind(&ChannelTest::CreateChannelOnIOThread, - base::Unretained(this))); + io_thread()->PostTaskAndWait(FROM_HERE, + base::Bind(&ChannelTest::CreateChannelOnIOThread, + base::Unretained(this))); ASSERT_TRUE(channel()); io_thread()->PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelTest::InitChannelOnIOThread, - base::Unretained(this))); + base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this))); EXPECT_EQ(TRISTATE_TRUE, init_result()); scoped_refptr<MessagePipe> mp(new MessagePipe( @@ -284,16 +271,14 @@ TEST_F(ChannelTest, ShutdownAfterAttach) { // ChannelTest.WaitAfterAttachRunAndShutdown ----------------------------------- TEST_F(ChannelTest, WaitAfterAttachRunAndShutdown) { - io_thread()->PostTaskAndWait( - FROM_HERE, - base::Bind(&ChannelTest::CreateChannelOnIOThread, - base::Unretained(this))); + io_thread()->PostTaskAndWait(FROM_HERE, + base::Bind(&ChannelTest::CreateChannelOnIOThread, + base::Unretained(this))); ASSERT_TRUE(channel()); io_thread()->PostTaskAndWait( FROM_HERE, - base::Bind(&ChannelTest::InitChannelOnIOThread, - base::Unretained(this))); + base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this))); EXPECT_EQ(TRISTATE_TRUE, init_result()); scoped_refptr<MessagePipe> mp(new MessagePipe( diff --git a/mojo/system/core.cc b/mojo/system/core.cc index 0f006eb..949653f 100644 --- a/mojo/system/core.cc +++ b/mojo/system/core.cc @@ -79,8 +79,7 @@ Core::Core() { Core::~Core() { } -MojoHandle Core::AddDispatcher( - const scoped_refptr<Dispatcher>& dispatcher) { +MojoHandle Core::AddDispatcher(const scoped_refptr<Dispatcher>& dispatcher) { base::AutoLock locker(handle_table_lock_); return handle_table_.AddDispatcher(dispatcher); } @@ -104,8 +103,8 @@ MojoResult Core::Close(MojoHandle handle) { scoped_refptr<Dispatcher> dispatcher; { base::AutoLock locker(handle_table_lock_); - MojoResult result = handle_table_.GetAndRemoveDispatcher(handle, - &dispatcher); + MojoResult result = + handle_table_.GetAndRemoveDispatcher(handle, &dispatcher); if (result != MOJO_RESULT_OK) return result; } @@ -138,10 +137,12 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles, num_handles); uint32_t result_index = static_cast<uint32_t>(-1); MojoResult result = WaitManyInternal(handles_reader.GetPointer(), - signals_reader.GetPointer(), num_handles, - deadline, &result_index); - return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index) : - result; + signals_reader.GetPointer(), + num_handles, + deadline, + &result_index); + return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index) + : result; } MojoResult Core::CreateMessagePipe( @@ -149,8 +150,8 @@ MojoResult Core::CreateMessagePipe( UserPointer<MojoHandle> message_pipe_handle0, UserPointer<MojoHandle> message_pipe_handle1) { MojoCreateMessagePipeOptions validated_options = {}; - MojoResult result = MessagePipeDispatcher::ValidateCreateOptions( - options, &validated_options); + MojoResult result = + MessagePipeDispatcher::ValidateCreateOptions(options, &validated_options); if (result != MOJO_RESULT_OK) return result; @@ -227,15 +228,17 @@ 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; } - MojoResult rv = dispatcher->WriteMessage(bytes, num_bytes, &transports, - flags); + MojoResult rv = + dispatcher->WriteMessage(bytes, num_bytes, &transports, flags); // We need to release the dispatcher locks before we take the handle table // lock. @@ -270,12 +273,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, NULL, &num_handles_value, - flags); + rv = dispatcher->ReadMessage( + bytes, num_bytes, NULL, &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()); @@ -315,8 +318,8 @@ MojoResult Core::CreateDataPipe( UserPointer<MojoHandle> data_pipe_producer_handle, UserPointer<MojoHandle> data_pipe_consumer_handle) { MojoCreateDataPipeOptions validated_options = {}; - MojoResult result = DataPipe::ValidateCreateOptions(options, - &validated_options); + MojoResult result = + DataPipe::ValidateCreateOptions(options, &validated_options); if (result != MOJO_RESULT_OK) return result; @@ -422,15 +425,14 @@ MojoResult Core::CreateSharedBuffer( uint64_t num_bytes, UserPointer<MojoHandle> shared_buffer_handle) { MojoCreateSharedBufferOptions validated_options = {}; - MojoResult result = - SharedBufferDispatcher::ValidateCreateOptions(options, - &validated_options); + MojoResult result = SharedBufferDispatcher::ValidateCreateOptions( + options, &validated_options); if (result != MOJO_RESULT_OK) return result; scoped_refptr<SharedBufferDispatcher> dispatcher; - result = SharedBufferDispatcher::Create(validated_options, num_bytes, - &dispatcher); + result = + SharedBufferDispatcher::Create(validated_options, num_bytes, &dispatcher); if (result != MOJO_RESULT_OK) { DCHECK(!dispatcher); return result; @@ -457,8 +459,8 @@ MojoResult Core::DuplicateBufferHandle( // Don't verify |options| here; that's the dispatcher's job. scoped_refptr<Dispatcher> new_dispatcher; - MojoResult result = dispatcher->DuplicateBufferHandle(options, - &new_dispatcher); + MojoResult result = + dispatcher->DuplicateBufferHandle(options, &new_dispatcher); if (result != MOJO_RESULT_OK) return result; diff --git a/mojo/system/core_test_base.cc b/mojo/system/core_test_base.cc index f0293f7..c27f595 100644 --- a/mojo/system/core_test_base.cc +++ b/mojo/system/core_test_base.cc @@ -24,21 +24,16 @@ namespace { class MockDispatcher : public Dispatcher { public: - explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) - : info_(info) { + explicit MockDispatcher(CoreTestBase::MockHandleInfo* info) : info_(info) { CHECK(info_); info_->IncrementCtorCallCount(); } // |Dispatcher| private methods: - virtual Type GetType() const OVERRIDE { - return kTypeUnknown; - } + virtual Type GetType() const OVERRIDE { return kTypeUnknown; } private: - virtual ~MockDispatcher() { - info_->IncrementDtorCallCount(); - } + virtual ~MockDispatcher() { info_->IncrementDtorCallCount(); } // |Dispatcher| protected methods: virtual void CloseImplNoLock() OVERRIDE { @@ -151,7 +146,7 @@ class MockDispatcher : public Dispatcher { } virtual scoped_refptr<Dispatcher> - CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { + CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { return scoped_refptr<Dispatcher>(new MockDispatcher(info_)); } diff --git a/mojo/system/core_unittest.cc b/mojo/system/core_unittest.cc index d0f3385..2b7b520 100644 --- a/mojo/system/core_unittest.cc +++ b/mojo/system/core_unittest.cc @@ -39,62 +39,73 @@ 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(), + 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()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->EndWriteData(h, 0)); + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndWriteData(h, 0)); 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()); - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - core()->EndReadData(h, 0)); + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0)); EXPECT_EQ(1u, info.GetEndReadDataCallCount()); EXPECT_EQ(0u, info.GetAddWaiterCallCount()); - EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ( + MOJO_RESULT_FAILED_PRECONDITION, + core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(1u, info.GetAddWaiterCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 0)); @@ -105,7 +116,8 @@ TEST_F(CoreTest, Basic) { MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->WaitMany(MakeUserPointer(&h), - MakeUserPointer(&handle_signals), 1, + MakeUserPointer(&handle_signals), + 1, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(4u, info.GetAddWaiterCallCount()); @@ -140,11 +152,12 @@ TEST_F(CoreTest, InvalidArguments) { // |Wait()|: { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE, - MOJO_DEADLINE_INDEFINITE)); - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, + core()->Wait(MOJO_HANDLE_INVALID, + ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE)); } // |WaitMany()|: @@ -154,17 +167,23 @@ TEST_F(CoreTest, InvalidArguments) { ~MOJO_HANDLE_SIGNAL_NONE}; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 0, + MakeUserPointer(signals), + 0, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0, + core()->WaitMany(NullUserPointer(), + MakeUserPointer(signals), + 0, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0, - MOJO_DEADLINE_INDEFINITE)); + core()->WaitMany(MakeUserPointer(handles), + NullUserPointer(), + 0, + MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 1, + MakeUserPointer(signals), + 1, MOJO_DEADLINE_INDEFINITE)); MockHandleInfo info[2]; @@ -172,21 +191,25 @@ TEST_F(CoreTest, InvalidArguments) { EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 1, + MakeUserPointer(signals), + 1, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 2, + MakeUserPointer(signals), + 2, MOJO_DEADLINE_INDEFINITE)); handles[1] = handles[0] + 1; // Invalid handle. EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 2, + MakeUserPointer(signals), + 2, MOJO_DEADLINE_INDEFINITE)); handles[1] = CreateMockHandle(&info[1]); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->WaitMany(MakeUserPointer(handles), - MakeUserPointer(signals), 2, + MakeUserPointer(signals), + 2, MOJO_DEADLINE_INDEFINITE)); EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[0])); @@ -201,8 +224,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; @@ -215,7 +241,9 @@ TEST_F(CoreTest, InvalidArguments) { // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or // not. EXPECT_NE(MOJO_RESULT_OK, - core()->WriteMessage(h, NullUserPointer(), 0, + core()->WriteMessage(h, + NullUserPointer(), + 0, MakeUserPointer(handles), std::numeric_limits<uint32_t>::max(), MOJO_WRITE_MESSAGE_FLAG_NONE)); @@ -223,32 +251,43 @@ TEST_F(CoreTest, InvalidArguments) { // Huge handle count (plausibly big). EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - core()->WriteMessage(h, NullUserPointer(), 0, - MakeUserPointer(handles), - std::numeric_limits<uint32_t>::max() / - sizeof(handles[0]), - MOJO_WRITE_MESSAGE_FLAG_NONE)); + core()->WriteMessage( + 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, + 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, + 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, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(0u, info.GetWriteMessageCallCount()); @@ -258,31 +297,43 @@ 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, + 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, + 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, + 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, + core()->WriteMessage(h, + NullUserPointer(), + 0, + MakeUserPointer(handles), + 2, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(1u, info.GetWriteMessageCallCount()); @@ -298,8 +349,10 @@ TEST_F(CoreTest, InvalidArguments) { // |num_handles|. { EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(), - NullUserPointer(), NullUserPointer(), + core()->ReadMessage(MOJO_HANDLE_INVALID, + NullUserPointer(), + NullUserPointer(), + NullUserPointer(), NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); @@ -309,7 +362,9 @@ TEST_F(CoreTest, InvalidArguments) { // Okay. uint32_t handle_count = 0; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), + core()->ReadMessage(h, + NullUserPointer(), + NullUserPointer(), NullUserPointer(), MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE)); @@ -334,30 +389,32 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID}; MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE, ~MOJO_HANDLE_SIGNAL_NONE}; - EXPECT_DEATH_IF_SUPPORTED( - core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 1, - MOJO_DEADLINE_INDEFINITE), - kMemoryCheckFailedRegex); - EXPECT_DEATH_IF_SUPPORTED( - core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 1, - MOJO_DEADLINE_INDEFINITE), - kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(NullUserPointer(), + MakeUserPointer(signals), + 1, + MOJO_DEADLINE_INDEFINITE), + kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(MakeUserPointer(handles), + NullUserPointer(), + 1, + MOJO_DEADLINE_INDEFINITE), + kMemoryCheckFailedRegex); } // |CreateMessagePipe()|: { 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); } @@ -370,8 +427,12 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { // Null |handles| with nonzero |num_handles|. EXPECT_DEATH_IF_SUPPORTED( - core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), - 1, MOJO_WRITE_MESSAGE_FLAG_NONE), + core()->WriteMessage(h, + NullUserPointer(), + 0, + NullUserPointer(), + 1, + MOJO_WRITE_MESSAGE_FLAG_NONE), kMemoryCheckFailedRegex); EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); @@ -386,7 +447,9 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { uint32_t handle_count = 1; EXPECT_DEATH_IF_SUPPORTED( - core()->ReadMessage(h, NullUserPointer(), NullUserPointer(), + core()->ReadMessage(h, + NullUserPointer(), + NullUserPointer(), NullUserPointer(), MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE), @@ -403,9 +466,10 @@ TEST_F(CoreTest, InvalidArgumentsDeath) { TEST_F(CoreTest, MessagePipe) { MojoHandle h[2]; - 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); @@ -414,17 +478,19 @@ TEST_F(CoreTest, MessagePipe) { // Neither should be readable. MojoHandleSignals signals[2] = {MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE}; - EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, - core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, - 0)); + EXPECT_EQ( + MOJO_RESULT_DEADLINE_EXCEEDED, + core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0)); // 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), + core()->ReadMessage(h[0], + UserPointer<void>(buffer), MakeUserPointer(&buffer_size), - NullUserPointer(), NullUserPointer(), + NullUserPointer(), + NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); // Check that it left its inputs alone. EXPECT_EQ('a', buffer[0]); @@ -439,38 +505,51 @@ TEST_F(CoreTest, MessagePipe) { // Also check that |h[1]| is writable using |WaitMany()|. signals[0] = MOJO_HANDLE_SIGNAL_READABLE; signals[1] = MOJO_HANDLE_SIGNAL_WRITABLE; - EXPECT_EQ(1, core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(1, + core()->WaitMany(MakeUserPointer(h), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE)); // Write to |h[1]|. buffer[0] = 'b'; EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1, - NullUserPointer(), 0, + 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; signals[1] = MOJO_HANDLE_SIGNAL_READABLE; - EXPECT_EQ(0, core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, - MOJO_DEADLINE_INDEFINITE)); + EXPECT_EQ(0, + core()->WaitMany(MakeUserPointer(h), + MakeUserPointer(signals), + 2, + MOJO_DEADLINE_INDEFINITE)); // Read from |h[0]|. // First, get only the size. buffer_size = 0; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - core()->ReadMessage(h[0], NullUserPointer(), + core()->ReadMessage(h[0], + NullUserPointer(), MakeUserPointer(&buffer_size), - NullUserPointer(), NullUserPointer(), + 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), + core()->ReadMessage(h[0], + UserPointer<void>(buffer), MakeUserPointer(&buffer_size), - NullUserPointer(), NullUserPointer(), + NullUserPointer(), + NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ('b', buffer[0]); EXPECT_EQ(1u, buffer_size); @@ -482,8 +561,11 @@ TEST_F(CoreTest, MessagePipe) { // Write to |h[0]|. buffer[0] = 'd'; EXPECT_EQ(MOJO_RESULT_OK, - core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1, - NullUserPointer(), 0, + core()->WriteMessage(h[0], + UserPointer<const void>(buffer), + 1, + NullUserPointer(), + 0, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Close |h[0]|. @@ -499,8 +581,11 @@ TEST_F(CoreTest, MessagePipe) { // 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). @@ -510,8 +595,11 @@ TEST_F(CoreTest, MessagePipe) { // 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, + 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])); @@ -538,16 +626,20 @@ 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)); - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -559,12 +651,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]; @@ -575,15 +673,19 @@ 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)); EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passed[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passed[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -594,17 +696,20 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) { // 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), + core()->WriteMessage(h_passing[0], + UserPointer<const void>(kWorld), kWorldSize, - MakeUserPointer(&h_passed[1]), 1, + MakeUserPointer(&h_passed[1]), + 1, MOJO_WRITE_MESSAGE_FLAG_NONE)); - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -627,15 +732,19 @@ 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)); EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_received, UserPointer<void>(buffer), + core()->ReadMessage(h_received, + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -654,8 +763,8 @@ TEST_F(CoreTest, DataPipe) { MojoHandle ph, ch; // p is for producer and c is for consumer. 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); @@ -664,8 +773,7 @@ TEST_F(CoreTest, DataPipe) { // Producer should be never-readable, but already writable. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(ph, MOJO_HANDLE_SIGNAL_READABLE, 0)); - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0)); + EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0)); // Consumer should be never-writable, and not yet readable. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, @@ -677,21 +785,22 @@ 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. - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0)); + EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0)); // Read one character. elements[0] = -1; elements[1] = -1; num_bytes = 1u; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadData(ch, UserPointer<void>(elements), + core()->ReadData(ch, + UserPointer<void>(elements), MakeUserPointer(&num_bytes), MOJO_READ_DATA_FLAG_NONE)); EXPECT_EQ('A', elements[0]); @@ -701,7 +810,8 @@ TEST_F(CoreTest, DataPipe) { void* write_ptr = NULL; 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. @@ -711,7 +821,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)); @@ -724,29 +835,36 @@ 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 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), - MOJO_READ_DATA_FLAG_DISCARD | - MOJO_READ_DATA_FLAG_ALL_OR_NONE)); + core()->ReadData( + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), + MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); // Discard two characters. num_bytes = 2; EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes), - MOJO_READ_DATA_FLAG_DISCARD | - MOJO_READ_DATA_FLAG_ALL_OR_NONE)); + core()->ReadData( + ch, + NullUserPointer(), + MakeUserPointer(&num_bytes), + MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE)); // Read the remaining two characters, in two-phase mode (all-or-none). const void* read_ptr = NULL; 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. @@ -755,7 +873,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. @@ -799,21 +919,25 @@ 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)); - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -837,14 +961,16 @@ 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)); EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); 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); @@ -852,16 +978,20 @@ 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)); - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -885,14 +1015,16 @@ 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)); EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); 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); @@ -907,28 +1039,36 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { void* write_ptr = NULL; 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), @@ -951,27 +1091,35 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) { const void* read_ptr = NULL; 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; - EXPECT_EQ(MOJO_RESULT_OK, - core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, - 1000000000)); + EXPECT_EQ( + MOJO_RESULT_OK, + core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000)); num_bytes = kBufferSize; num_handles = arraysize(handles); EXPECT_EQ(MOJO_RESULT_OK, - core()->ReadMessage(h_passing[1], UserPointer<void>(buffer), + core()->ReadMessage(h_passing[1], + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), MakeUserPointer(handles), MakeUserPointer(&num_handles), diff --git a/mojo/system/data_pipe.cc b/mojo/system/data_pipe.cc index 78e84f8..d6dcc0c 100644 --- a/mojo/system/data_pipe.cc +++ b/mojo/system/data_pipe.cc @@ -21,11 +21,9 @@ namespace system { // static const MojoCreateDataPipeOptions DataPipe::kDefaultCreateOptions = { - static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)), - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, - 1u, - static_cast<uint32_t>(kDefaultDataPipeCapacityBytes) -}; + static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)), + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, 1u, + static_cast<uint32_t>(kDefaultDataPipeCapacityBytes)}; // static MojoResult DataPipe::ValidateCreateOptions( @@ -50,22 +48,23 @@ 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). - out_options->capacity_num_bytes = std::max( - static_cast<uint32_t>(kDefaultDataPipeCapacityBytes - - (kDefaultDataPipeCapacityBytes % out_options->element_num_bytes)), - out_options->element_num_bytes); + out_options->capacity_num_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) @@ -120,9 +119,8 @@ MojoResult DataPipe::ProducerWriteData(UserPointer<const void> elements, uint32_t min_num_bytes_to_write = all_or_none ? max_num_bytes_to_write : 0; HandleSignalsState old_consumer_state = ConsumerGetHandleSignalsStateNoLock(); - MojoResult rv = ProducerWriteDataImplNoLock(elements, num_bytes, - max_num_bytes_to_write, - min_num_bytes_to_write); + MojoResult rv = ProducerWriteDataImplNoLock( + elements, num_bytes, max_num_bytes_to_write, min_num_bytes_to_write); HandleSignalsState new_consumer_state = ConsumerGetHandleSignalsStateNoLock(); if (!new_consumer_state.equals(old_consumer_state)) AwakeConsumerWaitersForStateChangeNoLock(new_consumer_state); @@ -148,8 +146,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 @@ -258,9 +256,8 @@ MojoResult DataPipe::ConsumerReadData(UserPointer<void> elements, uint32_t min_num_bytes_to_read = all_or_none ? max_num_bytes_to_read : 0; HandleSignalsState old_producer_state = ProducerGetHandleSignalsStateNoLock(); - MojoResult rv = ConsumerReadDataImplNoLock(elements, num_bytes, - max_num_bytes_to_read, - min_num_bytes_to_read); + MojoResult rv = ConsumerReadDataImplNoLock( + elements, num_bytes, max_num_bytes_to_read, min_num_bytes_to_read); HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock(); if (!new_producer_state.equals(old_producer_state)) AwakeProducerWaitersForStateChangeNoLock(new_producer_state); @@ -282,13 +279,12 @@ MojoResult DataPipe::ConsumerDiscardData(UserPointer<uint32_t> num_bytes, if (max_num_bytes_to_discard == 0) return MOJO_RESULT_OK; // Nothing to do. - uint32_t min_num_bytes_to_discard = all_or_none ? max_num_bytes_to_discard : - 0; + uint32_t min_num_bytes_to_discard = + all_or_none ? max_num_bytes_to_discard : 0; HandleSignalsState old_producer_state = ProducerGetHandleSignalsStateNoLock(); - MojoResult rv = ConsumerDiscardDataImplNoLock(num_bytes, - max_num_bytes_to_discard, - min_num_bytes_to_discard); + MojoResult rv = ConsumerDiscardDataImplNoLock( + num_bytes, max_num_bytes_to_discard, min_num_bytes_to_discard); HandleSignalsState new_producer_state = ProducerGetHandleSignalsStateNoLock(); if (!new_producer_state.equals(old_producer_state)) AwakeProducerWaitersForStateChangeNoLock(new_producer_state); @@ -323,8 +319,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()); @@ -387,12 +383,11 @@ bool DataPipe::ConsumerIsBusy() const { return consumer_in_two_phase_read_no_lock(); } - DataPipe::DataPipe(bool has_local_producer, bool has_local_consumer, const MojoCreateDataPipeOptions& validated_options) : may_discard_((validated_options.flags & - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD)), + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD)), element_num_bytes_(validated_options.element_num_bytes), capacity_num_bytes_(validated_options.capacity_num_bytes), producer_open_(true), @@ -402,7 +397,7 @@ DataPipe::DataPipe(bool has_local_producer, producer_two_phase_max_num_bytes_written_(0), consumer_two_phase_max_num_bytes_read_(0) { // Check that the passed in options actually are validated. - MojoCreateDataPipeOptions unused ALLOW_UNUSED = { 0 }; + MojoCreateDataPipeOptions unused ALLOW_UNUSED = {0}; DCHECK_EQ(ValidateCreateOptions(MakeUserPointer(&validated_options), &unused), MOJO_RESULT_OK); } diff --git a/mojo/system/data_pipe.h b/mojo/system/data_pipe.h index 8ead8ba..8ec6413 100644 --- a/mojo/system/data_pipe.h +++ b/mojo/system/data_pipe.h @@ -29,8 +29,8 @@ class WaiterList; // Its subclasses implement the three cases: local producer and consumer, local // producer and remote consumer, and remote producer and local consumer. This // class is thread-safe. -class MOJO_SYSTEM_IMPL_EXPORT DataPipe : - public base::RefCountedThreadSafe<DataPipe> { +class MOJO_SYSTEM_IMPL_EXPORT DataPipe + : public base::RefCountedThreadSafe<DataPipe> { public: // The default options for |MojoCreateDataPipe()|. (Real uses should obtain // this via |ValidateCreateOptions()| with a null |in_options|; this is diff --git a/mojo/system/data_pipe_unittest.cc b/mojo/system/data_pipe_unittest.cc index 373bf76..bbdafe9 100644 --- a/mojo/system/data_pipe_unittest.cc +++ b/mojo/system/data_pipe_unittest.cc @@ -59,9 +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); } @@ -69,7 +69,7 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Size member, but nothing beyond. { MojoCreateDataPipeOptions options = { - offsetof(MojoCreateDataPipeOptions, flags) // |struct_size|. + offsetof(MojoCreateDataPipeOptions, flags) // |struct_size|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -81,18 +81,17 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Different flags. MojoCreateDataPipeOptionsFlags flags_values[] = { - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD - }; + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD}; for (size_t i = 0; i < arraysize(flags_values); i++) { const MojoCreateDataPipeOptionsFlags flags = flags_values[i]; // Flags member, but nothing beyond. { MojoCreateDataPipeOptions options = { - // |struct_size|. - offsetof(MojoCreateDataPipeOptions, element_num_bytes), - flags // |flags|. + // |struct_size|. + offsetof(MojoCreateDataPipeOptions, element_num_bytes), + flags // |flags|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -106,10 +105,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Different capacities (size 1). for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags, // |flags|. - 1, // |element_num_bytes|. - capacity // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + flags, // |flags|. + 1, // |element_num_bytes|. + capacity // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -118,8 +117,7 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { << capacity; RevalidateCreateOptions(validated_options); EXPECT_EQ(options.flags, validated_options.flags); - EXPECT_EQ(options.element_num_bytes, - validated_options.element_num_bytes); + EXPECT_EQ(options.element_num_bytes, validated_options.element_num_bytes); EXPECT_EQ(options.capacity_num_bytes, validated_options.capacity_num_bytes); } @@ -129,10 +127,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Different capacities. for (uint32_t elements = 1; elements <= 1000 * 1000; elements *= 10) { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags, // |flags|. - size, // |element_num_bytes|. - size * elements // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + flags, // |flags|. + size, // |element_num_bytes|. + size * elements // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -150,10 +148,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Default capacity. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags, // |flags|. - size, // |element_num_bytes|. - 0 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + flags, // |flags|. + size, // |element_num_bytes|. + 0 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -170,10 +168,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // No capacity field. { MojoCreateDataPipeOptions options = { - // |struct_size|. - offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), - flags, // |flags|. - size // |element_num_bytes|. + // |struct_size|. + offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), + flags, // |flags|. + size // |element_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -193,10 +191,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Capacity of 1000 elements. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags, // |flags|. - size, // |element_num_bytes|. - 1000 * size // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + flags, // |flags|. + size, // |element_num_bytes|. + 1000 * size // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -214,10 +212,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // Default capacity. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags, // |flags|. - size, // |element_num_bytes|. - 0 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + flags, // |flags|. + size, // |element_num_bytes|. + 0 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -234,10 +232,10 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) { // No capacity field. { MojoCreateDataPipeOptions options = { - // |struct_size|. - offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), - flags, // |flags|. - size // |element_num_bytes|. + // |struct_size|. + offsetof(MojoCreateDataPipeOptions, capacity_num_bytes), + flags, // |flags|. + size // |element_num_bytes|. }; MojoCreateDataPipeOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -258,119 +256,119 @@ TEST(DataPipeTest, ValidateCreateOptionsInvalid) { // Invalid |struct_size|. { MojoCreateDataPipeOptions options = { - 1, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 1, // |element_num_bytes|. - 0 // |capacity_num_bytes|. + 1, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 1, // |element_num_bytes|. + 0 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } // Unknown |flags|. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - ~0u, // |flags|. - 1, // |element_num_bytes|. - 0 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + ~0u, // |flags|. + 1, // |element_num_bytes|. + 0 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } // Invalid |element_num_bytes|. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 0, // |element_num_bytes|. - 1000 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 0, // |element_num_bytes|. + 1000 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } // |element_num_bytes| too big. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - std::numeric_limits<uint32_t>::max(), // |element_num_bytes|. - std::numeric_limits<uint32_t>::max() // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + std::numeric_limits<uint32_t>::max(), // |element_num_bytes|. + std::numeric_limits<uint32_t>::max() // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_RESOURCE_EXHAUSTED, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - std::numeric_limits<uint32_t>::max() - 1000, // |element_num_bytes|. - std::numeric_limits<uint32_t>::max() - 1000 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + std::numeric_limits<uint32_t>::max() - 1000, // |element_num_bytes|. + std::numeric_limits<uint32_t>::max() - 1000 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_RESOURCE_EXHAUSTED, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } // Invalid |capacity_num_bytes|. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 2, // |element_num_bytes|. - 1 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 2, // |element_num_bytes|. + 1 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 2, // |element_num_bytes|. - 111 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 2, // |element_num_bytes|. + 111 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 5, // |element_num_bytes|. - 104 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 5, // |element_num_bytes|. + 104 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } // |capacity_num_bytes| too big. { MojoCreateDataPipeOptions options = { - kSizeOfCreateOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 8, // |element_num_bytes|. - 0xffff0000 // |capacity_num_bytes|. + kSizeOfCreateOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 8, // |element_num_bytes|. + 0xffff0000 // |capacity_num_bytes|. }; MojoCreateDataPipeOptions unused; - EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - DataPipe::ValidateCreateOptions(MakeUserPointer(&options), - &unused)); + EXPECT_EQ( + MOJO_RESULT_RESOURCE_EXHAUSTED, + DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &unused)); } } diff --git a/mojo/system/dispatcher.cc b/mojo/system/dispatcher.cc index bd42929..f310089 100644 --- a/mojo/system/dispatcher.cc +++ b/mojo/system/dispatcher.cc @@ -16,8 +16,7 @@ namespace system { namespace test { // TODO(vtl): Maybe this should be defined in a test-only file instead. -DispatcherTransport DispatcherTryStartTransport( - Dispatcher* dispatcher) { +DispatcherTransport DispatcherTryStartTransport(Dispatcher* dispatcher) { return Dispatcher::HandleTableAccess::TryStartTransport(dispatcher); } @@ -59,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 @@ -84,13 +83,11 @@ scoped_refptr<Dispatcher> Dispatcher::TransportDataAccess::Deserialize( << " not supported"; return scoped_refptr<Dispatcher>(); case kTypeSharedBuffer: - return scoped_refptr<Dispatcher>( - SharedBufferDispatcher::Deserialize(channel, source, size, - platform_handles)); + return scoped_refptr<Dispatcher>(SharedBufferDispatcher::Deserialize( + channel, source, size, platform_handles)); case kTypePlatformHandle: - return scoped_refptr<Dispatcher>( - PlatformHandleDispatcher::Deserialize(channel, source, size, - platform_handles)); + return scoped_refptr<Dispatcher>(PlatformHandleDispatcher::Deserialize( + channel, source, size, platform_handles)); } LOG(WARNING) << "Unknown dispatcher type " << type; return scoped_refptr<Dispatcher>(); @@ -124,7 +121,7 @@ MojoResult Dispatcher::ReadMessage(UserPointer<void> bytes, UserPointer<uint32_t> num_bytes, DispatcherVector* dispatchers, uint32_t* num_dispatchers, - MojoReadMessageFlags flags) { + MojoReadMessageFlags flags) { DCHECK(!num_dispatchers || *num_dispatchers == 0 || (dispatchers && dispatchers->empty())); @@ -132,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, @@ -202,11 +199,10 @@ MojoResult Dispatcher::DuplicateBufferHandle( return DuplicateBufferHandleImplNoLock(options, new_dispatcher); } -MojoResult Dispatcher::MapBuffer( - uint64_t offset, - uint64_t num_bytes, - MojoMapBufferFlags flags, - scoped_ptr<RawSharedBufferMapping>* mapping) { +MojoResult Dispatcher::MapBuffer(uint64_t offset, + uint64_t num_bytes, + MojoMapBufferFlags flags, + scoped_ptr<RawSharedBufferMapping>* mapping) { base::AutoLock locker(lock_); if (is_closed_) return MOJO_RESULT_INVALID_ARGUMENT; @@ -231,8 +227,7 @@ void Dispatcher::RemoveWaiter(Waiter* waiter) { RemoveWaiterImplNoLock(waiter); } -Dispatcher::Dispatcher() - : is_closed_(false) { +Dispatcher::Dispatcher() : is_closed_(false) { } Dispatcher::~Dispatcher() { @@ -330,8 +325,8 @@ MojoResult Dispatcher::EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) { } MojoResult Dispatcher::DuplicateBufferHandleImplNoLock( - UserPointer<const MojoDuplicateBufferHandleOptions> /*options*/, - scoped_refptr<Dispatcher>* /*new_dispatcher*/) { + UserPointer<const MojoDuplicateBufferHandleOptions> /*options*/, + scoped_refptr<Dispatcher>* /*new_dispatcher*/) { lock_.AssertAcquired(); DCHECK(!is_closed_); // By default, not supported. Only needed for buffer dispatchers. @@ -436,10 +431,9 @@ bool Dispatcher::EndSerializeAndClose( DCHECK(!is_closed_); // Like other |...Close()| methods, we mark ourselves as closed before calling - // the impl. + // the impl. But there's no need to cancel waiters: we shouldn't have any (and + // shouldn't be in |Core|'s handle table. is_closed_ = true; - // No need to cancel waiters: we shouldn't have any (and shouldn't be in - // |Core|'s handle table. #if !defined(NDEBUG) // See the comment above |EndSerializeAndCloseImplNoLock()|. In brief: Locking @@ -448,8 +442,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/system/dispatcher.h b/mojo/system/dispatcher.h index 2aee019..8765e72 100644 --- a/mojo/system/dispatcher.h +++ b/mojo/system/dispatcher.h @@ -42,8 +42,8 @@ typedef std::vector<scoped_refptr<Dispatcher> > DispatcherVector; namespace test { // Test helper. We need to declare it here so we can friend it. -MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport DispatcherTryStartTransport( - Dispatcher* dispatcher); +MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport + DispatcherTryStartTransport(Dispatcher* dispatcher); } // namespace test @@ -52,8 +52,8 @@ MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport DispatcherTryStartTransport( // object is thread-safe, with its state being protected by a single lock // |lock_|, which is also made available to implementation subclasses (via the // |lock()| method). -class MOJO_SYSTEM_IMPL_EXPORT Dispatcher : - public base::RefCountedThreadSafe<Dispatcher> { +class MOJO_SYSTEM_IMPL_EXPORT Dispatcher + : public base::RefCountedThreadSafe<Dispatcher> { public: enum Type { kTypeUnknown = 0, diff --git a/mojo/system/dispatcher_unittest.cc b/mojo/system/dispatcher_unittest.cc index 10cf4f5..9e7102b 100644 --- a/mojo/system/dispatcher_unittest.cc +++ b/mojo/system/dispatcher_unittest.cc @@ -23,16 +23,14 @@ class TrivialDispatcher : public Dispatcher { public: TrivialDispatcher() {} - virtual Type GetType() const OVERRIDE { - return kTypeUnknown; - } + virtual Type GetType() const OVERRIDE { return kTypeUnknown; } private: friend class base::RefCountedThreadSafe<TrivialDispatcher>; virtual ~TrivialDispatcher() {} virtual scoped_refptr<Dispatcher> - CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { + CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { lock().AssertAcquired(); return scoped_refptr<Dispatcher>(new TrivialDispatcher()); } @@ -46,27 +44,32 @@ TEST(DispatcherTest, Basic) { EXPECT_EQ(Dispatcher::kTypeUnknown, d->GetType()); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteMessage(NullUserPointer(), 0, NULL, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + d->WriteMessage( + NullUserPointer(), 0, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadMessage(NullUserPointer(), NullUserPointer(), NULL, NULL, + d->ReadMessage(NullUserPointer(), + NullUserPointer(), + NULL, + NULL, 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->EndReadData(0)); + 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->EndReadData(0)); Waiter w; w.Init(); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, @@ -78,27 +81,32 @@ TEST(DispatcherTest, Basic) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->WriteMessage(NullUserPointer(), 0, NULL, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + d->WriteMessage( + NullUserPointer(), 0, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - d->ReadMessage(NullUserPointer(), NullUserPointer(), NULL, NULL, + d->ReadMessage(NullUserPointer(), + NullUserPointer(), + NULL, + NULL, 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->EndReadData(0)); + 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->EndReadData(0)); EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->AddWaiter(&w, ~MOJO_HANDLE_SIGNAL_NONE, 0)); d->RemoveWaiter(&w); @@ -120,7 +128,6 @@ class ThreadSafetyStressThread : public base::SimpleThread { MAP_BUFFER, ADD_WAITER, REMOVE_WAITER, - DISPATCHER_OP_COUNT }; @@ -135,16 +142,14 @@ class ThreadSafetyStressThread : public base::SimpleThread { CHECK_LT(op_, DISPATCHER_OP_COUNT); } - virtual ~ThreadSafetyStressThread() { - Join(); - } + virtual ~ThreadSafetyStressThread() { Join(); } private: virtual void Run() OVERRIDE { event_->Wait(); waiter_.Init(); - switch(op_) { + switch (op_) { case CLOSE: { MojoResult r = dispatcher_->Close(); EXPECT_TRUE(r == MOJO_RESULT_OK || r == MOJO_RESULT_INVALID_ARGUMENT) @@ -152,19 +157,23 @@ class ThreadSafetyStressThread : public base::SimpleThread { break; } case WRITE_MESSAGE: - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->WriteMessage(NullUserPointer(), 0, NULL, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->WriteMessage( + NullUserPointer(), 0, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); break; case READ_MESSAGE: EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->ReadMessage(NullUserPointer(), NullUserPointer(), - NULL, NULL, + dispatcher_->ReadMessage(NullUserPointer(), + NullUserPointer(), + NULL, + NULL, 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: @@ -174,12 +183,12 @@ class ThreadSafetyStressThread : public base::SimpleThread { MOJO_WRITE_DATA_FLAG_NONE)); break; case END_WRITE_DATA: - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->EndWriteData(0)); + 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: @@ -189,26 +198,25 @@ class ThreadSafetyStressThread : public base::SimpleThread { MOJO_READ_DATA_FLAG_NONE)); break; case END_READ_DATA: - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->EndReadData(0)); + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndReadData(0)); break; case DUPLICATE_BUFFER_HANDLE: { scoped_refptr<Dispatcher> unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->DuplicateBufferHandle(NullUserPointer(), - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->DuplicateBufferHandle(NullUserPointer(), &unused)); break; } case MAP_BUFFER: { scoped_ptr<RawSharedBufferMapping> unused; - EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, - dispatcher_->MapBuffer(0u, 0u, MOJO_MAP_BUFFER_FLAG_NONE, - &unused)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dispatcher_->MapBuffer(0u, 0u, MOJO_MAP_BUFFER_FLAG_NONE, &unused)); break; } case ADD_WAITER: { - MojoResult r = dispatcher_->AddWaiter(&waiter_, - ~MOJO_HANDLE_SIGNAL_NONE, 0); + MojoResult r = + dispatcher_->AddWaiter(&waiter_, ~MOJO_HANDLE_SIGNAL_NONE, 0); EXPECT_TRUE(r == MOJO_RESULT_FAILED_PRECONDITION || r == MOJO_RESULT_INVALID_ARGUMENT); break; @@ -248,11 +256,12 @@ TEST(DispatcherTest, ThreadSafetyStress) { for (size_t j = 0; j < kNumThreads; j++) { ThreadSafetyStressThread::DispatcherOp op = static_cast<ThreadSafetyStressThread::DispatcherOp>( - (i+j) % ThreadSafetyStressThread::DISPATCHER_OP_COUNT); + (i + j) % ThreadSafetyStressThread::DISPATCHER_OP_COUNT); threads.push_back(new ThreadSafetyStressThread(&event, d, op)); threads.back()->Start(); } - event.Signal(); // Kicks off real work on the threads. + // Kicks off real work on the threads: + event.Signal(); } // Joins all the threads. // One of the threads should already have closed the dispatcher. @@ -274,11 +283,13 @@ TEST(DispatcherTest, ThreadSafetyStressNoClose) { for (size_t j = 0; j < kNumThreads; j++) { ThreadSafetyStressThread::DispatcherOp op = static_cast<ThreadSafetyStressThread::DispatcherOp>( - (i+j) % (ThreadSafetyStressThread::DISPATCHER_OP_COUNT-1) + 1); + (i + j) % (ThreadSafetyStressThread::DISPATCHER_OP_COUNT - 1) + + 1); threads.push_back(new ThreadSafetyStressThread(&event, d, op)); threads.back()->Start(); } - event.Signal(); // Kicks off real work on the threads. + // Kicks off real work on the threads: + event.Signal(); } // Joins all the threads. EXPECT_EQ(MOJO_RESULT_OK, d->Close()); diff --git a/mojo/system/entrypoints.cc b/mojo/system/entrypoints.cc index 576d6ae..fc4bdc6 100644 --- a/mojo/system/entrypoints.cc +++ b/mojo/system/entrypoints.cc @@ -32,7 +32,6 @@ Core* GetCore() { // Definitions of the system functions. extern "C" { - MojoTimeTicks MojoGetTimeTicksNow() { return g_core->GetTimeTicksNow(); } @@ -174,11 +173,8 @@ MojoResult MojoMapBuffer(MojoHandle buffer_handle, uint64_t num_bytes, void** buffer, MojoMapBufferFlags flags) { - return g_core->MapBuffer(buffer_handle, - offset, - num_bytes, - MakeUserPointer(buffer), - flags); + return g_core->MapBuffer( + buffer_handle, offset, num_bytes, MakeUserPointer(buffer), flags); } MojoResult MojoUnmapBuffer(void* buffer) { diff --git a/mojo/system/handle_table.cc b/mojo/system/handle_table.cc index cc5f2e3..5281655 100644 --- a/mojo/system/handle_table.cc +++ b/mojo/system/handle_table.cc @@ -12,21 +12,18 @@ namespace mojo { namespace system { -HandleTable::Entry::Entry() - : busy(false) { +HandleTable::Entry::Entry() : busy(false) { } HandleTable::Entry::Entry(const scoped_refptr<Dispatcher>& dispatcher) - : dispatcher(dispatcher), - busy(false) { + : dispatcher(dispatcher), busy(false) { } HandleTable::Entry::~Entry() { DCHECK(!busy); } -HandleTable::HandleTable() - : next_handle_(MOJO_HANDLE_INVALID + 1) { +HandleTable::HandleTable() : next_handle_(MOJO_HANDLE_INVALID + 1) { } HandleTable::~HandleTable() { @@ -84,8 +81,8 @@ bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers, // expression in C++03. COMPILE_ASSERT( static_cast<uint64_t>(kMaxHandleTableSize) + kMaxMessageNumHandles < - (sizeof(size_t) == 8 ? kuint64max : - static_cast<uint64_t>(kuint32max)), + (sizeof(size_t) == 8 ? kuint64max + : static_cast<uint64_t>(kuint32max)), addition_may_overflow); if (handle_to_entry_map_.size() + dispatchers.size() > kMaxHandleTableSize) @@ -149,8 +146,7 @@ MojoResult HandleTable::MarkBusyAndStartTransport( // Only log for Debug builds, since this is not a problem with the system // code, but with user code. DLOG(WARNING) << "Likely race condition in user code detected: attempt " - "to transfer handle " - << handles[i] + "to transfer handle " << handles[i] << " while it is in use on a different thread"; // Unset the busy flag (since it won't be unset below). @@ -197,7 +193,7 @@ MojoHandle HandleTable::AddDispatcherNoSizeCheck( // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try // assigning randomly?) while (handle_to_entry_map_.find(next_handle_) != - handle_to_entry_map_.end()) { + handle_to_entry_map_.end()) { next_handle_++; if (next_handle_ == MOJO_HANDLE_INVALID) next_handle_++; diff --git a/mojo/system/local_data_pipe.cc b/mojo/system/local_data_pipe.cc index acab04c..f4ea366 100644 --- a/mojo/system/local_data_pipe.cc +++ b/mojo/system/local_data_pipe.cc @@ -21,9 +21,7 @@ namespace mojo { namespace system { LocalDataPipe::LocalDataPipe(const MojoCreateDataPipeOptions& options) - : DataPipe(true, true, options), - start_index_(0), - current_num_bytes_(0) { + : DataPipe(true, true, options), start_index_(0), current_num_bytes_(0) { // Note: |buffer_| is lazily allocated, since a common case will be that one // of the handles is immediately passed off to another process. } @@ -63,8 +61,8 @@ MojoResult LocalDataPipe::ProducerWriteDataImplNoLock( capacity_num_bytes()); if (num_bytes_to_write > capacity_num_bytes() - current_num_bytes_) { // Discard as much as needed (discard oldest first). - MarkDataAsConsumedNoLock( - num_bytes_to_write - (capacity_num_bytes() - current_num_bytes_)); + MarkDataAsConsumedNoLock(num_bytes_to_write - + (capacity_num_bytes() - current_num_bytes_)); // No need to wake up write waiters, since we're definitely going to leave // the buffer full. } @@ -93,8 +91,8 @@ MojoResult LocalDataPipe::ProducerWriteDataImplNoLock( if (num_bytes_to_write_first < num_bytes_to_write) { // The "second write index" is zero. - elements.At(num_bytes_to_write_first).GetArray( - buffer_.get(), num_bytes_to_write - num_bytes_to_write_first); + elements.At(num_bytes_to_write_first) + .GetArray(buffer_.get(), num_bytes_to_write - num_bytes_to_write_first); } current_num_bytes_ += num_bytes_to_write; @@ -186,15 +184,15 @@ MojoResult LocalDataPipe::ConsumerReadDataImplNoLock( if (min_num_bytes_to_read > current_num_bytes_) { // Don't return "should wait" since you can't wait for a specified amount of // data. - return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE + : MOJO_RESULT_FAILED_PRECONDITION; } size_t num_bytes_to_read = std::min(static_cast<size_t>(max_num_bytes_to_read), current_num_bytes_); if (num_bytes_to_read == 0) { - return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT + : MOJO_RESULT_FAILED_PRECONDITION; } // The amount we can read in our first |memcpy()|. @@ -204,8 +202,8 @@ MojoResult LocalDataPipe::ConsumerReadDataImplNoLock( if (num_bytes_to_read_first < num_bytes_to_read) { // The "second read index" is zero. - elements.At(num_bytes_to_read_first).PutArray( - buffer_.get(), num_bytes_to_read - num_bytes_to_read_first); + elements.At(num_bytes_to_read_first) + .PutArray(buffer_.get(), num_bytes_to_read - num_bytes_to_read_first); } MarkDataAsConsumedNoLock(num_bytes_to_read); @@ -224,19 +222,18 @@ MojoResult LocalDataPipe::ConsumerDiscardDataImplNoLock( if (min_num_bytes_to_discard > current_num_bytes_) { // Don't return "should wait" since you can't wait for a specified amount of // data. - return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE + : MOJO_RESULT_FAILED_PRECONDITION; } // Be consistent with other operations; error if no data available. if (current_num_bytes_ == 0) { - return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT + : MOJO_RESULT_FAILED_PRECONDITION; } - size_t num_bytes_to_discard = - std::min(static_cast<size_t>(max_num_bytes_to_discard), - current_num_bytes_); + size_t num_bytes_to_discard = std::min( + static_cast<size_t>(max_num_bytes_to_discard), current_num_bytes_); MarkDataAsConsumedNoLock(num_bytes_to_discard); num_bytes.Put(static_cast<uint32_t>(num_bytes_to_discard)); return MOJO_RESULT_OK; @@ -257,14 +254,14 @@ MojoResult LocalDataPipe::ConsumerBeginReadDataImplNoLock( if (min_num_bytes_to_read > max_num_bytes_to_read) { // Don't return "should wait" since you can't wait for a specified amount of // data. - return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_OUT_OF_RANGE + : MOJO_RESULT_FAILED_PRECONDITION; } // Don't go into a two-phase read if there's no data. if (max_num_bytes_to_read == 0) { - return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT : - MOJO_RESULT_FAILED_PRECONDITION; + return producer_open_no_lock() ? MOJO_RESULT_SHOULD_WAIT + : MOJO_RESULT_FAILED_PRECONDITION; } buffer.Put(buffer_.get() + start_index_); diff --git a/mojo/system/local_data_pipe.h b/mojo/system/local_data_pipe.h index 189db098..4e3a2c9 100644 --- a/mojo/system/local_data_pipe.h +++ b/mojo/system/local_data_pipe.h @@ -42,8 +42,8 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe { uint32_t min_num_bytes_to_write) OVERRIDE; virtual MojoResult ProducerEndWriteDataImplNoLock( uint32_t num_bytes_written) OVERRIDE; - virtual HandleSignalsState - ProducerGetHandleSignalsStateNoLock() const OVERRIDE; + virtual HandleSignalsState ProducerGetHandleSignalsStateNoLock() + const OVERRIDE; virtual void ConsumerCloseImplNoLock() OVERRIDE; virtual MojoResult ConsumerReadDataImplNoLock( UserPointer<void> elements, @@ -62,8 +62,8 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe { uint32_t min_num_bytes_to_read) OVERRIDE; virtual MojoResult ConsumerEndReadDataImplNoLock( uint32_t num_bytes_read) OVERRIDE; - virtual HandleSignalsState - ConsumerGetHandleSignalsStateNoLock() const OVERRIDE; + virtual HandleSignalsState ConsumerGetHandleSignalsStateNoLock() + const OVERRIDE; void EnsureBufferNoLock(); void DestroyBufferNoLock(); diff --git a/mojo/system/local_data_pipe_unittest.cc b/mojo/system/local_data_pipe_unittest.cc index c55ee76..1a4747c 100644 --- a/mojo/system/local_data_pipe_unittest.cc +++ b/mojo/system/local_data_pipe_unittest.cc @@ -24,10 +24,10 @@ TEST(LocalDataPipeTest, Creation) { // Create using default options. { // Get default options. - MojoCreateDataPipeOptions default_options = { 0 }; - EXPECT_EQ(MOJO_RESULT_OK, - DataPipe::ValidateCreateOptions(NullUserPointer(), - &default_options)); + MojoCreateDataPipeOptions default_options = {0}; + EXPECT_EQ( + MOJO_RESULT_OK, + DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options)); dp->ProducerClose(); dp->ConsumerClose(); @@ -36,12 +36,12 @@ TEST(LocalDataPipeTest, Creation) { // Create using non-default options. { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 1, // |element_num_bytes|. - 1000 // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 1, // |element_num_bytes|. + 1000 // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -51,12 +51,12 @@ TEST(LocalDataPipeTest, Creation) { } { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 4, // |element_num_bytes|. - 4000 // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 4, // |element_num_bytes|. + 4000 // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -66,12 +66,12 @@ TEST(LocalDataPipeTest, Creation) { } { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - 7, // |element_num_bytes|. - 7000000 // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + 7, // |element_num_bytes|. + 7000000 // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -82,12 +82,12 @@ TEST(LocalDataPipeTest, Creation) { // Default capacity. { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - 100, // |element_num_bytes|. - 0 // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + 100, // |element_num_bytes|. + 0 // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -99,26 +99,27 @@ TEST(LocalDataPipeTest, Creation) { TEST(LocalDataPipeTest, SimpleReadWrite) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 1000 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); - int32_t elements[10] = { 0 }; + int32_t elements[10] = {0}; uint32_t num_bytes = 0; // 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)); + EXPECT_EQ( + MOJO_RESULT_SHOULD_WAIT, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), false)); // Query; nothing there yet. num_bytes = 0; @@ -132,9 +133,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), false)); // Write two elements. elements[0] = 123; @@ -142,7 +144,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); @@ -155,9 +158,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(1u * sizeof(elements[0]), num_bytes); EXPECT_EQ(123, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -171,9 +175,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OUT_OF_RANGE, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(-1, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -181,9 +186,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -204,12 +210,12 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // are strict maximums. This is not guaranteed by the API. const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 2 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 2 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -229,11 +235,12 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { dp->ProducerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 34)); // Write two elements. - int32_t elements[2] = { 123, 456 }; + int32_t elements[2] = {123, 456}; 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. @@ -253,9 +260,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(123, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -269,8 +277,8 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { void* buffer = NULL; 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 != NULL); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); @@ -287,18 +295,19 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { // Read one element, using a two-phase read. const void* read_buffer = NULL; 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 != NULL); // 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 // implementation detail! EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(456, static_cast<const int32_t*>(read_buffer)[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])))); // Waiting should succeed. EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context)); @@ -310,7 +319,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. @@ -331,12 +341,12 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) { TEST(LocalDataPipeTest, BasicConsumerWaiting) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 1000 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -359,11 +369,12 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { dp->ConsumerRemoveWaiter(&waiter); // Write two elements. - int32_t elements[2] = { 123, 456 }; + int32_t elements[2] = {123, 456}; 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(); @@ -385,9 +396,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(456, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -403,7 +415,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)); @@ -422,9 +435,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(elements), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); EXPECT_EQ(789, elements[0]); EXPECT_EQ(-1, elements[1]); @@ -450,8 +464,8 @@ 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 != NULL); EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0]))); elements = static_cast<int32_t*>(buffer); @@ -470,9 +484,10 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Request two in all-or-none mode, but only read one. const void* read_buffer = NULL; 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 != NULL); EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes); const int32_t* read_elements = static_cast<const int32_t*>(read_buffer); @@ -490,9 +505,10 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Request three, but not in all-or-none mode. read_buffer = NULL; 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 != NULL); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes); read_elements = static_cast<const int32_t*>(read_buffer); @@ -521,12 +537,12 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) { // Tests that data pipes aren't writable/readable during two-phase writes/reads. TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 1000 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 1000 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -541,9 +557,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); void* write_ptr = NULL; - 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 != NULL); EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); @@ -562,9 +579,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { dp->ConsumerRemoveWaiter(&waiter); 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(); @@ -580,9 +597,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // middle of it. num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); write_ptr = NULL; - 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 != NULL); EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t))); @@ -597,9 +615,10 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // Start a two-phase read. num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t)); const void* read_ptr = NULL; - 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 != NULL); EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes); @@ -630,12 +649,12 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) { // Test that a "may discard" data pipe is writable even when it's full. TEST(LocalDataPipeTest, BasicMayDiscardWaiting) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 1 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 1 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -659,7 +678,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). @@ -677,7 +697,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. @@ -693,9 +714,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(&element), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes); EXPECT_EQ(456, element); @@ -722,36 +744,37 @@ void Seq(int32_t start, size_t count, int32_t* out) { TEST(LocalDataPipeTest, MayDiscard) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 10 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 10 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); - int32_t buffer[100] = { 0 }; + int32_t buffer[100] = {0}; uint32_t num_bytes = 0; num_bytes = 20u * sizeof(int32_t); 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. num_bytes = 5u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); @@ -763,9 +786,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 @@ -774,8 +798,8 @@ TEST(LocalDataPipeTest, MayDiscard) { num_bytes = 5u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 8; @@ -790,9 +814,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, - @@ -800,9 +825,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 @@ -811,8 +837,8 @@ TEST(LocalDataPipeTest, MayDiscard) { num_bytes = sizeof(buffer); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 104; @@ -834,9 +860,10 @@ TEST(LocalDataPipeTest, MayDiscard) { num_bytes = 0u; void* write_ptr = NULL; - 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 != NULL); EXPECT_EQ(6u * sizeof(int32_t), num_bytes); Seq(400, 6, static_cast<int32_t*>(write_ptr)); @@ -848,9 +875,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // mode. num_bytes = 6u * sizeof(int32_t); write_ptr = NULL; - 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))); @@ -860,17 +888,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 = NULL; - 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 = NULL; - 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)); @@ -882,9 +912,10 @@ TEST(LocalDataPipeTest, MayDiscard) { // the internal buffer. num_bytes = 5u * sizeof(int32_t); write_ptr = NULL; - 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)); @@ -896,8 +927,8 @@ TEST(LocalDataPipeTest, MayDiscard) { num_bytes = sizeof(buffer); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), false)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(8u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); expected_buffer[0] = 500; @@ -916,12 +947,12 @@ TEST(LocalDataPipeTest, MayDiscard) { TEST(LocalDataPipeTest, AllOrNone) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 10 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 10 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -932,9 +963,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; @@ -944,9 +976,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. @@ -957,16 +990,17 @@ 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)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -979,17 +1013,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. @@ -1001,8 +1037,8 @@ TEST(LocalDataPipeTest, AllOrNone) { num_bytes = 5u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(5u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); Seq(100, 5, expected_buffer); @@ -1012,8 +1048,8 @@ TEST(LocalDataPipeTest, AllOrNone) { num_bytes = 6u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1040,8 +1076,8 @@ TEST(LocalDataPipeTest, AllOrNone) { num_bytes = 4u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1054,8 +1090,8 @@ TEST(LocalDataPipeTest, AllOrNone) { num_bytes = 2u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(2u * sizeof(int32_t), num_bytes); memset(expected_buffer, 0xab, sizeof(expected_buffer)); Seq(400, 2, expected_buffer); @@ -1077,12 +1113,12 @@ TEST(LocalDataPipeTest, AllOrNone) { TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 10 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 10 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1093,32 +1129,35 @@ 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. num_bytes = 1u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); EXPECT_EQ(1u * sizeof(int32_t), num_bytes); int32_t expected_buffer[100]; memset(expected_buffer, 0xab, sizeof(expected_buffer)); @@ -1129,8 +1168,8 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { num_bytes = 10u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer))); @@ -1152,17 +1191,18 @@ 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. num_bytes = 10u * sizeof(int32_t); memset(buffer, 0xab, sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(buffer), - MakeUserPointer(&num_bytes), true)); + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), true)); memset(expected_buffer, 0xab, sizeof(expected_buffer)); EXPECT_EQ(10u * sizeof(int32_t), num_bytes); Seq(300, 10, expected_buffer); @@ -1177,12 +1217,12 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) { TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 10 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 10 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1192,32 +1232,35 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { // Try writing way too much (two-phase). uint32_t num_bytes = 20u * sizeof(int32_t); void* write_ptr = NULL; - 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). COMPILE_ASSERT(sizeof(int32_t) > 1u, wow_int32_ts_have_size_1); num_bytes = 1u; write_ptr = NULL; - 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 = NULL; 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 = NULL; - 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 != NULL); @@ -1229,15 +1272,15 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 1u; read_ptr = NULL; 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 = NULL; 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))); @@ -1251,17 +1294,19 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { // two-phase write of six now. num_bytes = 6u * sizeof(int32_t); write_ptr = NULL; - 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. @@ -1273,8 +1318,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 10u * sizeof(int32_t); read_ptr = NULL; 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(); @@ -1283,8 +1328,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 9u * sizeof(int32_t); read_ptr = NULL; 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]); @@ -1301,8 +1346,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) { num_bytes = 2u * sizeof(int32_t); read_ptr = NULL; 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(); } @@ -1317,12 +1362,12 @@ TEST(LocalDataPipeTest, WrapAround) { test_data[i] = static_cast<unsigned char>(i); const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 1u, // |element_num_bytes|. - 100u // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 1u, // |element_num_bytes|. + 100u // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1336,15 +1381,17 @@ 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 }; + unsigned char read_buffer[1000] = {0}; num_bytes = 10u; - EXPECT_EQ(MOJO_RESULT_OK, - dp->ConsumerReadData(UserPointer<void>(read_buffer), - MakeUserPointer(&num_bytes), false)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(10u, num_bytes); EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u)); @@ -1355,7 +1402,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 != NULL); EXPECT_EQ(80u, num_bytes); EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u)); @@ -1365,7 +1413,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 @@ -1375,7 +1424,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 != NULL); EXPECT_EQ(90u, num_bytes); EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u)); @@ -1385,9 +1435,10 @@ 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(read_buffer), MakeUserPointer(&num_bytes), false)); EXPECT_EQ(100u, num_bytes); EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u)); @@ -1402,12 +1453,12 @@ TEST(LocalDataPipeTest, CloseWriteRead) { const uint32_t kTestDataSize = static_cast<uint32_t>(sizeof(kTestData)); const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - 1u, // |element_num_bytes|. - 1000u // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + 1u, // |element_num_bytes|. + 1000u // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1420,14 +1471,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. @@ -1435,7 +1488,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 != NULL); EXPECT_GT(num_bytes, 0u); @@ -1444,7 +1498,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 != NULL); EXPECT_EQ(2u * kTestDataSize, num_bytes); @@ -1460,7 +1515,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 != NULL); EXPECT_EQ(kTestDataSize, num_bytes); @@ -1476,7 +1532,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. @@ -1484,7 +1541,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 != NULL); ASSERT_GT(num_bytes, kTestDataSize); @@ -1493,7 +1551,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 != NULL); EXPECT_EQ(kTestDataSize, num_bytes); @@ -1511,14 +1570,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 = NULL; 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(); } @@ -1533,7 +1594,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 != NULL); ASSERT_GT(num_bytes, kTestDataSize); @@ -1549,7 +1611,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. @@ -1558,24 +1621,27 @@ TEST(LocalDataPipeTest, CloseWriteRead) { // Read 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)); + EXPECT_EQ( + MOJO_RESULT_OK, + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), 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)); + EXPECT_EQ( + MOJO_RESULT_FAILED_PRECONDITION, + dp->ConsumerReadData( + UserPointer<void>(buffer), MakeUserPointer(&num_bytes), false)); // A two-phase read should also fail. const void* read_buffer_ptr = NULL; 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; @@ -1588,12 +1654,12 @@ TEST(LocalDataPipeTest, CloseWriteRead) { TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. - static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. - 10 * sizeof(int32_t) // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, // |flags|. + static_cast<uint32_t>(sizeof(int32_t)), // |element_num_bytes|. + 10 * sizeof(int32_t) // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1617,12 +1683,13 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // Try ending a two-phase write with an invalid amount (too much). num_bytes = 0u; void* write_ptr = NULL; - 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)))); + dp->ProducerEndWriteData(num_bytes + + static_cast<uint32_t>(sizeof(int32_t)))); // But the two-phase write still ended. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, dp->ProducerEndWriteData(0u)); @@ -1636,9 +1703,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // element size). num_bytes = 0u; write_ptr = NULL; - 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)); @@ -1655,7 +1723,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; @@ -1674,12 +1743,13 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // Try ending a two-phase read with an invalid amount (too much). num_bytes = 0u; const void* read_ptr = NULL; - 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)))); + dp->ConsumerEndReadData(num_bytes + + static_cast<uint32_t>(sizeof(int32_t)))); // Still one element available. num_bytes = 0u; @@ -1690,9 +1760,10 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // element size). num_bytes = 0u; read_ptr = NULL; - 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)); @@ -1715,12 +1786,12 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) { // |ProducerWriteData()| then changes the data underneath the two-phase read.) TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { const MojoCreateDataPipeOptions options = { - kSizeOfOptions, // |struct_size|. - MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. - 1, // |element_num_bytes|. - 2 // |capacity_num_bytes|. + kSizeOfOptions, // |struct_size|. + MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD, // |flags|. + 1, // |element_num_bytes|. + 2 // |capacity_num_bytes|. }; - MojoCreateDataPipeOptions validated_options = { 0 }; + MojoCreateDataPipeOptions validated_options = {0}; EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(MakeUserPointer(&options), &validated_options)); @@ -1728,19 +1799,21 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) { scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options)); // Write some elements. - char elements[2] = { 'a', 'b' }; + char elements[2] = {'a', 'b'}; 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 = NULL; 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]); @@ -1756,7 +1829,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]); @@ -1768,14 +1842,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 = NULL; 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/system/local_message_pipe_endpoint.cc b/mojo/system/local_message_pipe_endpoint.cc index 3cbc712..de3eaa5 100644 --- a/mojo/system/local_message_pipe_endpoint.cc +++ b/mojo/system/local_message_pipe_endpoint.cc @@ -14,8 +14,7 @@ namespace mojo { namespace system { LocalMessagePipeEndpoint::LocalMessagePipeEndpoint() - : is_open_(true), - is_peer_open_(true) { + : is_open_(true), is_peer_open_(true) { } LocalMessagePipeEndpoint::~LocalMessagePipeEndpoint() { @@ -76,8 +75,8 @@ MojoResult LocalMessagePipeEndpoint::ReadMessage( const uint32_t max_num_dispatchers = num_dispatchers ? *num_dispatchers : 0; if (message_queue_.IsEmpty()) { - return is_peer_open_ ? MOJO_RESULT_SHOULD_WAIT : - MOJO_RESULT_FAILED_PRECONDITION; + return is_peer_open_ ? MOJO_RESULT_SHOULD_WAIT + : MOJO_RESULT_FAILED_PRECONDITION; } // TODO(vtl): If |flags & MOJO_READ_MESSAGE_FLAG_MAY_DISCARD|, we could pop diff --git a/mojo/system/mapping_table.cc b/mojo/system/mapping_table.cc index 6170679..497b9e0 100644 --- a/mojo/system/mapping_table.cc +++ b/mojo/system/mapping_table.cc @@ -28,7 +28,7 @@ MojoResult MappingTable::AddMapping( uintptr_t address = reinterpret_cast<uintptr_t>(mapping->base()); DCHECK(address_to_mapping_map_.find(address) == - address_to_mapping_map_.end()); + address_to_mapping_map_.end()); address_to_mapping_map_[address] = mapping.release(); return MOJO_RESULT_OK; } diff --git a/mojo/system/memory.cc b/mojo/system/memory.cc index 15f83f4..601123e 100644 --- a/mojo/system/memory.cc +++ b/mojo/system/memory.cc @@ -33,27 +33,24 @@ void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer) { } // Explicitly instantiate the sizes we need. Add instantiations as needed. -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<1, 1>( - const void*); -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<4, 4>( - const void*); -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<8, 8>( - const void*); +template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<1, 1>(const void*); +template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<4, 4>(const void*); +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) { +void MOJO_SYSTEM_IMPL_EXPORT +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); -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithCount<4, 4>( - const void*, size_t); -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithCount<8, 8>( - const void*, size_t); +template void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithCount<1, 1>(const void*, size_t); +template void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithCount<4, 4>(const void*, size_t); +template void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithCount<8, 8>(const void*, size_t); template <size_t alignment> void CheckUserPointerWithSize(const void* pointer, size_t size) { @@ -64,24 +61,24 @@ 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); -template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithSize<4>(const void*, - size_t); +template void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithSize<1>(const void*, size_t); +template void MOJO_SYSTEM_IMPL_EXPORT + 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 // MSVS *does* respect. #if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS) template <> -void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointerWithSize<8>(const void* pointer, - size_t size) { +void MOJO_SYSTEM_IMPL_EXPORT +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); +template void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithSize<8>(const void*, size_t); #endif } // namespace internal diff --git a/mojo/system/memory.h b/mojo/system/memory.h index 8721a30..3602be7 100644 --- a/mojo/system/memory.h +++ b/mojo/system/memory.h @@ -21,13 +21,28 @@ namespace internal { // Removes |const| from |T| (available as |remove_const<T>::type|): // TODO(vtl): Remove these once we have the C++11 |remove_const|. -template <typename T> struct remove_const { typedef T type; }; -template <typename T> struct remove_const<const T> { typedef T type; }; +template <typename T> +struct remove_const { + typedef T type; +}; +template <typename T> +struct remove_const<const T> { + typedef T type; +}; // Yields |(const) char| if |T| is |(const) void|, else |T|: -template <typename T> struct VoidToChar { typedef T type; }; -template <> struct VoidToChar<void> { typedef char type; }; -template <> struct VoidToChar<const void> { typedef const char type; }; +template <typename T> +struct VoidToChar { + typedef T type; +}; +template <> +struct VoidToChar<void> { + typedef char type; +}; +template <> +struct VoidToChar<const void> { + typedef const char type; +}; // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to // a buffer of the given size and alignment (both in bytes). @@ -37,22 +52,26 @@ void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer); // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to // 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); +void MOJO_SYSTEM_IMPL_EXPORT + 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); +void MOJO_SYSTEM_IMPL_EXPORT + CheckUserPointerWithSize(const void* pointer, size_t size); } // namespace internal // Forward declarations so that they can be friended. -template <typename Type> class UserPointerReader; -template <typename Type> class UserPointerWriter; -template <typename Type> class UserPointerReaderWriter; -template <class Options> class UserOptionsReader; +template <typename Type> +class UserPointerReader; +template <typename Type> +class UserPointerWriter; +template <typename Type> +class UserPointerReaderWriter; +template <class Options> +class UserOptionsReader; // Provides a convenient way to implicitly get null |UserPointer<Type>|s. struct NullUserPointer {}; @@ -89,9 +108,7 @@ class UserPointer { return UserPointer<const Type>(pointer_); } - bool IsNull() const { - return !pointer_; - } + bool IsNull() const { return !pointer_; } // "Reinterpret casts" to a |UserPointer<ToType>|. template <typename ToType> @@ -104,8 +121,8 @@ class UserPointer { // TODO(vtl): Logically, there should be separate read checks and write // checks. void Check() const { - internal::CheckUserPointer<sizeof(NonVoidType), - MOJO_ALIGNOF(NonVoidType)>(pointer_); + internal::CheckUserPointer<sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>( + pointer_); } // Checks that this pointer points to a valid array (of type |Type|, or just a @@ -116,8 +133,9 @@ class UserPointer { // checks. // TODO(vtl): Switch more things to use this. void CheckArray(size_t count) const { - internal::CheckUserPointerWithCount< - sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>(pointer_, count); + internal::CheckUserPointerWithCount<sizeof(NonVoidType), + MOJO_ALIGNOF(NonVoidType)>(pointer_, + count); } // Gets the value (of type |Type|, or a |char| if |Type| is |void|) pointed to @@ -128,8 +146,8 @@ class UserPointer { // (We want to force a copy here, so return |Type| not |const Type&|.) NonVoidType Get() const { Check(); - internal::CheckUserPointer<sizeof(NonVoidType), - MOJO_ALIGNOF(NonVoidType)>(pointer_); + internal::CheckUserPointer<sizeof(NonVoidType), MOJO_ALIGNOF(NonVoidType)>( + pointer_); return *pointer_; } @@ -181,8 +199,8 @@ class UserPointer { // Gets a |UserPointer| at offset |i| (in |Type|s) relative to this. UserPointer At(size_t i) const { - return UserPointer(static_cast<Type*>( - static_cast<NonVoidType*>(pointer_) + i)); + return UserPointer( + static_cast<Type*>(static_cast<NonVoidType*>(pointer_) + i)); } // Gets the value of the |UserPointer| as a |uintptr_t|. This should not be @@ -234,7 +252,8 @@ class UserPointer { friend class UserPointerReader<const Type>; friend class UserPointerWriter<Type>; friend class UserPointerReaderWriter<Type>; - template <class Options> friend class UserOptionsReader; + template <class Options> + friend class UserOptionsReader; Type* pointer_; // Allow copy and assignment. @@ -264,7 +283,8 @@ class UserPointerReader { const Type* GetPointer() const { return buffer_.get(); } private: - template <class Options> friend class UserOptionsReader; + template <class Options> + friend class UserOptionsReader; struct NoCheck {}; UserPointerReader(NoCheck, @@ -296,8 +316,7 @@ class UserPointerWriter { public: // Note: If |count| is zero, |GetPointer()| will always return null. UserPointerWriter(UserPointer<Type> user_pointer, size_t count) - : user_pointer_(user_pointer), - count_(count) { + : user_pointer_(user_pointer), count_(count) { if (count_ > 0) { buffer_.reset(new Type[count_]); memset(buffer_.get(), 0, count_ * sizeof(Type)); @@ -326,8 +345,7 @@ class UserPointerReaderWriter { public: // Note: If |count| is zero, |GetPointer()| will always return null. UserPointerReaderWriter(UserPointer<Type> user_pointer, size_t count) - : user_pointer_(user_pointer), - count_(count) { + : user_pointer_(user_pointer), count_(count) { if (count_ > 0) { internal::CheckUserPointerWithCount<sizeof(Type), MOJO_ALIGNOF(Type)>( user_pointer_.pointer_, count_); diff --git a/mojo/system/message_in_transit.cc b/mojo/system/message_in_transit.cc index 5ac0754..fe73a79 100644 --- a/mojo/system/message_in_transit.cc +++ b/mojo/system/message_in_transit.cc @@ -55,8 +55,8 @@ struct MessageInTransit::PrivateStructForCompileAsserts { 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()); @@ -90,12 +90,13 @@ MessageInTransit::MessageInTransit(Type type, uint32_t num_bytes, const void* bytes) : main_buffer_size_(RoundUpMessageAlignment(sizeof(Header) + num_bytes)), - main_buffer_(static_cast<char*>(base::AlignedAlloc(main_buffer_size_, - kMessageAlignment))) { + main_buffer_(static_cast<char*>( + base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) { 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)); @@ -107,16 +108,16 @@ MessageInTransit::MessageInTransit(Type type, uint32_t num_bytes, UserPointer<const void> bytes) : main_buffer_size_(RoundUpMessageAlignment(sizeof(Header) + num_bytes)), - main_buffer_(static_cast<char*>(base::AlignedAlloc(main_buffer_size_, - kMessageAlignment))) { + main_buffer_(static_cast<char*>( + base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) { ConstructorHelper(type, subtype, num_bytes); bytes.GetArray(MessageInTransit::bytes(), num_bytes); } MessageInTransit::MessageInTransit(const View& message_view) : main_buffer_size_(message_view.main_buffer_size()), - main_buffer_(static_cast<char*>(base::AlignedAlloc(main_buffer_size_, - kMessageAlignment))) { + main_buffer_(static_cast<char*>( + base::AlignedAlloc(main_buffer_size_, kMessageAlignment))) { DCHECK_GE(main_buffer_size_, sizeof(Header)); DCHECK_EQ(main_buffer_size_ % kMessageAlignment, 0u); @@ -145,8 +146,9 @@ bool MessageInTransit::GetNextMessageSize(const void* buffer, if (!buffer_size) return false; DCHECK(buffer); - DCHECK_EQ(reinterpret_cast<uintptr_t>(buffer) % - MessageInTransit::kMessageAlignment, 0u); + DCHECK_EQ( + reinterpret_cast<uintptr_t>(buffer) % MessageInTransit::kMessageAlignment, + 0u); if (buffer_size < sizeof(Header)) return false; diff --git a/mojo/system/message_in_transit.h b/mojo/system/message_in_transit.h index 82b9fda..c812d56 100644 --- a/mojo/system/message_in_transit.h +++ b/mojo/system/message_in_transit.h @@ -75,6 +75,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransit { // Forward-declare |Header| so that |View| can use it: private: struct Header; + public: // This represents a view of serialized message data in a raw buffer. class MOJO_SYSTEM_IMPL_EXPORT View { @@ -103,8 +104,9 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransit { return RoundUpMessageAlignment(sizeof(Header) + header()->num_bytes); } const void* transport_data_buffer() const { - return (total_size() > main_buffer_size()) ? - static_cast<const char*>(buffer_) + main_buffer_size() : NULL; + return (total_size() > main_buffer_size()) + ? static_cast<const char*>(buffer_) + main_buffer_size() + : NULL; } size_t transport_data_buffer_size() const { return total_size() - main_buffer_size(); @@ -228,9 +230,9 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransit { // correct value if dispatchers are attached but // |SerializeAndCloseDispatchers()| has not been called. uint32_t total_size; - Type type; // 2 bytes. - Subtype subtype; // 2 bytes. - EndpointId source_id; // 4 bytes. + Type type; // 2 bytes. + Subtype subtype; // 2 bytes. + EndpointId source_id; // 4 bytes. EndpointId destination_id; // 4 bytes. // Size of actual message data. uint32_t num_bytes; @@ -242,9 +244,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransit { } Header* header() { return reinterpret_cast<Header*>(main_buffer_.get()); } - void ConstructorHelper(Type type, - Subtype subtype, - uint32_t num_bytes); + void ConstructorHelper(Type type, Subtype subtype, uint32_t num_bytes); void UpdateTotalSize(); const size_t main_buffer_size_; diff --git a/mojo/system/message_in_transit_queue.h b/mojo/system/message_in_transit_queue.h index a70a7ef..2c1f4c7 100644 --- a/mojo/system/message_in_transit_queue.h +++ b/mojo/system/message_in_transit_queue.h @@ -29,9 +29,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransitQueue { ~MessageInTransitQueue(); - bool IsEmpty() const { - return queue_.empty(); - } + bool IsEmpty() const { return queue_.empty(); } void AddMessage(scoped_ptr<MessageInTransit> message) { queue_.push_back(message.release()); @@ -43,9 +41,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransitQueue { return make_scoped_ptr(rv); } - MessageInTransit* PeekMessage() { - return queue_.front(); - } + MessageInTransit* PeekMessage() { return queue_.front(); } void DiscardMessage() { delete queue_.front(); @@ -62,7 +58,6 @@ class MOJO_SYSTEM_IMPL_EXPORT MessageInTransitQueue { DISALLOW_COPY_AND_ASSIGN(MessageInTransitQueue); }; - } // namespace system } // namespace mojo diff --git a/mojo/system/message_pipe.cc b/mojo/system/message_pipe.cc index 5385a2b..93ad305 100644 --- a/mojo/system/message_pipe.cc +++ b/mojo/system/message_pipe.cc @@ -76,7 +76,9 @@ MojoResult MessagePipe::WriteMessage( GetPeerPort(port), make_scoped_ptr(new MessageInTransit( MessageInTransit::kTypeMessagePipeEndpoint, - MessageInTransit::kSubtypeMessagePipeEndpointData, num_bytes, bytes)), + MessageInTransit::kSubtypeMessagePipeEndpointData, + num_bytes, + bytes)), transports); } @@ -91,8 +93,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); } MojoResult MessagePipe::AddWaiter(unsigned port, @@ -139,9 +141,8 @@ void MessagePipe::ConvertLocalToProxy(unsigned port) { endpoints_[port].swap(replacement_endpoint); } -MojoResult MessagePipe::EnqueueMessage( - unsigned port, - scoped_ptr<MessageInTransit> message) { +MojoResult MessagePipe::EnqueueMessage(unsigned port, + scoped_ptr<MessageInTransit> message) { return EnqueueMessageInternal(port, message.Pass(), NULL); } diff --git a/mojo/system/message_pipe.h b/mojo/system/message_pipe.h index 360e725..3d13fad7 100644 --- a/mojo/system/message_pipe.h +++ b/mojo/system/message_pipe.h @@ -30,8 +30,8 @@ class Waiter; // |MessagePipe| is the secondary object implementing a message pipe (see the // explanatory comment in core.cc). It is typically owned by the dispatcher(s) // corresponding to the local endpoints. This class is thread-safe. -class MOJO_SYSTEM_IMPL_EXPORT MessagePipe : - public base::RefCountedThreadSafe<MessagePipe> { +class MOJO_SYSTEM_IMPL_EXPORT MessagePipe + : public base::RefCountedThreadSafe<MessagePipe> { public: MessagePipe(scoped_ptr<MessagePipeEndpoint> endpoint0, scoped_ptr<MessagePipeEndpoint> endpoint1); diff --git a/mojo/system/message_pipe_dispatcher.cc b/mojo/system/message_pipe_dispatcher.cc index 448b085..27792b2 100644 --- a/mojo/system/message_pipe_dispatcher.cc +++ b/mojo/system/message_pipe_dispatcher.cc @@ -32,9 +32,8 @@ struct SerializedMessagePipeDispatcher { // static const MojoCreateMessagePipeOptions MessagePipeDispatcher::kDefaultCreateOptions = { - static_cast<uint32_t>(sizeof(MojoCreateMessagePipeOptions)), - MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE -}; + static_cast<uint32_t>(sizeof(MojoCreateMessagePipeOptions)), + MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE}; MessagePipeDispatcher::MessagePipeDispatcher( const MojoCreateMessagePipeOptions& /*validated_options*/) @@ -85,12 +84,11 @@ Dispatcher::Type MessagePipeDispatcher::GetType() const { // static std::pair<scoped_refptr<MessagePipeDispatcher>, scoped_refptr<MessagePipe> > MessagePipeDispatcher::CreateRemoteMessagePipe() { - scoped_refptr<MessagePipe> message_pipe( - new MessagePipe( - scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()), - scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()))); - scoped_refptr<MessagePipeDispatcher> dispatcher(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipe> message_pipe(new MessagePipe( + scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()), + scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()))); + scoped_refptr<MessagePipeDispatcher> dispatcher( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); dispatcher->Init(message_pipe, 0); return std::make_pair(dispatcher, message_pipe); @@ -126,8 +124,8 @@ scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize( "attach; remote ID = " << remote_id << ")"; return scoped_refptr<MessagePipeDispatcher>(); } - DVLOG(2) << "Deserializing message pipe dispatcher (remote ID = " - << remote_id << ", new local ID = " << local_id << ")"; + DVLOG(2) << "Deserializing message pipe dispatcher (remote ID = " << remote_id + << ", new local ID = " << local_id << ")"; if (!channel->RunMessagePipeEndpoint(local_id, remote_id)) { // In general, this shouldn't fail, since we generated |local_id| locally. @@ -195,8 +193,8 @@ MojoResult MessagePipeDispatcher::WriteMessageImplNoLock( 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( @@ -206,8 +204,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); } MojoResult MessagePipeDispatcher::AddWaiterImplNoLock(Waiter* waiter, @@ -267,7 +265,8 @@ bool MessagePipeDispatcher::EndSerializeAndCloseImplNoLock( // MessagePipeDispatcherTransport ---------------------------------------------- MessagePipeDispatcherTransport::MessagePipeDispatcherTransport( - DispatcherTransport transport) : DispatcherTransport(transport) { + DispatcherTransport transport) + : DispatcherTransport(transport) { DCHECK_EQ(message_pipe_dispatcher()->GetType(), Dispatcher::kTypeMessagePipe); } diff --git a/mojo/system/message_pipe_dispatcher.h b/mojo/system/message_pipe_dispatcher.h index 45639a3..55b60c1 100644 --- a/mojo/system/message_pipe_dispatcher.h +++ b/mojo/system/message_pipe_dispatcher.h @@ -52,7 +52,8 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipeDispatcher : public Dispatcher { // TODO(vtl): This currently uses |kDefaultCreateOptions|, which is okay since // there aren't any options, but eventually options should be plumbed through. static std::pair<scoped_refptr<MessagePipeDispatcher>, - scoped_refptr<MessagePipe> > CreateRemoteMessagePipe(); + scoped_refptr<MessagePipe> > + CreateRemoteMessagePipe(); // The "opposite" of |SerializeAndClose()|. (Typically this is called by // |Dispatcher::Deserialize()|.) diff --git a/mojo/system/message_pipe_dispatcher_unittest.cc b/mojo/system/message_pipe_dispatcher_unittest.cc index 76408e2..d034aa4 100644 --- a/mojo/system/message_pipe_dispatcher_unittest.cc +++ b/mojo/system/message_pipe_dispatcher_unittest.cc @@ -44,7 +44,7 @@ TEST(MessagePipeDispatcherTest, Basic) { MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); - d0->Init(mp, i); // 0, 1. + d0->Init(mp, i); // 0, 1. d1->Init(mp, i ^ 1); // 1, 0. } Waiter w; @@ -63,8 +63,10 @@ TEST(MessagePipeDispatcherTest, Basic) { d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1)); buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); stopwatch.Start(); EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context)); EXPECT_EQ(1u, context); @@ -82,7 +84,9 @@ TEST(MessagePipeDispatcherTest, Basic) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -104,8 +108,8 @@ TEST(MessagePipeDispatcherTest, Basic) { EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), NULL)); base::TimeDelta elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); d0->RemoveWaiter(&w); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); @@ -116,10 +120,10 @@ TEST(MessagePipeDispatcherTest, Basic) { TEST(MessagePipeDispatcherTest, InvalidParams) { char buffer[1]; - scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); - scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d0( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d1( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); d0->Init(mp, 0); @@ -130,7 +134,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(), NULL, + std::numeric_limits<uint32_t>::max(), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); @@ -146,10 +151,10 @@ TEST(MessagePipeDispatcherTest, InvalidParams) { TEST(MessagePipeDispatcherTest, InvalidParamsDeath) { const char kMemoryCheckFailedRegex[] = "Check failed"; - scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); - scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d0( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d1( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); d0->Init(mp, 0); @@ -159,21 +164,24 @@ TEST(MessagePipeDispatcherTest, InvalidParamsDeath) { // |WriteMessage|: // Null buffer with nonzero buffer size. EXPECT_DEATH_IF_SUPPORTED( - d0->WriteMessage(NullUserPointer(), 1, NULL, - MOJO_WRITE_MESSAGE_FLAG_NONE), + d0->WriteMessage( + NullUserPointer(), 1, NULL, 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, NULL, - MOJO_WRITE_MESSAGE_FLAG_NONE)); + EXPECT_EQ( + MOJO_RESULT_OK, + d1->WriteMessage( + UserPointer<const void>("x"), 1, NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); uint32_t buffer_size = 1; - EXPECT_DEATH_IF_SUPPORTED( - d0->ReadMessage(NullUserPointer(), MakeUserPointer(&buffer_size), 0, NULL, - MOJO_READ_MESSAGE_FLAG_NONE), - kMemoryCheckFailedRegex); + EXPECT_DEATH_IF_SUPPORTED(d0->ReadMessage(NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + NULL, + MOJO_READ_MESSAGE_FLAG_NONE), + kMemoryCheckFailedRegex); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); EXPECT_EQ(MOJO_RESULT_OK, d1->Close()); @@ -193,7 +201,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); - d0->Init(mp, i); // 0, 1. + d0->Init(mp, i); // 0, 1. d1->Init(mp, i ^ 1); // 1, 0. } Waiter w; @@ -201,12 +209,16 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { // Write (twice) to |d1|. buffer[0] = 123456789; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); buffer[0] = 234567890; EXPECT_EQ(MOJO_RESULT_OK, - d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d1->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Try waiting for readable on |d0|; should fail (already satisfied). w.Init(); @@ -218,7 +230,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, d1->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); // Close |d1|. @@ -234,7 +248,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -249,7 +265,9 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(234567890, buffer[0]); @@ -270,14 +288,18 @@ TEST(MessagePipeDispatcherTest, BasicClosed) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, d0->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, 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, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d0->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); } @@ -307,29 +329,33 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); - d0->Init(mp, i); // 0, 1. + d0->Init(mp, i); // 0, 1. d1->Init(mp, i ^ 1); // 1, 0. } // 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); + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_DEADLINE_INDEFINITE, + 1, + &did_wait, + &result, + &context); 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, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + d0->WriteMessage(UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); } // Joins the thread. elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_OK, result); EXPECT_EQ(1u, context); @@ -340,7 +366,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 2, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); } // Joins the thread. @@ -353,7 +381,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { buffer_size = kBufferSize; EXPECT_EQ(MOJO_RESULT_OK, d1->ReadMessage(UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), 0, NULL, + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -365,15 +395,17 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 3, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); EXPECT_EQ(MOJO_RESULT_OK, d0->Close()); } // Joins the thread. elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(3u, context); @@ -388,7 +420,7 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); - d0->Init(mp, i); // 0, 1. + d0->Init(mp, i); // 0, 1. d1->Init(mp, i ^ 1); // 1, 0. } @@ -399,15 +431,17 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 4, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); EXPECT_EQ(MOJO_RESULT_OK, d1->Close()); } // Joins the thread. elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_CANCELLED, result); EXPECT_EQ(4u, context); @@ -425,7 +459,8 @@ class WriterThread : public base::SimpleThread { // |*messages_written| and |*bytes_written| belong to the thread while it's // alive. WriterThread(scoped_refptr<Dispatcher> write_dispatcher, - size_t* messages_written, size_t* bytes_written) + size_t* messages_written, + size_t* bytes_written) : base::SimpleThread("writer_thread"), write_dispatcher_(write_dispatcher), messages_written_(messages_written), @@ -434,9 +469,7 @@ class WriterThread : public base::SimpleThread { *bytes_written_ = 0; } - virtual ~WriterThread() { - Join(); - } + virtual ~WriterThread() { Join(); } private: virtual void Run() OVERRIDE { @@ -454,7 +487,8 @@ 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, NULL, + bytes_to_write, + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); *bytes_written_ += bytes_to_write; } @@ -462,7 +496,8 @@ class WriterThread : public base::SimpleThread { // Write one last "quit" message. EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage(UserPointer<const void>("quit"), - 4, NULL, + 4, + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); } @@ -477,7 +512,8 @@ class ReaderThread : public base::SimpleThread { public: // |*messages_read| and |*bytes_read| belong to the thread while it's alive. ReaderThread(scoped_refptr<Dispatcher> read_dispatcher, - size_t* messages_read, size_t* bytes_read) + size_t* messages_read, + size_t* bytes_read) : base::SimpleThread("reader_thread"), read_dispatcher_(read_dispatcher), messages_read_(messages_read), @@ -486,9 +522,7 @@ class ReaderThread : public base::SimpleThread { *bytes_read_ = 0; } - virtual ~ReaderThread() { - Join(); - } + virtual ~ReaderThread() { Join(); } private: virtual void Run() OVERRIDE { @@ -502,7 +536,8 @@ class ReaderThread : public base::SimpleThread { w.Init(); result = read_dispatcher_->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 0); EXPECT_TRUE(result == MOJO_RESULT_OK || - result == MOJO_RESULT_ALREADY_EXISTS) << "result: " << result; + result == MOJO_RESULT_ALREADY_EXISTS) + << "result: " << result; if (result == MOJO_RESULT_OK) { // Actually need to wait. EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, NULL)); @@ -514,10 +549,12 @@ class ReaderThread : public base::SimpleThread { 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, - NULL, MOJO_READ_MESSAGE_FLAG_NONE); - EXPECT_TRUE(result == MOJO_RESULT_OK || - result == MOJO_RESULT_SHOULD_WAIT) << "result: " << result; + MakeUserPointer(&buffer_size), + 0, + NULL, + 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. if (result == MOJO_RESULT_SHOULD_WAIT) continue; // In which case, try again. @@ -559,10 +596,10 @@ TEST(MessagePipeDispatcherTest, Stress) { static const size_t kNumWriters = 30; static const size_t kNumReaders = kNumWriters; - scoped_refptr<MessagePipeDispatcher> d_write(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); - scoped_refptr<MessagePipeDispatcher> d_read(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d_write( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> d_read( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); { scoped_refptr<MessagePipe> mp(new MessagePipe()); d_write->Init(mp, 0); diff --git a/mojo/system/message_pipe_endpoint.h b/mojo/system/message_pipe_endpoint.h index 8ba1b81..995d57c 100644 --- a/mojo/system/message_pipe_endpoint.h +++ b/mojo/system/message_pipe_endpoint.h @@ -37,10 +37,7 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipeEndpoint { public: virtual ~MessagePipeEndpoint() {} - enum Type { - kTypeLocal, - kTypeProxy - }; + enum Type { kTypeLocal, kTypeProxy }; virtual Type GetType() const = 0; // All implementations must implement these. diff --git a/mojo/system/message_pipe_unittest.cc b/mojo/system/message_pipe_unittest.cc index c3662b7..236e515 100644 --- a/mojo/system/message_pipe_unittest.cc +++ b/mojo/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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(789012345, buffer[0]); @@ -78,30 +89,40 @@ 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, 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])), NULL, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, 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, NULL, + mp->ReadMessage(1, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); @@ -111,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(123, buffer[0]); @@ -123,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(123456789, buffer[0]); @@ -135,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(234567890, buffer[0]); @@ -145,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(0, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Close port 0. @@ -164,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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 1; should still get message (even though port 0 was closed). @@ -173,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(345678901, buffer[0]); @@ -183,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); mp->Close(1); @@ -201,15 +244,21 @@ 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, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(1, + UserPointer<const void>(buffer), + kBufferSize, + NULL, + 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, NULL, + mp->ReadMessage(0, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(kBufferSize, buffer_size); @@ -229,31 +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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, 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, NULL, + mp->ReadMessage(0, + NullUserPointer(), + MakeUserPointer(&buffer_size), + 0, + NULL, 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Read from port 0 (buffer big enough). @@ -261,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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size); EXPECT_EQ(890123456, buffer[0]); @@ -271,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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, 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])), NULL, + mp->WriteMessage(1, + UserPointer<const void>(buffer), + static_cast<uint32_t>(sizeof(buffer[0])), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Discard from port 0. buffer_size = 1; EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, - mp->ReadMessage(0, NullUserPointer(), NullUserPointer(), 0, NULL, + mp->ReadMessage(0, + NullUserPointer(), + NullUserPointer(), + 0, + NULL, 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, NULL, + mp->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)); mp->Close(0); @@ -336,12 +418,12 @@ TEST(MessagePipeTest, BasicWaiting) { EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_WRITABLE, 0)); waiter.Init(); - EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(0, - &waiter, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE, - 0)); + EXPECT_EQ( + MOJO_RESULT_ALREADY_EXISTS, + mp->AddWaiter(0, + &waiter, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, + 0)); // Not yet readable. waiter.Init(); @@ -353,20 +435,23 @@ 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, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(0, + UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); // Port 1 should already be readable now. waiter.Init(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 2)); waiter.Init(); - EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, - mp->AddWaiter(1, - &waiter, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE, - 0)); + EXPECT_EQ( + MOJO_RESULT_ALREADY_EXISTS, + mp->AddWaiter(1, + &waiter, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE, + 0)); // ... and still writable. waiter.Init(); EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS, @@ -389,8 +474,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, NULL, + mp->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(123456789, buffer[0]); @@ -415,16 +503,19 @@ TEST(MessagePipeTest, ThreadedWaiting) { test::SimpleWaiterThread thread(&result, &context); thread.waiter()->Init(); - ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, - 1)); + ASSERT_EQ( + MOJO_RESULT_OK, + mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1)); 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, - NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); + mp->WriteMessage(0, + UserPointer<const void>(buffer), + kBufferSize, + NULL, + MOJO_WRITE_MESSAGE_FLAG_NONE)); mp->RemoveWaiter(1, thread.waiter()); @@ -441,9 +532,9 @@ TEST(MessagePipeTest, ThreadedWaiting) { test::SimpleWaiterThread thread(&result, &context); thread.waiter()->Init(); - ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, - 2)); + ASSERT_EQ( + MOJO_RESULT_OK, + mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2)); thread.Start(); // Close port 1 first -- this should result in the waiter being cancelled. @@ -464,9 +555,9 @@ TEST(MessagePipeTest, ThreadedWaiting) { test::SimpleWaiterThread thread(&result, &context); thread.waiter()->Init(); - ASSERT_EQ(MOJO_RESULT_OK, - mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, - 3)); + ASSERT_EQ( + MOJO_RESULT_OK, + mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3)); thread.Start(); // Close port 0 first -- this should wake the waiter up, since port 1 will diff --git a/mojo/system/multiprocess_message_pipe_unittest.cc b/mojo/system/multiprocess_message_pipe_unittest.cc index 5376800..2ca17ce 100644 --- a/mojo/system/multiprocess_message_pipe_unittest.cc +++ b/mojo/system/multiprocess_message_pipe_unittest.cc @@ -18,7 +18,7 @@ #include "base/logging.h" #include "base/macros.h" #include "base/threading/platform_thread.h" // For |Sleep()|. -#include "build/build_config.h" // TODO(vtl): Remove this. +#include "build/build_config.h" // TODO(vtl): Remove this. #include "mojo/common/test/multiprocess_test_helper.h" #include "mojo/common/test/test_utils.h" #include "mojo/embedder/scoped_platform_handle.h" @@ -42,9 +42,7 @@ namespace { class ChannelThread { public: ChannelThread() : test_io_thread_(test::TestIOThread::kManualStart) {} - ~ChannelThread() { - Stop(); - } + ~ChannelThread() { Stop(); } void Start(embedder::ScopedPlatformHandle platform_handle, scoped_refptr<MessagePipe> message_pipe) { @@ -52,7 +50,8 @@ class ChannelThread { test_io_thread_.PostTaskAndWait( FROM_HERE, base::Bind(&ChannelThread::InitChannelOnIOThread, - base::Unretained(this), base::Passed(&platform_handle), + base::Unretained(this), + base::Passed(&platform_handle), message_pipe)); } @@ -133,8 +132,8 @@ MojoResult WaitIfNecessary(scoped_refptr<MessagePipe> mp, MojoResult add_result = mp->AddWaiter(0, &waiter, signals, 0); if (add_result != MOJO_RESULT_OK) { - return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK : - add_result; + return (add_result == MOJO_RESULT_ALREADY_EXISTS) ? MOJO_RESULT_OK + : add_result; } MojoResult wait_result = waiter.Wait(MOJO_DEADLINE_INDEFINITE, NULL); @@ -169,8 +168,11 @@ 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), NULL, NULL, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); @@ -182,8 +184,10 @@ 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()), - static_cast<uint32_t>(write_buffer.size()), NULL, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(write_buffer.data()), + static_cast<uint32_t>(write_buffer.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); } @@ -203,16 +207,21 @@ 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()), NULL, + mp->WriteMessage(0, + UserPointer<const void>(hello.data()), + static_cast<uint32_t>(hello.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE)); 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), NULL, NULL, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); @@ -239,15 +248,19 @@ 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()), - static_cast<uint32_t>(write_buffer.size()), NULL, + mp->WriteMessage(0, + UserPointer<const void>(write_buffer.data()), + static_cast<uint32_t>(write_buffer.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); } const std::string quitquitquit("quitquitquit"); EXPECT_EQ(MOJO_RESULT_OK, - mp->WriteMessage(0, UserPointer<const void>(quitquitquit.data()), - static_cast<uint32_t>(quitquitquit.size()), NULL, + mp->WriteMessage(0, + UserPointer<const void>(quitquitquit.data()), + static_cast<uint32_t>(quitquitquit.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); for (size_t i = 0; i < kNumMessages; i++) { @@ -255,8 +268,11 @@ 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), NULL, NULL, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&read_buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(read_buffer_size); @@ -293,9 +309,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")); @@ -323,8 +342,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()), NULL, + CHECK_EQ(mp->WriteMessage(0, + UserPointer<const void>(&go2[0]), + static_cast<uint32_t>(go2.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); @@ -333,8 +354,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), NULL, NULL, + CHECK_EQ(mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE), MOJO_RESULT_OK); read_buffer.resize(num_bytes); @@ -366,10 +390,10 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) { // Make a shared buffer. scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); ASSERT_TRUE(dispatcher); // Make a mapping. @@ -389,8 +413,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(); @@ -403,8 +429,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), NULL, NULL, + mp->ReadMessage(0, + UserPointer<void>(&read_buffer[0]), + MakeUserPointer(&num_bytes), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); read_buffer.resize(num_bytes); EXPECT_EQ(std::string("go 2"), read_buffer); @@ -421,8 +450,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()), NULL, + mp->WriteMessage(0, + UserPointer<const void>(&go3[0]), + static_cast<uint32_t>(go3.size()), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait for |mp| to become readable, which should fail. @@ -450,9 +481,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); @@ -496,8 +530,8 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) { Init(mp); base::FilePath unused; - base::ScopedFILE fp(CreateAndOpenTemporaryFileInDir(temp_dir.path(), - &unused)); + base::ScopedFILE fp( + CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused)); const std::string world("world"); ASSERT_EQ(fwrite(&world[0], 1, world.size(), fp.get()), world.size()); fflush(fp.get()); @@ -516,8 +550,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/system/options_validation.h b/mojo/system/options_validation.h index 90c1568..3bb0d47 100644 --- a/mojo/system/options_validation.h +++ b/mojo/system/options_validation.h @@ -43,9 +43,7 @@ class UserOptionsReader { // == sizeof(uint32_t)| somewhere. } - bool is_valid() const { - return !!options_reader_.GetPointer(); - } + bool is_valid() const { return !!options_reader_.GetPointer(); } const Options& options() const { DCHECK(is_valid()); @@ -95,7 +93,7 @@ class UserOptionsReader { // contortion below). We might also be able to pull out the type |Options| from // |reader| (using |decltype|) instead of requiring a parameter. #define OPTIONS_STRUCT_HAS_MEMBER(Options, member, reader) \ - reader.HasMember(offsetof(Options, member), sizeof(reader.options().member)) + reader.HasMember(offsetof(Options, member), sizeof(reader.options().member)) } // namespace system } // namespace mojo diff --git a/mojo/system/options_validation_unittest.cc b/mojo/system/options_validation_unittest.cc index bf9570a..c845ffe 100644 --- a/mojo/system/options_validation_unittest.cc +++ b/mojo/system/options_validation_unittest.cc @@ -31,9 +31,7 @@ const uint32_t kSizeOfTestOptions = static_cast<uint32_t>(sizeof(TestOptions)); TEST(OptionsValidationTest, Valid) { { - const TestOptions kOptions = { - kSizeOfTestOptions - }; + const TestOptions kOptions = {kSizeOfTestOptions}; UserOptionsReader<TestOptions> reader(MakeUserPointer(&kOptions)); EXPECT_TRUE(reader.is_valid()); EXPECT_TRUE(OPTIONS_STRUCT_HAS_MEMBER(TestOptions, flags, reader)); @@ -41,10 +39,8 @@ TEST(OptionsValidationTest, Valid) { EXPECT_TRUE(OPTIONS_STRUCT_HAS_MEMBER(TestOptions, member2, reader)); } { - const TestOptions kOptions = { - static_cast<uint32_t>(offsetof(TestOptions, struct_size) + - sizeof(uint32_t)) - }; + const TestOptions kOptions = {static_cast<uint32_t>( + offsetof(TestOptions, struct_size) + sizeof(uint32_t))}; UserOptionsReader<TestOptions> reader(MakeUserPointer(&kOptions)); EXPECT_TRUE(reader.is_valid()); EXPECT_FALSE(OPTIONS_STRUCT_HAS_MEMBER(TestOptions, flags, reader)); @@ -54,8 +50,7 @@ TEST(OptionsValidationTest, Valid) { { const TestOptions kOptions = { - static_cast<uint32_t>(offsetof(TestOptions, flags) + sizeof(uint32_t)) - }; + static_cast<uint32_t>(offsetof(TestOptions, flags) + sizeof(uint32_t))}; UserOptionsReader<TestOptions> reader(MakeUserPointer(&kOptions)); EXPECT_TRUE(reader.is_valid()); EXPECT_TRUE(OPTIONS_STRUCT_HAS_MEMBER(TestOptions, flags, reader)); @@ -109,8 +104,10 @@ TEST(OptionsValidationTest, InvalidDeath) { // Unaligned: EXPECT_DEATH_IF_SUPPORTED( - { UserOptionsReader<TestOptions> reader( - MakeUserPointer(reinterpret_cast<const TestOptions*>(1))); }, + { + UserOptionsReader<TestOptions> reader( + MakeUserPointer(reinterpret_cast<const TestOptions*>(1))); + }, kMemoryCheckFailedRegex); // Note: The current implementation checks the size only after checking the // alignment versus that required for the |uint32_t| size, so it won't die in @@ -119,9 +116,9 @@ TEST(OptionsValidationTest, InvalidDeath) { EXPECT_DEATH_IF_SUPPORTED( { uint32_t buffer[100] = {}; - TestOptions* options = (reinterpret_cast<uintptr_t>(buffer) % 8 == 0) ? - reinterpret_cast<TestOptions*>(&buffer[1]) : - reinterpret_cast<TestOptions*>(&buffer[0]); + TestOptions* options = (reinterpret_cast<uintptr_t>(buffer) % 8 == 0) + ? reinterpret_cast<TestOptions*>(&buffer[1]) + : reinterpret_cast<TestOptions*>(&buffer[0]); options->struct_size = static_cast<uint32_t>(sizeof(TestOptions)); UserOptionsReader<TestOptions> reader(MakeUserPointer(options)); }, diff --git a/mojo/system/platform_handle_dispatcher.cc b/mojo/system/platform_handle_dispatcher.cc index 63a5e71..d1c5669 100644 --- a/mojo/system/platform_handle_dispatcher.cc +++ b/mojo/system/platform_handle_dispatcher.cc @@ -79,7 +79,7 @@ void PlatformHandleDispatcher::CloseImplNoLock() { } scoped_refptr<Dispatcher> - PlatformHandleDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { +PlatformHandleDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { lock().AssertAcquired(); return scoped_refptr<Dispatcher>( new PlatformHandleDispatcher(platform_handle_.Pass())); @@ -114,8 +114,8 @@ bool PlatformHandleDispatcher::EndSerializeAndCloseImplNoLock( return true; } -HandleSignalsState - PlatformHandleDispatcher::GetHandleSignalsStateNoLock() const { +HandleSignalsState PlatformHandleDispatcher::GetHandleSignalsStateNoLock() + const { return HandleSignalsState(); } diff --git a/mojo/system/platform_handle_dispatcher_unittest.cc b/mojo/system/platform_handle_dispatcher_unittest.cc index 7ff7d10..e8a8399 100644 --- a/mojo/system/platform_handle_dispatcher_unittest.cc +++ b/mojo/system/platform_handle_dispatcher_unittest.cc @@ -25,14 +25,14 @@ TEST(PlatformHandleDispatcherTest, Basic) { static const char kHelloWorld[] = "hello world"; base::FilePath unused; - base::ScopedFILE fp(CreateAndOpenTemporaryFileInDir(temp_dir.path(), - &unused)); + base::ScopedFILE fp( + CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused)); ASSERT_TRUE(fp); EXPECT_EQ(sizeof(kHelloWorld), fwrite(kHelloWorld, 1, sizeof(kHelloWorld), fp.get())); - embedder::ScopedPlatformHandle - h(mojo::test::PlatformHandleFromFILE(fp.Pass())); + embedder::ScopedPlatformHandle h( + mojo::test::PlatformHandleFromFILE(fp.Pass())); EXPECT_FALSE(fp); ASSERT_TRUE(h.is_valid()); @@ -68,8 +68,8 @@ TEST(PlatformHandleDispatcherTest, CreateEquivalentDispatcherAndClose) { static const char kFooBar[] = "foo bar"; base::FilePath unused; - base::ScopedFILE fp(CreateAndOpenTemporaryFileInDir(temp_dir.path(), - &unused)); + base::ScopedFILE fp( + CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused)); EXPECT_EQ(sizeof(kFooBar), fwrite(kFooBar, 1, sizeof(kFooBar), fp.get())); scoped_refptr<PlatformHandleDispatcher> dispatcher( diff --git a/mojo/system/proxy_message_pipe_endpoint.h b/mojo/system/proxy_message_pipe_endpoint.h index 6959679..3a9b0ea 100644 --- a/mojo/system/proxy_message_pipe_endpoint.h +++ b/mojo/system/proxy_message_pipe_endpoint.h @@ -68,9 +68,7 @@ class MOJO_SYSTEM_IMPL_EXPORT ProxyMessagePipeEndpoint void AssertConsistentState() const; #endif - bool is_attached() const { - return !!channel_; - } + bool is_attached() const { return !!channel_; } bool is_running() const { return remote_id_ != MessageInTransit::kInvalidEndpointId; diff --git a/mojo/system/raw_channel.h b/mojo/system/raw_channel.h index 965e109..4a35da0 100644 --- a/mojo/system/raw_channel.h +++ b/mojo/system/raw_channel.h @@ -48,10 +48,7 @@ class MOJO_SYSTEM_IMPL_EXPORT RawChannel { // (passed in on creation). class MOJO_SYSTEM_IMPL_EXPORT Delegate { public: - enum FatalError { - FATAL_ERROR_READ = 0, - FATAL_ERROR_WRITE - }; + enum FatalError { FATAL_ERROR_READ = 0, FATAL_ERROR_WRITE }; // Called when a message is read. This may call |Shutdown()| (on the // |RawChannel|), but must not destroy it. @@ -107,11 +104,7 @@ class MOJO_SYSTEM_IMPL_EXPORT RawChannel { protected: // Return values of |[Schedule]Read()| and |[Schedule]WriteNoLock()|. - enum IOResult { - IO_SUCCEEDED, - IO_FAILED, - IO_PENDING - }; + enum IOResult { IO_SUCCEEDED, IO_FAILED, IO_PENDING }; class MOJO_SYSTEM_IMPL_EXPORT ReadBuffer { public: @@ -270,9 +263,8 @@ class MOJO_SYSTEM_IMPL_EXPORT RawChannel { // On shutdown, passes the ownership of the buffers to subclasses, which may // want to preserve them if there are pending read/write. Must be called on // the I/O thread under |write_lock_|. - virtual void OnShutdownNoLock( - scoped_ptr<ReadBuffer> read_buffer, - scoped_ptr<WriteBuffer> write_buffer) = 0; + virtual void OnShutdownNoLock(scoped_ptr<ReadBuffer> read_buffer, + scoped_ptr<WriteBuffer> write_buffer) = 0; private: // Calls |delegate_->OnFatalError(fatal_error)|. Must be called on the I/O diff --git a/mojo/system/raw_channel_posix.cc b/mojo/system/raw_channel_posix.cc index 8fbcff0..a08e4e7 100644 --- a/mojo/system/raw_channel_posix.cc +++ b/mojo/system/raw_channel_posix.cc @@ -56,9 +56,8 @@ class RawChannelPosix : public RawChannel, size_t* bytes_written) OVERRIDE; virtual IOResult ScheduleWriteNoLock() OVERRIDE; virtual bool OnInit() OVERRIDE; - virtual void OnShutdownNoLock( - scoped_ptr<ReadBuffer> read_buffer, - scoped_ptr<WriteBuffer> write_buffer) OVERRIDE; + virtual void OnShutdownNoLock(scoped_ptr<ReadBuffer> read_buffer, + scoped_ptr<WriteBuffer> write_buffer) OVERRIDE; // |base::MessageLoopForIO::Watcher| implementation: virtual void OnFileCanReadWithoutBlocking(int fd) OVERRIDE; @@ -132,12 +131,11 @@ void RawChannelPosix::EnqueueMessageNoLock( for (; platform_handles->size() - i > embedder::kPlatformChannelMaxNumHandles; i += embedder::kPlatformChannelMaxNumHandles) { - scoped_ptr<MessageInTransit> fd_message( - new MessageInTransit( - MessageInTransit::kTypeRawChannel, - MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, - 0, - NULL)); + scoped_ptr<MessageInTransit> fd_message(new MessageInTransit( + MessageInTransit::kTypeRawChannel, + MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, + 0, + NULL)); embedder::ScopedPlatformHandleVectorPtr fds( new embedder::PlatformHandleVector( platform_handles->begin() + i, @@ -162,7 +160,7 @@ bool RawChannelPosix::OnReadMessageForRawChannel( DCHECK_EQ(message_view.type(), MessageInTransit::kTypeRawChannel); if (message_view.subtype() == - MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles) { + MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles) { // We don't need to do anything. |RawChannel| won't extract the platform // handles, and they'll be accumulated in |Read()|. return true; @@ -180,11 +178,8 @@ RawChannel::IOResult RawChannelPosix::Read(size_t* bytes_read) { read_buffer()->GetBuffer(&buffer, &bytes_to_read); size_t old_num_platform_handles = read_platform_handles_.size(); - ssize_t read_result = - embedder::PlatformChannelRecvmsg(fd_.get(), - buffer, - bytes_to_read, - &read_platform_handles_); + ssize_t read_result = embedder::PlatformChannelRecvmsg( + fd_.get(), buffer, bytes_to_read, &read_platform_handles_); if (read_platform_handles_.size() > old_num_platform_handles) { DCHECK_LE(read_platform_handles_.size() - old_num_platform_handles, embedder::kPlatformChannelMaxNumHandles); @@ -194,8 +189,9 @@ RawChannel::IOResult RawChannelPosix::Read(size_t* bytes_read) { // possible because we could have accumulated all the handles for a message, // 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::kMaxPlatformHandles + - embedder::kPlatformChannelMaxNumHandles)) { + if (read_platform_handles_.size() > + (TransportData::kMaxPlatformHandles + + embedder::kPlatformChannelMaxNumHandles)) { LOG(WARNING) << "Received too many platform handles"; embedder::CloseAllPlatformHandles(&read_platform_handles_); read_platform_handles_.clear(); @@ -263,9 +259,8 @@ RawChannel::IOResult RawChannelPosix::WriteNoLock( if (write_buffer_no_lock()->HavePlatformHandlesToSend()) { embedder::PlatformHandle* platform_handles; void* serialization_data; // Actually unused. - write_buffer_no_lock()->GetPlatformHandlesToSend(&num_platform_handles, - &platform_handles, - &serialization_data); + write_buffer_no_lock()->GetPlatformHandlesToSend( + &num_platform_handles, &platform_handles, &serialization_data); DCHECK_GT(num_platform_handles, 0u); DCHECK_LE(num_platform_handles, embedder::kPlatformChannelMaxNumHandles); DCHECK(platform_handles); @@ -292,8 +287,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]; @@ -303,8 +298,8 @@ RawChannel::IOResult RawChannelPosix::WriteNoLock( iov[i].iov_len = buffers[i].size; } - write_result = embedder::PlatformChannelWritev(fd_.get(), iov, - buffer_count); + write_result = + embedder::PlatformChannelWritev(fd_.get(), iov, buffer_count); } } @@ -330,16 +325,19 @@ RawChannel::IOResult RawChannelPosix::ScheduleWriteNoLock() { // Set up to wait for the FD to become writable. // If we're not on the I/O thread, we have to post a task to do this. if (base::MessageLoop::current() != message_loop_for_io()) { - message_loop_for_io()->PostTask( - FROM_HERE, - base::Bind(&RawChannelPosix::WaitToWrite, - weak_ptr_factory_.GetWeakPtr())); + message_loop_for_io()->PostTask(FROM_HERE, + base::Bind(&RawChannelPosix::WaitToWrite, + weak_ptr_factory_.GetWeakPtr())); pending_write_ = true; return IO_PENDING; } - if (message_loop_for_io()->WatchFileDescriptor(fd_.get().fd, false, - base::MessageLoopForIO::WATCH_WRITE, write_watcher_.get(), this)) { + if (message_loop_for_io()->WatchFileDescriptor( + fd_.get().fd, + false, + base::MessageLoopForIO::WATCH_WRITE, + write_watcher_.get(), + this)) { pending_write_ = true; return IO_PENDING; } @@ -355,8 +353,12 @@ bool RawChannelPosix::OnInit() { DCHECK(!write_watcher_); 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)) { + if (!message_loop_for_io()->WatchFileDescriptor( + 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). @@ -374,7 +376,7 @@ void RawChannelPosix::OnShutdownNoLock( DCHECK_EQ(base::MessageLoop::current(), message_loop_for_io()); write_lock().AssertAcquired(); - read_watcher_.reset(); // This will stop watching (if necessary). + read_watcher_.reset(); // This will stop watching (if necessary). write_watcher_.reset(); // This will stop watching (if necessary). pending_read_ = false; @@ -429,9 +431,8 @@ void RawChannelPosix::OnFileCanWriteWithoutBlocking(int fd) { } if (result != IO_PENDING) { - OnWriteCompleted(result == IO_SUCCEEDED, - platform_handles_written, - bytes_written); + OnWriteCompleted( + result == IO_SUCCEEDED, platform_handles_written, bytes_written); } } @@ -441,8 +442,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/system/raw_channel_unittest.cc b/mojo/system/raw_channel_unittest.cc index 2a386833..2158b76 100644 --- a/mojo/system/raw_channel_unittest.cc +++ b/mojo/system/raw_channel_unittest.cc @@ -40,7 +40,8 @@ scoped_ptr<MessageInTransit> MakeTestMessage(uint32_t num_bytes) { return make_scoped_ptr( new MessageInTransit(MessageInTransit::kTypeMessagePipeEndpoint, MessageInTransit::kSubtypeMessagePipeEndpointData, - num_bytes, bytes.empty() ? NULL : &bytes[0])); + num_bytes, + bytes.empty() ? NULL : &bytes[0])); } bool CheckMessageData(const void* bytes, uint32_t num_bytes) { @@ -133,8 +134,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); @@ -163,8 +164,7 @@ class TestMessageReaderAndChecker { // Erase message data. bytes_.erase(bytes_.begin(), - bytes_.begin() + - message_view.main_buffer_size()); + bytes_.begin() + message_view.main_buffer_size()); return rv; } } @@ -194,9 +194,9 @@ TEST_F(RawChannelTest, WriteMessage) { WriteOnlyRawChannelDelegate delegate; scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); TestMessageReaderAndChecker checker(handles[1].get()); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Write and read, for a variety of sizes. for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) { @@ -210,18 +210,15 @@ TEST_F(RawChannelTest, WriteMessage) { for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) EXPECT_TRUE(checker.ReadAndCheckNextMessage(size)) << size; - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get()))); } // RawChannelTest.OnReadMessage ------------------------------------------------ class ReadCheckerRawChannelDelegate : public RawChannel::Delegate { public: - ReadCheckerRawChannelDelegate() - : done_event_(false, false), - position_(0) {} + ReadCheckerRawChannelDelegate() : done_event_(false, false), position_(0) {} virtual ~ReadCheckerRawChannelDelegate() {} // |RawChannel::Delegate| implementation (called on the I/O thread): @@ -245,8 +242,9 @@ class ReadCheckerRawChannelDelegate : public RawChannel::Delegate { EXPECT_EQ(expected_size, message_view.num_bytes()) << position; if (message_view.num_bytes() == expected_size) { - EXPECT_TRUE(CheckMessageData(message_view.bytes(), - message_view.num_bytes())) << position; + EXPECT_TRUE( + CheckMessageData(message_view.bytes(), message_view.num_bytes())) + << position; } if (should_signal) @@ -258,9 +256,7 @@ class ReadCheckerRawChannelDelegate : public RawChannel::Delegate { } // Waits for all the messages (of sizes |expected_sizes_|) to be seen. - void Wait() { - done_event_.Wait(); - } + void Wait() { done_event_.Wait(); } void SetExpectedSizes(const std::vector<uint32_t>& expected_sizes) { base::AutoLock locker(lock_); @@ -283,9 +279,9 @@ class ReadCheckerRawChannelDelegate : public RawChannel::Delegate { TEST_F(RawChannelTest, OnReadMessage) { ReadCheckerRawChannelDelegate delegate; scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Write and read, for a variety of sizes. for (uint32_t size = 1; size < 5 * 1000 * 1000; size += size / 2 + 1) { @@ -306,9 +302,8 @@ TEST_F(RawChannelTest, OnReadMessage) { EXPECT_TRUE(WriteTestMessageToHandle(handles[1].get(), size)); delegate.Wait(); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get()))); } // RawChannelTest.WriteMessageAndOnReadMessage --------------------------------- @@ -318,12 +313,9 @@ class RawChannelWriterThread : public base::SimpleThread { RawChannelWriterThread(RawChannel* raw_channel, size_t write_count) : base::SimpleThread("raw_channel_writer_thread"), raw_channel_(raw_channel), - left_to_write_(write_count) { - } + left_to_write_(write_count) {} - virtual ~RawChannelWriterThread() { - Join(); - } + virtual ~RawChannelWriterThread() { Join(); } private: virtual void Run() OVERRIDE { @@ -344,9 +336,7 @@ class RawChannelWriterThread : public base::SimpleThread { class ReadCountdownRawChannelDelegate : public RawChannel::Delegate { public: explicit ReadCountdownRawChannelDelegate(size_t expected_count) - : done_event_(false, false), - expected_count_(expected_count), - count_(0) {} + : done_event_(false, false), expected_count_(expected_count), count_(0) {} virtual ~ReadCountdownRawChannelDelegate() {} // |RawChannel::Delegate| implementation (called on the I/O thread): @@ -358,8 +348,8 @@ class ReadCountdownRawChannelDelegate : public RawChannel::Delegate { EXPECT_LT(count_, expected_count_); count_++; - EXPECT_TRUE(CheckMessageData(message_view.bytes(), - message_view.num_bytes())); + EXPECT_TRUE( + CheckMessageData(message_view.bytes(), message_view.num_bytes())); if (count_ >= expected_count_) done_event_.Signal(); @@ -370,9 +360,7 @@ class ReadCountdownRawChannelDelegate : public RawChannel::Delegate { } // Waits for all the messages to have been seen. - void Wait() { - done_event_.Wait(); - } + void Wait() { done_event_.Wait(); } private: base::WaitableEvent done_event_; @@ -389,14 +377,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); + 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))); { @@ -416,13 +406,13 @@ TEST_F(RawChannelTest, WriteMessageAndOnReadMessage) { // Wait for reading to finish. reader_delegate.Wait(); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(reader_rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&RawChannel::Shutdown, base::Unretained(reader_rc.get()))); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(writer_rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&RawChannel::Shutdown, base::Unretained(writer_rc.get()))); } // RawChannelTest.OnFatalError ------------------------------------------------- @@ -437,8 +427,7 @@ class FatalErrorRecordingRawChannelDelegate got_read_fatal_error_event_(false, false), got_write_fatal_error_event_(false, false), expecting_read_error_(expect_read_error), - expecting_write_error_(expect_write_error) { - } + expecting_write_error_(expect_write_error) {} virtual ~FatalErrorRecordingRawChannelDelegate() {} @@ -474,9 +463,9 @@ class FatalErrorRecordingRawChannelDelegate TEST_F(RawChannelTest, OnFatalError) { FatalErrorRecordingRawChannelDelegate delegate(0, true, true); scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Close the handle of the other end, which should make writing fail. handles[1].reset(); @@ -495,9 +484,8 @@ TEST_F(RawChannelTest, OnFatalError) { // notification. (If we actually get another one, |OnFatalError()| crashes.) base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20)); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get()))); } // RawChannelTest.ReadUnaffectedByWriteFatalError ------------------------------ @@ -518,9 +506,9 @@ TEST_F(RawChannelTest, ReadUnaffectedByWriteFatalError) { // messages that were written. FatalErrorRecordingRawChannelDelegate delegate(kMessageCount, true, true); scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1))); @@ -533,9 +521,8 @@ TEST_F(RawChannelTest, ReadUnaffectedByWriteFatalError) { // And then we should get a read fatal error. delegate.WaitForReadFatalError(); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get()))); } // RawChannelTest.WriteMessageAfterShutdown ------------------------------------ @@ -545,12 +532,11 @@ TEST_F(RawChannelTest, ReadUnaffectedByWriteFatalError) { TEST_F(RawChannelTest, WriteMessageAfterShutdown) { WriteOnlyRawChannelDelegate delegate; scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&RawChannel::Shutdown, - base::Unretained(rc.get()))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, base::Bind(&RawChannel::Shutdown, base::Unretained(rc.get()))); EXPECT_FALSE(rc->WriteMessage(MakeTestMessage(1))); } @@ -571,8 +557,8 @@ class ShutdownOnReadMessageRawChannelDelegate : public RawChannel::Delegate { embedder::ScopedPlatformHandleVectorPtr platform_handles) OVERRIDE { EXPECT_FALSE(platform_handles); EXPECT_FALSE(did_shutdown_); - EXPECT_TRUE(CheckMessageData(message_view.bytes(), - message_view.num_bytes())); + EXPECT_TRUE( + CheckMessageData(message_view.bytes(), message_view.num_bytes())); raw_channel_->Shutdown(); did_shutdown_ = true; done_event_.Signal(); @@ -602,9 +588,9 @@ TEST_F(RawChannelTest, ShutdownOnReadMessage) { scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); ShutdownOnReadMessageRawChannelDelegate delegate(rc.get()); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Wait for the delegate, which will shut the |RawChannel| down. delegate.Wait(); @@ -656,9 +642,9 @@ TEST_F(RawChannelTest, ShutdownOnFatalErrorRead) { scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); ShutdownOnFatalErrorRawChannelDelegate delegate( rc.get(), RawChannel::Delegate::FATAL_ERROR_READ); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Close the handle of the other end, which should stuff fail. handles[1].reset(); @@ -671,9 +657,9 @@ TEST_F(RawChannelTest, ShutdownOnFatalErrorWrite) { scoped_ptr<RawChannel> rc(RawChannel::Create(handles[0].Pass())); ShutdownOnFatalErrorRawChannelDelegate delegate( rc.get(), RawChannel::Delegate::FATAL_ERROR_WRITE); - io_thread()->PostTaskAndWait(FROM_HERE, - base::Bind(&InitOnIOThread, rc.get(), - base::Unretained(&delegate))); + io_thread()->PostTaskAndWait( + FROM_HERE, + base::Bind(&InitOnIOThread, rc.get(), base::Unretained(&delegate))); // Close the handle of the other end, which should stuff fail. handles[1].reset(); diff --git a/mojo/system/raw_shared_buffer.h b/mojo/system/raw_shared_buffer.h index d38acb8..cc2a787 100644 --- a/mojo/system/raw_shared_buffer.h +++ b/mojo/system/raw_shared_buffer.h @@ -118,8 +118,10 @@ class MOJO_SYSTEM_IMPL_EXPORT RawSharedBufferMapping { size_t length, void* real_base, size_t real_length) - : base_(base), length_(length), - real_base_(real_base), real_length_(real_length) {} + : base_(base), + length_(length), + real_base_(real_base), + real_length_(real_length) {} void Unmap(); void* const base_; diff --git a/mojo/system/raw_shared_buffer_posix.cc b/mojo/system/raw_shared_buffer_posix.cc index 5c98737..779bcd6 100644 --- a/mojo/system/raw_shared_buffer_posix.cc +++ b/mojo/system/raw_shared_buffer_posix.cc @@ -5,7 +5,7 @@ #include "mojo/system/raw_shared_buffer.h" #include <stdint.h> -#include <stdio.h> // For |fileno()|. +#include <stdio.h> // For |fileno()|. #include <sys/mman.h> // For |mmap()|/|munmap()|. #include <sys/stat.h> #include <sys/types.h> // For |off_t|. @@ -39,7 +39,7 @@ bool RawSharedBuffer::Init() { base::ThreadRestrictions::ScopedAllowIO allow_io; if (static_cast<uint64_t>(num_bytes_) > - static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { + static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { return false; } @@ -88,7 +88,7 @@ bool RawSharedBuffer::InitFromPlatformHandle( DCHECK(!handle_.is_valid()); if (static_cast<uint64_t>(num_bytes_) > - static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { + static_cast<uint64_t>(std::numeric_limits<off_t>::max())) { return false; } @@ -126,8 +126,12 @@ scoped_ptr<RawSharedBufferMapping> RawSharedBuffer::MapImpl(size_t offset, DCHECK_LE(static_cast<uint64_t>(real_offset), static_cast<uint64_t>(std::numeric_limits<off_t>::max())); - void* real_base = mmap(NULL, real_length, PROT_READ | PROT_WRITE, MAP_SHARED, - handle_.get().fd, static_cast<off_t>(real_offset)); + void* real_base = mmap(NULL, + real_length, + PROT_READ | PROT_WRITE, + MAP_SHARED, + handle_.get().fd, + static_cast<off_t>(real_offset)); // |mmap()| should return |MAP_FAILED| (a.k.a. -1) on error. But it shouldn't // return null either. if (real_base == MAP_FAILED || !real_base) { diff --git a/mojo/system/raw_shared_buffer_unittest.cc b/mojo/system/raw_shared_buffer_unittest.cc index 07da4f9..862bb83 100644 --- a/mojo/system/raw_shared_buffer_unittest.cc +++ b/mojo/system/raw_shared_buffer_unittest.cc @@ -146,7 +146,7 @@ TEST(RawSharedBufferTest, MappingsDistinct) { } TEST(RawSharedBufferTest, BufferZeroInitialized) { - static const size_t kSizes[] = { 10, 100, 1000, 10000, 100000 }; + static const size_t kSizes[] = {10, 100, 1000, 10000, 100000}; for (size_t i = 0; i < arraysize(kSizes); i++) { scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(kSizes[i])); scoped_ptr<RawSharedBufferMapping> mapping(buffer->Map(0, kSizes[i])); diff --git a/mojo/system/raw_shared_buffer_win.cc b/mojo/system/raw_shared_buffer_win.cc index fdccd36..14f9c2e 100644 --- a/mojo/system/raw_shared_buffer_win.cc +++ b/mojo/system/raw_shared_buffer_win.cc @@ -23,7 +23,7 @@ bool RawSharedBuffer::Init() { // TODO(vtl): Currently, we only support mapping up to 2^32-1 bytes. if (static_cast<uint64_t>(num_bytes_) > - static_cast<uint64_t>(std::numeric_limits<DWORD>::max())) { + static_cast<uint64_t>(std::numeric_limits<DWORD>::max())) { return false; } @@ -33,9 +33,13 @@ bool RawSharedBuffer::Init() { // TODO(vtl): Unlike |base::SharedMemory|, we don't round up the size (to a // multiple of 64 KB). This may cause problems with NaCl. Cross this bridge // when we get there. crbug.com/210609 - handle_.reset(embedder::PlatformHandle(CreateFileMapping( - INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, - static_cast<DWORD>(num_bytes_), NULL))); + handle_.reset( + embedder::PlatformHandle(CreateFileMapping(INVALID_HANDLE_VALUE, + NULL, + PAGE_READWRITE, + 0, + static_cast<DWORD>(num_bytes_), + NULL))); if (!handle_.is_valid()) { PLOG(ERROR) << "CreateFileMapping"; return false; @@ -64,9 +68,11 @@ scoped_ptr<RawSharedBufferMapping> RawSharedBuffer::MapImpl(size_t offset, DCHECK_LE(static_cast<uint64_t>(real_offset), static_cast<uint64_t>(std::numeric_limits<DWORD>::max())); - void* real_base = MapViewOfFile( - handle_.get().handle, FILE_MAP_READ | FILE_MAP_WRITE, 0, - static_cast<DWORD>(real_offset), real_length); + void* real_base = MapViewOfFile(handle_.get().handle, + FILE_MAP_READ | FILE_MAP_WRITE, + 0, + static_cast<DWORD>(real_offset), + real_length); if (!real_base) { PLOG(ERROR) << "MapViewOfFile"; return scoped_ptr<RawSharedBufferMapping>(); diff --git a/mojo/system/remote_message_pipe_unittest.cc b/mojo/system/remote_message_pipe_unittest.cc index c0a78ff..8f15e10 100644 --- a/mojo/system/remote_message_pipe_unittest.cc +++ b/mojo/system/remote_message_pipe_unittest.cc @@ -18,7 +18,7 @@ #include "base/macros.h" #include "base/message_loop/message_loop.h" #include "base/threading/platform_thread.h" // For |Sleep()|. -#include "build/build_config.h" // TODO(vtl): Remove this. +#include "build/build_config.h" // TODO(vtl): Remove this. #include "mojo/common/test/test_utils.h" #include "mojo/embedder/platform_channel_pair.h" #include "mojo/embedder/scoped_platform_handle.h" @@ -66,7 +66,9 @@ class RemoteMessagePipeTest : public testing::Test { io_thread_.PostTaskAndWait( FROM_HERE, base::Bind(&RemoteMessagePipeTest::ConnectMessagePipesOnIOThread, - base::Unretained(this), mp0, mp1)); + base::Unretained(this), + mp0, + mp1)); } // This connects |mp|'s port |channel_index ^ 1| to channel |channel_index|. @@ -78,7 +80,9 @@ class RemoteMessagePipeTest : public testing::Test { io_thread_.PostTask( FROM_HERE, base::Bind(&RemoteMessagePipeTest::BootstrapMessagePipeOnIOThread, - base::Unretained(this), channel_index, mp)); + base::Unretained(this), + channel_index, + mp)); } void RestoreInitialState() { @@ -175,7 +179,7 @@ class RemoteMessagePipeTest : public testing::Test { TEST_F(RemoteMessagePipeTest, Basic) { static const char kHello[] = "hello"; static const char kWorld[] = "world!!!1!!!1!"; - char buffer[100] = { 0 }; + char buffer[100] = {0}; uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); Waiter waiter; uint32_t context = 0; @@ -202,8 +206,10 @@ TEST_F(RemoteMessagePipeTest, Basic) { // Write to MP 0, port 0. EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), - sizeof(kHello), NULL, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait. @@ -213,8 +219,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), NULL, NULL, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -226,8 +235,10 @@ TEST_F(RemoteMessagePipeTest, Basic) { mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456)); EXPECT_EQ(MOJO_RESULT_OK, - mp1->WriteMessage(1, UserPointer<const void>(kWorld), - sizeof(kWorld), NULL, + mp1->WriteMessage(1, + UserPointer<const void>(kWorld), + sizeof(kWorld), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -236,8 +247,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), NULL, NULL, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kWorld, buffer); @@ -267,7 +281,7 @@ TEST_F(RemoteMessagePipeTest, Basic) { TEST_F(RemoteMessagePipeTest, Multiplex) { static const char kHello[] = "hello"; static const char kWorld[] = "world!!!1!!!1!"; - char buffer[100] = { 0 }; + char buffer[100] = {0}; uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); Waiter waiter; uint32_t context = 0; @@ -299,8 +313,10 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { mp3->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789)); EXPECT_EQ(MOJO_RESULT_OK, - mp2->WriteMessage(0, UserPointer<const void>(kHello), - sizeof(kHello), NULL, + mp2->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -310,25 +326,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), NULL, NULL, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, 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), NULL, NULL, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, 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), NULL, NULL, + mp2->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, 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(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), NULL, NULL, + mp3->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -340,8 +368,10 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123)); EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kWorld), - sizeof(kWorld), NULL, + mp0->WriteMessage(0, + UserPointer<const void>(kWorld), + sizeof(kWorld), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context)); @@ -351,24 +381,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), NULL, NULL, + mp0->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, 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), NULL, NULL, + mp2->ReadMessage(0, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); buffer_size = static_cast<uint32_t>(sizeof(buffer)); EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT, - mp3->ReadMessage(1, UserPointer<void>(buffer), - MakeUserPointer(&buffer_size), NULL, NULL, + mp3->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, 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), NULL, NULL, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kWorld, buffer); @@ -381,7 +423,7 @@ TEST_F(RemoteMessagePipeTest, Multiplex) { TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { static const char kHello[] = "hello"; - char buffer[100] = { 0 }; + char buffer[100] = {0}; uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer)); Waiter waiter; uint32_t context = 0; @@ -396,13 +438,14 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) { // Write to MP 0, port 0. EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), - sizeof(kHello), NULL, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); BootstrapMessagePipeNoWait(0, mp0); - // Close MP 0, port 0 before channel 1 is even connected. mp0->Close(0); @@ -425,8 +468,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), NULL, NULL, + mp1->ReadMessage(1, + UserPointer<void>(buffer), + MakeUserPointer(&buffer_size), + NULL, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size)); EXPECT_STREQ(kHello, buffer); @@ -449,8 +495,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { ConnectMessagePipes(mp0, mp1); // We'll try to pass this dispatcher. - scoped_refptr<MessagePipeDispatcher> dispatcher(new MessagePipeDispatcher( - MessagePipeDispatcher::kDefaultCreateOptions)); + scoped_refptr<MessagePipeDispatcher> dispatcher( + new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions)); scoped_refptr<MessagePipe> local_mp(new MessagePipe()); dispatcher->Init(local_mp, 0); @@ -462,15 +508,17 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { // Write to MP 0, port 0. { - DispatcherTransport - transport(test::DispatcherTryStartTransport(dispatcher.get())); + DispatcherTransport transport( + test::DispatcherTryStartTransport(dispatcher.get())); EXPECT_TRUE(transport.is_valid()); std::vector<DispatcherTransport> transports; transports.push_back(transport); EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), - sizeof(kHello), &transports, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); @@ -486,14 +534,16 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { mp1->RemoveWaiter(1, &waiter); // Read from MP 1, port 1. - char read_buffer[100] = { 0 }; + char read_buffer[100] = {0}; 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), + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), MakeUserPointer(&read_buffer_size), - &read_dispatchers, &read_num_dispatchers, + &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); @@ -512,8 +562,10 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { // Write to "local_mp", port 1. EXPECT_EQ(MOJO_RESULT_OK, - local_mp->WriteMessage(1, UserPointer<const void>(kHello), - sizeof(kHello), NULL, + local_mp->WriteMessage(1, + UserPointer<const void>(kHello), + sizeof(kHello), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately @@ -529,7 +581,9 @@ 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, NULL, + MakeUserPointer(&read_buffer_size), + 0, + NULL, MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); @@ -542,7 +596,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) { // Write to the dispatcher. EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(UserPointer<const void>(kHello), - sizeof(kHello), NULL, + sizeof(kHello), + NULL, MOJO_WRITE_MESSAGE_FLAG_NONE)); // Wait. @@ -554,9 +609,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), NULL, - NULL, MOJO_READ_MESSAGE_FLAG_NONE)); + local_mp->ReadMessage(1, + UserPointer<void>(read_buffer), + MakeUserPointer(&read_buffer_size), + NULL, + NULL, + MOJO_READ_MESSAGE_FLAG_NONE)); EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size)); EXPECT_STREQ(kHello, read_buffer); @@ -592,17 +650,17 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { // We'll try to pass this dispatcher. scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); ASSERT_TRUE(dispatcher); // Make a mapping. scoped_ptr<RawSharedBufferMapping> 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->base()); ASSERT_EQ(100u, mapping0->length()); @@ -618,15 +676,17 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { // Write to MP 0, port 0. { - DispatcherTransport - transport(test::DispatcherTryStartTransport(dispatcher.get())); + DispatcherTransport transport( + test::DispatcherTryStartTransport(dispatcher.get())); EXPECT_TRUE(transport.is_valid()); std::vector<DispatcherTransport> transports; transports.push_back(transport); EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kHello), - sizeof(kHello), &transports, + mp0->WriteMessage(0, + UserPointer<const void>(kHello), + sizeof(kHello), + &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); @@ -642,14 +702,16 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { mp1->RemoveWaiter(1, &waiter); // Read from MP 1, port 1. - char read_buffer[100] = { 0 }; + char read_buffer[100] = {0}; 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), + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), MakeUserPointer(&read_buffer_size), - &read_dispatchers, &read_num_dispatchers, + &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); @@ -659,14 +721,13 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) { EXPECT_TRUE(read_dispatchers[0]->HasOneRef()); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, read_dispatchers[0]->GetType()); - dispatcher = - static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get()); + dispatcher = static_cast<SharedBufferDispatcher*>(read_dispatchers[0].get()); // Make another mapping. scoped_ptr<RawSharedBufferMapping> 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->base()); ASSERT_EQ(100u, mapping1->length()); @@ -718,8 +779,8 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { ConnectMessagePipes(mp0, mp1); base::FilePath unused; - base::ScopedFILE fp(CreateAndOpenTemporaryFileInDir(temp_dir.path(), - &unused)); + base::ScopedFILE fp( + CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused)); EXPECT_EQ(sizeof(kHello), fwrite(kHello, 1, sizeof(kHello), fp.get())); // We'll try to pass this dispatcher, which will cause a |PlatformHandle| to // be passed. @@ -735,15 +796,17 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { // Write to MP 0, port 0. { - DispatcherTransport - transport(test::DispatcherTryStartTransport(dispatcher.get())); + DispatcherTransport transport( + test::DispatcherTryStartTransport(dispatcher.get())); EXPECT_TRUE(transport.is_valid()); std::vector<DispatcherTransport> transports; transports.push_back(transport); EXPECT_EQ(MOJO_RESULT_OK, - mp0->WriteMessage(0, UserPointer<const void>(kWorld), - sizeof(kWorld), &transports, + mp0->WriteMessage(0, + UserPointer<const void>(kWorld), + sizeof(kWorld), + &transports, MOJO_WRITE_MESSAGE_FLAG_NONE)); transport.End(); @@ -759,14 +822,16 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) { mp1->RemoveWaiter(1, &waiter); // Read from MP 1, port 1. - char read_buffer[100] = { 0 }; + char read_buffer[100] = {0}; 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), + mp1->ReadMessage(1, + UserPointer<void>(read_buffer), MakeUserPointer(&read_buffer_size), - &read_dispatchers, &read_num_dispatchers, + &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); diff --git a/mojo/system/run_all_unittests.cc b/mojo/system/run_all_unittests.cc index 7e9c8c5..2855e96 100644 --- a/mojo/system/run_all_unittests.cc +++ b/mojo/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, base::Bind(&base::TestSuite::Run, - base::Unretained(&test_suite))); + argc, + argv, + base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite))); } diff --git a/mojo/system/shared_buffer_dispatcher.cc b/mojo/system/shared_buffer_dispatcher.cc index 375ae7c..c30abeb 100644 --- a/mojo/system/shared_buffer_dispatcher.cc +++ b/mojo/system/shared_buffer_dispatcher.cc @@ -29,9 +29,8 @@ struct SerializedSharedBufferDispatcher { // static const MojoCreateSharedBufferOptions SharedBufferDispatcher::kDefaultCreateOptions = { - static_cast<uint32_t>(sizeof(MojoCreateSharedBufferOptions)), - MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE -}; + static_cast<uint32_t>(sizeof(MojoCreateSharedBufferOptions)), + MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE}; // static MojoResult SharedBufferDispatcher::ValidateCreateOptions( @@ -121,16 +120,16 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize( // Wrapping |platform_handle| in a |ScopedPlatformHandle| means that it'll be // closed even if creation fails. scoped_refptr<RawSharedBuffer> shared_buffer( - RawSharedBuffer::CreateFromPlatformHandle(num_bytes, - embedder::ScopedPlatformHandle(platform_handle))); + RawSharedBuffer::CreateFromPlatformHandle( + num_bytes, embedder::ScopedPlatformHandle(platform_handle))); if (!shared_buffer) { LOG(ERROR) << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)"; return scoped_refptr<SharedBufferDispatcher>(); } - return scoped_refptr<SharedBufferDispatcher>(new SharedBufferDispatcher( - shared_buffer)); + return scoped_refptr<SharedBufferDispatcher>( + new SharedBufferDispatcher(shared_buffer)); } SharedBufferDispatcher::SharedBufferDispatcher( @@ -149,9 +148,8 @@ MojoResult SharedBufferDispatcher::ValidateDuplicateOptions( const MojoDuplicateBufferHandleOptionsFlags kKnownFlags = MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE; static const MojoDuplicateBufferHandleOptions kDefaultOptions = { - static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), - MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE - }; + static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions)), + MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}; *out_options = kDefaultOptions; if (in_options.IsNull()) @@ -161,8 +159,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; @@ -182,7 +180,7 @@ void SharedBufferDispatcher::CloseImplNoLock() { } scoped_refptr<Dispatcher> - SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { +SharedBufferDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() { lock().AssertAcquired(); DCHECK(shared_buffer_); scoped_refptr<RawSharedBuffer> shared_buffer; @@ -253,9 +251,8 @@ bool SharedBufferDispatcher::EndSerializeAndCloseImplNoLock( // one else can make any more references to it), so we can just take its // handle. embedder::ScopedPlatformHandle platform_handle( - shared_buffer_->HasOneRef() ? - shared_buffer_->PassPlatformHandle() : - shared_buffer_->DuplicatePlatformHandle()); + shared_buffer_->HasOneRef() ? shared_buffer_->PassPlatformHandle() + : shared_buffer_->DuplicatePlatformHandle()); if (!platform_handle.is_valid()) { shared_buffer_ = NULL; return false; diff --git a/mojo/system/shared_buffer_dispatcher_unittest.cc b/mojo/system/shared_buffer_dispatcher_unittest.cc index a5198d7..0e53330 100644 --- a/mojo/system/shared_buffer_dispatcher_unittest.cc +++ b/mojo/system/shared_buffer_dispatcher_unittest.cc @@ -52,16 +52,15 @@ TEST(SharedBufferDispatcherTest, ValidateCreateOptionsValid) { // Different flags. MojoCreateSharedBufferOptionsFlags flags_values[] = { - MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE - }; + MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE}; for (size_t i = 0; i < arraysize(flags_values); i++) { const MojoCreateSharedBufferOptionsFlags flags = flags_values[i]; // Different capacities (size 1). for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) { MojoCreateSharedBufferOptions options = { - kSizeOfCreateOptions, // |struct_size|. - flags // |flags|. + kSizeOfCreateOptions, // |struct_size|. + flags // |flags|. }; MojoCreateSharedBufferOptions validated_options = {}; EXPECT_EQ(MOJO_RESULT_OK, @@ -78,8 +77,8 @@ TEST(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { // Invalid |struct_size|. { MojoCreateSharedBufferOptions options = { - 1, // |struct_size|. - MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE // |flags|. + 1, // |struct_size|. + MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE // |flags|. }; MojoCreateSharedBufferOptions unused; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, @@ -90,8 +89,8 @@ TEST(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { // Unknown |flags|. { MojoCreateSharedBufferOptions options = { - kSizeOfCreateOptions, // |struct_size|. - ~0u // |flags|. + kSizeOfCreateOptions, // |struct_size|. + ~0u // |flags|. }; MojoCreateSharedBufferOptions unused; EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, @@ -102,18 +101,18 @@ TEST(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) { TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); ASSERT_TRUE(dispatcher); EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType()); // Make a couple of mappings. scoped_ptr<RawSharedBufferMapping> 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->base()); EXPECT_EQ(100u, mapping1->length()); @@ -121,9 +120,9 @@ TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { static_cast<char*>(mapping1->base())[50] = 'x'; scoped_ptr<RawSharedBufferMapping> 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->base()); EXPECT_EQ(50u, mapping2->length()); @@ -139,33 +138,33 @@ TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) { TEST(SharedBufferDispatcher, DuplicateBufferHandle) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher1)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher1)); // Map and write something. scoped_ptr<RawSharedBufferMapping> 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->base())[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); 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->base())[0]); EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close()); @@ -173,16 +172,15 @@ TEST(SharedBufferDispatcher, DuplicateBufferHandle) { TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher1)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher1)); MojoDuplicateBufferHandleOptions options[] = { - {sizeof(MojoDuplicateBufferHandleOptions), - MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, - {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u} - }; + {sizeof(MojoDuplicateBufferHandleOptions), + MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}, + {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u}}; for (size_t i = 0; i < arraysize(options); i++) { scoped_refptr<Dispatcher> dispatcher2; EXPECT_EQ(MOJO_RESULT_OK, @@ -198,16 +196,15 @@ TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) { TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { scoped_refptr<SharedBufferDispatcher> dispatcher1; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher1)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher1)); // Invalid |struct_size|. { MojoDuplicateBufferHandleOptions options = { - 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE - }; + 1u, MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE}; scoped_refptr<Dispatcher> dispatcher2; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), @@ -218,8 +215,7 @@ TEST(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) { // Unknown |flags|. { MojoDuplicateBufferHandleOptions options = { - sizeof(MojoDuplicateBufferHandleOptions), ~0u - }; + sizeof(MojoDuplicateBufferHandleOptions), ~0u}; scoped_refptr<Dispatcher> dispatcher2; EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options), @@ -236,7 +232,8 @@ TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED, SharedBufferDispatcher::Create( SharedBufferDispatcher::kDefaultCreateOptions, - std::numeric_limits<uint64_t>::max(), &dispatcher)); + std::numeric_limits<uint64_t>::max(), + &dispatcher)); EXPECT_FALSE(dispatcher); // Zero size. @@ -248,10 +245,10 @@ TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) { TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) { scoped_refptr<SharedBufferDispatcher> dispatcher; - EXPECT_EQ(MOJO_RESULT_OK, - SharedBufferDispatcher::Create( - SharedBufferDispatcher::kDefaultCreateOptions, 100, - &dispatcher)); + EXPECT_EQ( + MOJO_RESULT_OK, + SharedBufferDispatcher::Create( + SharedBufferDispatcher::kDefaultCreateOptions, 100, &dispatcher)); scoped_ptr<RawSharedBufferMapping> mapping; EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, diff --git a/mojo/system/simple_dispatcher_unittest.cc b/mojo/system/simple_dispatcher_unittest.cc index 778e7e2..27aedb1d 100644 --- a/mojo/system/simple_dispatcher_unittest.cc +++ b/mojo/system/simple_dispatcher_unittest.cc @@ -60,16 +60,14 @@ class MockSimpleDispatcher : public SimpleDispatcher { HandleSignalsStateChangedNoLock(); } - virtual Type GetType() const OVERRIDE { - return kTypeUnknown; - } + virtual Type GetType() const OVERRIDE { return kTypeUnknown; } private: friend class base::RefCountedThreadSafe<MockSimpleDispatcher>; virtual ~MockSimpleDispatcher() {} virtual scoped_refptr<Dispatcher> - CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { + CreateEquivalentDispatcherAndCloseImplNoLock() OVERRIDE { scoped_refptr<MockSimpleDispatcher> rv(new MockSimpleDispatcher()); rv->state_ = state_; return scoped_refptr<Dispatcher>(rv.get()); @@ -159,8 +157,8 @@ TEST(SimpleDispatcherTest, MAYBE_Basic) { EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, w.Wait(2 * test::EpsilonTimeout().InMicroseconds(), NULL)); base::TimeDelta elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); d->RemoveWaiter(&w); EXPECT_EQ(MOJO_RESULT_OK, d->Close()); @@ -183,8 +181,8 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { // Wait (forever) for writable and then it becomes never writable. w.Init(); - d->SetSatisfiableSignals( - MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); + d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 2)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); @@ -196,8 +194,8 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { // Wait for zero time for writable and then it becomes never writable. w.Init(); - d->SetSatisfiableSignals( - MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); + d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 3)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); @@ -209,8 +207,8 @@ TEST(SimpleDispatcherTest, BasicUnsatisfiable) { // Wait for non-zero, finite time for writable and then it becomes never // writable. w.Init(); - d->SetSatisfiableSignals( - MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE); + d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE | + MOJO_HANDLE_SIGNAL_WRITABLE); ASSERT_EQ(MOJO_RESULT_OK, d->AddWaiter(&w, MOJO_HANDLE_SIGNAL_WRITABLE, 4)); d->SetSatisfiableSignals(MOJO_HANDLE_SIGNAL_READABLE); stopwatch.Start(); @@ -295,7 +293,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 1, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); } // Joins the thread. @@ -313,7 +313,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 2, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -321,8 +323,8 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); } // Joins the thread. base::TimeDelta elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_OK, result); EXPECT_EQ(2u, context); @@ -334,7 +336,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 3, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); @@ -342,8 +346,8 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); } // Joins the thread. elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(3u, context); @@ -355,15 +359,17 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, 4, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); EXPECT_EQ(MOJO_RESULT_OK, d->Close()); } // Joins the thread. elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_CANCELLED, result); EXPECT_EQ(4u, context); @@ -376,7 +382,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { MOJO_HANDLE_SIGNAL_READABLE, 2 * test::EpsilonTimeout().InMicroseconds(), 5, - &did_wait, &result, &context); + &did_wait, + &result, + &context); stopwatch.Start(); thread.Start(); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); @@ -387,8 +395,8 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) { EXPECT_EQ(MOJO_RESULT_OK, d->Close()); } elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_TRUE(did_wait); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result); } @@ -524,7 +532,9 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { MOJO_HANDLE_SIGNAL_READABLE, 3 * test::EpsilonTimeout().InMicroseconds(), i, - &did_wait[i], &result[i], &context[i])); + &did_wait[i], + &result[i], + &context[i])); threads.back()->Start(); } for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) { @@ -533,7 +543,9 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) { MOJO_HANDLE_SIGNAL_WRITABLE, 1 * test::EpsilonTimeout().InMicroseconds(), i, - &did_wait[i], &result[i], &context[i])); + &did_wait[i], + &result[i], + &context[i])); threads.back()->Start(); } base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); diff --git a/mojo/system/test_utils.cc b/mojo/system/test_utils.cc index 48f1091..d4e8d28 100644 --- a/mojo/system/test_utils.cc +++ b/mojo/system/test_utils.cc @@ -34,14 +34,14 @@ void PostTaskAndWait(scoped_refptr<base::TaskRunner> task_runner, } base::TimeDelta EpsilonTimeout() { - // Originally, our epsilon timeout was 10 ms, which was mostly fine but flaky - // on some Windows bots. I don't recall ever seeing flakes on other bots. At - // 30 ms tests seem reliable on Windows bots, but not at 25 ms. We'd like this - // timeout to be as small as possible (see the description in the .h file). - // - // Currently, |tiny_timeout()| is usually 100 ms (possibly scaled under ASAN, - // etc.). Based on this, set it to (usually be) 30 ms on Windows and 20 ms - // elsewhere. +// Originally, our epsilon timeout was 10 ms, which was mostly fine but flaky on +// some Windows bots. I don't recall ever seeing flakes on other bots. At 30 ms +// tests seem reliable on Windows bots, but not at 25 ms. We'd like this timeout +// to be as small as possible (see the description in the .h file). +// +// Currently, |tiny_timeout()| is usually 100 ms (possibly scaled under ASAN, +// etc.). Based on this, set it to (usually be) 30 ms on Windows and 20 ms +// elsewhere. #if defined(OS_WIN) return (TestTimeouts::tiny_timeout() * 3) / 10; #else @@ -52,8 +52,7 @@ base::TimeDelta EpsilonTimeout() { // TestIOThread ---------------------------------------------------------------- TestIOThread::TestIOThread(Mode mode) - : io_thread_("test_io_thread"), - io_thread_started_(false) { + : io_thread_("test_io_thread"), io_thread_started_(false) { switch (mode) { case kAutoStart: Start(); diff --git a/mojo/system/test_utils.h b/mojo/system/test_utils.h index cf1a2f8..8c0609f 100644 --- a/mojo/system/test_utils.h +++ b/mojo/system/test_utils.h @@ -44,13 +44,9 @@ class Stopwatch { Stopwatch() {} ~Stopwatch() {} - void Start() { - start_time_ = base::TimeTicks::Now(); - } + void Start() { start_time_ = base::TimeTicks::Now(); } - base::TimeDelta Elapsed() { - return base::TimeTicks::Now() - start_time_; - } + base::TimeDelta Elapsed() { return base::TimeTicks::Now() - start_time_; } private: base::TimeTicks start_time_; diff --git a/mojo/system/transport_data.cc b/mojo/system/transport_data.cc index 10a3228e..d14ac71f 100644 --- a/mojo/system/transport_data.cc +++ b/mojo/system/transport_data.cc @@ -23,7 +23,8 @@ namespace system { // space needed need not be a multiple of the alignment. const size_t kMaxSizePerPlatformHandle = 8; COMPILE_ASSERT(kMaxSizePerPlatformHandle % - MessageInTransit::kMessageAlignment == 0, + MessageInTransit::kMessageAlignment == + 0, kMaxSizePerPlatformHandle_not_a_multiple_of_alignment); STATIC_CONST_MEMBER_DEFINITION const size_t @@ -42,8 +43,8 @@ const size_t TransportData::kMaxPlatformHandles = // static const size_t TransportData::kMaxBufferSize = sizeof(Header) + - kMaxMessageNumHandles * (sizeof(HandleTableEntry) + - kMaxSerializedDispatcherSize) + + kMaxMessageNumHandles * + (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) + kMaxPlatformHandles * kMaxSizePerPlatformHandle; struct TransportData::PrivateStructForCompileAsserts { @@ -53,12 +54,14 @@ struct TransportData::PrivateStructForCompileAsserts { // The maximum serialized dispatcher size must be a multiple of the alignment. COMPILE_ASSERT(kMaxSerializedDispatcherSize % - MessageInTransit::kMessageAlignment == 0, + MessageInTransit::kMessageAlignment == + 0, kMaxSerializedDispatcherSize_not_a_multiple_of_alignment); // The size of |HandleTableEntry| must be a multiple of the alignment. COMPILE_ASSERT(sizeof(HandleTableEntry) % - MessageInTransit::kMessageAlignment == 0, + MessageInTransit::kMessageAlignment == + 0, sizeof_MessageInTransit_HandleTableEntry_invalid); }; @@ -88,14 +91,13 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers, size_t max_size = 0; size_t max_platform_handles = 0; Dispatcher::TransportDataAccess::StartSerialize( - dispatcher, channel, &max_size, &max_platform_handles); + dispatcher, channel, &max_size, &max_platform_handles); DCHECK_LE(max_size, kMaxSerializedDispatcherSize); estimated_size += MessageInTransit::RoundUpMessageAlignment(max_size); DCHECK_LE(estimated_size, kMaxBufferSize); - DCHECK_LE(max_platform_handles, - kMaxSerializedDispatcherPlatformHandles); + DCHECK_LE(max_platform_handles, kMaxSerializedDispatcherPlatformHandles); estimated_num_platform_handles += max_platform_handles; DCHECK_LE(estimated_num_platform_handles, kMaxPlatformHandles); @@ -151,17 +153,21 @@ 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); handle_table[i].size = static_cast<uint32_t>(actual_size); - // (Okay to not set |unused| since we cleared the entire buffer.) +// (Okay to not set |unused| since we cleared the entire buffer.) #if DCHECK_IS_ON DCHECK_LE(actual_size, all_max_sizes[i]); - DCHECK_LE(platform_handles_ ? (platform_handles_->size() - - old_platform_handles_size) : 0, + DCHECK_LE(platform_handles_ + ? (platform_handles_->size() - old_platform_handles_size) + : 0, all_max_platform_handles[i]); #endif } else { @@ -195,8 +201,7 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers, #if defined(OS_POSIX) TransportData::TransportData( embedder::ScopedPlatformHandleVectorPtr platform_handles) - : buffer_size_(sizeof(Header)), - platform_handles_(platform_handles.Pass()) { + : buffer_size_(sizeof(Header)), platform_handles_(platform_handles.Pass()) { buffer_.reset(static_cast<char*>( base::AlignedAlloc(buffer_size_, MessageInTransit::kMessageAlignment))); memset(buffer_.get(), 0, buffer_size_); @@ -242,13 +247,13 @@ const char* TransportData::ValidateBuffer( if (header->num_platform_handles == 0) { // Then |platform_handle_table_offset| should also be zero. if (header->platform_handle_table_offset != 0) { - return - "Message has no handles attached, but platform handle table present"; + return "Message has no handles attached, but platform handle table " + "present"; } } else { // |num_handles| has already been validated, so the multiplication is okay. if (header->num_platform_handles > - num_handles * kMaxSerializedDispatcherPlatformHandles) + num_handles * kMaxSerializedDispatcherPlatformHandles) return "Message has too many platform handles attached"; static const char kInvalidPlatformHandleTableOffset[] = @@ -256,7 +261,8 @@ const char* TransportData::ValidateBuffer( // This doesn't check that the platform handle table doesn't alias other // stuff, but it doesn't matter, since it's all read-only. if (header->platform_handle_table_offset % - MessageInTransit::kMessageAlignment != 0) + MessageInTransit::kMessageAlignment != + 0) return kInvalidPlatformHandleTableOffset; // ">" instead of ">=" since the size per handle may be zero. @@ -267,7 +273,7 @@ const char* TransportData::ValidateBuffer( // |num_platform_handles|, so the addition and multiplication are okay. if (header->platform_handle_table_offset + header->num_platform_handles * serialized_platform_handle_size > - buffer_size) + buffer_size) return kInvalidPlatformHandleTableOffset; } @@ -305,7 +311,7 @@ void TransportData::GetPlatformHandleTable(const void* transport_data_buffer, const Header* header = static_cast<const Header*>(transport_data_buffer); *num_platform_handles = header->num_platform_handles; *platform_handle_table = static_cast<const char*>(transport_data_buffer) + - header->platform_handle_table_offset; + header->platform_handle_table_offset; } // static diff --git a/mojo/system/transport_data.h b/mojo/system/transport_data.h index ddaa20b..b74623c 100644 --- a/mojo/system/transport_data.h +++ b/mojo/system/transport_data.h @@ -164,9 +164,9 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData { }; struct HandleTableEntry { - int32_t type; // From |Dispatcher::Type| (|kTypeUnknown| for "invalid"). + int32_t type; // From |Dispatcher::Type| (|kTypeUnknown| for "invalid"). uint32_t offset; // Relative to the start of the "secondary buffer". - uint32_t size; // (Not including any padding.) + uint32_t size; // (Not including any padding.) uint32_t unused; }; diff --git a/mojo/system/waiter.cc b/mojo/system/waiter.cc index 381f9bb..70e6c29 100644 --- a/mojo/system/waiter.cc +++ b/mojo/system/waiter.cc @@ -64,7 +64,8 @@ MojoResult Waiter::Wait(MojoDeadline deadline, uint32_t* context) { } else { // NOTE(vtl): This is very inefficient on POSIX, since pthreads condition // variables take an absolute deadline. - const base::TimeTicks end_time = base::TimeTicks::Now() + + const base::TimeTicks end_time = + base::TimeTicks::Now() + base::TimeDelta::FromMicroseconds(static_cast<int64_t>(deadline)); do { base::TimeTicks now_time = base::TimeTicks::Now(); diff --git a/mojo/system/waiter.h b/mojo/system/waiter.h index 66fe6e7..af85e9c 100644 --- a/mojo/system/waiter.h +++ b/mojo/system/waiter.h @@ -61,7 +61,7 @@ class MOJO_SYSTEM_IMPL_EXPORT Waiter { private: base::ConditionVariable cv_; // Associated to |lock_|. - base::Lock lock_; // Protects the following members. + base::Lock lock_; // Protects the following members. #ifndef NDEBUG bool initialized_; #endif diff --git a/mojo/system/waiter_list_unittest.cc b/mojo/system/waiter_list_unittest.cc index 1abe5e7..647fb64 100644 --- a/mojo/system/waiter_list_unittest.cc +++ b/mojo/system/waiter_list_unittest.cc @@ -32,7 +32,8 @@ TEST(WaiterListTest, BasicCancel) { waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); waiter_list.CancelAllWaiters(); - waiter_list.RemoveWaiter(thread.waiter()); // Double-remove okay. + // Double-remove okay: + waiter_list.RemoveWaiter(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_CANCELLED, result); EXPECT_EQ(1u, context); @@ -71,10 +72,9 @@ TEST(WaiterListTest, BasicAwakeSatisfied) { test::SimpleWaiterThread thread(&result, &context); waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); waiter_list.RemoveWaiter(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); @@ -85,12 +85,12 @@ TEST(WaiterListTest, BasicAwakeSatisfied) { WaiterList waiter_list; test::SimpleWaiterThread thread(&result, &context); waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_WRITABLE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_WRITABLE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.RemoveWaiter(thread.waiter()); + // Double-remove okay: waiter_list.RemoveWaiter(thread.waiter()); - waiter_list.RemoveWaiter(thread.waiter()); // Double-remove okay. thread.Start(); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); @@ -103,10 +103,9 @@ TEST(WaiterListTest, BasicAwakeSatisfied) { waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); waiter_list.RemoveWaiter(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_OK, result); @@ -123,9 +122,8 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) { test::SimpleWaiterThread thread(&result, &context); waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1); thread.Start(); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE, - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE)); waiter_list.RemoveWaiter(thread.waiter()); } // Join |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); @@ -136,9 +134,8 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) { WaiterList waiter_list; test::SimpleWaiterThread thread(&result, &context); waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 2); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE, - MOJO_HANDLE_SIGNAL_READABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_READABLE, MOJO_HANDLE_SIGNAL_READABLE)); waiter_list.RemoveWaiter(thread.waiter()); thread.Start(); } // Join |thread|. @@ -152,11 +149,11 @@ TEST(WaiterListTest, BasicAwakeUnsatisfiable) { waiter_list.AddWaiter(thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3); thread.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE, - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.RemoveWaiter(thread.waiter()); + // Double-remove okay: waiter_list.RemoveWaiter(thread.waiter()); - waiter_list.RemoveWaiter(thread.waiter()); // Double-remove okay. } // Join |thread|. EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(3u, context); @@ -199,10 +196,9 @@ TEST(WaiterListTest, MultipleWaiters) { waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 4); thread2.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); waiter_list.RemoveWaiter(thread1.waiter()); waiter_list.CancelAllWaiters(); } // Join threads. @@ -221,9 +217,8 @@ TEST(WaiterListTest, MultipleWaiters) { waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 6); thread2.Start(); base::PlatformThread::Sleep(2 * test::EpsilonTimeout()); - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE, - MOJO_HANDLE_SIGNAL_READABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE)); waiter_list.RemoveWaiter(thread2.waiter()); waiter_list.CancelAllWaiters(); } // Join threads. @@ -242,10 +237,9 @@ TEST(WaiterListTest, MultipleWaiters) { base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Should do nothing. - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_NONE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); test::SimpleWaiterThread thread2(&result2, &context2); waiter_list.AddWaiter(thread2.waiter(), MOJO_HANDLE_SIGNAL_WRITABLE, 8); @@ -254,10 +248,9 @@ TEST(WaiterListTest, MultipleWaiters) { base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Awake #1. - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_READABLE, - MOJO_HANDLE_SIGNAL_READABLE | - MOJO_HANDLE_SIGNAL_WRITABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_READABLE, + MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE)); waiter_list.RemoveWaiter(thread1.waiter()); base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); @@ -273,9 +266,8 @@ TEST(WaiterListTest, MultipleWaiters) { base::PlatformThread::Sleep(1 * test::EpsilonTimeout()); // Awake #2 and #3 for unsatisfiability. - waiter_list.AwakeWaitersForStateChange( - HandleSignalsState(MOJO_HANDLE_SIGNAL_NONE, - MOJO_HANDLE_SIGNAL_READABLE)); + waiter_list.AwakeWaitersForStateChange(HandleSignalsState( + MOJO_HANDLE_SIGNAL_NONE, MOJO_HANDLE_SIGNAL_READABLE)); waiter_list.RemoveWaiter(thread2.waiter()); waiter_list.RemoveWaiter(thread3.waiter()); diff --git a/mojo/system/waiter_test_utils.cc b/mojo/system/waiter_test_utils.cc index f762e985f..00e080c 100644 --- a/mojo/system/waiter_test_utils.cc +++ b/mojo/system/waiter_test_utils.cc @@ -9,11 +9,9 @@ namespace system { namespace test { SimpleWaiterThread::SimpleWaiterThread(MojoResult* result, uint32_t* context) - : base::SimpleThread("waiter_thread"), - result_(result), - context_(context) { + : base::SimpleThread("waiter_thread"), result_(result), context_(context) { waiter_.Init(); - *result_ = -5420734; // Totally invalid result. + *result_ = -5420734; // Totally invalid result. *context_ = 23489023; // "Random". } @@ -41,7 +39,7 @@ WaiterThread::WaiterThread(scoped_refptr<Dispatcher> dispatcher, result_out_(result_out), context_out_(context_out) { *did_wait_out_ = false; - *result_out_ = -8542346; // Totally invalid result. + *result_out_ = -8542346; // Totally invalid result. *context_out_ = 89023444; // "Random". } diff --git a/mojo/system/waiter_unittest.cc b/mojo/system/waiter_unittest.cc index 53f8ec4..4656927 100644 --- a/mojo/system/waiter_unittest.cc +++ b/mojo/system/waiter_unittest.cc @@ -37,9 +37,7 @@ class WaitingThread : public base::SimpleThread { waiter_.Init(); } - virtual ~WaitingThread() { - Join(); - } + virtual ~WaitingThread() { Join(); } void WaitUntilDone(MojoResult* result, uint32_t* context, @@ -132,8 +130,8 @@ TEST(WaiterTest, Basic) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(1, result); EXPECT_EQ(3u, context); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); } // Awake some longer time after thread start. @@ -145,8 +143,8 @@ TEST(WaiterTest, Basic) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(2, result); EXPECT_EQ(4u, context); - EXPECT_GT(elapsed, (5-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (5+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (5 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (5 + 1) * test::EpsilonTimeout()); } // Don't awake -- time out (on another thread). @@ -156,8 +154,8 @@ TEST(WaiterTest, Basic) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, result); EXPECT_EQ(static_cast<uint32_t>(-1), context); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); } // No (indefinite) deadline. @@ -193,8 +191,8 @@ TEST(WaiterTest, Basic) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(1, result); EXPECT_EQ(7u, context); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); } // Awake some longer time after thread start. @@ -206,8 +204,8 @@ TEST(WaiterTest, Basic) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(2, result); EXPECT_EQ(8u, context); - EXPECT_GT(elapsed, (5-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (5+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (5 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (5 + 1) * test::EpsilonTimeout()); } } @@ -230,8 +228,8 @@ TEST(WaiterTest, TimeOut) { EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(2 * test::EpsilonTimeout().InMicroseconds(), &context)); elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (2 + 1) * test::EpsilonTimeout()); EXPECT_EQ(123u, context); waiter.Init(); @@ -239,8 +237,8 @@ TEST(WaiterTest, TimeOut) { EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(5 * test::EpsilonTimeout().InMicroseconds(), &context)); elapsed = stopwatch.Elapsed(); - EXPECT_GT(elapsed, (5-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (5+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (5 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (5 + 1) * test::EpsilonTimeout()); EXPECT_EQ(123u, context); } @@ -294,8 +292,8 @@ TEST(WaiterTest, MultipleAwakes) { thread.WaitUntilDone(&result, &context, &elapsed); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result); EXPECT_EQ(7u, context); - EXPECT_GT(elapsed, (1-1) * test::EpsilonTimeout()); - EXPECT_LT(elapsed, (1+1) * test::EpsilonTimeout()); + EXPECT_GT(elapsed, (1 - 1) * test::EpsilonTimeout()); + EXPECT_LT(elapsed, (1 + 1) * test::EpsilonTimeout()); } } |