Mojo: Move waiting APIs to public library

mojo/edk/js/core.cc

 // 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.
 
 #include "mojo/edk/js/core.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
 #include "gin/function_template.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/wrapper_info.h"
 #include "gin/wrappable.h"
 #include "mojo/edk/js/drain_data.h"
 #include "mojo/edk/js/handle.h"
+#include "mojo/public/cpp/system/wait.h"
 
 namespace mojo {
 namespace edk {
 namespace js {
 
 namespace {
 
 MojoResult CloseHandle(gin::Handle<HandleWrapper> handle) {
   if (!handle->get().is_valid())
     return MOJO_RESULT_INVALID_ARGUMENT;
@@ skipping 10 matching lines @@
     HandleSignalsState state = handle.QuerySignalsState();
     dictionary.Set("result", MOJO_RESULT_OK);
     dictionary.Set("satisfiedSignals", state.satisfied_signals);
     dictionary.Set("satisfiableSignals", state.satisfiable_signals);
   }
   return dictionary;
 }
 
 gin::Dictionary WaitHandle(const gin::Arguments& args,
                            mojo::Handle handle,
-                           MojoHandleSignals signals,
-                           MojoDeadline deadline) {
+                           MojoHandleSignals signals) {
   v8::Isolate* isolate = args.isolate();
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(isolate);
 
   MojoHandleSignalsState signals_state;
-  MojoResult result = mojo::Wait(handle, signals, deadline, &signals_state);
+  MojoResult result = Wait(handle, signals, &signals_state);
   dictionary.Set("result", result);
 
-  mojo::WaitManyResult wmv(result, 0);
-  if (!wmv.AreSignalsStatesValid()) {
+  if (result != MOJO_RESULT_OK && result != MOJO_RESULT_FAILED_PRECONDITION) {
     dictionary.Set("signalsState", v8::Null(isolate).As<v8::Value>());
   } else {
     gin::Dictionary signalsStateDict = gin::Dictionary::CreateEmpty(isolate);
     signalsStateDict.Set("satisfiedSignals", signals_state.satisfied_signals);
     signalsStateDict.Set("satisfiableSignals",
                          signals_state.satisfiable_signals);
     dictionary.Set("signalsState", signalsStateDict);
   }
 
   return dictionary;
 }
 
-gin::Dictionary WaitMany(const gin::Arguments& args,
-                         const std::vector<mojo::Handle>& handles,
-                         const std::vector<MojoHandleSignals>& signals,
-                         MojoDeadline deadline) {
-  v8::Isolate* isolate = args.isolate();
-  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(isolate);
-
-  std::vector<MojoHandleSignalsState> signals_states(signals.size());
-  mojo::WaitManyResult wmv =
-      mojo::WaitMany(handles, signals, deadline, &signals_states);
-  dictionary.Set("result", wmv.result);
-  if (wmv.IsIndexValid()) {
-    dictionary.Set("index", wmv.index);
-  } else {
-    dictionary.Set("index", v8::Null(isolate).As<v8::Value>());
-  }
-  if (wmv.AreSignalsStatesValid()) {
-    std::vector<gin::Dictionary> vec;
-    for (size_t i = 0; i < handles.size(); ++i) {
-      gin::Dictionary signalsStateDict = gin::Dictionary::CreateEmpty(isolate);
-      signalsStateDict.Set("satisfiedSignals",
-                           signals_states[i].satisfied_signals);
-      signalsStateDict.Set("satisfiableSignals",
-                           signals_states[i].satisfiable_signals);
-      vec.push_back(signalsStateDict);
-    }
-    dictionary.Set("signalsState", vec);
-  } else {
-    dictionary.Set("signalsState", v8::Null(isolate).As<v8::Value>());
-  }
-
-  return dictionary;
-}
-
 gin::Dictionary CreateMessagePipe(const gin::Arguments& args) {
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
   dictionary.Set("result", MOJO_RESULT_INVALID_ARGUMENT);
 
   MojoHandle handle0 = MOJO_HANDLE_INVALID;
   MojoHandle handle1 = MOJO_HANDLE_INVALID;
   MojoResult result = MOJO_RESULT_OK;
 
   v8::Handle<v8::Value> options_value = args.PeekNext();
   if (options_value.IsEmpty() || options_value->IsNull() ||
@@ skipping 276 matching lines @@
       &g_wrapper_info);
 
   if (templ.IsEmpty()) {
     templ =
         gin::ObjectTemplateBuilder(isolate)
             // TODO(mpcomplete): Should these just be methods on the JS Handle
             // object?
             .SetMethod("close", CloseHandle)
             .SetMethod("queryHandleSignalsState", QueryHandleSignalsState)
             .SetMethod("wait", WaitHandle)
-            .SetMethod("waitMany", WaitMany)
             .SetMethod("createMessagePipe", CreateMessagePipe)
             .SetMethod("writeMessage", WriteMessage)
             .SetMethod("readMessage", ReadMessage)
             .SetMethod("createDataPipe", CreateDataPipe)
             .SetMethod("writeData", WriteData)
             .SetMethod("readData", ReadData)
             .SetMethod("drainData", DoDrainData)
             .SetMethod("isHandle", IsHandle)
             .SetMethod("createSharedBuffer", CreateSharedBuffer)
             .SetMethod("duplicateBufferHandle", DuplicateBufferHandle)
@@ skipping 14 matching lines @@
                       MOJO_RESULT_FAILED_PRECONDITION)
             .SetValue("RESULT_ABORTED", MOJO_RESULT_ABORTED)
             .SetValue("RESULT_OUT_OF_RANGE", MOJO_RESULT_OUT_OF_RANGE)
             .SetValue("RESULT_UNIMPLEMENTED", MOJO_RESULT_UNIMPLEMENTED)
             .SetValue("RESULT_INTERNAL", MOJO_RESULT_INTERNAL)
             .SetValue("RESULT_UNAVAILABLE", MOJO_RESULT_UNAVAILABLE)
             .SetValue("RESULT_DATA_LOSS", MOJO_RESULT_DATA_LOSS)
             .SetValue("RESULT_BUSY", MOJO_RESULT_BUSY)
             .SetValue("RESULT_SHOULD_WAIT", MOJO_RESULT_SHOULD_WAIT)
 
-            .SetValue("DEADLINE_INDEFINITE", MOJO_DEADLINE_INDEFINITE)
-
             .SetValue("HANDLE_SIGNAL_NONE", MOJO_HANDLE_SIGNAL_NONE)
             .SetValue("HANDLE_SIGNAL_READABLE", MOJO_HANDLE_SIGNAL_READABLE)
             .SetValue("HANDLE_SIGNAL_WRITABLE", MOJO_HANDLE_SIGNAL_WRITABLE)
             .SetValue("HANDLE_SIGNAL_PEER_CLOSED",
                       MOJO_HANDLE_SIGNAL_PEER_CLOSED)
 
             .SetValue("CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE",
                       MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE)
 
             .SetValue("WRITE_MESSAGE_FLAG_NONE", MOJO_WRITE_MESSAGE_FLAG_NONE)
@@ skipping 29 matching lines @@
 
     data->SetObjectTemplate(&g_wrapper_info, templ);
   }
 
   return templ->NewInstance();
 }
 
 }  // namespace js
 }  // namespace edk
 }  // namespace mojo