Mojo: Move waiting APIs to public library

mojo/edk/system/core.cc

Index: mojo/edk/system/core.cc
diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc
index 263f9cd6f859a4dacbabafd802dca0340bf7d35c..360e8c3012fd56be5c239ca454a66a975b92c59e 100644
--- a/mojo/edk/system/core.cc
+++ b/mojo/edk/system/core.cc
@@ -33,8 +33,6 @@
 #include "mojo/edk/system/ports/node.h"
 #include "mojo/edk/system/request_context.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
-#include "mojo/edk/system/wait_set_dispatcher.h"
-#include "mojo/edk/system/waiter.h"
 #include "mojo/edk/system/watcher_dispatcher.h"
 
 namespace mojo {
@@ -389,48 +387,6 @@ MojoResult Core::QueryHandleSignalsState(
   return MOJO_RESULT_OK;
 }
 
-MojoResult Core::Wait(MojoHandle handle,
-                      MojoHandleSignals signals,
-                      MojoDeadline deadline,
-                      MojoHandleSignalsState* signals_state) {
-  RequestContext request_context;
-  uint32_t unused = static_cast<uint32_t>(-1);
-  HandleSignalsState hss;
-  MojoResult rv = WaitManyInternal(&handle, &signals, 1, deadline, &unused,
-                                   signals_state ? &hss : nullptr);
-  if (rv != MOJO_RESULT_INVALID_ARGUMENT && signals_state)
-    *signals_state = hss;
-  return rv;
-}
-
-MojoResult Core::WaitMany(const MojoHandle* handles,
-                          const MojoHandleSignals* signals,
-                          uint32_t num_handles,
-                          MojoDeadline deadline,
-                          uint32_t* result_index,
-                          MojoHandleSignalsState* signals_state) {
-  RequestContext request_context;
-  if (num_handles < 1)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-  if (num_handles > GetConfiguration().max_wait_many_num_handles)
-    return MOJO_RESULT_RESOURCE_EXHAUSTED;
-
-  uint32_t index = static_cast<uint32_t>(-1);
-  MojoResult rv;
-  if (!signals_state) {
-    rv = WaitManyInternal(handles, signals, num_handles, deadline, &index,
-                          nullptr);
-  } else {
-    // Note: The |reinterpret_cast| is safe, since |HandleSignalsState| is a
-    // subclass of |MojoHandleSignalsState| that doesn't add any data members.
-    rv = WaitManyInternal(handles, signals, num_handles, deadline, &index,
-                          reinterpret_cast<HandleSignalsState*>(signals_state));
-  }
-  if (index != static_cast<uint32_t>(-1) && result_index)
-    *result_index = index;
-  return rv;
-}
-
 MojoResult Core::CreateWatcher(MojoWatcherCallback callback,
                                MojoHandle* watcher_handle) {
   RequestContext request_context;
@@ -558,83 +514,6 @@ MojoResult Core::GetProperty(MojoPropertyType type, void* value) {
   }
 }
 
-MojoResult Core::CreateWaitSet(MojoHandle* wait_set_handle) {
-  RequestContext request_context;
-  if (!wait_set_handle)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  scoped_refptr<WaitSetDispatcher> dispatcher = new WaitSetDispatcher();
-  MojoHandle h = AddDispatcher(dispatcher);
-  if (h == MOJO_HANDLE_INVALID) {
-    LOG(ERROR) << "Handle table full";
-    dispatcher->Close();
-    return MOJO_RESULT_RESOURCE_EXHAUSTED;
-  }
-
-  *wait_set_handle = h;
-  return MOJO_RESULT_OK;
-}
-
-MojoResult Core::AddHandle(MojoHandle wait_set_handle,
-                           MojoHandle handle,
-                           MojoHandleSignals signals) {
-  RequestContext request_context;
-  scoped_refptr<Dispatcher> wait_set_dispatcher(GetDispatcher(wait_set_handle));
-  if (!wait_set_dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  scoped_refptr<Dispatcher> dispatcher(GetDispatcher(handle));
-  if (!dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  return wait_set_dispatcher->AddWaitingDispatcher(dispatcher, signals, handle);
-}
-
-MojoResult Core::RemoveHandle(MojoHandle wait_set_handle,
-                              MojoHandle handle) {
-  RequestContext request_context;
-  scoped_refptr<Dispatcher> wait_set_dispatcher(GetDispatcher(wait_set_handle));
-  if (!wait_set_dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  scoped_refptr<Dispatcher> dispatcher(GetDispatcher(handle));
-  if (!dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  return wait_set_dispatcher->RemoveWaitingDispatcher(dispatcher);
-}
-
-MojoResult Core::GetReadyHandles(MojoHandle wait_set_handle,
-                                 uint32_t* count,
-                                 MojoHandle* handles,
-                                 MojoResult* results,
-                                 MojoHandleSignalsState* signals_states) {
-  RequestContext request_context;
-  if (!handles || !count || !(*count) || !results)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  scoped_refptr<Dispatcher> wait_set_dispatcher(GetDispatcher(wait_set_handle));
-  if (!wait_set_dispatcher)
-    return MOJO_RESULT_INVALID_ARGUMENT;
-
-  DispatcherVector awoken_dispatchers;
-  base::StackVector<uintptr_t, 16> contexts;
-  contexts->assign(*count, MOJO_HANDLE_INVALID);
-
-  MojoResult result = wait_set_dispatcher->GetReadyDispatchers(
-      count, &awoken_dispatchers, results, contexts->data());
-
-  if (result == MOJO_RESULT_OK) {
-    for (size_t i = 0; i < *count; i++) {
-      handles[i] = static_cast<MojoHandle>(contexts[i]);
-      if (signals_states)
-        signals_states[i] = awoken_dispatchers[i]->GetHandleSignalsState();
-    }
-  }
-
-  return result;
-}
-
 MojoResult Core::CreateMessagePipe(
     const MojoCreateMessagePipeOptions* options,
     MojoHandle* message_pipe_handle0,
@@ -1126,74 +1005,6 @@ void Core::GetActiveHandlesForTest(std::vector<MojoHandle>* handles) {
   handles_.GetActiveHandlesForTest(handles);
 }
 
-MojoResult Core::WaitManyInternal(const MojoHandle* handles,
-                                  const MojoHandleSignals* signals,
-                                  uint32_t num_handles,
-                                  MojoDeadline deadline,
-                                  uint32_t* result_index,
-                                  HandleSignalsState* signals_states) {
-  CHECK(handles);
-  CHECK(signals);
-  DCHECK_GT(num_handles, 0u);
-  if (result_index) {
-    DCHECK_EQ(*result_index, static_cast<uint32_t>(-1));
-  }
-
-  // The primary caller of |WaitManyInternal()| is |Wait()|, which only waits on
-  // a single handle. In the common case of a single handle, this avoid a heap
-  // allocation.
-  base::StackVector<scoped_refptr<Dispatcher>, 1> dispatchers;
-  dispatchers->reserve(num_handles);
-  for (uint32_t i = 0; i < num_handles; i++) {
-    scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handles[i]);
-    if (!dispatcher) {
-      if (result_index)
-        *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]->AddAwakable(
-        &waiter, signals[i], i, signals_states ? &signals_states[i] : nullptr);
-    if (rv != MOJO_RESULT_OK) {
-      if (result_index)
-        *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) {
-    uintptr_t uintptr_result = *result_index;
-    rv = waiter.Wait(deadline, &uintptr_result);
-    *result_index = static_cast<uint32_t>(uintptr_result);
-  }
-
-  // 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]->RemoveAwakable(
-        &waiter, signals_states ? &signals_states[i] : nullptr);
-  }
-  if (signals_states) {
-    for (; i < num_handles; i++)
-      signals_states[i] = dispatchers[i]->GetHandleSignalsState();
-  }
-
-  return rv;
-}
-
 // static
 void Core::PassNodeControllerToIOThread(
     std::unique_ptr<NodeController> node_controller) {