Mojo: Move waiting APIs to public library

mojo/public/c/system/thunks.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/public/c/system/thunks.h"
 
 #include <assert.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
   return g_thunks.Close(handle);
 }
 
 MojoResult MojoQueryHandleSignalsState(
     MojoHandle handle,
     struct MojoHandleSignalsState* signals_state) {
   assert(g_thunks.QueryHandleSignalsState);
   return g_thunks.QueryHandleSignalsState(handle, signals_state);
 }
 
-MojoResult MojoWait(MojoHandle handle,
-                    MojoHandleSignals signals,
-                    MojoDeadline deadline,
-                    struct MojoHandleSignalsState* signals_state) {
-  assert(g_thunks.Wait);
-  return g_thunks.Wait(handle, signals, deadline, signals_state);
-}
-
-MojoResult MojoWaitMany(const MojoHandle* handles,
-                        const MojoHandleSignals* signals,
-                        uint32_t num_handles,
-                        MojoDeadline deadline,
-                        uint32_t* result_index,
-                        struct MojoHandleSignalsState* signals_states) {
-  assert(g_thunks.WaitMany);
-  return g_thunks.WaitMany(handles, signals, num_handles, deadline,
-                           result_index, signals_states);
-}
-
 MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options,
                                  MojoHandle* message_pipe_handle0,
                                  MojoHandle* message_pipe_handle1) {
   assert(g_thunks.CreateMessagePipe);
   return g_thunks.CreateMessagePipe(options, message_pipe_handle0,
                                     message_pipe_handle1);
 }
 
 MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
                             const void* bytes,
@@ skipping 97 matching lines @@
                          MojoMapBufferFlags flags) {
   assert(g_thunks.MapBuffer);
   return g_thunks.MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
 }
 
 MojoResult MojoUnmapBuffer(void* buffer) {
   assert(g_thunks.UnmapBuffer);
   return g_thunks.UnmapBuffer(buffer);
 }
 
-MojoResult MojoCreateWaitSet(MojoHandle* wait_set) {
-  assert(g_thunks.CreateWaitSet);
-  return g_thunks.CreateWaitSet(wait_set);
-}
-
-MojoResult MojoAddHandle(MojoHandle wait_set,
-                         MojoHandle handle,
-                         MojoHandleSignals signals) {
-  assert(g_thunks.AddHandle);
-  return g_thunks.AddHandle(wait_set, handle, signals);
-}
-
-MojoResult MojoRemoveHandle(MojoHandle wait_set, MojoHandle handle) {
-  assert(g_thunks.RemoveHandle);
-  return g_thunks.RemoveHandle(wait_set, handle);
-}
-
-MojoResult MojoGetReadyHandles(MojoHandle wait_set,
-                               uint32_t* count,
-                               MojoHandle* handles,
-                               MojoResult* results,
-                               struct MojoHandleSignalsState* signals_states) {
-  assert(g_thunks.GetReadyHandles);
-  return g_thunks.GetReadyHandles(wait_set, count, handles, results,
-                                  signals_states);
-}
-
 MojoResult MojoCreateWatcher(MojoWatcherCallback callback,
                              MojoHandle* watcher_handle) {
   assert(g_thunks.CreateWatcher);
   return g_thunks.CreateWatcher(callback, watcher_handle);
 }
 
 MojoResult MojoWatch(MojoHandle watcher_handle,
                      MojoHandle handle,
                      MojoHandleSignals signals,
                      uintptr_t context) {
@@ skipping 105 matching lines @@
   return g_thunks.GetProperty(type, value);
 }
 
 }  // extern "C"
 
 size_t MojoEmbedderSetSystemThunks(const MojoSystemThunks* system_thunks) {
   if (system_thunks->size >= sizeof(g_thunks))
     g_thunks = *system_thunks;
   return sizeof(g_thunks);
 }