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

mojo/system/core.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "mojo/system/core.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "mojo/public/c/system/macros.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/data_pipe.h"
 #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"
 #include "mojo/system/message_pipe_dispatcher.h"
 #include "mojo/system/raw_shared_buffer.h"
 #include "mojo/system/shared_buffer_dispatcher.h"
 #include "mojo/system/waiter.h"
 
 namespace mojo {
 namespace system {
@@ skipping 84 matching lines @@
 
   // The dispatcher doesn't have a say in being closed, but gets notified of it.
   // Note: This is done outside of |handle_table_lock_|. As a result, there's a
   // race condition that the dispatcher must handle; see the comment in
   // |Dispatcher| in dispatcher.h.
   return dispatcher->Close();
 }
 
 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)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   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(
     UserPointer<const MojoCreateMessagePipeOptions> options,
     UserPointer<MojoHandle> message_pipe_handle0,
     UserPointer<MojoHandle> message_pipe_handle1) {
   MojoCreateMessagePipeOptions validated_options = {};
   MojoResult result =
       MessagePipeDispatcher::ValidateCreateOptions(options, &validated_options);
   if (result != MOJO_RESULT_OK)
@@ skipping 352 matching lines @@
 }
 
 // Note: We allow |handles| to repeat the same handle multiple times, since
 // different flags may be specified.
 // TODO(vtl): This incurs a performance cost in |RemoveWaiter()|. Analyze this
 // more carefully and address it if necessary.
 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));
 
   DispatcherVector dispatchers;
   dispatchers.reserve(num_handles);
   for (uint32_t i = 0; i < num_handles; i++) {
     scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handles[i]);
     if (!dispatcher) {
       *result_index = i;
       return MOJO_RESULT_INVALID_ARGUMENT;
     }
     dispatchers.push_back(dispatcher);
   }
 
   // TODO(vtl): Should make the waiter live (permanently) in TLS.
   Waiter waiter;
   waiter.Init();
 
   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;
     }
   }
   uint32_t num_added = i;
 
   if (rv == MOJO_RESULT_ALREADY_EXISTS)
     rv = MOJO_RESULT_OK;  // The i-th one is already "triggered".
   else if (rv == MOJO_RESULT_OK)
     rv = waiter.Wait(deadline, result_index);
 
   // 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;
 }
 
 }  // namespace system
 }  // namespace mojo