Mojo: Move waiting APIs to public library

mojo/edk/system/core.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_CORE_H_
 #define MOJO_EDK_SYSTEM_CORE_H_
 
 #include <memory>
 #include <string>
 #include <vector>
@@ skipping 120 matching lines @@
   // "mojo/edk/embedder/entrypoints.cc". The best way to understand the contract
   // of these methods is to look at the header files defining the corresponding
   // API functions, referenced below.
 
   // These methods correspond to the API functions defined in
   // "mojo/public/c/system/functions.h":
   MojoTimeTicks GetTimeTicksNow();
   MojoResult Close(MojoHandle handle);
   MojoResult QueryHandleSignalsState(MojoHandle handle,
                                      MojoHandleSignalsState* signals_state);
-  MojoResult Wait(MojoHandle handle,
-                  MojoHandleSignals signals,
-                  MojoDeadline deadline,
-                  MojoHandleSignalsState* signals_state);
-  MojoResult WaitMany(const MojoHandle* handles,
-                      const MojoHandleSignals* signals,
-                      uint32_t num_handles,
-                      MojoDeadline deadline,
-                      uint32_t* result_index,
-                      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,
                         MojoResult* ready_results,
                         MojoHandleSignalsState* ready_signals_states);
   MojoResult AllocMessage(uint32_t num_bytes,
                           const MojoHandle* handles,
                           uint32_t num_handles,
                           MojoAllocMessageFlags flags,
                           MojoMessageHandle* message);
   MojoResult FreeMessage(MojoMessageHandle message);
   MojoResult GetMessageBuffer(MojoMessageHandle message, void** buffer);
   MojoResult GetProperty(MojoPropertyType type, void* value);
 
   // These methods correspond to the API functions defined in
-  // "mojo/public/c/system/wait_set.h":
-  MojoResult CreateWaitSet(MojoHandle* wait_set_handle);
-  MojoResult AddHandle(MojoHandle wait_set_handle,
-                       MojoHandle handle,
-                       MojoHandleSignals signals);
-  MojoResult RemoveHandle(MojoHandle wait_set_handle,
-                          MojoHandle handle);
-  MojoResult GetReadyHandles(MojoHandle wait_set_handle,
-                             uint32_t* count,
-                             MojoHandle* handles,
-                             MojoResult* results,
-                             MojoHandleSignalsState* signals_states);
-
-  // These methods correspond to the API functions defined in
   // "mojo/public/c/system/message_pipe.h":
   MojoResult CreateMessagePipe(
       const 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,
@@ skipping 75 matching lines @@
       MojoHandle* mojo_handle);
   MojoResult UnwrapPlatformSharedBufferHandle(
       MojoHandle mojo_handle,
       MojoPlatformHandle* platform_handle,
       size_t* size,
       MojoPlatformSharedBufferHandleFlags* flags);
 
   void GetActiveHandlesForTest(std::vector<MojoHandle>* handles);
 
  private:
-  MojoResult WaitManyInternal(const MojoHandle* handles,
-                              const MojoHandleSignals* signals,
-                              uint32_t num_handles,
-                              MojoDeadline deadline,
-                              uint32_t* result_index,
-                              HandleSignalsState* signals_states);
-
   // Used to pass ownership of our NodeController over to the IO thread in the
   // event that we're torn down before said thread.
   static void PassNodeControllerToIOThread(
       std::unique_ptr<NodeController> node_controller);
 
   // Guards node_controller_.
   //
   // TODO(rockot): Consider removing this. It's only needed because we
   // initialize node_controller_ lazily and that may happen on any thread.
   // Otherwise it's effectively const and shouldn't need to be guarded.
@@ skipping 20 matching lines @@
   // Properties that can be read using the MojoGetProperty() API.
   bool property_sync_call_allowed_ = true;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CORE_H_