Mojo: Move waiting APIs to public library

mojo/edk/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/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/message_for_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/ports/name.h"
 #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 {
 namespace edk {
 
 namespace {
 
 // This is an unnecessarily large limit that is relatively easy to enforce.
 const uint32_t kMaxHandlesPerMessage = 1024 * 1024;
 
@@ skipping 334 matching lines @@
     MojoHandle handle,
     MojoHandleSignalsState* signals_state) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handle);
   if (!dispatcher || !signals_state)
     return MOJO_RESULT_INVALID_ARGUMENT;
   *signals_state = dispatcher->GetHandleSignalsState();
   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;
   if (!watcher_handle)
     return MOJO_RESULT_INVALID_ARGUMENT;
   *watcher_handle = AddDispatcher(new WatcherDispatcher(callback));
   if (*watcher_handle == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   return MOJO_RESULT_OK;
 }
@@ skipping 107 matching lines @@
   base::AutoLock locker(property_lock_);
   switch (type) {
     case MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED:
       *static_cast<bool*>(value) = property_sync_call_allowed_;
       return MOJO_RESULT_OK;
     default:
       return MOJO_RESULT_INVALID_ARGUMENT;
   }
 }
 
-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,
     MojoHandle* message_pipe_handle1) {
   RequestContext request_context;
   ports::PortRef port0, port1;
   GetNodeController()->node()->CreatePortPair(&port0, &port1);
 
   CHECK(message_pipe_handle0);
   CHECK(message_pipe_handle1);
@@ skipping 471 matching lines @@
   ScopedPlatformHandle handle = platform_shared_buffer->PassPlatformHandle();
   return ScopedPlatformHandleToMojoPlatformHandle(std::move(handle),
                                                   platform_handle);
 }
 
 void Core::GetActiveHandlesForTest(std::vector<MojoHandle>* handles) {
   base::AutoLock lock(handles_lock_);
   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) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo