Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

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 "base/bind.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
@@ skipping 13 matching lines @@
 
 namespace {
 
 MojoResult CloseHandle(gin::Handle<HandleWrapper> handle) {
   if (!handle->get().is_valid())
     return MOJO_RESULT_INVALID_ARGUMENT;
   handle->Close();
   return MOJO_RESULT_OK;
 }
 
-MojoResult WaitHandle(mojo::Handle handle,
-                      MojoHandleSignals signals,
-                      MojoDeadline deadline) {
-  return MojoWait(handle.value(), signals, deadline);
+gin::Dictionary WaitHandle(const gin::Arguments& args,
+                           mojo::Handle handle,
+                           MojoHandleSignals signals,
+                           MojoDeadline deadline) {
+  v8::Isolate* isolate = args.isolate();
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(isolate);
+
+  MojoHandleSignalsState signals_state;
+  MojoResult result = mojo::Wait(handle, signals, deadline, &signals_state);
+  dictionary.Set("result", result);
+
+  mojo::WaitManyResult wmv(result, 0);
+  if (!wmv.AreSignalsStatesValid()) {
+    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;
 }
 
-MojoResult WaitMany(
-    const std::vector<mojo::Handle>& handles,
-    const std::vector<MojoHandleSignals>& signals,
-    MojoDeadline deadline) {
-  return mojo::WaitMany(handles, signals, deadline);
+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;
 
@@ skipping 173 matching lines @@
 // {result: core.RESULT_OK, buffer: dataArrayBuffer}. If the read failed,
 // then the Promise is rejected, the result will be the actual error code,
 // and the buffer will contain whatever was read before the error occurred.
 // The drainData data pipe handle argument is closed automatically.
 
 v8::Handle<v8::Value> DoDrainData(gin::Arguments* args,
                                   gin::Handle<HandleWrapper> handle) {
   return (new DrainData(args->isolate(), handle->release()))->GetPromise();
 }
 
+bool IsHandle(gin::Arguments* args, v8::Handle<v8::Value> val) {
+  gin::Handle<mojo::js::HandleWrapper> ignore_handle;
+  return gin::Converter<gin::Handle<mojo::js::HandleWrapper>>::FromV8(
+      args->isolate(), val, &ignore_handle);
+}
+
+
 gin::WrapperInfo g_wrapper_info = { gin::kEmbedderNativeGin };
 
 }  // namespace
 
 const char Core::kModuleName[] = "mojo/public/js/core";
 
 v8::Local<v8::Value> Core::GetModule(v8::Isolate* isolate) {
   gin::PerIsolateData* data = gin::PerIsolateData::From(isolate);
   v8::Local<v8::ObjectTemplate> templ = data->GetObjectTemplate(
       &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("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)
 
             .SetValue("RESULT_OK", MOJO_RESULT_OK)
             .SetValue("RESULT_CANCELLED", MOJO_RESULT_CANCELLED)
             .SetValue("RESULT_UNKNOWN", MOJO_RESULT_UNKNOWN)
             .SetValue("RESULT_INVALID_ARGUMENT", MOJO_RESULT_INVALID_ARGUMENT)
             .SetValue("RESULT_DEADLINE_EXCEEDED", MOJO_RESULT_DEADLINE_EXCEEDED)
             .SetValue("RESULT_NOT_FOUND", MOJO_RESULT_NOT_FOUND)
             .SetValue("RESULT_ALREADY_EXISTS", MOJO_RESULT_ALREADY_EXISTS)
             .SetValue("RESULT_PERMISSION_DENIED", MOJO_RESULT_PERMISSION_DENIED)
             .SetValue("RESULT_RESOURCE_EXHAUSTED",
@@ skipping 44 matching lines @@
             .Build();
 
     data->SetObjectTemplate(&g_wrapper_info, templ);
   }
 
   return templ->NewInstance();
 }
 
 }  // namespace js
 }  // namespace mojo