Update mojo sdk to rev cc531b32182099a5a034a99daff35ed5d38a61c8

mojo/public/go/system/impl/core_impl.go

 // 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.
 
 package impl
 
 //#include "mojo/public/platform/native/system_thunks.h"
 //#include "mojo/public/c/system/main.h"
 import "C"
 import "unsafe"
@@ skipping 13 matching lines @@
 }
 
 func (c *CoreImpl) GetTimeTicksNow() MojoTimeTicks {
         return (MojoTimeTicks)(C.MojoGetTimeTicksNow())
 }
 
 func (c *CoreImpl) Close(handle MojoHandle) MojoResult {
         return (MojoResult)(C.MojoClose(handle.cType()))
 }
 
-func (c *CoreImpl) Wait(handle MojoHandle, signal MojoHandleSignals, deadline MojoDeadline) MojoResult {
-        return (MojoResult)(C.MojoWait(handle.cType(), signal.cType(), deadline.cType()))
+func (c *CoreImpl) Wait(handle MojoHandle, signal MojoHandleSignals, deadline MojoDeadline) (MojoResult, *MojoHandleSignalsState) {
+        var signal_states C.struct_MojoHandleSignalsState
+        result := C.MojoNewWait(handle.cType(), signal.cType(), deadline.cType(), &signal_states)
+        return MojoResult(result), &MojoHandleSignalsState{MojoHandleSignals(signal_states.satisfied_signals), MojoHandleSignals(signal_states.satisfiable_signals)}
 }
 
-func (c *CoreImpl) WaitMany(handles []MojoHandle, signals []MojoHandleSignals, deadline MojoDeadline) MojoResult {
-        return (MojoResult)(C.MojoWaitMany(cArrayMojoHandle(handles), cArrayMojoHandleSignals(signals), (C.uint32_t)(len(handles)), deadline.cType()))
+func (c *CoreImpl) WaitMany(handles []MojoHandle, signals []MojoHandleSignals, deadline MojoDeadline) (result MojoResult, index *uint32, state []MojoHandleSignalsState) {
+        // Set "-1" using the instructions from http://blog.golang.org/constants
+        cindex := ^C.uint32_t(0)
+        cstate := make([]C.struct_MojoHandleSignalsState, len(handles))
+
+        result = (MojoResult)(C.MojoNewWaitMany(cArrayMojoHandle(handles), cArrayMojoHandleSignals(signals), (C.uint32_t)(len(handles)), deadline.cType(), &cindex, &cstate[0]))
+
+        if uint32(cindex) < uint32(len(handles)) {
+                temp := uint32(cindex)
+                index = &temp
+        }
+
+        if result != MOJO_RESULT_INVALID_ARGUMENT && result != MOJO_RESULT_RESOURCE_EXHAUSTED {
+                state = make([]MojoHandleSignalsState, len(cstate))
+                for i, value := range cstate {
+                        state[i] = NewMojoHandleSignalsState(value)
+                }
+        }
+
+        return
 }
 
 func (c *CoreImpl) CreateMessagePipe(opts *MessagePipeOptions) (MojoResult, MojoHandle, MojoHandle) {
         var handle0, handle1 C.MojoHandle
         result := C.MojoCreateMessagePipe(opts.cType(), &handle0, &handle1)
         return (MojoResult)(result), (MojoHandle)(handle0), (MojoHandle)(handle1)
 }
 
 func (c *CoreImpl) WriteMessage(handle MojoHandle, msg []byte, attached []MojoHandle, flags MojoWriteMessageFlags) MojoResult {
         return (MojoResult)(C.MojoWriteMessage(handle.cType(), cArrayBytes(msg), (C.uint32_t)(len(msg)), cArrayMojoHandle(attached), (C.uint32_t)(len(attached)), flags.cType()))
@@ skipping 50 matching lines @@
         result := C.MojoMapBuffer(handle.cType(), (C.uint64_t)(offset), (C.uint64_t)(numBytes), &bufPtr, flags.cType())
         if result != C.MOJO_RESULT_OK {
                 return (MojoResult)(result), nil
         }
         return MOJO_RESULT_OK, bufPtr
 }
 
 func (c *CoreImpl) UnmapBuffer(buffer unsafe.Pointer) MojoResult {
         return (MojoResult)(C.MojoUnmapBuffer(buffer))
 }