Re-run clang-format on mojo/edk/{embedder,system,test}.
Our "standard" format changed. This avoids distracting format changes in
future CLs (at the cost of a "one"-time mega-churn).
TBR=yzshen@chromium.org
Review URL: https://codereview.chromium.org/724493002
diff --git a/mojo/edk/embedder/channel_init.cc b/mojo/edk/embedder/channel_init.cc
index 9ea984b..0e7a7b6 100644
--- a/mojo/edk/embedder/channel_init.cc
+++ b/mojo/edk/embedder/channel_init.cc
@@ -25,12 +25,11 @@
DCHECK(!io_thread_task_runner_.get()); // Should only init once.
io_thread_task_runner_ = io_thread_task_runner;
ScopedMessagePipeHandle message_pipe =
- CreateChannel(ScopedPlatformHandle(PlatformHandle(file)),
- io_thread_task_runner,
- base::Bind(&ChannelInit::OnCreatedChannel,
- weak_factory_.GetWeakPtr(),
- io_thread_task_runner),
- base::MessageLoop::current()->message_loop_proxy()).Pass();
+ CreateChannel(
+ ScopedPlatformHandle(PlatformHandle(file)), io_thread_task_runner,
+ base::Bind(&ChannelInit::OnCreatedChannel, weak_factory_.GetWeakPtr(),
+ io_thread_task_runner),
+ base::MessageLoop::current()->message_loop_proxy()).Pass();
return message_pipe.Pass();
}
diff --git a/mojo/edk/embedder/embedder.cc b/mojo/edk/embedder/embedder.cc
index b80ae0a..a790da0 100644
--- a/mojo/edk/embedder/embedder.cc
+++ b/mojo/edk/embedder/embedder.cc
@@ -126,13 +126,11 @@
channel_info->channel_thread_task_runner = io_thread_task_runner;
if (rv.is_valid()) {
- io_thread_task_runner->PostTask(FROM_HERE,
- base::Bind(&CreateChannelHelper,
- base::Passed(&platform_handle),
- base::Passed(&channel_info),
- channel_endpoint,
- callback,
- callback_thread_task_runner));
+ io_thread_task_runner->PostTask(
+ FROM_HERE,
+ base::Bind(&CreateChannelHelper, base::Passed(&platform_handle),
+ base::Passed(&channel_info), channel_endpoint, callback,
+ callback_thread_task_runner));
} else {
(callback_thread_task_runner.get() ? callback_thread_task_runner
: io_thread_task_runner)
diff --git a/mojo/edk/embedder/embedder.h b/mojo/edk/embedder/embedder.h
index cfaf025..11a352c 100644
--- a/mojo/edk/embedder/embedder.h
+++ b/mojo/edk/embedder/embedder.h
@@ -71,8 +71,8 @@
// |DestroyChannelOnIOThread()| (or |DestoryChannel()|) to tear down the
// channel. Returns a handle to the bootstrap message pipe.
MOJO_SYSTEM_IMPL_EXPORT ScopedMessagePipeHandle
- CreateChannelOnIOThread(ScopedPlatformHandle platform_handle,
- ChannelInfo** channel_info);
+CreateChannelOnIOThread(ScopedPlatformHandle platform_handle,
+ ChannelInfo** channel_info);
typedef base::Callback<void(ChannelInfo*)> DidCreateChannelCallback;
// Creates a channel asynchronously; may be called from any thread.
@@ -85,10 +85,10 @@
// it will be called using |io_thread_task_runner|. Returns a handle to the
// bootstrap message pipe.
MOJO_SYSTEM_IMPL_EXPORT ScopedMessagePipeHandle
- CreateChannel(ScopedPlatformHandle platform_handle,
- scoped_refptr<base::TaskRunner> io_thread_task_runner,
- DidCreateChannelCallback callback,
- scoped_refptr<base::TaskRunner> callback_thread_task_runner);
+CreateChannel(ScopedPlatformHandle platform_handle,
+ scoped_refptr<base::TaskRunner> io_thread_task_runner,
+ DidCreateChannelCallback callback,
+ scoped_refptr<base::TaskRunner> callback_thread_task_runner);
// Destroys a channel that was created using either |CreateChannelOnIOThread()|
// or |CreateChannel()|; must only be called from the I/O thread. |channel_info|
@@ -113,14 +113,14 @@
// failure, which is different from what you'd expect from a Mojo API, but it
// makes for a more convenient embedder API.
MOJO_SYSTEM_IMPL_EXPORT MojoResult
- CreatePlatformHandleWrapper(ScopedPlatformHandle platform_handle,
- MojoHandle* platform_handle_wrapper_handle);
+CreatePlatformHandleWrapper(ScopedPlatformHandle platform_handle,
+ MojoHandle* platform_handle_wrapper_handle);
// Retrieves the |PlatformHandle| that was wrapped into a |MojoHandle| (using
// |CreatePlatformHandleWrapper()| above). Note that the |MojoHandle| must still
// be closed separately.
MOJO_SYSTEM_IMPL_EXPORT MojoResult
- PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle,
- ScopedPlatformHandle* platform_handle);
+PassWrappedPlatformHandle(MojoHandle platform_handle_wrapper_handle,
+ ScopedPlatformHandle* platform_handle);
} // namespace embedder
} // namespace mojo
diff --git a/mojo/edk/embedder/embedder_unittest.cc b/mojo/edk/embedder/embedder_unittest.cc
index 5c4d0d8..78423d2 100644
--- a/mojo/edk/embedder/embedder_unittest.cc
+++ b/mojo/edk/embedder/embedder_unittest.cc
@@ -39,8 +39,7 @@
did_create_channel_event_(true, false),
channel_info_(nullptr) {
bootstrap_message_pipe_ =
- CreateChannel(platform_handle.Pass(),
- io_thread_task_runner_,
+ CreateChannel(platform_handle.Pass(), io_thread_task_runner_,
base::Bind(&ScopedTestChannel::DidCreateChannel,
base::Unretained(this)),
nullptr)
@@ -53,8 +52,7 @@
// the I/O thread must be alive and pumping messages.)
~ScopedTestChannel() {
system::test::PostTaskAndWait(
- io_thread_task_runner_,
- FROM_HERE,
+ io_thread_task_runner_, FROM_HERE,
base::Bind(&ScopedTestChannel::DestroyChannel, base::Unretained(this)));
}
@@ -130,27 +128,18 @@
// We can write to a message pipe handle immediately.
const char kHello[] = "hello";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp,
- kHello,
- static_cast<uint32_t>(sizeof(kHello)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(server_mp, kHello,
+ static_cast<uint32_t>(sizeof(kHello)), nullptr,
+ 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Now wait for the other side to become readable.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(
- client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
char buffer[1000] = {};
uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), num_bytes);
EXPECT_STREQ(kHello, buffer);
@@ -189,40 +178,28 @@
// Write a message to |h0| (attaching nothing).
const char kHello[] = "hello";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(h0,
- kHello,
- static_cast<uint32_t>(sizeof(kHello)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ MojoWriteMessage(h0, kHello, static_cast<uint32_t>(sizeof(kHello)),
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Write one message to |server_mp|, attaching |h1|.
const char kWorld[] = "world!!!";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp,
- kWorld,
- static_cast<uint32_t>(sizeof(kWorld)),
- &h1,
- 1,
+ MojoWriteMessage(server_mp, kWorld,
+ static_cast<uint32_t>(sizeof(kWorld)), &h1, 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
h1 = MOJO_HANDLE_INVALID;
// Write another message to |h0|.
const char kFoo[] = "foo";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(h0,
- kFoo,
- static_cast<uint32_t>(sizeof(kFoo)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(h0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait for |client_mp| to become readable.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(
- client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
// Read a message from |client_mp|.
char buffer[1000] = {};
@@ -230,12 +207,8 @@
MojoHandle handles[10] = {};
uint32_t num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp,
- buffer,
- &num_bytes,
- handles,
- &num_handles,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ MojoReadMessage(client_mp, buffer, &num_bytes, handles,
+ &num_handles, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), num_bytes);
EXPECT_STREQ(kWorld, buffer);
EXPECT_EQ(1u, num_handles);
@@ -243,9 +216,8 @@
h1 = handles[0];
// Wait for |h1| to become readable.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
// Read a message from |h1|.
memset(buffer, 0, sizeof(buffer));
@@ -253,58 +225,41 @@
memset(handles, 0, sizeof(handles));
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h1,
- buffer,
- &num_bytes,
- handles,
- &num_handles,
+ MojoReadMessage(h1, buffer, &num_bytes, handles, &num_handles,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(0u, num_handles);
// Wait for |h1| to become readable (again).
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
// Read the second message from |h1|.
memset(buffer, 0, sizeof(buffer));
num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h1,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(h1, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kFoo), num_bytes);
EXPECT_STREQ(kFoo, buffer);
// Write a message to |h1|.
const char kBarBaz[] = "barbaz";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(h1,
- kBarBaz,
- static_cast<uint32_t>(sizeof(kBarBaz)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
-
- // Wait for |h0| to become readable.
EXPECT_EQ(
MOJO_RESULT_OK,
- MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ MojoWriteMessage(h1, kBarBaz, static_cast<uint32_t>(sizeof(kBarBaz)),
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
+
+ // Wait for |h0| to become readable.
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(h0, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
// Read a message from |h0|.
memset(buffer, 0, sizeof(buffer));
num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(h0,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(h0, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kBarBaz), num_bytes);
EXPECT_STREQ(kBarBaz, buffer);
@@ -354,29 +309,20 @@
// 1. Write a message to |server_mp| (attaching nothing).
const char kHello[] = "hello";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp,
- kHello,
- static_cast<uint32_t>(sizeof(kHello)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(server_mp, kHello,
+ static_cast<uint32_t>(sizeof(kHello)), nullptr,
+ 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// TODO(vtl): If the scope were ended immediately here (maybe after closing
// |server_mp|), we die with a fatal error in |Channel::HandleLocalError()|.
// 2. Read a message from |server_mp|.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(
- server_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(server_mp, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
char buffer[1000] = {};
uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(server_mp,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(server_mp, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kWorld[] = "world!";
EXPECT_EQ(sizeof(kWorld), num_bytes);
@@ -389,41 +335,29 @@
// 3. Write something to |mp0|.
const char kFoo[] = "FOO";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp0,
- kFoo,
- static_cast<uint32_t>(sizeof(kFoo)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(mp0, kFoo, static_cast<uint32_t>(sizeof(kFoo)),
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// 4. Write a message to |server_mp|, attaching |mp1|.
const char kBar[] = "Bar";
- EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(server_mp,
- kBar,
- static_cast<uint32_t>(sizeof(kBar)),
- &mp1,
- 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ MojoWriteMessage(server_mp, kBar, static_cast<uint32_t>(sizeof(kBar)),
+ &mp1, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
mp1 = MOJO_HANDLE_INVALID;
// 5. Close |server_mp|.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(server_mp));
// 9. Read a message from |mp0|, which should have |mp2| attached.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp0, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
memset(buffer, 0, sizeof(buffer));
num_bytes = static_cast<uint32_t>(sizeof(buffer));
MojoHandle mp2 = MOJO_HANDLE_INVALID;
uint32_t num_handles = 1;
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp0,
- buffer,
- &num_bytes,
- &mp2,
- &num_handles,
+ MojoReadMessage(mp0, buffer, &num_bytes, &mp2, &num_handles,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kQuux[] = "quux";
EXPECT_EQ(sizeof(kQuux), num_bytes);
@@ -432,17 +366,12 @@
EXPECT_NE(mp2, MOJO_HANDLE_INVALID);
// 7. Read a message from |mp2|.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp2, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
memset(buffer, 0, sizeof(buffer));
num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp2,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(mp2, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kBaz[] = "baz";
EXPECT_EQ(sizeof(kBaz), num_bytes);
@@ -482,18 +411,12 @@
CHECK(client_channel.channel_info() != nullptr);
// 1. Read the first message from |client_mp|.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(
- client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
char buffer[1000] = {};
uint32_t num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(client_mp, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kHello[] = "hello";
EXPECT_EQ(sizeof(kHello), num_bytes);
@@ -502,18 +425,13 @@
// 2. Write a message to |client_mp| (attaching nothing).
const char kWorld[] = "world!";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(client_mp,
- kWorld,
- static_cast<uint32_t>(sizeof(kWorld)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(client_mp, kWorld,
+ static_cast<uint32_t>(sizeof(kWorld)), nullptr,
+ 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// 4. Read a message from |client_mp|, which should have |mp1| attached.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(
- client_mp, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(client_mp, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
// TODO(vtl): If the scope were to end here (and |client_mp| closed), we'd
// die (again due to |Channel::HandleLocalError()|).
memset(buffer, 0, sizeof(buffer));
@@ -521,11 +439,7 @@
MojoHandle mp1 = MOJO_HANDLE_INVALID;
uint32_t num_handles = 1;
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(client_mp,
- buffer,
- &num_bytes,
- &mp1,
- &num_handles,
+ MojoReadMessage(client_mp, buffer, &num_bytes, &mp1, &num_handles,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kBar[] = "Bar";
EXPECT_EQ(sizeof(kBar), num_bytes);
@@ -546,12 +460,8 @@
// 7. Write a message to |mp3|.
const char kBaz[] = "baz";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp3,
- kBaz,
- static_cast<uint32_t>(sizeof(kBaz)),
- nullptr,
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(mp3, kBaz, static_cast<uint32_t>(sizeof(kBaz)),
+ nullptr, 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// 8. Close |mp3|.
EXPECT_EQ(MOJO_RESULT_OK, MojoClose(mp3));
@@ -559,26 +469,17 @@
// 9. Write a message to |mp1|, attaching |mp2|.
const char kQuux[] = "quux";
EXPECT_EQ(MOJO_RESULT_OK,
- MojoWriteMessage(mp1,
- kQuux,
- static_cast<uint32_t>(sizeof(kQuux)),
- &mp2,
- 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ MojoWriteMessage(mp1, kQuux, static_cast<uint32_t>(sizeof(kQuux)),
+ &mp2, 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
mp2 = MOJO_HANDLE_INVALID;
// 3. Read a message from |mp1|.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE));
+ EXPECT_EQ(MOJO_RESULT_OK, MojoWait(mp1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE));
memset(buffer, 0, sizeof(buffer));
num_bytes = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- MojoReadMessage(mp1,
- buffer,
- &num_bytes,
- nullptr,
- nullptr,
+ MojoReadMessage(mp1, buffer, &num_bytes, nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
const char kFoo[] = "FOO";
EXPECT_EQ(sizeof(kFoo), num_bytes);
diff --git a/mojo/edk/embedder/platform_channel_pair_posix.cc b/mojo/edk/embedder/platform_channel_pair_posix.cc
index f9886b5..2242cce 100644
--- a/mojo/edk/embedder/platform_channel_pair_posix.cc
+++ b/mojo/edk/embedder/platform_channel_pair_posix.cc
@@ -46,14 +46,10 @@
// fail with |EPIPE| instead). On Linux, we have to use |send...()| with
// |MSG_NOSIGNAL| -- which is not supported on Mac -- instead.
int no_sigpipe = 1;
- PCHECK(
- setsockopt(
- fds[0], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe, sizeof(no_sigpipe)) ==
- 0);
- PCHECK(
- setsockopt(
- fds[1], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe, sizeof(no_sigpipe)) ==
- 0);
+ PCHECK(setsockopt(fds[0], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
+ sizeof(no_sigpipe)) == 0);
+ PCHECK(setsockopt(fds[1], SOL_SOCKET, SO_NOSIGPIPE, &no_sigpipe,
+ sizeof(no_sigpipe)) == 0);
#endif // defined(OS_MACOSX)
server_handle_.reset(PlatformHandle(fds[0]));
diff --git a/mojo/edk/embedder/platform_channel_pair_posix_unittest.cc b/mojo/edk/embedder/platform_channel_pair_posix_unittest.cc
index 926bbc5..c3b1ef1 100644
--- a/mojo/edk/embedder/platform_channel_pair_posix_unittest.cc
+++ b/mojo/edk/embedder/platform_channel_pair_posix_unittest.cc
@@ -112,15 +112,15 @@
std::string send_string(1 << i, 'A' + i);
EXPECT_EQ(static_cast<ssize_t>(send_string.size()),
- PlatformChannelWrite(
- server_handle.get(), send_string.data(), send_string.size()));
+ PlatformChannelWrite(server_handle.get(), send_string.data(),
+ send_string.size()));
WaitReadable(client_handle.get());
char buf[10000] = {};
std::deque<PlatformHandle> received_handles;
- ssize_t result = PlatformChannelRecvmsg(
- client_handle.get(), buf, sizeof(buf), &received_handles);
+ ssize_t result = PlatformChannelRecvmsg(client_handle.get(), buf,
+ sizeof(buf), &received_handles);
EXPECT_EQ(static_cast<ssize_t>(send_string.size()), result);
EXPECT_EQ(send_string, std::string(buf, static_cast<size_t>(result)));
EXPECT_TRUE(received_handles.empty());
@@ -155,9 +155,7 @@
struct iovec iov = {const_cast<char*>(kHello), sizeof(kHello)};
// We assume that the |sendmsg()| actually sends all the data.
EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
- PlatformChannelSendmsgWithHandles(server_handle.get(),
- &iov,
- 1,
+ PlatformChannelSendmsgWithHandles(server_handle.get(), &iov, 1,
&platform_handles[0],
platform_handles.size()));
@@ -167,8 +165,8 @@
std::deque<PlatformHandle> received_handles;
// We assume that the |recvmsg()| actually reads all the data.
EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
- PlatformChannelRecvmsg(
- client_handle.get(), buf, sizeof(buf), &received_handles));
+ PlatformChannelRecvmsg(client_handle.get(), buf, sizeof(buf),
+ &received_handles));
EXPECT_STREQ(kHello, buf);
EXPECT_EQ(i, received_handles.size());
@@ -214,9 +212,7 @@
struct iovec iov = {const_cast<char*>(kHello), sizeof(kHello)};
// We assume that the |sendmsg()| actually sends all the data.
EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
- PlatformChannelSendmsgWithHandles(server_handle.get(),
- &iov,
- 1,
+ PlatformChannelSendmsgWithHandles(server_handle.get(), &iov, 1,
&platform_handles[0],
platform_handles.size()));
}
@@ -230,8 +226,8 @@
char buf[100] = {};
// We assume that the |recvmsg()| actually reads all the data.
EXPECT_EQ(static_cast<ssize_t>(sizeof(kHello)),
- PlatformChannelRecvmsg(
- client_handle.get(), buf, sizeof(buf), &received_handles));
+ PlatformChannelRecvmsg(client_handle.get(), buf, sizeof(buf),
+ &received_handles));
EXPECT_STREQ(kHello, buf);
ASSERT_EQ(2u, received_handles.size());
EXPECT_FALSE(received_handles[0].is_valid());
diff --git a/mojo/edk/embedder/platform_channel_pair_win.cc b/mojo/edk/embedder/platform_channel_pair_win.cc
index 4804eed..25306a6 100644
--- a/mojo/edk/embedder/platform_channel_pair_win.cc
+++ b/mojo/edk/embedder/platform_channel_pair_win.cc
@@ -23,8 +23,7 @@
std::wstring GeneratePipeName() {
return base::StringPrintf(L"\\\\.\\pipe\\mojo.%u.%u.%I64u",
- GetCurrentProcessId(),
- GetCurrentThreadId(),
+ GetCurrentProcessId(), GetCurrentThreadId(),
base::RandUint64());
}
@@ -37,9 +36,7 @@
PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED | FILE_FLAG_FIRST_PIPE_INSTANCE;
const DWORD kPipeMode = PIPE_TYPE_BYTE | PIPE_READMODE_BYTE;
server_handle_.reset(PlatformHandle(
- CreateNamedPipeW(pipe_name.c_str(),
- kOpenMode,
- kPipeMode,
+ CreateNamedPipeW(pipe_name.c_str(), kOpenMode, kPipeMode,
1, // Max instances.
4096, // Out buffer size.
4096, // In buffer size.
@@ -56,12 +53,9 @@
SECURITY_ATTRIBUTES security_attributes = {
sizeof(SECURITY_ATTRIBUTES), nullptr, TRUE};
client_handle_.reset(
- PlatformHandle(CreateFileW(pipe_name.c_str(),
- kDesiredAccess,
+ PlatformHandle(CreateFileW(pipe_name.c_str(), kDesiredAccess,
0, // No sharing.
- &security_attributes,
- OPEN_EXISTING,
- kFlags,
+ &security_attributes, OPEN_EXISTING, kFlags,
nullptr))); // No template file.
PCHECK(client_handle_.is_valid());
diff --git a/mojo/edk/embedder/platform_channel_utils_posix.h b/mojo/edk/embedder/platform_channel_utils_posix.h
index 87176fb..34efcad 100644
--- a/mojo/edk/embedder/platform_channel_utils_posix.h
+++ b/mojo/edk/embedder/platform_channel_utils_posix.h
@@ -30,9 +30,9 @@
// never raise |SIGPIPE|. (Note: On Mac, the suppression of |SIGPIPE| is set up
// by |PlatformChannelPair|.)
MOJO_SYSTEM_IMPL_EXPORT ssize_t
- PlatformChannelWrite(PlatformHandle h, const void* bytes, size_t num_bytes);
+PlatformChannelWrite(PlatformHandle h, const void* bytes, size_t num_bytes);
MOJO_SYSTEM_IMPL_EXPORT ssize_t
- PlatformChannelWritev(PlatformHandle h, struct iovec* iov, size_t num_iov);
+PlatformChannelWritev(PlatformHandle h, struct iovec* iov, size_t num_iov);
// Writes data, and the given set of |PlatformHandle|s (i.e., file descriptors)
// over the Unix domain socket given by |h| (e.g., created using
@@ -43,11 +43,11 @@
// specified by |iov|). (The handles are not closed, regardless of success or
// failure.)
MOJO_SYSTEM_IMPL_EXPORT ssize_t
- PlatformChannelSendmsgWithHandles(PlatformHandle h,
- struct iovec* iov,
- size_t num_iov,
- PlatformHandle* platform_handles,
- size_t num_platform_handles);
+PlatformChannelSendmsgWithHandles(PlatformHandle h,
+ struct iovec* iov,
+ size_t num_iov,
+ PlatformHandle* platform_handles,
+ size_t num_platform_handles);
// TODO(vtl): Remove this once I've switched things over to
// |PlatformChannelSendmsgWithHandles()|.
@@ -65,10 +65,10 @@
// (in the control message) to |PlatformHandle|s (and append them to
// |platform_handles|). (This also handles |EINTR|.)
MOJO_SYSTEM_IMPL_EXPORT ssize_t
- PlatformChannelRecvmsg(PlatformHandle h,
- void* buf,
- size_t num_bytes,
- std::deque<PlatformHandle>* platform_handles);
+PlatformChannelRecvmsg(PlatformHandle h,
+ void* buf,
+ size_t num_bytes,
+ std::deque<PlatformHandle>* platform_handles);
} // namespace embedder
} // namespace mojo
diff --git a/mojo/edk/embedder/platform_handle_utils.h b/mojo/edk/embedder/platform_handle_utils.h
index f594e21..b3d7a79 100644
--- a/mojo/edk/embedder/platform_handle_utils.h
+++ b/mojo/edk/embedder/platform_handle_utils.h
@@ -18,15 +18,14 @@
PlatformHandleContainer* platform_handles) {
for (typename PlatformHandleContainer::iterator it =
platform_handles->begin();
- it != platform_handles->end();
- ++it)
+ it != platform_handles->end(); ++it)
it->CloseIfNecessary();
}
// Duplicates the given |PlatformHandle| (which must be valid). (Returns an
// invalid |ScopedPlatformHandle| on failure.)
MOJO_SYSTEM_IMPL_EXPORT ScopedPlatformHandle
- DuplicatePlatformHandle(PlatformHandle platform_handle);
+DuplicatePlatformHandle(PlatformHandle platform_handle);
} // namespace embedder
} // namespace mojo
diff --git a/mojo/edk/embedder/platform_handle_utils_win.cc b/mojo/edk/embedder/platform_handle_utils_win.cc
index 12745d0..43d1331 100644
--- a/mojo/edk/embedder/platform_handle_utils_win.cc
+++ b/mojo/edk/embedder/platform_handle_utils_win.cc
@@ -15,12 +15,8 @@
DCHECK(platform_handle.is_valid());
HANDLE new_handle;
- if (!DuplicateHandle(GetCurrentProcess(),
- platform_handle.handle,
- GetCurrentProcess(),
- &new_handle,
- 0,
- TRUE,
+ if (!DuplicateHandle(GetCurrentProcess(), platform_handle.handle,
+ GetCurrentProcess(), &new_handle, 0, TRUE,
DUPLICATE_SAME_ACCESS))
return ScopedPlatformHandle();
DCHECK_NE(new_handle, INVALID_HANDLE_VALUE);
diff --git a/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc b/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc
index ebb55ee..8dfcf44 100644
--- a/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc
+++ b/mojo/edk/embedder/simple_platform_shared_buffer_posix.cc
@@ -127,12 +127,9 @@
DCHECK_LE(static_cast<uint64_t>(real_offset),
static_cast<uint64_t>(std::numeric_limits<off_t>::max()));
- void* real_base = mmap(nullptr,
- real_length,
- PROT_READ | PROT_WRITE,
- MAP_SHARED,
- handle_.get().fd,
- static_cast<off_t>(real_offset));
+ void* real_base =
+ mmap(nullptr, 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/edk/embedder/simple_platform_shared_buffer_win.cc b/mojo/edk/embedder/simple_platform_shared_buffer_win.cc
index fd3de83..0737465 100644
--- a/mojo/edk/embedder/simple_platform_shared_buffer_win.cc
+++ b/mojo/edk/embedder/simple_platform_shared_buffer_win.cc
@@ -33,12 +33,9 @@
// 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(PlatformHandle(CreateFileMapping(INVALID_HANDLE_VALUE,
- nullptr,
- PAGE_READWRITE,
- 0,
- static_cast<DWORD>(num_bytes_),
- nullptr)));
+ handle_.reset(PlatformHandle(
+ CreateFileMapping(INVALID_HANDLE_VALUE, nullptr, PAGE_READWRITE, 0,
+ static_cast<DWORD>(num_bytes_), nullptr)));
if (!handle_.is_valid()) {
PLOG(ERROR) << "CreateFileMapping";
return false;
@@ -68,11 +65,9 @@
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 nullptr;
diff --git a/mojo/edk/embedder/test_embedder.cc b/mojo/edk/embedder/test_embedder.cc
index e374e77..1eca9c8 100644
--- a/mojo/edk/embedder/test_embedder.cc
+++ b/mojo/edk/embedder/test_embedder.cc
@@ -28,8 +28,7 @@
for (HandleTable::HandleToEntryMap::const_iterator it =
handle_to_entry_map.begin();
- it != handle_to_entry_map.end();
- ++it) {
+ it != handle_to_entry_map.end(); ++it) {
LOG(ERROR) << "Mojo embedder shutdown: Leaking handle " << (*it).first;
}
return false;
diff --git a/mojo/edk/system/channel.cc b/mojo/edk/system/channel.cc
index 856b7f1..0205312 100644
--- a/mojo/edk/system/channel.cc
+++ b/mojo/edk/system/channel.cc
@@ -72,8 +72,7 @@
size_t num_live = 0;
size_t num_zombies = 0;
for (IdToEndpointMap::iterator it = to_destroy.begin();
- it != to_destroy.end();
- ++it) {
+ it != to_destroy.end(); ++it) {
if (it->second.get()) {
num_live++;
it->second->OnDisconnect();
@@ -131,8 +130,7 @@
if (!is_bootstrap) {
if (!SendControlMessage(
- MessageInTransit::kSubtypeChannelAttachAndRunEndpoint,
- local_id,
+ MessageInTransit::kSubtypeChannelAttachAndRunEndpoint, local_id,
remote_id)) {
HandleLocalError(base::StringPrintf(
"Failed to send message to run remote message pipe endpoint (local "
@@ -196,8 +194,7 @@
}
if (!SendControlMessage(
- MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint,
- local_id,
+ MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, local_id,
remote_id)) {
HandleLocalError(base::StringPrintf(
"Failed to send message to remove remote message pipe endpoint (local "
@@ -470,8 +467,7 @@
if (!SendControlMessage(
MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck,
- local_id,
- remote_id)) {
+ local_id, remote_id)) {
HandleLocalError(base::StringPrintf(
"Failed to send message to remove remote message pipe endpoint ack "
"(local ID %u, remote ID %u)",
diff --git a/mojo/edk/system/channel_endpoint.cc b/mojo/edk/system/channel_endpoint.cc
index 8b64643..dd7cd5b 100644
--- a/mojo/edk/system/channel_endpoint.cc
+++ b/mojo/edk/system/channel_endpoint.cc
@@ -109,8 +109,7 @@
DCHECK(message_view.transport_data_buffer());
message->SetDispatchers(TransportData::DeserializeDispatchers(
message_view.transport_data_buffer(),
- message_view.transport_data_buffer_size(),
- platform_handles.Pass(),
+ message_view.transport_data_buffer_size(), platform_handles.Pass(),
channel_));
}
diff --git a/mojo/edk/system/channel_unittest.cc b/mojo/edk/system/channel_unittest.cc
index f6cf896..68b1315 100644
--- a/mojo/edk/system/channel_unittest.cc
+++ b/mojo/edk/system/channel_unittest.cc
@@ -104,9 +104,8 @@
EXPECT_EQ(TRISTATE_TRUE, init_result());
io_thread()->PostTaskAndWait(
- FROM_HERE,
- base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+ base::Unretained(this)));
// Okay to destroy |Channel| on not-the-I/O-thread.
EXPECT_TRUE(channel()->HasOneRef());
@@ -203,9 +202,8 @@
channel()->AttachAndRunEndpoint(channel_endpoint, true);
io_thread()->PostTaskAndWait(
- FROM_HERE,
- base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+ base::Unretained(this)));
EXPECT_TRUE(channel()->HasOneRef());
}
@@ -273,9 +271,8 @@
channel()->AttachAndRunEndpoint(channel_endpoint, true);
io_thread()->PostTaskAndWait(
- FROM_HERE,
- base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+ base::Unretained(this)));
Waiter waiter;
waiter.Init();
diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc
index caced83..27d33b2 100644
--- a/mojo/edk/system/core.cc
+++ b/mojo/edk/system/core.cc
@@ -126,11 +126,7 @@
UserPointer<MojoHandleSignalsState> signals_state) {
uint32_t unused = static_cast<uint32_t>(-1);
HandleSignalsState hss;
- MojoResult rv = WaitManyInternal(&handle,
- &signals,
- 1,
- deadline,
- &unused,
+ MojoResult rv = WaitManyInternal(&handle, &signals, 1, deadline, &unused,
signals_state.IsNull() ? nullptr : &hss);
if (rv != MOJO_RESULT_INVALID_ARGUMENT && !signals_state.IsNull())
signals_state.Put(hss);
@@ -155,23 +151,17 @@
MojoResult rv;
if (signals_states.IsNull()) {
rv = WaitManyInternal(handles_reader.GetPointer(),
- signals_reader.GetPointer(),
- num_handles,
- deadline,
- &index,
- nullptr);
+ signals_reader.GetPointer(), num_handles, deadline,
+ &index, nullptr);
} else {
UserPointer<MojoHandleSignalsState>::Writer signals_states_writer(
signals_states, num_handles);
// Note: The |reinterpret_cast| is safe, since |HandleSignalsState| is a
// subclass of |MojoHandleSignalsState| that doesn't add any data members.
rv = WaitManyInternal(handles_reader.GetPointer(),
- signals_reader.GetPointer(),
- num_handles,
- deadline,
- &index,
- reinterpret_cast<HandleSignalsState*>(
- signals_states_writer.GetPointer()));
+ signals_reader.GetPointer(), num_handles, deadline,
+ &index, reinterpret_cast<HandleSignalsState*>(
+ signals_states_writer.GetPointer()));
if (rv != MOJO_RESULT_INVALID_ARGUMENT)
signals_states_writer.Commit();
}
@@ -263,11 +253,9 @@
// 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;
}
@@ -308,12 +296,12 @@
MojoResult rv;
if (num_handles_value == 0) {
// Easy case: won't receive any handles.
- rv = dispatcher->ReadMessage(
- bytes, num_bytes, nullptr, &num_handles_value, flags);
+ rv = dispatcher->ReadMessage(bytes, num_bytes, nullptr, &num_handles_value,
+ flags);
} else {
DispatcherVector dispatchers;
- rv = dispatcher->ReadMessage(
- bytes, num_bytes, &dispatchers, &num_handles_value, flags);
+ rv = dispatcher->ReadMessage(bytes, num_bytes, &dispatchers,
+ &num_handles_value, flags);
if (!dispatchers.empty()) {
DCHECK_EQ(rv, MOJO_RESULT_OK);
DCHECK(!num_handles.IsNull());
@@ -466,8 +454,8 @@
return result;
scoped_refptr<SharedBufferDispatcher> dispatcher;
- result = SharedBufferDispatcher::Create(
- platform_support(), validated_options, num_bytes, &dispatcher);
+ result = SharedBufferDispatcher::Create(platform_support(), validated_options,
+ num_bytes, &dispatcher);
if (result != MOJO_RESULT_OK) {
DCHECK(!dispatcher.get());
return result;
diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc
index e6607df..96780f7 100644
--- a/mojo/edk/system/core_unittest.cc
+++ b/mojo/edk/system/core_unittest.cc
@@ -42,45 +42,34 @@
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- NullUserPointer(),
- 0,
+ core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0,
MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteMessageCallCount());
EXPECT_EQ(0u, info.GetReadMessageCallCount());
uint32_t num_bytes = 0;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
- NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->ReadMessage(h, NullUserPointer(), MakeUserPointer(&num_bytes),
+ NullUserPointer(), NullUserPointer(),
+ MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetReadMessageCallCount());
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h,
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
+ core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
+ NullUserPointer(), NullUserPointer(),
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(2u, info.GetReadMessageCallCount());
EXPECT_EQ(0u, info.GetWriteDataCallCount());
- EXPECT_EQ(
- MOJO_RESULT_UNIMPLEMENTED,
- core()->WriteData(
- h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+ core()->WriteData(h, NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteDataCallCount());
EXPECT_EQ(0u, info.GetBeginWriteDataCallCount());
- EXPECT_EQ(
- MOJO_RESULT_UNIMPLEMENTED,
- core()->BeginWriteData(
- h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+ core()->BeginWriteData(h, NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(1u, info.GetBeginWriteDataCallCount());
EXPECT_EQ(0u, info.GetEndWriteDataCallCount());
@@ -88,17 +77,15 @@
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());
@@ -107,9 +94,7 @@
EXPECT_EQ(0u, info.GetAddWaiterCallCount());
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->Wait(h,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
NullUserPointer()));
EXPECT_EQ(1u, info.GetAddWaiterCallCount());
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ -117,9 +102,7 @@
EXPECT_EQ(2u, info.GetAddWaiterCallCount());
MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->Wait(h,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
MakeUserPointer(&hss)));
EXPECT_EQ(3u, info.GetAddWaiterCallCount());
EXPECT_EQ(0u, hss.satisfied_signals);
@@ -130,51 +113,43 @@
EXPECT_EQ(4u, info.GetAddWaiterCallCount());
hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->Wait(
- h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, MakeUserPointer(&hss)));
+ core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000,
+ MakeUserPointer(&hss)));
EXPECT_EQ(5u, info.GetAddWaiterCallCount());
EXPECT_EQ(0u, hss.satisfied_signals);
EXPECT_EQ(0u, hss.satisfiable_signals);
MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(&h),
- MakeUserPointer(&handle_signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()));
EXPECT_EQ(6u, info.GetAddWaiterCallCount());
uint32_t result_index = static_cast<uint32_t>(-1);
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(&h),
- MakeUserPointer(&handle_signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- NullUserPointer()));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ NullUserPointer()));
EXPECT_EQ(7u, info.GetAddWaiterCallCount());
EXPECT_EQ(0u, result_index);
hss = kFullMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(&h),
- MakeUserPointer(&handle_signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- MakeUserPointer(&hss)));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ MakeUserPointer(&hss)));
EXPECT_EQ(8u, info.GetAddWaiterCallCount());
EXPECT_EQ(0u, hss.satisfied_signals);
EXPECT_EQ(0u, hss.satisfiable_signals);
result_index = static_cast<uint32_t>(-1);
hss = kFullMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(&h),
- MakeUserPointer(&handle_signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(&hss)));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(&hss)));
EXPECT_EQ(9u, info.GetAddWaiterCallCount());
EXPECT_EQ(0u, result_index);
EXPECT_EQ(0u, hss.satisfied_signals);
@@ -211,22 +186,16 @@
// |Wait()|:
{
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->Wait(MOJO_HANDLE_INVALID,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer()));
+ core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->Wait(10,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer()));
+ core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->Wait(MOJO_HANDLE_INVALID,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&hss)));
+ core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
// On invalid argument, it shouldn't modify the handle signals state.
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
hss.satisfied_signals);
@@ -234,10 +203,8 @@
hss.satisfiable_signals);
hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->Wait(10,
- ~MOJO_HANDLE_SIGNAL_NONE,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&hss)));
+ core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
// On invalid argument, it shouldn't modify the handle signals state.
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
hss.satisfied_signals);
@@ -250,19 +217,14 @@
MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
~MOJO_HANDLE_SIGNAL_NONE};
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 0,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 0,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()));
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(NullUserPointer(),
- MakeUserPointer(signals),
- 0,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
+ core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
NullUserPointer()));
// If |num_handles| is invalid, it should leave |result_index| and
// |signals_states| alone.
@@ -270,9 +232,7 @@
uint32_t result_index = 123;
MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(NullUserPointer(),
- MakeUserPointer(signals),
- 0,
+ core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
MOJO_DEADLINE_INDEFINITE,
MakeUserPointer(&result_index),
MakeUserPointer(&hss)));
@@ -283,30 +243,23 @@
hss.satisfiable_signals);
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- NullUserPointer(),
- 0,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
+ core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
NullUserPointer()));
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 1,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()));
// But if a handle is bad, then it should set |result_index| but still leave
// |signals_states| alone.
result_index = static_cast<uint32_t>(-1);
hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(&hss)));
+ core()->WaitMany(
+ MakeUserPointer(handles), MakeUserPointer(signals), 1,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(&hss)));
EXPECT_EQ(0u, result_index);
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
hss.satisfied_signals);
@@ -319,12 +272,10 @@
result_index = static_cast<uint32_t>(-1);
hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(&hss)));
+ core()->WaitMany(
+ MakeUserPointer(handles), MakeUserPointer(signals), 1,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(&hss)));
EXPECT_EQ(0u, result_index);
EXPECT_EQ(0u, hss.satisfied_signals);
EXPECT_EQ(0u, hss.satisfiable_signals);
@@ -333,33 +284,27 @@
result_index = static_cast<uint32_t>(-1);
hss = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 2,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(&hss)));
+ core()->WaitMany(
+ MakeUserPointer(handles), MakeUserPointer(signals), 2,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(&hss)));
EXPECT_EQ(1u, result_index);
EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
hss.satisfied_signals);
EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
hss.satisfiable_signals);
handles[1] = handles[0] + 1; // Invalid handle.
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 2,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()));
handles[1] = CreateMockHandle(&info[1]);
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WaitMany(MakeUserPointer(handles),
- MakeUserPointer(signals),
- 2,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()));
// TODO(vtl): Test one where we get "failed precondition" only for the
// second handle (and the first one is valid to wait on).
@@ -376,11 +321,8 @@
// |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;
@@ -392,55 +334,41 @@
// Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
// |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
// not.
- EXPECT_NE(MOJO_RESULT_OK,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- std::numeric_limits<uint32_t>::max(),
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_NE(
+ MOJO_RESULT_OK,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ std::numeric_limits<uint32_t>::max(),
+ MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
// Huge handle count (plausibly big).
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
core()->WriteMessage(
- h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
+ h, NullUserPointer(), 0, MakeUserPointer(handles),
std::numeric_limits<uint32_t>::max() / sizeof(handles[0]),
MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
// Invalid handle in |handles|.
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
// Two invalid handles in |handles|.
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 2,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 2, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
// Can't send a handle over itself.
handles[0] = h;
- EXPECT_EQ(MOJO_RESULT_BUSY,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_BUSY,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(0u, info.GetWriteMessageCallCount());
MockHandleInfo info2;
@@ -448,45 +376,33 @@
// This is "okay", but |MockDispatcher| doesn't implement it.
handles[0] = h2;
- EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 1,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_UNIMPLEMENTED,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 1, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteMessageCallCount());
// One of the |handles| is still invalid.
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 2,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 2, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteMessageCallCount());
// One of the |handles| is the same as |handle|.
handles[1] = h;
- EXPECT_EQ(MOJO_RESULT_BUSY,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 2,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_BUSY,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 2, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteMessageCallCount());
// Can't send a handle twice in the same message.
handles[1] = h2;
- EXPECT_EQ(MOJO_RESULT_BUSY,
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- MakeUserPointer(handles),
- 2,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_BUSY,
+ core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+ 2, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, info.GetWriteMessageCallCount());
// Note: Since we never successfully sent anything with it, |h2| should
@@ -500,13 +416,11 @@
// Only check arguments checked by |Core|, namely |handle|, |handles|, and
// |num_handles|.
{
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->ReadMessage(MOJO_HANDLE_INVALID,
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(),
+ NullUserPointer(), NullUserPointer(),
+ NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
MockHandleInfo info;
MojoHandle h = CreateMockHandle(&info);
@@ -514,12 +428,9 @@
// Okay.
uint32_t handle_count = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h,
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- MakeUserPointer(&handle_count),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h, NullUserPointer(), NullUserPointer(), NullUserPointer(),
+ MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE));
// Checked by |Core|, shouldn't go through to the dispatcher.
EXPECT_EQ(1u, info.GetReadMessageCallCount());
@@ -540,20 +451,16 @@
{
MojoHandle handle = MOJO_HANDLE_INVALID;
MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
- EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(NullUserPointer(),
- MakeUserPointer(&signals),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()),
- kMemoryCheckFailedRegex);
- EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(MakeUserPointer(&handle),
- NullUserPointer(),
- 1,
- MOJO_DEADLINE_INDEFINITE,
- NullUserPointer(),
- NullUserPointer()),
- kMemoryCheckFailedRegex);
+ EXPECT_DEATH_IF_SUPPORTED(
+ core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()),
+ kMemoryCheckFailedRegex);
+ EXPECT_DEATH_IF_SUPPORTED(
+ core()->WaitMany(MakeUserPointer(&handle), NullUserPointer(), 1,
+ MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+ NullUserPointer()),
+ kMemoryCheckFailedRegex);
// TODO(vtl): |result_index| and |signals_states| are optional. Test them
// with non-null invalid pointers?
}
@@ -562,16 +469,16 @@
{
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);
}
@@ -584,11 +491,7 @@
// Null |handles| with nonzero |num_handles|.
EXPECT_DEATH_IF_SUPPORTED(
- core()->WriteMessage(h,
- NullUserPointer(),
- 0,
- NullUserPointer(),
- 1,
+ core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE),
kMemoryCheckFailedRegex);
@@ -604,11 +507,8 @@
uint32_t handle_count = 1;
EXPECT_DEATH_IF_SUPPORTED(
- core()->ReadMessage(h,
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- MakeUserPointer(&handle_count),
+ core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
+ NullUserPointer(), MakeUserPointer(&handle_count),
MOJO_READ_MESSAGE_FLAG_NONE),
kMemoryCheckFailedRegex);
@@ -625,10 +525,9 @@
MojoHandleSignalsState hss[2];
uint32_t result_index;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- core()->CreateMessagePipe(
- NullUserPointer(), MakeUserPointer(&h[0]), MakeUserPointer(&h[1])));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]),
+ MakeUserPointer(&h[1])));
// Should get two distinct, valid handles.
EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
@@ -640,13 +539,10 @@
result_index = static_cast<uint32_t>(-1);
hss[0] = kEmptyMojoHandleSignalsState;
hss[1] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
- core()->WaitMany(MakeUserPointer(h),
- MakeUserPointer(signals),
- 2,
- 0,
- MakeUserPointer(&result_index),
- MakeUserPointer(hss)));
+ EXPECT_EQ(
+ MOJO_RESULT_DEADLINE_EXCEEDED,
+ core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0,
+ MakeUserPointer(&result_index), MakeUserPointer(hss)));
EXPECT_EQ(static_cast<uint32_t>(-1), result_index);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -658,33 +554,25 @@
// Try to read anyway.
char buffer[1] = {'a'};
uint32_t buffer_size = 1;
- EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- core()->ReadMessage(h[0],
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_SHOULD_WAIT,
+ core()->ReadMessage(h[0], UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), NullUserPointer(),
+ NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
// Check that it left its inputs alone.
EXPECT_EQ('a', buffer[0]);
EXPECT_EQ(1u, buffer_size);
// Both should be writable.
hss[0] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h[0],
- MOJO_HANDLE_SIGNAL_WRITABLE,
- 1000000000,
- MakeUserPointer(&hss[0])));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE,
+ 1000000000, MakeUserPointer(&hss[0])));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss[0].satisfiable_signals);
hss[0] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h[1],
- MOJO_HANDLE_SIGNAL_WRITABLE,
- 1000000000,
- MakeUserPointer(&hss[0])));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE,
+ 1000000000, MakeUserPointer(&hss[0])));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss[0].satisfiable_signals);
@@ -695,13 +583,11 @@
result_index = static_cast<uint32_t>(-1);
hss[0] = kEmptyMojoHandleSignalsState;
hss[1] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->WaitMany(MakeUserPointer(h),
- MakeUserPointer(signals),
- 2,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(hss)));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(hss)));
EXPECT_EQ(1u, result_index);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -712,13 +598,10 @@
// Write to |h[1]|.
buffer[0] = 'b';
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h[1],
- UserPointer<const void>(buffer),
- 1,
- NullUserPointer(),
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
+ NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Check that |h[0]| is now readable.
signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
@@ -726,13 +609,11 @@
result_index = static_cast<uint32_t>(-1);
hss[0] = kEmptyMojoHandleSignalsState;
hss[1] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->WaitMany(MakeUserPointer(h),
- MakeUserPointer(signals),
- 2,
- MOJO_DEADLINE_INDEFINITE,
- MakeUserPointer(&result_index),
- MakeUserPointer(hss)));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
+ MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+ MakeUserPointer(hss)));
EXPECT_EQ(0u, result_index);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss[0].satisfied_signals);
@@ -745,46 +626,38 @@
// Read from |h[0]|.
// First, get only the size.
buffer_size = 0;
- EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- core()->ReadMessage(h[0],
- NullUserPointer(),
- MakeUserPointer(&buffer_size),
- NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_RESOURCE_EXHAUSTED,
+ core()->ReadMessage(h[0], NullUserPointer(),
+ MakeUserPointer(&buffer_size), NullUserPointer(),
+ NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(1u, buffer_size);
// Then actually read it.
buffer[0] = 'c';
buffer_size = 1;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h[0],
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->ReadMessage(h[0], UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), NullUserPointer(),
+ NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ('b', buffer[0]);
EXPECT_EQ(1u, buffer_size);
// |h[0]| should no longer be readable.
hss[0] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(
- MOJO_RESULT_DEADLINE_EXCEEDED,
- core()->Wait(
- h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss[0])));
+ EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+ core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0,
+ MakeUserPointer(&hss[0])));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss[0].satisfiable_signals);
// Write to |h[0]|.
buffer[0] = 'd';
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h[0],
- UserPointer<const void>(buffer),
- 1,
- NullUserPointer(),
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1,
+ NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Close |h[0]|.
EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
@@ -792,51 +665,38 @@
// Check that |h[1]| is no longer writable (and will never be).
hss[0] = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->Wait(h[1],
- MOJO_HANDLE_SIGNAL_WRITABLE,
- 1000000000,
+ core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000,
MakeUserPointer(&hss[0])));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
// Check that |h[1]| is still readable (for the moment).
hss[0] = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
- MakeUserPointer(&hss[0])));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE,
+ 1000000000, MakeUserPointer(&hss[0])));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
// Discard a message from |h[1]|.
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- core()->ReadMessage(h[1],
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
- NullUserPointer(),
+ core()->ReadMessage(h[1], NullUserPointer(), NullUserPointer(),
+ NullUserPointer(), NullUserPointer(),
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
// |h[1]| is no longer readable (and will never be).
hss[0] = kFullMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->Wait(h[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss[0])));
EXPECT_EQ(0u, hss[0].satisfied_signals);
EXPECT_EQ(0u, hss[0].satisfiable_signals);
// Try writing to |h[1]|.
buffer[0] = 'e';
- EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- core()->WriteMessage(h[1],
- UserPointer<const void>(buffer),
- 1,
- NullUserPointer(),
- 0,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_FAILED_PRECONDITION,
+ core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
+ NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
}
@@ -863,17 +723,12 @@
// Make sure that |h_passing[]| work properly.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- NullUserPointer(),
- 0,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+ kHelloSize, NullUserPointer(), 0,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -882,12 +737,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(0u, num_handles);
@@ -895,18 +748,12 @@
// 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];
@@ -917,17 +764,12 @@
// Make sure that |h_passed[]| work properly.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passed[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- NullUserPointer(),
- 0,
+ core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
+ kHelloSize, NullUserPointer(), 0,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passed[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -936,29 +778,22 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passed[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passed[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(0u, num_handles);
// Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kWorld),
- kWorldSize,
- MakeUserPointer(&h_passed[1]),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+ kWorldSize, MakeUserPointer(&h_passed[1]), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -967,12 +802,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kWorldSize, num_bytes);
EXPECT_STREQ(kWorld, buffer);
EXPECT_EQ(1u, num_handles);
@@ -991,17 +824,12 @@
// Write to |h_passed[0]|. Should receive on |h_received|.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passed[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- NullUserPointer(),
- 0,
+ core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
+ kHelloSize, NullUserPointer(), 0,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_received,
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -1010,12 +838,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_received,
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_received, UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(0u, num_handles);
@@ -1031,8 +857,8 @@
MojoHandleSignalsState hss;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->CreateDataPipe(
- NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
+ core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
+ MakeUserPointer(&ch)));
// Should get two distinct, valid handles.
EXPECT_NE(ph, MOJO_HANDLE_INVALID);
EXPECT_NE(ch, MOJO_HANDLE_INVALID);
@@ -1046,9 +872,8 @@
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
hss = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss)));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
+ MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
@@ -1070,17 +895,15 @@
char elements[2] = {'A', 'B'};
uint32_t num_bytes = 2u;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteData(ph,
- UserPointer<const void>(elements),
+ core()->WriteData(ph, UserPointer<const void>(elements),
MakeUserPointer(&num_bytes),
MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(2u, num_bytes);
// Consumer should now be readable.
hss = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0,
+ MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
@@ -1090,9 +913,7 @@
num_bytes = 1u;
EXPECT_EQ(MOJO_RESULT_OK,
core()->ReadData(
- ch,
- UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
+ ch, UserPointer<void>(elements), MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK));
EXPECT_EQ('A', elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -1101,11 +922,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = 1u;
- EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadData(ch,
- UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes),
+ MOJO_READ_DATA_FLAG_NONE));
EXPECT_EQ('A', elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -1113,8 +932,7 @@
void* write_ptr = nullptr;
num_bytes = 0u;
ASSERT_EQ(MOJO_RESULT_OK,
- core()->BeginWriteData(ph,
- MakeUserPointer(&write_ptr),
+ core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
MakeUserPointer(&num_bytes),
MOJO_WRITE_DATA_FLAG_NONE));
// We count on the default options providing a decent buffer size.
@@ -1124,8 +942,7 @@
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));
@@ -1138,63 +955,51 @@
// Query how much data we have.
num_bytes = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadData(ch,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
+ core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_QUERY));
EXPECT_EQ(4u, num_bytes);
// Try to query with peek. Should fail.
num_bytes = 0;
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->ReadData(
- ch,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
- MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
+ MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
EXPECT_EQ(0u, num_bytes);
// Try to discard ten characters, in all-or-none mode. Should fail.
num_bytes = 10;
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
core()->ReadData(
- ch,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
+ ch, NullUserPointer(), MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
// Try to discard two characters, in peek mode. Should fail.
num_bytes = 2;
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->ReadData(
- ch,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
- MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
+ MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
// Discard two characters.
num_bytes = 2;
EXPECT_EQ(MOJO_RESULT_OK,
core()->ReadData(
- ch,
- NullUserPointer(),
- MakeUserPointer(&num_bytes),
+ ch, NullUserPointer(), MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
// Try a two-phase read of the remaining two bytes with peek. Should fail.
const void* read_ptr = nullptr;
num_bytes = 2;
ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- core()->BeginReadData(ch,
- MakeUserPointer(&read_ptr),
+ core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_PEEK));
// Read the remaining two characters, in two-phase mode (all-or-none).
num_bytes = 2;
ASSERT_EQ(MOJO_RESULT_OK,
- core()->BeginReadData(ch,
- MakeUserPointer(&read_ptr),
+ core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_ALL_OR_NONE));
// Note: Count on still being able to do the contiguous read here.
@@ -1203,9 +1008,7 @@
// 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.
@@ -1258,22 +1061,17 @@
MojoHandle ph, ch;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->CreateDataPipe(
- NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
+ core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
+ MakeUserPointer(&ch)));
// Send |ch| from |h_passing[0]| to |h_passing[1]|.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- MakeUserPointer(&ch),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+ kHelloSize, MakeUserPointer(&ch), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -1282,12 +1080,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(1u, num_handles);
@@ -1307,22 +1103,18 @@
// Write to |ph|. Should receive on |ch_received|.
num_bytes = kWorldSize;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteData(ph,
- UserPointer<const void>(kWorld),
+ core()->WriteData(ph, UserPointer<const void>(kWorld),
MakeUserPointer(&num_bytes),
MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(ch_received,
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
num_bytes = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadData(ch_received,
- UserPointer<void>(buffer),
+ core()->ReadData(ch_received, UserPointer<void>(buffer),
MakeUserPointer(&num_bytes),
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kWorldSize, num_bytes);
@@ -1330,17 +1122,12 @@
// Now pass |ph| in the same direction.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kWorld),
- kWorldSize,
- MakeUserPointer(&ph),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+ kWorldSize, MakeUserPointer(&ph), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -1349,12 +1136,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kWorldSize, num_bytes);
EXPECT_STREQ(kWorld, buffer);
EXPECT_EQ(1u, num_handles);
@@ -1374,22 +1159,18 @@
// Write to |ph_received|. Should receive on |ch_received|.
num_bytes = kHelloSize;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteData(ph_received,
- UserPointer<const void>(kHello),
+ core()->WriteData(ph_received, UserPointer<const void>(kHello),
MakeUserPointer(&num_bytes),
MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(ch_received,
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
num_bytes = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadData(ch_received,
- UserPointer<void>(buffer),
+ core()->ReadData(ch_received, UserPointer<void>(buffer),
MakeUserPointer(&num_bytes),
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
@@ -1404,42 +1185,31 @@
void* write_ptr = nullptr;
num_bytes = 0;
ASSERT_EQ(MOJO_RESULT_OK,
- core()->BeginWriteData(ph,
- MakeUserPointer(&write_ptr),
+ core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
MakeUserPointer(&num_bytes),
MOJO_WRITE_DATA_FLAG_NONE));
ASSERT_GE(num_bytes, 1u);
EXPECT_EQ(MOJO_RESULT_BUSY,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- MakeUserPointer(&ph),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+ kHelloSize, MakeUserPointer(&ph), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// But |ch| can, even if |ph| is in a two-phase write.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- MakeUserPointer(&ch),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+ kHelloSize, MakeUserPointer(&ch), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
ch = MOJO_HANDLE_INVALID;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
NullUserPointer()));
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kHelloSize, num_bytes);
EXPECT_STREQ(kHello, buffer);
EXPECT_EQ(1u, num_handles);
@@ -1452,10 +1222,8 @@
// Wait for |ch| to be readable.
hss = kEmptyMojoHandleSignalsState;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- core()->Wait(
- ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, MakeUserPointer(&hss)));
+ EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE,
+ 1000000000, MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
@@ -1463,32 +1231,23 @@
const void* read_ptr = nullptr;
num_bytes = 1;
ASSERT_EQ(MOJO_RESULT_OK,
- core()->BeginReadData(ch,
- MakeUserPointer(&read_ptr),
+ core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
MakeUserPointer(&num_bytes),
MOJO_READ_DATA_FLAG_ALL_OR_NONE));
EXPECT_EQ(MOJO_RESULT_BUSY,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kHello),
- kHelloSize,
- MakeUserPointer(&ch),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+ kHelloSize, MakeUserPointer(&ch), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// But |ph| can, even if |ch| is in a two-phase read.
EXPECT_EQ(MOJO_RESULT_OK,
- core()->WriteMessage(h_passing[0],
- UserPointer<const void>(kWorld),
- kWorldSize,
- MakeUserPointer(&ph),
- 1,
+ core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+ kWorldSize, MakeUserPointer(&ph), 1,
MOJO_WRITE_MESSAGE_FLAG_NONE));
ph = MOJO_HANDLE_INVALID;
hss = kEmptyMojoHandleSignalsState;
EXPECT_EQ(MOJO_RESULT_OK,
- core()->Wait(h_passing[1],
- MOJO_HANDLE_SIGNAL_READABLE,
- 1000000000,
+ core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
MakeUserPointer(&hss)));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -1497,12 +1256,10 @@
num_bytes = kBufferSize;
num_handles = arraysize(handles);
EXPECT_EQ(MOJO_RESULT_OK,
- core()->ReadMessage(h_passing[1],
- UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- MakeUserPointer(handles),
- MakeUserPointer(&num_handles),
- MOJO_READ_MESSAGE_FLAG_NONE));
+ core()->ReadMessage(
+ h_passing[1], UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+ MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kWorldSize, num_bytes);
EXPECT_STREQ(kWorld, buffer);
EXPECT_EQ(1u, num_handles);
diff --git a/mojo/edk/system/data_pipe.cc b/mojo/edk/system/data_pipe.cc
index c5a44e7..cbacb89 100644
--- a/mojo/edk/system/data_pipe.cc
+++ b/mojo/edk/system/data_pipe.cc
@@ -52,15 +52,15 @@
// 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).
@@ -155,8 +155,8 @@
return MOJO_RESULT_INVALID_ARGUMENT;
}
- MojoResult rv = ProducerBeginWriteDataImplNoLock(
- buffer, buffer_num_bytes, min_num_bytes_to_write);
+ MojoResult rv = ProducerBeginWriteDataImplNoLock(buffer, buffer_num_bytes,
+ min_num_bytes_to_write);
if (rv != MOJO_RESULT_OK)
return rv;
// Note: No need to awake producer waiters, even though we're going from
@@ -352,8 +352,8 @@
return MOJO_RESULT_INVALID_ARGUMENT;
}
- MojoResult rv = ConsumerBeginReadDataImplNoLock(
- buffer, buffer_num_bytes, min_num_bytes_to_read);
+ MojoResult rv = ConsumerBeginReadDataImplNoLock(buffer, buffer_num_bytes,
+ min_num_bytes_to_read);
if (rv != MOJO_RESULT_OK)
return rv;
DCHECK(consumer_in_two_phase_read_no_lock());
diff --git a/mojo/edk/system/data_pipe.h b/mojo/edk/system/data_pipe.h
index a6b816e..767d405 100644
--- a/mojo/edk/system/data_pipe.h
+++ b/mojo/edk/system/data_pipe.h
@@ -117,12 +117,11 @@
virtual void ConsumerCloseImplNoLock() = 0;
// |*num_bytes| will be a nonzero multiple of |element_num_bytes_|.
- virtual MojoResult ConsumerReadDataImplNoLock(
- UserPointer<void> elements,
- UserPointer<uint32_t> num_bytes,
- uint32_t max_num_bytes_to_read,
- uint32_t min_num_bytes_to_read,
- bool peek) = 0;
+ virtual MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements,
+ UserPointer<uint32_t> num_bytes,
+ uint32_t max_num_bytes_to_read,
+ uint32_t min_num_bytes_to_read,
+ bool peek) = 0;
virtual MojoResult ConsumerDiscardDataImplNoLock(
UserPointer<uint32_t> num_bytes,
uint32_t max_num_bytes_to_discard,
diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.cc b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
index fa103c3..3c14f35 100644
--- a/mojo/edk/system/data_pipe_consumer_dispatcher.cc
+++ b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
@@ -77,9 +77,7 @@
}
return data_pipe_->ConsumerReadData(
- elements,
- num_bytes,
- !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE),
+ elements, num_bytes, !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE),
!!(flags & MOJO_READ_DATA_FLAG_PEEK));
}
@@ -91,8 +89,7 @@
// These flags may not be used in two-phase mode.
if ((flags & MOJO_READ_DATA_FLAG_DISCARD) ||
- (flags & MOJO_READ_DATA_FLAG_QUERY) ||
- (flags & MOJO_READ_DATA_FLAG_PEEK))
+ (flags & MOJO_READ_DATA_FLAG_QUERY) || (flags & MOJO_READ_DATA_FLAG_PEEK))
return MOJO_RESULT_INVALID_ARGUMENT;
return data_pipe_->ConsumerBeginReadData(
diff --git a/mojo/edk/system/data_pipe_unittest.cc b/mojo/edk/system/data_pipe_unittest.cc
index 756ea0e..ad02222 100644
--- a/mojo/edk/system/data_pipe_unittest.cc
+++ b/mojo/edk/system/data_pipe_unittest.cc
@@ -28,9 +28,8 @@
// Nothing to check for flags.
EXPECT_GT(validated_options.element_num_bytes, 0u);
EXPECT_GT(validated_options.capacity_num_bytes, 0u);
- EXPECT_EQ(0u,
- validated_options.capacity_num_bytes %
- validated_options.element_num_bytes);
+ EXPECT_EQ(0u, validated_options.capacity_num_bytes %
+ validated_options.element_num_bytes);
MojoCreateDataPipeOptions revalidated_options = {};
EXPECT_EQ(MOJO_RESULT_OK,
@@ -59,9 +58,8 @@
// Default options.
{
MojoCreateDataPipeOptions validated_options = {};
- EXPECT_EQ(
- MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(NullUserPointer(), &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ NullUserPointer(), &validated_options));
RevalidateCreateOptions(validated_options);
CheckDefaultCapacity(validated_options);
}
diff --git a/mojo/edk/system/dispatcher.cc b/mojo/edk/system/dispatcher.cc
index b88f433..c58da9f 100644
--- a/mojo/edk/system/dispatcher.cc
+++ b/mojo/edk/system/dispatcher.cc
@@ -58,8 +58,8 @@
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
@@ -130,8 +130,8 @@
if (is_closed_)
return MOJO_RESULT_INVALID_ARGUMENT;
- return ReadMessageImplNoLock(
- bytes, num_bytes, dispatchers, num_dispatchers, flags);
+ return ReadMessageImplNoLock(bytes, num_bytes, dispatchers, num_dispatchers,
+ flags);
}
MojoResult Dispatcher::WriteData(UserPointer<const void> elements,
@@ -474,8 +474,8 @@
base::AutoLock locker(lock_);
#endif
- return EndSerializeAndCloseImplNoLock(
- channel, destination, actual_size, platform_handles);
+ return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
+ platform_handles);
}
// DispatcherTransport ---------------------------------------------------------
diff --git a/mojo/edk/system/dispatcher.h b/mojo/edk/system/dispatcher.h
index 8d3edd4..d4db54b 100644
--- a/mojo/edk/system/dispatcher.h
+++ b/mojo/edk/system/dispatcher.h
@@ -48,7 +48,7 @@
// Test helper. We need to declare it here so we can friend it.
MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport
- DispatcherTryStartTransport(Dispatcher* dispatcher);
+DispatcherTryStartTransport(Dispatcher* dispatcher);
} // namespace test
diff --git a/mojo/edk/system/dispatcher_unittest.cc b/mojo/edk/system/dispatcher_unittest.cc
index b5a05d4..0b15436 100644
--- a/mojo/edk/system/dispatcher_unittest.cc
+++ b/mojo/edk/system/dispatcher_unittest.cc
@@ -44,31 +44,24 @@
EXPECT_EQ(Dispatcher::kTypeUnknown, d->GetType());
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- d->WriteMessage(
- NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d->WriteMessage(NullUserPointer(), 0, nullptr,
+ MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- d->ReadMessage(NullUserPointer(),
- NullUserPointer(),
- nullptr,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->WriteData(
- NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->BeginWriteData(
- NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+ d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->WriteData(NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->ReadData(
- NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->BeginReadData(
- NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->ReadData(NullUserPointer(), NullUserPointer(),
+ MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->BeginReadData(NullUserPointer(), NullUserPointer(),
+ MOJO_READ_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
Waiter w;
w.Init();
@@ -90,31 +83,24 @@
EXPECT_EQ(MOJO_RESULT_OK, d->Close());
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- d->WriteMessage(
- NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d->WriteMessage(NullUserPointer(), 0, nullptr,
+ MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- d->ReadMessage(NullUserPointer(),
- NullUserPointer(),
- nullptr,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->WriteData(
- NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->BeginWriteData(
- NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+ d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->WriteData(NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->ReadData(
- NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- d->BeginReadData(
- NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->ReadData(NullUserPointer(), NullUserPointer(),
+ MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ d->BeginReadData(NullUserPointer(), NullUserPointer(),
+ MOJO_READ_DATA_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
hss = HandleSignalsState();
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
@@ -172,45 +158,40 @@
break;
}
case WRITE_MESSAGE:
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->WriteMessage(
- NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ dispatcher_->WriteMessage(NullUserPointer(), 0, nullptr,
+ MOJO_WRITE_MESSAGE_FLAG_NONE));
break;
case READ_MESSAGE:
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->ReadMessage(NullUserPointer(),
- NullUserPointer(),
- nullptr,
- nullptr,
+ dispatcher_->ReadMessage(NullUserPointer(), NullUserPointer(),
+ nullptr, nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
break;
case WRITE_DATA:
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->WriteData(NullUserPointer(),
- NullUserPointer(),
+ dispatcher_->WriteData(NullUserPointer(), NullUserPointer(),
MOJO_WRITE_DATA_FLAG_NONE));
break;
case BEGIN_WRITE_DATA:
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->BeginWriteData(NullUserPointer(),
- NullUserPointer(),
- MOJO_WRITE_DATA_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ dispatcher_->BeginWriteData(NullUserPointer(), NullUserPointer(),
+ MOJO_WRITE_DATA_FLAG_NONE));
break;
case END_WRITE_DATA:
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndWriteData(0));
break;
case READ_DATA:
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->ReadData(NullUserPointer(),
- NullUserPointer(),
+ dispatcher_->ReadData(NullUserPointer(), NullUserPointer(),
MOJO_READ_DATA_FLAG_NONE));
break;
case BEGIN_READ_DATA:
- EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dispatcher_->BeginReadData(NullUserPointer(),
- NullUserPointer(),
- MOJO_READ_DATA_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_INVALID_ARGUMENT,
+ dispatcher_->BeginReadData(NullUserPointer(), NullUserPointer(),
+ MOJO_READ_DATA_FLAG_NONE));
break;
case END_READ_DATA:
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndReadData(0));
diff --git a/mojo/edk/system/local_data_pipe.h b/mojo/edk/system/local_data_pipe.h
index c98cb7e..abe3a46 100644
--- a/mojo/edk/system/local_data_pipe.h
+++ b/mojo/edk/system/local_data_pipe.h
@@ -44,12 +44,11 @@
uint32_t num_bytes_written) override;
HandleSignalsState ProducerGetHandleSignalsStateImplNoLock() const override;
void ConsumerCloseImplNoLock() override;
- MojoResult ConsumerReadDataImplNoLock(
- UserPointer<void> elements,
- UserPointer<uint32_t> num_bytes,
- uint32_t max_num_bytes_to_read,
- uint32_t min_num_bytes_to_read,
- bool peek) override;
+ MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements,
+ UserPointer<uint32_t> num_bytes,
+ uint32_t max_num_bytes_to_read,
+ uint32_t min_num_bytes_to_read,
+ bool peek) override;
MojoResult ConsumerDiscardDataImplNoLock(
UserPointer<uint32_t> num_bytes,
uint32_t max_num_bytes_to_discard,
diff --git a/mojo/edk/system/local_data_pipe_unittest.cc b/mojo/edk/system/local_data_pipe_unittest.cc
index e8bc716..9ba6b21 100644
--- a/mojo/edk/system/local_data_pipe_unittest.cc
+++ b/mojo/edk/system/local_data_pipe_unittest.cc
@@ -25,9 +25,8 @@
{
// Get default options.
MojoCreateDataPipeOptions default_options = {0};
- EXPECT_EQ(
- MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ NullUserPointer(), &default_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options));
dp->ProducerClose();
dp->ConsumerClose();
@@ -105,9 +104,8 @@
1000 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -116,12 +114,9 @@
// Try reading; nothing there yet.
num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_SHOULD_WAIT,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), false, false));
// Query; nothing there yet.
num_bytes = 0;
@@ -135,12 +130,9 @@
// Read with invalid |num_bytes|.
num_bytes = sizeof(elements[0]) + 1;
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), false, false));
// Write two elements.
elements[0] = 123;
@@ -148,8 +140,7 @@
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);
@@ -162,12 +153,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
EXPECT_EQ(123, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -181,12 +169,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- false,
- true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), false, true));
EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
EXPECT_EQ(456, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -200,12 +185,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OUT_OF_RANGE,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(-1, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -213,12 +195,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(456, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -245,9 +224,8 @@
2 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
Waiter waiter;
@@ -275,8 +253,7 @@
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.
@@ -295,12 +272,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, true));
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
EXPECT_EQ(123, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -327,12 +301,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
EXPECT_EQ(123, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -349,15 +320,14 @@
void* buffer = nullptr;
num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
EXPECT_EQ(MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), false));
+ dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(buffer);
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
static_cast<int32_t*>(buffer)[0] = 789;
- EXPECT_EQ(MOJO_RESULT_OK,
- dp->ProducerEndWriteData(
- static_cast<uint32_t>(1u * sizeof(elements[0]))));
+ EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>(
+ 1u * sizeof(elements[0]))));
// Add a waiter.
waiter.Init();
@@ -368,10 +338,9 @@
// Read one element, using a two-phase read.
const void* read_buffer = nullptr;
num_bytes = 0u;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer);
// Since we only read one element (after having written three in all), the
// two-phase read should only allow us to read one. This checks an
@@ -395,8 +364,7 @@
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.
@@ -427,9 +395,8 @@
1000 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
{
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -449,8 +416,8 @@
// Not yet readable.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- dp->ConsumerAddWaiter(
- &waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, nullptr));
+ dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
+ nullptr));
EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
hss = HandleSignalsState();
dp->ConsumerRemoveWaiter(&waiter, &hss);
@@ -462,8 +429,7 @@
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();
@@ -493,12 +459,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, true));
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
EXPECT_EQ(456, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -516,12 +479,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
EXPECT_EQ(456, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -529,8 +489,8 @@
// Adding a waiter should now succeed.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- dp->ConsumerAddWaiter(
- &waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, nullptr));
+ dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90,
+ nullptr));
// Write one element.
elements[0] = 789;
@@ -538,8 +498,7 @@
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));
@@ -565,12 +524,9 @@
elements[0] = -1;
elements[1] = -1;
num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(elements),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(elements),
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
EXPECT_EQ(789, elements[0]);
EXPECT_EQ(-1, elements[1]);
@@ -601,16 +557,15 @@
// Request room for three (but we'll only write two).
uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
EXPECT_EQ(MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), true));
+ dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+ MakeUserPointer(&num_bytes), true));
EXPECT_TRUE(buffer);
EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
elements = static_cast<int32_t*>(buffer);
elements[0] = 123;
elements[1] = 456;
- EXPECT_EQ(MOJO_RESULT_OK,
- dp->ProducerEndWriteData(
- static_cast<uint32_t>(2u * sizeof(elements[0]))));
+ EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>(
+ 2u * sizeof(elements[0]))));
// Should already be readable.
waiter.Init();
@@ -625,17 +580,15 @@
// Request two in all-or-none mode, but only read one.
const void* read_buffer = nullptr;
num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+ MakeUserPointer(&num_bytes), true));
EXPECT_TRUE(read_buffer);
EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
const int32_t* read_elements = static_cast<const int32_t*>(read_buffer);
EXPECT_EQ(123, read_elements[0]);
- EXPECT_EQ(MOJO_RESULT_OK,
- dp->ConsumerEndReadData(
- static_cast<uint32_t>(1u * sizeof(elements[0]))));
+ EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>(
+ 1u * sizeof(elements[0]))));
// Should still be readable.
waiter.Init();
@@ -650,23 +603,21 @@
// Request three, but not in all-or-none mode.
read_buffer = nullptr;
num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer);
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
read_elements = static_cast<const int32_t*>(read_buffer);
EXPECT_EQ(456, read_elements[0]);
- EXPECT_EQ(MOJO_RESULT_OK,
- dp->ConsumerEndReadData(
- static_cast<uint32_t>(1u * sizeof(elements[0]))));
+ EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>(
+ 1u * sizeof(elements[0]))));
// Adding a waiter should now succeed.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- dp->ConsumerAddWaiter(
- &waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, nullptr));
+ dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
+ nullptr));
// Close the producer.
dp->ProducerClose();
@@ -692,9 +643,8 @@
1000 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
Waiter waiter;
@@ -711,10 +661,9 @@
uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
void* write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_ptr);
EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
@@ -741,9 +690,8 @@
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
static_cast<int32_t*>(write_ptr)[0] = 123;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerEndWriteData(static_cast<uint32_t>(1u * sizeof(int32_t))));
+ EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
+ static_cast<uint32_t>(1u * sizeof(int32_t))));
// It should be writable again.
waiter.Init();
@@ -767,10 +715,9 @@
// middle of it.
num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_ptr);
EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
@@ -789,10 +736,9 @@
// Start a two-phase read.
num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
const void* read_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_ptr);
EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
@@ -841,9 +787,8 @@
1 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
Waiter waiter;
@@ -873,8 +818,7 @@
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).
@@ -900,8 +844,7 @@
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.
@@ -925,12 +868,9 @@
// Read that element.
num_bytes = static_cast<uint32_t>(sizeof(int32_t));
element = 0;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(&element),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(&element),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
EXPECT_EQ(456, element);
@@ -971,9 +911,8 @@
10 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -984,10 +923,9 @@
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.
@@ -995,9 +933,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
int32_t expected_buffer[100];
memset(expected_buffer, 0xab, sizeof(expected_buffer));
@@ -1009,10 +945,9 @@
// 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
@@ -1022,9 +957,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
memset(expected_buffer, 0xab, sizeof(expected_buffer));
expected_buffer[0] = 8;
@@ -1039,10 +972,9 @@
// 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, -
@@ -1050,10 +982,9 @@
// 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
@@ -1063,9 +994,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
memset(expected_buffer, 0xab, sizeof(expected_buffer));
expected_buffer[0] = 104;
@@ -1087,10 +1016,9 @@
num_bytes = 0u;
void* write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_ptr);
EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
Seq(400, 6, static_cast<int32_t*>(write_ptr));
@@ -1102,10 +1030,9 @@
// mode.
num_bytes = 6u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
static_cast<int32_t*>(write_ptr)[0] = 500;
EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t)));
@@ -1115,19 +1042,17 @@
// Requesting a 10-element buffer in all-or-none mode fails at this point.
num_bytes = 10u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OUT_OF_RANGE,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
// But requesting, say, a 5-element (up to 9, really) buffer should be okay.
// It will discard two elements.
num_bytes = 5u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
// Only write 4 elements though.
Seq(600, 4, static_cast<int32_t*>(write_ptr));
@@ -1139,10 +1064,9 @@
// the internal buffer.
num_bytes = 5u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
// Only write 3 elements though.
Seq(700, 3, static_cast<int32_t*>(write_ptr));
@@ -1155,9 +1079,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
memset(expected_buffer, 0xab, sizeof(expected_buffer));
expected_buffer[0] = 500;
@@ -1182,9 +1104,8 @@
10 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -1192,10 +1113,9 @@
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;
@@ -1205,10 +1125,9 @@
// 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.
@@ -1219,19 +1138,16 @@
// Too much.
num_bytes = 6u * sizeof(int32_t);
Seq(200, arraysize(buffer), buffer);
- EXPECT_EQ(
- MOJO_RESULT_OUT_OF_RANGE,
- dp->ProducerWriteData(
- UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+ dp->ProducerWriteData(UserPointer<const void>(buffer),
+ MakeUserPointer(&num_bytes), true));
// Try reading too much.
num_bytes = 11u * sizeof(int32_t);
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
int32_t expected_buffer[100];
memset(expected_buffer, 0xab, sizeof(expected_buffer));
EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
@@ -1244,19 +1160,17 @@
// 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.
@@ -1269,9 +1183,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
memset(expected_buffer, 0xab, sizeof(expected_buffer));
Seq(100, 5, expected_buffer);
@@ -1282,9 +1194,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
memset(expected_buffer, 0xab, sizeof(expected_buffer));
EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
@@ -1312,9 +1222,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
memset(expected_buffer, 0xab, sizeof(expected_buffer));
EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
@@ -1328,9 +1236,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
memset(expected_buffer, 0xab, sizeof(expected_buffer));
Seq(400, 2, expected_buffer);
@@ -1358,9 +1264,8 @@
10 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -1368,27 +1273,24 @@
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.
@@ -1396,9 +1298,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
int32_t expected_buffer[100];
memset(expected_buffer, 0xab, sizeof(expected_buffer));
@@ -1410,9 +1310,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
memset(expected_buffer, 0xab, sizeof(expected_buffer));
EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
@@ -1434,10 +1332,9 @@
// 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.
@@ -1445,9 +1342,7 @@
memset(buffer, 0xab, sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- true,
- false));
+ MakeUserPointer(&num_bytes), true, false));
memset(expected_buffer, 0xab, sizeof(expected_buffer));
EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
Seq(300, 10, expected_buffer);
@@ -1468,44 +1363,40 @@
10 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
// Try writing way too much (two-phase).
uint32_t num_bytes = 20u * sizeof(int32_t);
void* write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OUT_OF_RANGE,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
// Try writing an amount which isn't a multiple of the element size
// (two-phase).
static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1");
num_bytes = 1u;
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_INVALID_ARGUMENT,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
// Try reading way too much (two-phase).
num_bytes = 20u * sizeof(int32_t);
const void* read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
// Write half (two-phase).
num_bytes = 5u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
// May provide more space than requested.
EXPECT_GE(num_bytes, 5u * sizeof(int32_t));
EXPECT_TRUE(write_ptr);
@@ -1517,15 +1408,15 @@
num_bytes = 1u;
read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
// Read one (two-phase).
num_bytes = 1u * sizeof(int32_t);
read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
EXPECT_GE(num_bytes, 1u * sizeof(int32_t));
EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]);
EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(1u * sizeof(int32_t)));
@@ -1539,19 +1430,17 @@
// two-phase write of six now.
num_bytes = 6u * sizeof(int32_t);
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OUT_OF_RANGE,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), true));
// Write six elements (simple), filling the buffer.
num_bytes = 6u * sizeof(int32_t);
int32_t buffer[100];
Seq(100, 6, buffer);
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerWriteData(
- UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerWriteData(UserPointer<const void>(buffer),
+ MakeUserPointer(&num_bytes), true));
EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
// We have ten.
@@ -1563,8 +1452,8 @@
num_bytes = 10u * sizeof(int32_t);
read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
// Close the producer.
dp->ProducerClose();
@@ -1573,8 +1462,8 @@
num_bytes = 9u * sizeof(int32_t);
read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
EXPECT_GE(num_bytes, 9u * sizeof(int32_t));
EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]);
EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]);
@@ -1591,8 +1480,8 @@
num_bytes = 2u * sizeof(int32_t);
read_ptr = nullptr;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), true));
dp->ConsumerClose();
}
@@ -1613,9 +1502,8 @@
100u // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
// This test won't be valid if |ValidateCreateOptions()| decides to give the
// pipe more space.
ASSERT_EQ(100u, validated_options.capacity_num_bytes);
@@ -1626,19 +1514,15 @@
uint32_t num_bytes = 20u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerWriteData(UserPointer<const void>(&test_data[0]),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(20u, num_bytes);
// Read 10 bytes.
unsigned char read_buffer[1000] = {0};
num_bytes = 10u;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(read_buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(read_buffer),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(10u, num_bytes);
EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
@@ -1649,8 +1533,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_buffer_ptr);
EXPECT_EQ(80u, num_bytes);
EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
@@ -1660,8 +1543,7 @@
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
@@ -1671,8 +1553,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer_ptr);
EXPECT_EQ(90u, num_bytes);
EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
@@ -1682,12 +1563,9 @@
num_bytes =
static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0]));
memset(read_buffer, 0, num_bytes);
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(read_buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(read_buffer),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(100u, num_bytes);
EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u));
@@ -1708,9 +1586,8 @@
1000u // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
// Close producer first, then consumer.
{
@@ -1720,16 +1597,14 @@
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.
@@ -1737,8 +1612,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_buffer_ptr);
EXPECT_GT(num_bytes, 0u);
@@ -1747,8 +1621,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer_ptr);
EXPECT_EQ(2u * kTestDataSize, num_bytes);
@@ -1764,8 +1637,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer_ptr);
EXPECT_EQ(kTestDataSize, num_bytes);
@@ -1781,8 +1653,7 @@
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.
@@ -1790,8 +1661,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_buffer_ptr);
ASSERT_GT(num_bytes, kTestDataSize);
@@ -1800,8 +1670,7 @@
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(read_buffer_ptr);
EXPECT_EQ(kTestDataSize, num_bytes);
@@ -1819,16 +1688,14 @@
num_bytes = kTestDataSize;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
dp->ProducerWriteData(UserPointer<const void>(kTestData),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
// As will trying to start another two-phase write.
write_buffer_ptr = nullptr;
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
dp->ProducerClose();
}
@@ -1843,8 +1710,7 @@
uint32_t num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_TRUE(write_buffer_ptr);
ASSERT_GT(num_bytes, kTestDataSize);
@@ -1860,8 +1726,7 @@
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.
@@ -1870,43 +1735,33 @@
// Peek that data.
char buffer[1000];
num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- true));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), false, true));
EXPECT_EQ(kTestDataSize, num_bytes);
EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
// Read that data.
memset(buffer, 0, 1000);
num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerReadData(UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), false, false));
EXPECT_EQ(kTestDataSize, num_bytes);
EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
// A second read should fail.
num_bytes = static_cast<uint32_t>(sizeof(buffer));
- EXPECT_EQ(
- MOJO_RESULT_FAILED_PRECONDITION,
- dp->ConsumerReadData(UserPointer<void>(buffer),
- MakeUserPointer(&num_bytes),
- false,
- false));
+ EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+ dp->ConsumerReadData(UserPointer<void>(buffer),
+ MakeUserPointer(&num_bytes), false, false));
// A two-phase read should also fail.
const void* read_buffer_ptr = nullptr;
num_bytes = 0u;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
// Ditto for discard.
num_bytes = 10u;
@@ -1925,9 +1780,8 @@
10 * sizeof(int32_t) // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -1948,10 +1802,9 @@
// Try ending a two-phase write with an invalid amount (too much).
num_bytes = 0u;
void* write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
dp->ProducerEndWriteData(num_bytes +
static_cast<uint32_t>(sizeof(int32_t))));
@@ -1968,10 +1821,9 @@
// element size).
num_bytes = 0u;
write_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ProducerBeginWriteData(
- MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_GE(num_bytes, 1u);
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u));
@@ -1988,8 +1840,7 @@
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;
@@ -2008,10 +1859,9 @@
// Try ending a two-phase read with an invalid amount (too much).
num_bytes = 0u;
const void* read_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
dp->ConsumerEndReadData(num_bytes +
static_cast<uint32_t>(sizeof(int32_t))));
@@ -2025,10 +1875,9 @@
// element size).
num_bytes = 0u;
read_ptr = nullptr;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]);
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(1u));
@@ -2057,9 +1906,8 @@
2 // |capacity_num_bytes|.
};
MojoCreateDataPipeOptions validated_options = {0};
- EXPECT_EQ(MOJO_RESULT_OK,
- DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
- &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+ MakeUserPointer(&options), &validated_options));
scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -2068,17 +1916,15 @@
uint32_t num_bytes = 2u;
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerWriteData(UserPointer<const void>(elements),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(2u, num_bytes);
// Begin reading.
const void* read_ptr = nullptr;
num_bytes = 2u;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(2u, num_bytes);
EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
@@ -2094,8 +1940,7 @@
// 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]);
@@ -2107,16 +1952,14 @@
// Now writing should succeed.
EXPECT_EQ(MOJO_RESULT_OK,
dp->ProducerWriteData(UserPointer<const void>(elements),
- MakeUserPointer(&num_bytes),
- false));
+ MakeUserPointer(&num_bytes), false));
// And if we read, we should get the new values.
read_ptr = nullptr;
num_bytes = 2u;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dp->ConsumerBeginReadData(
- MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+ EXPECT_EQ(MOJO_RESULT_OK,
+ dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+ MakeUserPointer(&num_bytes), false));
EXPECT_EQ(2u, num_bytes);
EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]);
diff --git a/mojo/edk/system/memory.cc b/mojo/edk/system/memory.cc
index 1d7f792..0e3d9a9 100644
--- a/mojo/edk/system/memory.cc
+++ b/mojo/edk/system/memory.cc
@@ -40,20 +40,20 @@
template <size_t size, size_t alignment>
void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount(const void* pointer, size_t count) {
+CheckUserPointerWithCount(const void* pointer, size_t count) {
CHECK_LE(count, std::numeric_limits<size_t>::max() / size);
CHECK(count == 0 || (pointer && IsAligned<alignment>(pointer)));
}
// Explicitly instantiate the sizes we need. Add instantiations as needed.
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount<1, 1>(const void*, size_t);
+CheckUserPointerWithCount<1, 1>(const void*, size_t);
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount<4, 4>(const void*, size_t);
+CheckUserPointerWithCount<4, 4>(const void*, size_t);
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount<8, 4>(const void*, size_t);
+CheckUserPointerWithCount<8, 4>(const void*, size_t);
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount<8, 8>(const void*, size_t);
+CheckUserPointerWithCount<8, 8>(const void*, size_t);
template <size_t alignment>
void CheckUserPointerWithSize(const void* pointer, size_t size) {
@@ -65,9 +65,9 @@
// Explicitly instantiate the sizes we need. Add instantiations as needed.
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithSize<1>(const void*, size_t);
+CheckUserPointerWithSize<1>(const void*, size_t);
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithSize<4>(const void*, size_t);
+CheckUserPointerWithSize<4>(const void*, size_t);
// Whereas the other |Check...()| functions are usually used with integral typs
// or arrays of integral types, this one is used with Options structs for which
// alignment has been explicitly been specified (using |MOJO_ALIGNAS()|), which
@@ -75,13 +75,13 @@
#if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
template <>
void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithSize<8>(const void* pointer, size_t size) {
+CheckUserPointerWithSize<8>(const void* pointer, size_t size) {
CHECK(size == 0 ||
(!!pointer && reinterpret_cast<uintptr_t>(pointer) % 8 == 0));
}
#else
template void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithSize<8>(const void*, size_t);
+CheckUserPointerWithSize<8>(const void*, size_t);
#endif
} // namespace internal
diff --git a/mojo/edk/system/memory.h b/mojo/edk/system/memory.h
index 7b5b724..96cf219 100644
--- a/mojo/edk/system/memory.h
+++ b/mojo/edk/system/memory.h
@@ -53,13 +53,13 @@
// a buffer of |count| elements of the given size and alignment (both in bytes).
template <size_t size, size_t alignment>
void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithCount(const void* pointer, size_t count);
+CheckUserPointerWithCount(const void* pointer, size_t count);
// Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
// a buffer of the given size and alignment (both in bytes).
template <size_t alignment>
void MOJO_SYSTEM_IMPL_EXPORT
- CheckUserPointerWithSize(const void* pointer, size_t size);
+CheckUserPointerWithSize(const void* pointer, size_t size);
} // namespace internal
diff --git a/mojo/edk/system/message_in_transit.cc b/mojo/edk/system/message_in_transit.cc
index ccb1523..0f2ff5e 100644
--- a/mojo/edk/system/message_in_transit.cc
+++ b/mojo/edk/system/message_in_transit.cc
@@ -43,8 +43,8 @@
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());
@@ -72,10 +72,9 @@
}
if (transport_data_buffer_size() > 0) {
- const char* e =
- TransportData::ValidateBuffer(serialized_platform_handle_size,
- transport_data_buffer(),
- transport_data_buffer_size());
+ const char* e = TransportData::ValidateBuffer(
+ serialized_platform_handle_size, transport_data_buffer(),
+ transport_data_buffer_size());
if (e) {
*error_message = e;
return false;
@@ -95,8 +94,7 @@
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));
diff --git a/mojo/edk/system/message_pipe.cc b/mojo/edk/system/message_pipe.cc
index e215730..ce529ed 100644
--- a/mojo/edk/system/message_pipe.cc
+++ b/mojo/edk/system/message_pipe.cc
@@ -100,9 +100,7 @@
GetPeerPort(port),
make_scoped_ptr(new MessageInTransit(
MessageInTransit::kTypeMessagePipeEndpoint,
- MessageInTransit::kSubtypeMessagePipeEndpointData,
- num_bytes,
- bytes)),
+ MessageInTransit::kSubtypeMessagePipeEndpointData, num_bytes, bytes)),
transports);
}
@@ -117,8 +115,8 @@
base::AutoLock locker(lock_);
DCHECK(endpoints_[port]);
- return endpoints_[port]->ReadMessage(
- bytes, num_bytes, dispatchers, num_dispatchers, flags);
+ return endpoints_[port]->ReadMessage(bytes, num_bytes, dispatchers,
+ num_dispatchers, flags);
}
HandleSignalsState MessagePipe::GetHandleSignalsState(unsigned port) const {
@@ -165,10 +163,8 @@
// send the already-queued messages.
if (!endpoints_[GetPeerPort(port)]) {
scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint(
- nullptr,
- 0,
- static_cast<LocalMessagePipeEndpoint*>(endpoints_[port].get())
- ->message_queue()));
+ nullptr, 0, static_cast<LocalMessagePipeEndpoint*>(
+ endpoints_[port].get())->message_queue()));
endpoints_[port]->Close();
endpoints_[port].reset();
return channel_endpoint;
@@ -177,18 +173,15 @@
// TODO(vtl): Allowing this case is a temporary hack. It'll set up a
// |MessagePipe| with two proxy endpoints, which will then act as a proxy
// (rather than trying to connect the two ends directly).
- DLOG_IF(WARNING,
- endpoints_[GetPeerPort(port)]->GetType() !=
- MessagePipeEndpoint::kTypeLocal)
+ DLOG_IF(WARNING, endpoints_[GetPeerPort(port)]->GetType() !=
+ MessagePipeEndpoint::kTypeLocal)
<< "Direct message pipe passing across multiple channels not yet "
"implemented; will proxy";
scoped_ptr<MessagePipeEndpoint> old_endpoint(endpoints_[port].Pass());
scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint(
- this,
- port,
- static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get())
- ->message_queue()));
+ this, port, static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get())
+ ->message_queue()));
endpoints_[port].reset(new ProxyMessagePipeEndpoint(channel_endpoint.get()));
old_endpoint->Close();
diff --git a/mojo/edk/system/message_pipe_dispatcher.cc b/mojo/edk/system/message_pipe_dispatcher.cc
index df95c98..826cf26 100644
--- a/mojo/edk/system/message_pipe_dispatcher.cc
+++ b/mojo/edk/system/message_pipe_dispatcher.cc
@@ -182,8 +182,8 @@
if (num_bytes > GetConfiguration().max_message_num_bytes)
return MOJO_RESULT_RESOURCE_EXHAUSTED;
- return message_pipe_->WriteMessage(
- port_, bytes, num_bytes, transports, flags);
+ return message_pipe_->WriteMessage(port_, bytes, num_bytes, transports,
+ flags);
}
MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
@@ -193,8 +193,8 @@
uint32_t* num_dispatchers,
MojoReadMessageFlags flags) {
lock().AssertAcquired();
- return message_pipe_->ReadMessage(
- port_, bytes, num_bytes, dispatchers, num_dispatchers, flags);
+ return message_pipe_->ReadMessage(port_, bytes, num_bytes, dispatchers,
+ num_dispatchers, flags);
}
HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock()
@@ -209,8 +209,8 @@
uint32_t context,
HandleSignalsState* signals_state) {
lock().AssertAcquired();
- return message_pipe_->AddWaiter(
- port_, waiter, signals, context, signals_state);
+ return message_pipe_->AddWaiter(port_, waiter, signals, context,
+ signals_state);
}
void MessagePipeDispatcher::RemoveWaiterImplNoLock(
diff --git a/mojo/edk/system/message_pipe_dispatcher_unittest.cc b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
index ae651fa..8076a99 100644
--- a/mojo/edk/system/message_pipe_dispatcher_unittest.cc
+++ b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
@@ -68,10 +68,8 @@
d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
buffer[0] = 123456789;
EXPECT_EQ(MOJO_RESULT_OK,
- d1->WriteMessage(UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
stopwatch.Start();
EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
EXPECT_EQ(1u, context);
@@ -99,9 +97,7 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
d0->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
EXPECT_EQ(123456789, buffer[0]);
@@ -157,8 +153,7 @@
// Huge buffer size.
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
d0->WriteMessage(UserPointer<const void>(buffer),
- std::numeric_limits<uint32_t>::max(),
- nullptr,
+ std::numeric_limits<uint32_t>::max(), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
@@ -186,26 +181,21 @@
// |WriteMessage|:
// Null buffer with nonzero buffer size.
- EXPECT_DEATH_IF_SUPPORTED(
- d0->WriteMessage(
- NullUserPointer(), 1, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE),
- kMemoryCheckFailedRegex);
+ EXPECT_DEATH_IF_SUPPORTED(d0->WriteMessage(NullUserPointer(), 1, nullptr,
+ MOJO_WRITE_MESSAGE_FLAG_NONE),
+ kMemoryCheckFailedRegex);
// |ReadMessage|:
// Null buffer with nonzero buffer size.
// First write something so that we actually have something to read.
EXPECT_EQ(MOJO_RESULT_OK,
- d1->WriteMessage(UserPointer<const void>("x"),
- 1,
- nullptr,
+ d1->WriteMessage(UserPointer<const void>("x"), 1, nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
uint32_t buffer_size = 1;
- EXPECT_DEATH_IF_SUPPORTED(d0->ReadMessage(NullUserPointer(),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE),
- kMemoryCheckFailedRegex);
+ EXPECT_DEATH_IF_SUPPORTED(
+ d0->ReadMessage(NullUserPointer(), MakeUserPointer(&buffer_size), 0,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
+ kMemoryCheckFailedRegex);
EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
@@ -234,16 +224,12 @@
// Write (twice) to |d1|.
buffer[0] = 123456789;
EXPECT_EQ(MOJO_RESULT_OK,
- d1->WriteMessage(UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
buffer[0] = 234567890;
EXPECT_EQ(MOJO_RESULT_OK,
- d1->WriteMessage(UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Try waiting for readable on |d0|; should fail (already satisfied).
w.Init();
@@ -260,9 +246,7 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
d1->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Close |d1|.
@@ -281,9 +265,7 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
d0->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
EXPECT_EQ(123456789, buffer[0]);
@@ -301,9 +283,7 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
d0->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
EXPECT_EQ(234567890, buffer[0]);
@@ -330,18 +310,14 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
d0->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Try writing to |d0|; should fail (other end closed).
buffer[0] = 345678901;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- d0->WriteMessage(UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
}
@@ -378,24 +354,17 @@
// Wait for readable on |d1|, which will become readable after some time.
{
- test::WaiterThread thread(d1,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 1,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
// Wake it up by writing to |d0|.
buffer[0] = 123456789;
EXPECT_EQ(MOJO_RESULT_OK,
- d0->WriteMessage(UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
} // Joins the thread.
elapsed = stopwatch.Elapsed();
EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout());
@@ -410,14 +379,9 @@
// Now |d1| is already readable. Try waiting for it again.
{
- test::WaiterThread thread(d1,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 2,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
} // Joins the thread.
@@ -434,9 +398,7 @@
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
d1->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
EXPECT_EQ(123456789, buffer[0]);
@@ -444,14 +406,9 @@
// Wait for readable on |d1| and close |d0| after some time, which should
// cancel that wait.
{
- test::WaiterThread thread(d1,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 3,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -483,14 +440,9 @@
// Wait for readable on |d1| and close |d1| after some time, which should
// cancel that wait.
{
- test::WaiterThread thread(d1,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 4,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -546,18 +498,15 @@
base::RandInt(1, static_cast<int>(kMaxMessageSize)));
EXPECT_EQ(MOJO_RESULT_OK,
write_dispatcher_->WriteMessage(UserPointer<const void>(buffer),
- bytes_to_write,
- nullptr,
+ bytes_to_write, nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
*bytes_written_ += bytes_to_write;
}
// Write one last "quit" message.
- EXPECT_EQ(MOJO_RESULT_OK,
- write_dispatcher_->WriteMessage(UserPointer<const void>("quit"),
- 4,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage(
+ UserPointer<const void>("quit"), 4, nullptr,
+ MOJO_WRITE_MESSAGE_FLAG_NONE));
}
const scoped_refptr<Dispatcher> write_dispatcher_;
@@ -612,11 +561,9 @@
// Clear the buffer so that we can check the result.
memset(buffer, 0, sizeof(buffer));
uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
- result = read_dispatcher_->ReadMessage(UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE);
+ result = read_dispatcher_->ReadMessage(
+ UserPointer<void>(buffer), MakeUserPointer(&buffer_size), 0, nullptr,
+ MOJO_READ_MESSAGE_FLAG_NONE);
EXPECT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_SHOULD_WAIT)
<< "result: " << result;
// We're racing with others to read, so maybe we failed.
diff --git a/mojo/edk/system/message_pipe_perftest.cc b/mojo/edk/system/message_pipe_perftest.cc
index 9861e0b..9f1ac5d 100644
--- a/mojo/edk/system/message_pipe_perftest.cc
+++ b/mojo/edk/system/message_pipe_perftest.cc
@@ -47,31 +47,23 @@
protected:
void WriteWaitThenRead(scoped_refptr<MessagePipe> mp) {
- CHECK_EQ(mp->WriteMessage(0,
- UserPointer<const void>(payload_.data()),
- static_cast<uint32_t>(payload_.size()),
- nullptr,
+ CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(payload_.data()),
+ static_cast<uint32_t>(payload_.size()), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
HandleSignalsState hss;
CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
MOJO_RESULT_OK);
uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer_.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&read_buffer_[0]),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE),
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer_[0]),
+ MakeUserPointer(&read_buffer_size), nullptr,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
CHECK_EQ(read_buffer_size, static_cast<uint32_t>(payload_.size()));
}
void SendQuitMessage(scoped_refptr<MessagePipe> mp) {
- CHECK_EQ(mp->WriteMessage(0,
- UserPointer<const void>(""),
- 0,
- nullptr,
+ CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(""), 0, nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
}
@@ -81,8 +73,7 @@
WriteWaitThenRead(mp);
std::string test_name =
- base::StringPrintf("IPC_Perf_%dx_%u",
- message_count_,
+ base::StringPrintf("IPC_Perf_%dx_%u", message_count_,
static_cast<unsigned>(message_size_));
base::PerfTimeLogger logger(test_name.c_str());
@@ -127,11 +118,8 @@
}
uint32_t read_size = static_cast<uint32_t>(buffer.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&buffer[0]),
- MakeUserPointer(&read_size),
- nullptr,
- nullptr,
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&buffer[0]),
+ MakeUserPointer(&read_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
@@ -139,10 +127,8 @@
if (0 == read_size)
break;
- CHECK_EQ(mp->WriteMessage(0,
- UserPointer<const void>(&buffer[0]),
- static_cast<uint32_t>(read_size),
- nullptr,
+ CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&buffer[0]),
+ static_cast<uint32_t>(read_size), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
}
diff --git a/mojo/edk/system/message_pipe_test_utils.cc b/mojo/edk/system/message_pipe_test_utils.cc
index 8f217ca..e5df26d 100644
--- a/mojo/edk/system/message_pipe_test_utils.cc
+++ b/mojo/edk/system/message_pipe_test_utils.cc
@@ -46,10 +46,8 @@
test_io_thread_.Start();
test_io_thread_.PostTaskAndWait(
FROM_HERE,
- base::Bind(&ChannelThread::InitChannelOnIOThread,
- base::Unretained(this),
- base::Passed(&platform_handle),
- channel_endpoint));
+ base::Bind(&ChannelThread::InitChannelOnIOThread, base::Unretained(this),
+ base::Passed(&platform_handle), channel_endpoint));
}
void ChannelThread::Stop() {
@@ -61,9 +59,8 @@
base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
test_io_thread_.PostTaskAndWait(
- FROM_HERE,
- base::Bind(&ChannelThread::ShutdownChannelOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&ChannelThread::ShutdownChannelOnIOThread,
+ base::Unretained(this)));
}
test_io_thread_.Stop();
}
diff --git a/mojo/edk/system/message_pipe_unittest.cc b/mojo/edk/system/message_pipe_unittest.cc
index dbffb4c..030084b 100644
--- a/mojo/edk/system/message_pipe_unittest.cc
+++ b/mojo/edk/system/message_pipe_unittest.cc
@@ -39,11 +39,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
EXPECT_EQ(123, buffer[0]);
@@ -54,21 +51,16 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Write from port 1 (to port 0).
buffer[0] = 789012345;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read from port 0.
@@ -76,11 +68,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(789012345, buffer[0]);
@@ -89,41 +78,30 @@
// Read again from port 0 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Write two messages from port 0 (to port 1).
buffer[0] = 123456789;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(0, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
buffer[0] = 234567890;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(0, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read from port 1 with buffer size 0 (should get the size of next message).
// Also test that giving a null buffer is okay when the buffer size is 0.
buffer_size = 0;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(1,
- NullUserPointer(),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ mp->ReadMessage(1, NullUserPointer(), MakeUserPointer(&buffer_size),
+ 0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
// Read from port 1 with buffer size 1 (too small; should get the size of next
@@ -132,11 +110,8 @@
buffer[1] = 456;
buffer_size = 1;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(123, buffer[0]);
@@ -147,11 +122,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(123456789, buffer[0]);
@@ -162,11 +134,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(234567890, buffer[0]);
@@ -175,21 +144,16 @@
// Read again from port 1 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Write from port 0 (to port 1).
buffer[0] = 345678901;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(0, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Close port 0.
@@ -199,10 +163,8 @@
buffer[0] = 456789012;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read from port 1; should still get message (even though port 0 was closed).
@@ -210,11 +172,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(345678901, buffer[0]);
@@ -223,11 +182,8 @@
// Read again from port 1 -- it should be empty (and port 0 is closed).
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
mp->Close(1);
@@ -244,22 +200,15 @@
for (int32_t i = 0; i < 5; i++) {
buffer[0] = i;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ mp->WriteMessage(1, UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
}
// Port 0 shouldn't be empty.
buffer_size = 0;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(0,
- NullUserPointer(),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size),
+ 0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(kBufferSize, buffer_size);
// Close port 0 first, which should have outstanding (incoming) messages.
@@ -278,41 +227,30 @@
buffer[0] = 789012345;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read/discard from port 0 (no buffer); get size.
buffer_size = 0;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(0,
- NullUserPointer(),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+ mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size),
+ 0, nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
// Read again from port 0 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
// Write from port 1 (to port 0).
buffer[0] = 890123456;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read from port 0 (buffer big enough).
@@ -320,11 +258,8 @@
buffer[1] = 456;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
EXPECT_EQ(890123456, buffer[0]);
@@ -333,72 +268,52 @@
// Read again from port 0 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
// Write from port 1 (to port 0).
buffer[0] = 901234567;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Read/discard from port 0 (buffer too small); get size.
buffer_size = 1;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
// Read again from port 0 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
// Write from port 1 (to port 0).
buffer[0] = 123456789;
buffer[1] = 0;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(1,
- UserPointer<const void>(buffer),
- static_cast<uint32_t>(sizeof(buffer[0])),
- nullptr,
+ mp->WriteMessage(1, UserPointer<const void>(buffer),
+ static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Discard from port 0.
buffer_size = 1;
EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- mp->ReadMessage(0,
- NullUserPointer(),
- NullUserPointer(),
- 0,
- nullptr,
+ mp->ReadMessage(0, NullUserPointer(), NullUserPointer(), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
// Read again from port 0 -- it should be empty.
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
mp->Close(0);
@@ -424,13 +339,10 @@
hss.satisfiable_signals);
waiter.Init();
hss = HandleSignalsState();
- EXPECT_EQ(
- MOJO_RESULT_ALREADY_EXISTS,
- mp->AddWaiter(0,
- &waiter,
- MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
- 0,
- &hss));
+ EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+ mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+ MOJO_HANDLE_SIGNAL_WRITABLE,
+ 0, &hss));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfiable_signals);
@@ -449,11 +361,8 @@
// Write from port 0 (to port 1), to make port 1 readable.
buffer[0] = 123456789;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Port 1 should already be readable now.
waiter.Init();
@@ -466,13 +375,10 @@
hss.satisfiable_signals);
waiter.Init();
hss = HandleSignalsState();
- EXPECT_EQ(
- MOJO_RESULT_ALREADY_EXISTS,
- mp->AddWaiter(1,
- &waiter,
- MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
- 0,
- &hss));
+ EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+ mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+ MOJO_HANDLE_SIGNAL_WRITABLE,
+ 0, &hss));
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -510,11 +416,8 @@
buffer[0] = 0;
buffer_size = kBufferSize;
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- 0,
- nullptr,
+ mp->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), 0, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(123456789, buffer[0]);
@@ -543,18 +446,15 @@
thread.waiter()->Init();
ASSERT_EQ(MOJO_RESULT_OK,
- mp->AddWaiter(
- 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
+ mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1,
+ nullptr));
thread.Start();
buffer[0] = 123456789;
// Write from port 0 (to port 1), which should wake up the waiter.
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(buffer),
- kBufferSize,
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize,
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
HandleSignalsState hss;
mp->RemoveWaiter(1, thread.waiter(), &hss);
@@ -577,8 +477,8 @@
thread.waiter()->Init();
ASSERT_EQ(MOJO_RESULT_OK,
- mp->AddWaiter(
- 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr));
+ mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2,
+ nullptr));
thread.Start();
// Close port 1 first -- this should result in the waiter being cancelled.
@@ -600,8 +500,8 @@
thread.waiter()->Init();
ASSERT_EQ(MOJO_RESULT_OK,
- mp->AddWaiter(
- 1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
+ mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3,
+ nullptr));
thread.Start();
// Close port 0 first -- this should wake the waiter up, since port 1 will
diff --git a/mojo/edk/system/multiprocess_message_pipe_unittest.cc b/mojo/edk/system/multiprocess_message_pipe_unittest.cc
index 2f22d67..ab2e75c 100644
--- a/mojo/edk/system/multiprocess_message_pipe_unittest.cc
+++ b/mojo/edk/system/multiprocess_message_pipe_unittest.cc
@@ -72,12 +72,9 @@
std::string read_buffer(1000, '\0');
uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&read_buffer[0]),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE),
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+ MakeUserPointer(&read_buffer_size), nullptr,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
read_buffer.resize(read_buffer_size);
VLOG(2) << "Child got: " << read_buffer;
@@ -88,11 +85,9 @@
}
std::string write_buffer = read_buffer + read_buffer;
- CHECK_EQ(mp->WriteMessage(0,
- UserPointer<const void>(write_buffer.data()),
+ CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
static_cast<uint32_t>(write_buffer.size()),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
}
@@ -110,10 +105,8 @@
std::string hello("hello");
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(hello.data()),
- static_cast<uint32_t>(hello.size()),
- nullptr,
+ mp->WriteMessage(0, UserPointer<const void>(hello.data()),
+ static_cast<uint32_t>(hello.size()), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
HandleSignalsState hss;
@@ -127,11 +120,8 @@
std::string read_buffer(1000, '\0');
uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&read_buffer[0]),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+ MakeUserPointer(&read_buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
read_buffer.resize(read_buffer_size);
@@ -157,20 +147,16 @@
for (size_t i = 0; i < kNumMessages; i++) {
std::string write_buffer(i, 'A' + (i % 26));
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(write_buffer.data()),
+ mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
static_cast<uint32_t>(write_buffer.size()),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
}
const std::string quitquitquit("quitquitquit");
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(quitquitquit.data()),
+ mp->WriteMessage(0, UserPointer<const void>(quitquitquit.data()),
static_cast<uint32_t>(quitquitquit.size()),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
for (size_t i = 0; i < kNumMessages; i++) {
HandleSignalsState hss;
@@ -184,12 +170,9 @@
std::string read_buffer(kNumMessages * 2, '\0');
uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&read_buffer[0]),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE),
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+ MakeUserPointer(&read_buffer_size), nullptr,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
read_buffer.resize(read_buffer_size);
@@ -236,12 +219,9 @@
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"));
@@ -269,10 +249,8 @@
// And send a message to signal that we've written stuff.
const std::string go2("go 2");
- CHECK_EQ(mp->WriteMessage(0,
- UserPointer<const void>(&go2[0]),
- static_cast<uint32_t>(go2.size()),
- nullptr,
+ CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&go2[0]),
+ static_cast<uint32_t>(go2.size()), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
@@ -287,11 +265,8 @@
read_buffer = std::string(100, '\0');
num_bytes = static_cast<uint32_t>(read_buffer.size());
- CHECK_EQ(mp->ReadMessage(0,
- UserPointer<void>(&read_buffer[0]),
- MakeUserPointer(&num_bytes),
- nullptr,
- nullptr,
+ CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+ MakeUserPointer(&num_bytes), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE),
MOJO_RESULT_OK);
read_buffer.resize(num_bytes);
@@ -322,12 +297,10 @@
// Make a shared buffer.
scoped_refptr<SharedBufferDispatcher> dispatcher;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher));
ASSERT_TRUE(dispatcher.get());
// Make a mapping.
@@ -347,10 +320,8 @@
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();
@@ -367,11 +338,8 @@
std::string read_buffer(100, '\0');
uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
EXPECT_EQ(MOJO_RESULT_OK,
- mp->ReadMessage(0,
- UserPointer<void>(&read_buffer[0]),
- MakeUserPointer(&num_bytes),
- nullptr,
- nullptr,
+ mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+ MakeUserPointer(&num_bytes), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
read_buffer.resize(num_bytes);
EXPECT_EQ(std::string("go 2"), read_buffer);
@@ -388,10 +356,8 @@
// And send a message to signal that we've written stuff.
const std::string go3("go 3");
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(&go3[0]),
- static_cast<uint32_t>(go3.size()),
- nullptr,
+ mp->WriteMessage(0, UserPointer<const void>(&go3[0]),
+ static_cast<uint32_t>(go3.size()), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait for |mp| to become readable, which should fail.
@@ -428,12 +394,9 @@
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,10 +459,8 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
EXPECT_EQ(MOJO_RESULT_OK,
- mp->WriteMessage(0,
- UserPointer<const void>(&hello[0]),
- static_cast<uint32_t>(hello.size()),
- &transports,
+ mp->WriteMessage(0, UserPointer<const void>(&hello[0]),
+ static_cast<uint32_t>(hello.size()), &transports,
MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
diff --git a/mojo/edk/system/raw_channel.cc b/mojo/edk/system/raw_channel.cc
index 0bfe104..4331166 100644
--- a/mojo/edk/system/raw_channel.cc
+++ b/mojo/edk/system/raw_channel.cc
@@ -133,9 +133,8 @@
// attached.
// Write from both buffers.
- DCHECK_EQ(
- bytes_to_write,
- message->main_buffer_size() - data_offset_ + transport_data_buffer_size);
+ DCHECK_EQ(bytes_to_write, message->main_buffer_size() - data_offset_ +
+ transport_data_buffer_size);
Buffer buffer1 = {
static_cast<const char*>(message->main_buffer()) + data_offset_,
message->main_buffer_size() - data_offset_};
@@ -195,11 +194,9 @@
if (io_result != IO_PENDING) {
// This will notify the delegate about the read failure. Although we're on
// the I/O thread, don't call it in the nested context.
- message_loop_for_io_->PostTask(FROM_HERE,
- base::Bind(&RawChannel::OnReadCompleted,
- weak_ptr_factory_.GetWeakPtr(),
- io_result,
- 0));
+ message_loop_for_io_->PostTask(
+ FROM_HERE, base::Bind(&RawChannel::OnReadCompleted,
+ weak_ptr_factory_.GetWeakPtr(), io_result, 0));
}
// ScheduleRead() failure is treated as a read failure (by notifying the
@@ -246,15 +243,15 @@
if (io_result == IO_PENDING)
return true;
- bool result = OnWriteCompletedNoLock(
- io_result, platform_handles_written, bytes_written);
+ bool result = OnWriteCompletedNoLock(io_result, platform_handles_written,
+ bytes_written);
if (!result) {
// Even if we're on the I/O thread, don't call |OnError()| in the nested
// context.
- message_loop_for_io_->PostTask(FROM_HERE,
- base::Bind(&RawChannel::CallOnError,
- weak_ptr_factory_.GetWeakPtr(),
- Delegate::ERROR_WRITE));
+ message_loop_for_io_->PostTask(
+ FROM_HERE,
+ base::Bind(&RawChannel::CallOnError, weak_ptr_factory_.GetWeakPtr(),
+ Delegate::ERROR_WRITE));
}
return result;
@@ -312,8 +309,7 @@
// TODO(vtl): Validate that |message_size| is sane.
while (remaining_bytes > 0 && MessageInTransit::GetNextMessageSize(
&read_buffer_->buffer_[read_buffer_start],
- remaining_bytes,
- &message_size) &&
+ remaining_bytes, &message_size) &&
remaining_bytes >= message_size) {
MessageInTransit::View message_view(
message_size, &read_buffer_->buffer_[read_buffer_start]);
@@ -341,8 +337,7 @@
size_t num_platform_handles;
const void* platform_handle_table;
TransportData::GetPlatformHandleTable(
- message_view.transport_data_buffer(),
- &num_platform_handles,
+ message_view.transport_data_buffer(), &num_platform_handles,
&platform_handle_table);
if (num_platform_handles > 0) {
@@ -383,8 +378,7 @@
read_buffer_->num_valid_bytes_ = remaining_bytes;
if (read_buffer_->num_valid_bytes_ > 0) {
memmove(&read_buffer_->buffer_[0],
- &read_buffer_->buffer_[read_buffer_start],
- remaining_bytes);
+ &read_buffer_->buffer_[read_buffer_start], remaining_bytes);
}
read_buffer_start = 0;
}
@@ -433,8 +427,8 @@
return;
}
- did_fail = !OnWriteCompletedNoLock(
- io_result, platform_handles_written, bytes_written);
+ did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written,
+ bytes_written);
}
if (did_fail)
diff --git a/mojo/edk/system/raw_channel_posix.cc b/mojo/edk/system/raw_channel_posix.cc
index ca43845..71ec02f 100644
--- a/mojo/edk/system/raw_channel_posix.cc
+++ b/mojo/edk/system/raw_channel_posix.cc
@@ -135,8 +135,7 @@
i += embedder::kPlatformChannelMaxNumHandles) {
scoped_ptr<MessageInTransit> fd_message(new MessageInTransit(
MessageInTransit::kTypeRawChannel,
- MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles,
- 0,
+ MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, 0,
nullptr));
embedder::ScopedPlatformHandleVectorPtr fds(
new embedder::PlatformHandleVector(
@@ -253,8 +252,8 @@
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];
@@ -302,11 +301,8 @@
}
if (message_loop_for_io()->WatchFileDescriptor(
- fd_.get().fd,
- false,
- base::MessageLoopForIO::WATCH_WRITE,
- write_watcher_.get(),
- this)) {
+ fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+ write_watcher_.get(), this)) {
pending_write_ = true;
return IO_PENDING;
}
@@ -323,11 +319,8 @@
write_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
if (!message_loop_for_io()->WatchFileDescriptor(
- fd_.get().fd,
- true,
- base::MessageLoopForIO::WATCH_READ,
- read_watcher_.get(),
- this)) {
+ fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ,
+ read_watcher_.get(), this)) {
// TODO(vtl): I'm not sure |WatchFileDescriptor()| actually fails cleanly
// (in the sense of returning the message loop's state to what it was before
// it was called).
@@ -455,11 +448,8 @@
DCHECK(write_watcher_);
if (!message_loop_for_io()->WatchFileDescriptor(
- fd_.get().fd,
- false,
- base::MessageLoopForIO::WATCH_WRITE,
- write_watcher_.get(),
- this)) {
+ fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+ write_watcher_.get(), this)) {
{
base::AutoLock locker(write_lock());
diff --git a/mojo/edk/system/raw_channel_unittest.cc b/mojo/edk/system/raw_channel_unittest.cc
index 9ee937d..7717f49 100644
--- a/mojo/edk/system/raw_channel_unittest.cc
+++ b/mojo/edk/system/raw_channel_unittest.cc
@@ -41,8 +41,7 @@
return make_scoped_ptr(
new MessageInTransit(MessageInTransit::kTypeMessagePipeEndpoint,
MessageInTransit::kSubtypeMessagePipeEndpointData,
- num_bytes,
- bytes.empty() ? nullptr : &bytes[0]));
+ num_bytes, bytes.empty() ? nullptr : &bytes[0]));
}
bool CheckMessageData(const void* bytes, uint32_t num_bytes) {
@@ -63,8 +62,8 @@
scoped_ptr<MessageInTransit> message(MakeTestMessage(num_bytes));
size_t write_size = 0;
- mojo::test::BlockingWrite(
- handle, message->main_buffer(), message->main_buffer_size(), &write_size);
+ mojo::test::BlockingWrite(handle, message->main_buffer(),
+ message->main_buffer_size(), &write_size);
return write_size == message->main_buffer_size();
}
@@ -135,8 +134,8 @@
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);
@@ -144,8 +143,7 @@
// If we have the header....
size_t message_size;
if (MessageInTransit::GetNextMessageSize(
- bytes_.empty() ? nullptr : &bytes_[0],
- bytes_.size(),
+ bytes_.empty() ? nullptr : &bytes_[0], bytes_.size(),
&message_size)) {
// If we've read the whole message....
if (bytes_.size() >= message_size) {
@@ -378,16 +376,14 @@
WriteOnlyRawChannelDelegate writer_delegate;
scoped_ptr<RawChannel> writer_rc(RawChannel::Create(handles[0].Pass()));
io_thread()->PostTaskAndWait(FROM_HERE,
- base::Bind(&InitOnIOThread,
- writer_rc.get(),
+ base::Bind(&InitOnIOThread, writer_rc.get(),
base::Unretained(&writer_delegate)));
ReadCountdownRawChannelDelegate reader_delegate(kNumWriterThreads *
kNumWriteMessagesPerThread);
scoped_ptr<RawChannel> reader_rc(RawChannel::Create(handles[1].Pass()));
io_thread()->PostTaskAndWait(FROM_HERE,
- base::Bind(&InitOnIOThread,
- reader_rc.get(),
+ base::Bind(&InitOnIOThread, reader_rc.get(),
base::Unretained(&reader_delegate)));
{
diff --git a/mojo/edk/system/raw_channel_win.cc b/mojo/edk/system/raw_channel_win.cc
index 98380a9..27b9ccf 100644
--- a/mojo/edk/system/raw_channel_win.cc
+++ b/mojo/edk/system/raw_channel_win.cc
@@ -371,11 +371,9 @@
size_t bytes_to_read = 0;
read_buffer()->GetBuffer(&buffer, &bytes_to_read);
- BOOL result = ReadFile(io_handler_->handle(),
- buffer,
- static_cast<DWORD>(bytes_to_read),
- nullptr,
- &io_handler_->read_context()->overlapped);
+ BOOL result =
+ ReadFile(io_handler_->handle(), buffer, static_cast<DWORD>(bytes_to_read),
+ nullptr, &io_handler_->read_context()->overlapped);
if (!result) {
DWORD error = GetLastError();
if (error == ERROR_BROKEN_PIPE)
@@ -388,11 +386,9 @@
if (result && skip_completion_port_on_success_) {
DWORD bytes_read_dword = 0;
- BOOL get_size_result =
- GetOverlappedResult(io_handler_->handle(),
- &io_handler_->read_context()->overlapped,
- &bytes_read_dword,
- FALSE);
+ BOOL get_size_result = GetOverlappedResult(
+ io_handler_->handle(), &io_handler_->read_context()->overlapped,
+ &bytes_read_dword, FALSE);
DPCHECK(get_size_result);
*bytes_read = bytes_read_dword;
return IO_SUCCEEDED;
@@ -426,12 +422,10 @@
// |io_handler_| won't go away before the task is run, so it is safe to use
// |base::Unretained()|.
message_loop_for_io()->PostTask(
- FROM_HERE,
- base::Bind(&RawChannelIOHandler::OnIOCompleted,
- base::Unretained(io_handler_),
- base::Unretained(io_handler_->read_context()),
- static_cast<DWORD>(bytes_read),
- ERROR_SUCCESS));
+ FROM_HERE, base::Bind(&RawChannelIOHandler::OnIOCompleted,
+ base::Unretained(io_handler_),
+ base::Unretained(io_handler_->read_context()),
+ static_cast<DWORD>(bytes_read), ERROR_SUCCESS));
return IO_PENDING;
}
@@ -465,11 +459,10 @@
// TODO(yzshen): Handle multi-segment writes more efficiently.
DWORD bytes_written_dword = 0;
- BOOL result = WriteFile(io_handler_->handle(),
- buffers[0].addr,
- static_cast<DWORD>(buffers[0].size),
- &bytes_written_dword,
- &io_handler_->write_context_no_lock()->overlapped);
+ BOOL result =
+ WriteFile(io_handler_->handle(), buffers[0].addr,
+ static_cast<DWORD>(buffers[0].size), &bytes_written_dword,
+ &io_handler_->write_context_no_lock()->overlapped);
if (!result) {
DWORD error = GetLastError();
if (error == ERROR_BROKEN_PIPE)
@@ -521,8 +514,7 @@
base::Bind(&RawChannelIOHandler::OnIOCompleted,
base::Unretained(io_handler_),
base::Unretained(io_handler_->write_context_no_lock()),
- static_cast<DWORD>(bytes_written),
- ERROR_SUCCESS));
+ static_cast<DWORD>(bytes_written), ERROR_SUCCESS));
return IO_PENDING;
}
diff --git a/mojo/edk/system/remote_message_pipe_unittest.cc b/mojo/edk/system/remote_message_pipe_unittest.cc
index d3a95df..e3a320e 100644
--- a/mojo/edk/system/remote_message_pipe_unittest.cc
+++ b/mojo/edk/system/remote_message_pipe_unittest.cc
@@ -48,16 +48,14 @@
void SetUp() override {
io_thread_.PostTaskAndWait(
- FROM_HERE,
- base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
+ base::Unretained(this)));
}
void TearDown() override {
io_thread_.PostTaskAndWait(
- FROM_HERE,
- base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
- base::Unretained(this)));
+ FROM_HERE, base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
+ base::Unretained(this)));
}
protected:
@@ -69,9 +67,7 @@
io_thread_.PostTaskAndWait(
FROM_HERE,
base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointsOnIOThread,
- base::Unretained(this),
- ep0,
- ep1));
+ base::Unretained(this), ep0, ep1));
}
// This bootstraps |ep| on |channels_[channel_index]|. It assumes/requires
@@ -82,9 +78,7 @@
io_thread_.PostTask(
FROM_HERE,
base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointOnIOThread,
- base::Unretained(this),
- channel_index,
- ep));
+ base::Unretained(this), channel_index, ep));
}
void RestoreInitialState() {
@@ -198,12 +192,10 @@
mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
// Write to MP 0, port 0.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait.
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -217,11 +209,8 @@
// Read from MP 1, port 1.
EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kHello, buffer);
@@ -233,12 +222,10 @@
MOJO_RESULT_OK,
mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->WriteMessage(1,
- UserPointer<const void>(kWorld),
- sizeof(kWorld),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
EXPECT_EQ(456u, context);
@@ -251,11 +238,8 @@
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- mp0->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp0->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kWorld, buffer);
@@ -320,10 +304,8 @@
mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(&remote_id),
- sizeof(remote_id),
- nullptr,
+ mp0->WriteMessage(0, UserPointer<const void>(&remote_id),
+ sizeof(remote_id), nullptr,
MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -338,11 +320,8 @@
ChannelEndpointId received_id;
buffer_size = static_cast<uint32_t>(sizeof(received_id));
EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(&received_id),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(&received_id),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(received_id), static_cast<size_t>(buffer_size));
EXPECT_EQ(remote_id, received_id);
@@ -359,12 +338,10 @@
MOJO_RESULT_OK,
mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
- EXPECT_EQ(MOJO_RESULT_OK,
- mp2->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp2->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
EXPECT_EQ(789u, context);
@@ -378,37 +355,25 @@
// Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0.
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp0->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp0->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp1->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp2->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp2->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
// Read from MP 3, port 1.
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- mp3->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp3->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kHello, buffer);
@@ -420,12 +385,10 @@
MOJO_RESULT_OK,
mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kWorld),
- sizeof(kWorld),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
EXPECT_EQ(123u, context);
@@ -439,36 +402,24 @@
// Make sure there's nothing on the other ports.
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp0->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp0->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp2->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp2->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
- mp3->ReadMessage(0,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp3->ReadMessage(0, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
buffer_size = static_cast<uint32_t>(sizeof(buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kWorld, buffer);
@@ -495,12 +446,10 @@
scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
// Write to MP 0, port 0.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Close MP 0, port 0 before it's even been attached to the channel and run.
mp0->Close(0);
@@ -533,11 +482,8 @@
// Read from MP 1, port 1.
EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kHello, buffer);
@@ -562,12 +508,10 @@
scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
// Write to MP 0, port 0.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
BootstrapChannelEndpointNoWait(0, ep0);
@@ -600,11 +544,8 @@
// Read from MP 1, port 1.
EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(buffer),
- MakeUserPointer(&buffer_size),
- nullptr,
- nullptr,
+ mp1->ReadMessage(1, UserPointer<void>(buffer),
+ MakeUserPointer(&buffer_size), nullptr, nullptr,
MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
EXPECT_STREQ(kHello, buffer);
@@ -646,12 +587,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -675,13 +614,11 @@
uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
DispatcherVector read_dispatchers;
uint32_t read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -695,16 +632,14 @@
// Add the waiter now, before it becomes readable to avoid a race.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- dispatcher->AddWaiter(
- &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
+ dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
+ nullptr));
// Write to "local_mp", port 1.
- EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->WriteMessage(1,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately
// here. (We don't crash if I sleep and then close.)
@@ -724,25 +659,21 @@
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dispatcher->ReadMessage(UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ MakeUserPointer(&read_buffer_size), 0,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
// Prepare to wait on "local_mp", port 1.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- local_mp->AddWaiter(
- 1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+ local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+ nullptr));
// Write to the dispatcher.
- EXPECT_EQ(MOJO_RESULT_OK,
- dispatcher->WriteMessage(UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+ UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait.
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -758,12 +689,9 @@
memset(read_buffer, 0, sizeof(read_buffer));
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), nullptr,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
@@ -796,24 +724,20 @@
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfiable_signals);
// Write to the other end (|local_mp|, port 1), and then close it.
- EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->WriteMessage(1,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = local_mp->GetHandleSignalsState(0);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfiable_signals);
// Then the second message....
- EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->WriteMessage(1,
- UserPointer<const void>(kWorld),
- sizeof(kWorld),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ local_mp->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
hss = local_mp->GetHandleSignalsState(0);
EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
hss.satisfied_signals);
@@ -843,12 +767,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -872,13 +794,11 @@
uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
DispatcherVector read_dispatchers;
uint32_t read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -898,10 +818,8 @@
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dispatcher->ReadMessage(UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ MakeUserPointer(&read_buffer_size), 0,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
// It should still be readable.
@@ -913,10 +831,8 @@
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dispatcher->ReadMessage(UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ MakeUserPointer(&read_buffer_size), 0,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kWorld, read_buffer);
// Now it should no longer be readable.
@@ -950,19 +866,16 @@
// We'll try to pass this dispatcher.
scoped_refptr<SharedBufferDispatcher> dispatcher;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher));
ASSERT_TRUE(dispatcher.get());
// Make a mapping.
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+ 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
ASSERT_TRUE(mapping0);
ASSERT_TRUE(mapping0->GetBase());
ASSERT_EQ(100u, mapping0->GetLength());
@@ -985,12 +898,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1014,13 +925,11 @@
uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
DispatcherVector read_dispatchers;
uint32_t read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -1033,9 +942,8 @@
// Make another mapping.
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+ 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
ASSERT_TRUE(mapping1);
ASSERT_TRUE(mapping1->GetBase());
ASSERT_EQ(100u, mapping1->GetLength());
@@ -1110,12 +1018,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kWorld),
- sizeof(kWorld),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1139,13 +1045,11 @@
uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
DispatcherVector read_dispatchers;
uint32_t read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kWorld, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -1252,12 +1156,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->WriteMessage(0,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1281,13 +1183,11 @@
uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
DispatcherVector read_dispatchers;
uint32_t read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -1316,12 +1216,10 @@
std::vector<DispatcherTransport> transports;
transports.push_back(transport);
- EXPECT_EQ(MOJO_RESULT_OK,
- mp1->WriteMessage(1,
- UserPointer<const void>(kWorld),
- sizeof(kWorld),
- &transports,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+ &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
transport.End();
// |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1343,13 +1241,11 @@
// Read from MP 0, port 0.
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
read_num_dispatchers = 10; // Maximum to get.
- EXPECT_EQ(MOJO_RESULT_OK,
- mp0->ReadMessage(0,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- &read_dispatchers,
- &read_num_dispatchers,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ mp0->ReadMessage(0, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), &read_dispatchers,
+ &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kWorld, read_buffer);
EXPECT_EQ(1u, read_dispatchers.size());
@@ -1364,16 +1260,14 @@
// Add the waiter now, before it becomes readable to avoid a race.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- dispatcher->AddWaiter(
- &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+ dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+ nullptr));
// Write to "local_mp", port 1.
- EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->WriteMessage(1,
- UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(
+ MOJO_RESULT_OK,
+ local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait for the dispatcher to become readable.
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -1390,25 +1284,21 @@
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
dispatcher->ReadMessage(UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- 0,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ MakeUserPointer(&read_buffer_size), 0,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
// Prepare to wait on "local_mp", port 1.
waiter.Init();
ASSERT_EQ(MOJO_RESULT_OK,
- local_mp->AddWaiter(
- 1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+ local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+ nullptr));
// Write to the dispatcher.
- EXPECT_EQ(MOJO_RESULT_OK,
- dispatcher->WriteMessage(UserPointer<const void>(kHello),
- sizeof(kHello),
- nullptr,
- MOJO_WRITE_MESSAGE_FLAG_NONE));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+ UserPointer<const void>(kHello), sizeof(kHello),
+ nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
// Wait.
EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -1424,12 +1314,9 @@
memset(read_buffer, 0, sizeof(read_buffer));
read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
EXPECT_EQ(MOJO_RESULT_OK,
- local_mp->ReadMessage(1,
- UserPointer<void>(read_buffer),
- MakeUserPointer(&read_buffer_size),
- nullptr,
- nullptr,
- MOJO_READ_MESSAGE_FLAG_NONE));
+ local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+ MakeUserPointer(&read_buffer_size), nullptr,
+ nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
EXPECT_STREQ(kHello, read_buffer);
diff --git a/mojo/edk/system/run_all_unittests.cc b/mojo/edk/system/run_all_unittests.cc
index 2855e96..3ea1682 100644
--- a/mojo/edk/system/run_all_unittests.cc
+++ b/mojo/edk/system/run_all_unittests.cc
@@ -15,7 +15,6 @@
base::TestSuite test_suite(argc, argv);
return base::LaunchUnitTests(
- argc,
- argv,
+ argc, argv,
base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
}
diff --git a/mojo/edk/system/shared_buffer_dispatcher.cc b/mojo/edk/system/shared_buffer_dispatcher.cc
index 2993df9..38ac390 100644
--- a/mojo/edk/system/shared_buffer_dispatcher.cc
+++ b/mojo/edk/system/shared_buffer_dispatcher.cc
@@ -163,8 +163,8 @@
if (!reader.is_valid())
return MOJO_RESULT_INVALID_ARGUMENT;
- if (!OPTIONS_STRUCT_HAS_MEMBER(
- MojoDuplicateBufferHandleOptions, flags, reader))
+ if (!OPTIONS_STRUCT_HAS_MEMBER(MojoDuplicateBufferHandleOptions, flags,
+ reader))
return MOJO_RESULT_OK;
if ((reader.options().flags & ~kKnownFlags))
return MOJO_RESULT_UNIMPLEMENTED;
diff --git a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
index a80f71d..5866089 100644
--- a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
+++ b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
@@ -58,9 +58,8 @@
// Default options.
{
MojoCreateSharedBufferOptions validated_options = {};
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::ValidateCreateOptions(
- NullUserPointer(), &validated_options));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::ValidateCreateOptions(
+ NullUserPointer(), &validated_options));
RevalidateCreateOptions(validated_options);
}
@@ -115,20 +114,17 @@
TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) {
scoped_refptr<SharedBufferDispatcher> dispatcher;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher));
ASSERT_TRUE(dispatcher.get());
EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType());
// Make a couple of mappings.
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+ 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
ASSERT_TRUE(mapping1);
ASSERT_TRUE(mapping1->GetBase());
EXPECT_EQ(100u, mapping1->GetLength());
@@ -136,9 +132,8 @@
static_cast<char*>(mapping1->GetBase())[50] = 'x';
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping2;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher->MapBuffer(50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+ 50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2));
ASSERT_TRUE(mapping2);
ASSERT_TRUE(mapping2->GetBase());
EXPECT_EQ(50u, mapping2->GetLength());
@@ -154,35 +149,30 @@
TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) {
scoped_refptr<SharedBufferDispatcher> dispatcher1;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher1));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher1));
// Map and write something.
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->MapBuffer(
+ 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
static_cast<char*>(mapping->GetBase())[0] = 'x';
mapping.reset();
// Duplicate |dispatcher1| and then close it.
scoped_refptr<Dispatcher> dispatcher2;
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher1->DuplicateBufferHandle(NullUserPointer(), &dispatcher2));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle(
+ NullUserPointer(), &dispatcher2));
ASSERT_TRUE(dispatcher2.get());
EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
// Map |dispatcher2| and read something.
- EXPECT_EQ(
- MOJO_RESULT_OK,
- dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->MapBuffer(
+ 0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
EXPECT_EQ('x', static_cast<char*>(mapping->GetBase())[0]);
EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
@@ -190,12 +180,10 @@
TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) {
scoped_refptr<SharedBufferDispatcher> dispatcher1;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher1));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher1));
MojoDuplicateBufferHandleOptions options[] = {
{sizeof(MojoDuplicateBufferHandleOptions),
@@ -203,9 +191,8 @@
{sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u}};
for (size_t i = 0; i < arraysize(options); i++) {
scoped_refptr<Dispatcher> dispatcher2;
- EXPECT_EQ(MOJO_RESULT_OK,
- dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options[i]),
- &dispatcher2));
+ EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle(
+ MakeUserPointer(&options[i]), &dispatcher2));
ASSERT_TRUE(dispatcher2.get());
EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
@@ -216,12 +203,10 @@
TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) {
scoped_refptr<SharedBufferDispatcher> dispatcher1;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher1));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher1));
// Invalid |struct_size|.
{
@@ -251,32 +236,27 @@
TEST_F(SharedBufferDispatcherTest, CreateInvalidNumBytes) {
// Size too big.
scoped_refptr<SharedBufferDispatcher> dispatcher;
- EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- std::numeric_limits<uint64_t>::max(),
- &dispatcher));
+ EXPECT_EQ(
+ MOJO_RESULT_RESOURCE_EXHAUSTED,
+ SharedBufferDispatcher::Create(
+ platform_support(), SharedBufferDispatcher::kDefaultCreateOptions,
+ std::numeric_limits<uint64_t>::max(), &dispatcher));
EXPECT_FALSE(dispatcher.get());
// Zero size.
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
SharedBufferDispatcher::Create(
platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 0,
- &dispatcher));
+ SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher));
EXPECT_FALSE(dispatcher.get());
}
TEST_F(SharedBufferDispatcherTest, MapBufferInvalidArguments) {
scoped_refptr<SharedBufferDispatcher> dispatcher;
- EXPECT_EQ(MOJO_RESULT_OK,
- SharedBufferDispatcher::Create(
- platform_support(),
- SharedBufferDispatcher::kDefaultCreateOptions,
- 100,
- &dispatcher));
+ EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+ platform_support(),
+ SharedBufferDispatcher::kDefaultCreateOptions,
+ 100, &dispatcher));
scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
diff --git a/mojo/edk/system/simple_dispatcher_unittest.cc b/mojo/edk/system/simple_dispatcher_unittest.cc
index 502e34b..f23ff68 100644
--- a/mojo/edk/system/simple_dispatcher_unittest.cc
+++ b/mojo/edk/system/simple_dispatcher_unittest.cc
@@ -343,14 +343,9 @@
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
{
d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
- test::WaiterThread thread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 1,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
} // Joins the thread.
@@ -368,14 +363,9 @@
{
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
{
- test::WaiterThread thread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 2,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -397,14 +387,9 @@
{
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
{
- test::WaiterThread thread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 3,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -424,14 +409,9 @@
// Wait for readable and dispatcher gets closed.
{
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
- test::WaiterThread thread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- 4,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+ MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
+ &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -450,14 +430,9 @@
{
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
{
- test::WaiterThread thread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- 2 * test::EpsilonTimeout().InMicroseconds(),
- 5,
- &did_wait,
- &result,
- &context,
- &hss);
+ test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+ 2 * test::EpsilonTimeout().InMicroseconds(), 5,
+ &did_wait, &result, &context, &hss);
stopwatch.Start();
thread.Start();
base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -496,14 +471,9 @@
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
ScopedVector<test::WaiterThread> threads;
for (uint32_t i = 0; i < kNumWaiters; i++) {
- threads.push_back(new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+ &did_wait[i], &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -524,25 +494,15 @@
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
ScopedVector<test::WaiterThread> threads;
for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
- threads.push_back(new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+ &did_wait[i], &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
- threads.push_back(new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_WRITABLE,
- MOJO_DEADLINE_INDEFINITE,
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
+ &did_wait[i], &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -571,25 +531,15 @@
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
ScopedVector<test::WaiterThread> threads;
for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
- threads.push_back(new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- MOJO_DEADLINE_INDEFINITE,
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+ &did_wait[i], &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
- threads.push_back(new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_WRITABLE,
- MOJO_DEADLINE_INDEFINITE,
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
+ &did_wait[i], &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -619,27 +569,17 @@
scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
ScopedVector<test::WaiterThread> threads;
for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
- threads.push_back(
- new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_READABLE,
- 3 * test::EpsilonTimeout().InMicroseconds(),
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_READABLE,
+ 3 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i],
+ &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
- threads.push_back(
- new test::WaiterThread(d,
- MOJO_HANDLE_SIGNAL_WRITABLE,
- 1 * test::EpsilonTimeout().InMicroseconds(),
- i,
- &did_wait[i],
- &result[i],
- &context[i],
- &hss[i]));
+ threads.push_back(new test::WaiterThread(
+ d, MOJO_HANDLE_SIGNAL_WRITABLE,
+ 1 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i],
+ &result[i], &context[i], &hss[i]));
threads.back()->Start();
}
base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
diff --git a/mojo/edk/system/transport_data.cc b/mojo/edk/system/transport_data.cc
index a767d24..300b731 100644
--- a/mojo/edk/system/transport_data.cc
+++ b/mojo/edk/system/transport_data.cc
@@ -149,10 +149,7 @@
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);
diff --git a/mojo/edk/system/waiter_test_utils.cc b/mojo/edk/system/waiter_test_utils.cc
index 06a4033..39cb14e 100644
--- a/mojo/edk/system/waiter_test_utils.cc
+++ b/mojo/edk/system/waiter_test_utils.cc
@@ -55,8 +55,8 @@
void WaiterThread::Run() {
waiter_.Init();
- *result_out_ = dispatcher_->AddWaiter(
- &waiter_, handle_signals_, context_, signals_state_out_);
+ *result_out_ = dispatcher_->AddWaiter(&waiter_, handle_signals_, context_,
+ signals_state_out_);
if (*result_out_ != MOJO_RESULT_OK)
return;
diff --git a/mojo/edk/test/multiprocess_test_helper.cc b/mojo/edk/test/multiprocess_test_helper.cc
index 02367d6..30aa0be 100644
--- a/mojo/edk/test/multiprocess_test_helper.cc
+++ b/mojo/edk/test/multiprocess_test_helper.cc
@@ -60,8 +60,8 @@
CHECK_NE(test_child_handle_, base::kNullProcessHandle);
int rv = -1;
- CHECK(base::WaitForExitCodeWithTimeout(
- test_child_handle_, &rv, TestTimeouts::action_timeout()));
+ CHECK(base::WaitForExitCodeWithTimeout(test_child_handle_, &rv,
+ TestTimeouts::action_timeout()));
base::CloseProcessHandle(test_child_handle_);
test_child_handle_ = base::kNullProcessHandle;
return rv;
diff --git a/mojo/edk/test/run_all_unittests.cc b/mojo/edk/test/run_all_unittests.cc
index c66ea50..166a73e 100644
--- a/mojo/edk/test/run_all_unittests.cc
+++ b/mojo/edk/test/run_all_unittests.cc
@@ -21,7 +21,6 @@
mojo::test::TestSupport::Init(new mojo::test::TestSupportImpl());
return base::LaunchUnitTests(
- argc,
- argv,
+ argc, argv,
base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
}
diff --git a/mojo/edk/test/test_support_impl.cc b/mojo/edk/test/test_support_impl.cc
index 2a86331..fae3a8f 100644
--- a/mojo/edk/test/test_support_impl.cc
+++ b/mojo/edk/test/test_support_impl.cc
@@ -56,8 +56,7 @@
char** TestSupportImpl::EnumerateSourceRootRelativeDirectory(
const char* relative_path) {
std::vector<std::string> names;
- base::FileEnumerator e(ResolveSourceRootRelativePath(relative_path),
- false,
+ base::FileEnumerator e(ResolveSourceRootRelativePath(relative_path), false,
base::FileEnumerator::FILES);
for (base::FilePath name = e.Next(); !name.empty(); name = e.Next())
names.push_back(name.BaseName().AsUTF8Unsafe());
diff --git a/mojo/edk/test/test_utils_win.cc b/mojo/edk/test/test_utils_win.cc
index 5d5b942..2387945 100644
--- a/mojo/edk/test/test_utils_win.cc
+++ b/mojo/edk/test/test_utils_win.cc
@@ -23,14 +23,11 @@
OVERLAPPED overlapped = {0};
DWORD bytes_written_dword = 0;
- if (!WriteFile(handle.handle,
- buffer,
- static_cast<DWORD>(bytes_to_write),
- &bytes_written_dword,
- &overlapped)) {
+ if (!WriteFile(handle.handle, buffer, static_cast<DWORD>(bytes_to_write),
+ &bytes_written_dword, &overlapped)) {
if (GetLastError() != ERROR_IO_PENDING ||
- !GetOverlappedResult(
- handle.handle, &overlapped, &bytes_written_dword, TRUE)) {
+ !GetOverlappedResult(handle.handle, &overlapped, &bytes_written_dword,
+ TRUE)) {
return false;
}
}
@@ -46,14 +43,11 @@
OVERLAPPED overlapped = {0};
DWORD bytes_read_dword = 0;
- if (!ReadFile(handle.handle,
- buffer,
- static_cast<DWORD>(buffer_size),
- &bytes_read_dword,
- &overlapped)) {
+ if (!ReadFile(handle.handle, buffer, static_cast<DWORD>(buffer_size),
+ &bytes_read_dword, &overlapped)) {
if (GetLastError() != ERROR_IO_PENDING ||
- !GetOverlappedResult(
- handle.handle, &overlapped, &bytes_read_dword, TRUE)) {
+ !GetOverlappedResult(handle.handle, &overlapped, &bytes_read_dword,
+ TRUE)) {
return false;
}
}
@@ -69,18 +63,15 @@
OVERLAPPED overlapped = {0};
DWORD bytes_read_dword = 0;
- if (!ReadFile(handle.handle,
- buffer,
- static_cast<DWORD>(buffer_size),
- &bytes_read_dword,
- &overlapped)) {
+ if (!ReadFile(handle.handle, buffer, static_cast<DWORD>(buffer_size),
+ &bytes_read_dword, &overlapped)) {
if (GetLastError() != ERROR_IO_PENDING)
return false;
CancelIo(handle.handle);
- if (!GetOverlappedResult(
- handle.handle, &overlapped, &bytes_read_dword, TRUE)) {
+ if (!GetOverlappedResult(handle.handle, &overlapped, &bytes_read_dword,
+ TRUE)) {
*bytes_read = 0;
return true;
}
@@ -97,11 +88,7 @@
PCHECK(DuplicateHandle(
GetCurrentProcess(),
reinterpret_cast<HANDLE>(_get_osfhandle(_fileno(fp.get()))),
- GetCurrentProcess(),
- &rv,
- 0,
- TRUE,
- DUPLICATE_SAME_ACCESS))
+ GetCurrentProcess(), &rv, 0, TRUE, DUPLICATE_SAME_ACCESS))
<< "DuplicateHandle";
return embedder::ScopedPlatformHandle(embedder::PlatformHandle(rv));
}
