Mojo: Plumb new Wait/WaitMany API out to Core.

We still need to expose these to apps, and transition things
appropriately.

R=darin@chromium.org

Review URL: https://codereview.chromium.org/454603002

Cr-Commit-Position: refs/heads/master@{#288453}
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@288453 0039d316-1c4b-4281-b951-d872f2087c98

mojo/system/core.cc

@@ -14,6 +14,7 @@
 #include "mojo/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/system/data_pipe_producer_dispatcher.h"
 #include "mojo/system/dispatcher.h"
+#include "mojo/system/handle_signals_state.h"
 #include "mojo/system/local_data_pipe.h"
 #include "mojo/system/memory.h"
 #include "mojo/system/message_pipe.h"
@@ -118,15 +119,27 @@ MojoResult Core::Close(MojoHandle handle) {
 
 MojoResult Core::Wait(MojoHandle handle,
                       MojoHandleSignals signals,
-                      MojoDeadline deadline) {
+                      MojoDeadline deadline,
+                      UserPointer<MojoHandleSignalsState> signals_state) {
   uint32_t unused = static_cast<uint32_t>(-1);
-  return WaitManyInternal(&handle, &signals, 1, deadline, &unused);
+  HandleSignalsState hss;
+  MojoResult rv = WaitManyInternal(&handle,
+                                   &signals,
+                                   1,
+                                   deadline,
+                                   &unused,
+                                   signals_state.IsNull() ? NULL : &hss);
+  if (rv != MOJO_RESULT_INVALID_ARGUMENT && !signals_state.IsNull())
+    signals_state.Put(hss);
+  return rv;
 }
 
 MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles,
                           UserPointer<const MojoHandleSignals> signals,
                           uint32_t num_handles,
-                          MojoDeadline deadline) {
+                          MojoDeadline deadline,
+                          UserPointer<uint32_t> result_index,
+                          UserPointer<MojoHandleSignalsState> signals_states) {
   if (num_handles < 1)
     return MOJO_RESULT_INVALID_ARGUMENT;
   if (num_handles > kMaxWaitManyNumHandles)
@@ -135,14 +148,33 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles,
   UserPointer<const MojoHandle>::Reader handles_reader(handles, num_handles);
   UserPointer<const MojoHandleSignals>::Reader signals_reader(signals,
                                                               num_handles);
-  uint32_t result_index = static_cast<uint32_t>(-1);
-  MojoResult result = WaitManyInternal(handles_reader.GetPointer(),
-                                       signals_reader.GetPointer(),
-                                       num_handles,
-                                       deadline,
-                                       &result_index);
-  return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index)
-                                    : result;
+  uint32_t index = static_cast<uint32_t>(-1);
+  MojoResult rv;
+  if (signals_states.IsNull()) {
+    rv = WaitManyInternal(handles_reader.GetPointer(),
+                          signals_reader.GetPointer(),
+                          num_handles,
+                          deadline,
+                          &index,
+                          NULL);
+  } 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()));
+    if (rv != MOJO_RESULT_INVALID_ARGUMENT)
+      signals_states_writer.Commit();
+  }
+  if (index != static_cast<uint32_t>(-1) && !result_index.IsNull())
+    result_index.Put(index);
+  return rv;
 }
 
 MojoResult Core::CreateMessagePipe(
@@ -515,7 +547,8 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles,
                                   const MojoHandleSignals* signals,
                                   uint32_t num_handles,
                                   MojoDeadline deadline,
-                                  uint32_t* result_index) {
+                                  uint32_t* result_index,
+                                  HandleSignalsState* signals_states) {
   DCHECK_GT(num_handles, 0u);
   DCHECK_EQ(*result_index, static_cast<uint32_t>(-1));
 
@@ -537,7 +570,8 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles,
   uint32_t i;
   MojoResult rv = MOJO_RESULT_OK;
   for (i = 0; i < num_handles; i++) {
-    rv = dispatchers[i]->AddWaiter(&waiter, signals[i], i, NULL);
+    rv = dispatchers[i]->AddWaiter(
+        &waiter, signals[i], i, signals_states ? &signals_states[i] : NULL);
     if (rv != MOJO_RESULT_OK) {
       *result_index = i;
       break;
@@ -553,8 +587,14 @@ MojoResult Core::WaitManyInternal(const MojoHandle* handles,
   // Make sure no other dispatchers try to wake |waiter| for the current
   // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be
   // destroyed, but this would still be required if the waiter were in TLS.)
-  for (i = 0; i < num_added; i++)
-    dispatchers[i]->RemoveWaiter(&waiter, NULL);
+  for (i = 0; i < num_added; i++) {
+    dispatchers[i]->RemoveWaiter(&waiter,
+                                 signals_states ? &signals_states[i] : NULL);
+  }
+  if (signals_states) {
+    for (; i < num_handles; i++)
+      signals_states[i] = dispatchers[i]->GetHandleSignalsState();
+  }
 
   return rv;
 }

mojo/system/core.h

@@ -23,6 +23,7 @@ namespace mojo {
 namespace system {
 
 class Dispatcher;
+struct HandleSignalsState;
 
 // |Core| is an object that implements the Mojo system calls. All public methods
 // are thread-safe.
@@ -45,11 +46,14 @@ class MOJO_SYSTEM_IMPL_EXPORT Core {
   MojoResult Close(MojoHandle handle);
   MojoResult Wait(MojoHandle handle,
                   MojoHandleSignals signals,
-                  MojoDeadline deadline);
+                  MojoDeadline deadline,
+                  UserPointer<MojoHandleSignalsState> signals_state);
   MojoResult WaitMany(UserPointer<const MojoHandle> handles,
                       UserPointer<const MojoHandleSignals> signals,
                       uint32_t num_handles,
-                      MojoDeadline deadline);
+                      MojoDeadline deadline,
+                      UserPointer<uint32_t> result_index,
+                      UserPointer<MojoHandleSignalsState> signals_states);
   MojoResult CreateMessagePipe(
       UserPointer<const MojoCreateMessagePipeOptions> options,
       UserPointer<MojoHandle> message_pipe_handle0,
@@ -116,7 +120,8 @@ class MOJO_SYSTEM_IMPL_EXPORT Core {
                               const MojoHandleSignals* signals,
                               uint32_t num_handles,
                               MojoDeadline deadline,
-                              uint32_t* result_index);
+                              uint32_t* result_index,
+                              HandleSignalsState* signals_states);
 
   // ---------------------------------------------------------------------------
 

mojo/system/entrypoints.cc

@@ -4,6 +4,7 @@
 
 #include "mojo/system/entrypoints.h"
 
+#include "base/logging.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/functions.h"
@@ -43,17 +44,23 @@ MojoResult MojoClose(MojoHandle handle) {
 MojoResult MojoWait(MojoHandle handle,
                     MojoHandleSignals signals,
                     MojoDeadline deadline) {
-  return g_core->Wait(handle, signals, deadline);
+  return g_core->Wait(
+      handle, signals, deadline, mojo::system::NullUserPointer());
 }
 
 MojoResult MojoWaitMany(const MojoHandle* handles,
                         const MojoHandleSignals* signals,
                         uint32_t num_handles,
                         MojoDeadline deadline) {
-  return g_core->WaitMany(MakeUserPointer(handles),
-                          MakeUserPointer(signals),
-                          num_handles,
-                          deadline);
+  uint32_t result_index = static_cast<uint32_t>(-1);
+  MojoResult result = g_core->WaitMany(MakeUserPointer(handles),
+                                       MakeUserPointer(signals),
+                                       num_handles,
+                                       deadline,
+                                       MakeUserPointer(&result_index),
+                                       mojo::system::NullUserPointer());
+  return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index)
+                                    : result;
 }
 
 MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options,

mojo/system/memory.cc

@@ -35,6 +35,7 @@ void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer) {
 // Explicitly instantiate the sizes we need. Add instantiations as needed.
 template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<1, 1>(const void*);
 template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<4, 4>(const void*);
+template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<8, 4>(const void*);
 template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<8, 8>(const void*);
 
 template <size_t size, size_t alignment>
@@ -49,6 +50,8 @@ template void MOJO_SYSTEM_IMPL_EXPORT
     CheckUserPointerWithCount<1, 1>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
     CheckUserPointerWithCount<4, 4>(const void*, size_t);
+template void MOJO_SYSTEM_IMPL_EXPORT
+    CheckUserPointerWithCount<8, 4>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
     CheckUserPointerWithCount<8, 8>(const void*, size_t);