Mojo: Move waiting APIs to public library

mojo/public/c/system/thunks.h

 // Copyright 2014 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.
 
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_THUNKS_H_
 #define MOJO_PUBLIC_C_SYSTEM_THUNKS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/c/system/system_export.h"
 
 // Structure used to bind the basic Mojo Core functions to an embedder
 // implementation. This is intended to eventually be used as a stable ABI
 // between a Mojo embedder and some loaded application code, but for now it is
 // still effectively safe to rearrange entries as needed.
 #pragma pack(push, 8)
 struct MojoSystemThunks {
   size_t size;  // Should be set to sizeof(MojoSystemThunks).
   MojoTimeTicks (*GetTimeTicksNow)();
   MojoResult (*Close)(MojoHandle handle);
   MojoResult (*QueryHandleSignalsState)(
       MojoHandle handle,
       struct MojoHandleSignalsState* signals_state);
-  MojoResult (*Wait)(MojoHandle handle,
-                     MojoHandleSignals signals,
-                     MojoDeadline deadline,
-                     struct MojoHandleSignalsState* signals_state);
-  MojoResult (*WaitMany)(const MojoHandle* handles,
-                         const MojoHandleSignals* signals,
-                         uint32_t num_handles,
-                         MojoDeadline deadline,
-                         uint32_t* result_index,
-                         struct MojoHandleSignalsState* signals_states);
   MojoResult (*CreateMessagePipe)(
       const struct MojoCreateMessagePipeOptions* options,
       MojoHandle* message_pipe_handle0,
       MojoHandle* message_pipe_handle1);
   MojoResult (*WriteMessage)(MojoHandle message_pipe_handle,
                              const void* bytes,
                              uint32_t num_bytes,
                              const MojoHandle* handles,
                              uint32_t num_handles,
                              MojoWriteMessageFlags flags);
@@ skipping 33 matching lines @@
   MojoResult (*DuplicateBufferHandle)(
       MojoHandle buffer_handle,
       const struct MojoDuplicateBufferHandleOptions* options,
       MojoHandle* new_buffer_handle);
   MojoResult (*MapBuffer)(MojoHandle buffer_handle,
                           uint64_t offset,
                           uint64_t num_bytes,
                           void** buffer,
                           MojoMapBufferFlags flags);
   MojoResult (*UnmapBuffer)(void* buffer);
-
-  MojoResult (*CreateWaitSet)(MojoHandle* wait_set);
-  MojoResult (*AddHandle)(MojoHandle wait_set,
-                          MojoHandle handle,
-                          MojoHandleSignals signals);
-  MojoResult (*RemoveHandle)(MojoHandle wait_set,
-                             MojoHandle handle);
-  MojoResult (*GetReadyHandles)(MojoHandle wait_set,
-                                uint32_t* count,
-                                MojoHandle* handles,
-                                MojoResult* results,
-                                struct MojoHandleSignalsState* signals_states);
   MojoResult (*CreateWatcher)(MojoWatcherCallback callback,
                               MojoHandle* watcher_handle);
   MojoResult (*Watch)(MojoHandle watcher_handle,
                       MojoHandle handle,
                       MojoHandleSignals signals,
                       uintptr_t context);
   MojoResult (*CancelWatch)(MojoHandle watcher_handle, uintptr_t context);
   MojoResult (*ArmWatcher)(MojoHandle watcher_handle,
                            uint32_t* num_ready_contexts,
                            uintptr_t* ready_contexts,
@@ skipping 48 matching lines @@
 // The contents of |system_thunks| are copied.
 typedef size_t (*MojoSetSystemThunksFn)(
     const struct MojoSystemThunks* system_thunks);
 
 // A function for setting up the embedder's own system thunks. This should only
 // be called by Mojo embedder code.
 MOJO_SYSTEM_EXPORT size_t MojoEmbedderSetSystemThunks(
     const struct MojoSystemThunks* system_thunks);
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_THUNKS_H_