Revert of Mojo EDK: Introduce MojoQueryHandleSignalsState API

mojo/android/system/src/org/chromium/mojo/system/impl/CoreImpl.java

 // 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 org.chromium.mojo.system.impl;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.base.annotations.MainDex;
 import org.chromium.mojo.system.Core;
-import org.chromium.mojo.system.Core.HandleSignalsState;
 import org.chromium.mojo.system.DataPipe;
 import org.chromium.mojo.system.DataPipe.ConsumerHandle;
 import org.chromium.mojo.system.DataPipe.ProducerHandle;
 import org.chromium.mojo.system.Handle;
 import org.chromium.mojo.system.MessagePipeHandle;
 import org.chromium.mojo.system.MojoException;
 import org.chromium.mojo.system.MojoResult;
 import org.chromium.mojo.system.Pair;
 import org.chromium.mojo.system.ResultAnd;
 import org.chromium.mojo.system.RunLoop;
 import org.chromium.mojo.system.SharedBufferHandle;
 import org.chromium.mojo.system.SharedBufferHandle.DuplicateOptions;
 import org.chromium.mojo.system.SharedBufferHandle.MapFlags;
 import org.chromium.mojo.system.UntypedHandle;
 import org.chromium.mojo.system.Watcher;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 /**
  * Implementation of {@link Core}.
  */
 @JNINamespace("mojo::android")
 @MainDex
 public class CoreImpl implements Core {
     /**
      * Discard flag for the |MojoReadData| operation.
@@ skipping 43 matching lines @@
 
     /**
      * @see Core#getTimeTicksNow()
      */
     @Override
     public long getTimeTicksNow() {
         return nativeGetTimeTicksNow();
     }
 
     /**
+     * @see Core#waitMany(List, long)
+     */
+    @Override
+    public WaitManyResult waitMany(List<Pair<Handle, HandleSignals>> handles, long deadline) {
+        // Allocate a direct buffer to allow native code not to reach back to java. The buffer
+        // layout will be:
+        // input: The array of handles (int, 4 bytes each)
+        // input: The array of signals (int, 4 bytes each)
+        // space for output: The array of handle states (2 ints, 8 bytes each)
+        // Space for output: The result index (int, 4 bytes)
+        // The handles and signals will be filled before calling the native method. When the native
+        // method returns, the handle states and the index will have been set.
+        ByteBuffer buffer = allocateDirectBuffer(handles.size() * 16 + 4);
+        int index = 0;
+        for (Pair<Handle, HandleSignals> handle : handles) {
+            buffer.putInt(HANDLE_SIZE * index, getMojoHandle(handle.first));
+            buffer.putInt(
+                    HANDLE_SIZE * handles.size() + FLAG_SIZE * index, handle.second.getFlags());
+            index++;
+        }
+        int code = nativeWaitMany(buffer, deadline);
+        WaitManyResult result = new WaitManyResult();
+        result.setMojoResult(filterMojoResultForWait(code));
+        result.setHandleIndex(buffer.getInt(handles.size() * 16));
+        if (result.getMojoResult() != MojoResult.INVALID_ARGUMENT
+                && result.getMojoResult() != MojoResult.RESOURCE_EXHAUSTED) {
+            HandleSignalsState[] states = new HandleSignalsState[handles.size()];
+            for (int i = 0; i < handles.size(); ++i) {
+                states[i] = new HandleSignalsState(
+                        new HandleSignals(buffer.getInt(8 * (handles.size() + i))),
+                        new HandleSignals(buffer.getInt(8 * (handles.size() + i) + 4)));
+            }
+            result.setSignalStates(Arrays.asList(states));
+        }
+        return result;
+    }
+
+    /**
+     * @see Core#wait(Handle, HandleSignals, long)
+     */
+    @Override
+    public WaitResult wait(Handle handle, HandleSignals signals, long deadline) {
+        // Allocate a direct buffer to allow native code not to reach back to java. Buffer will
+        // contain spaces to write the handle state.
+        ByteBuffer buffer = allocateDirectBuffer(8);
+        WaitResult result = new WaitResult();
+        result.setMojoResult(filterMojoResultForWait(
+                nativeWait(buffer, getMojoHandle(handle), signals.getFlags(), deadline)));
+        HandleSignalsState signalsState = new HandleSignalsState(
+                new HandleSignals(buffer.getInt(0)), new HandleSignals(buffer.getInt(4)));
+        result.setHandleSignalsState(signalsState);
+        return result;
+    }
+
+    /**
      * @see Core#createMessagePipe(MessagePipeHandle.CreateOptions)
      */
     @Override
     public Pair<MessagePipeHandle, MessagePipeHandle> createMessagePipe(
             MessagePipeHandle.CreateOptions options) {
         ByteBuffer optionsBuffer = null;
         if (options != null) {
             optionsBuffer = allocateDirectBuffer(8);
             optionsBuffer.putInt(0, 8);
             optionsBuffer.putInt(4, options.getFlags().getFlags());
@@ skipping 96 matching lines @@
         return nativeClose(mojoHandle);
     }
 
     void close(int mojoHandle) {
         int mojoResult = nativeClose(mojoHandle);
         if (mojoResult != MojoResult.OK) {
             throw new MojoException(mojoResult);
         }
     }
 
-    HandleSignalsState queryHandleSignalsState(int mojoHandle) {
-        ByteBuffer buffer = allocateDirectBuffer(8);
-        int result = nativeQueryHandleSignalsState(mojoHandle, buffer);
-        if (result != MojoResult.OK) throw new MojoException(result);
-        return new HandleSignalsState(
-                new HandleSignals(buffer.getInt(0)), new HandleSignals(buffer.getInt(4)));
-    }
-
     /**
      * @see MessagePipeHandle#writeMessage(ByteBuffer, List, MessagePipeHandle.WriteFlags)
      */
     void writeMessage(MessagePipeHandleImpl pipeHandle, ByteBuffer bytes,
             List<? extends Handle> handles, MessagePipeHandle.WriteFlags flags) {
         ByteBuffer handlesBuffer = null;
         if (handles != null && !handles.isEmpty()) {
             handlesBuffer = allocateDirectBuffer(handles.size() * HANDLE_SIZE);
             for (Handle handle : handles) {
                 handlesBuffer.putInt(getMojoHandle(handle));
@@ skipping 243 matching lines @@
     }
 
     @CalledByNative
     private static ResultAnd<IntegerPair> newNativeCreationResult(
             int mojoResult, int mojoHandle1, int mojoHandle2) {
         return new ResultAnd<>(mojoResult, new IntegerPair(mojoHandle1, mojoHandle2));
     }
 
     private native long nativeGetTimeTicksNow();
 
+    private native int nativeWaitMany(ByteBuffer buffer, long deadline);
+
     private native ResultAnd<IntegerPair> nativeCreateMessagePipe(ByteBuffer optionsBuffer);
 
     private native ResultAnd<IntegerPair> nativeCreateDataPipe(ByteBuffer optionsBuffer);
 
     private native ResultAnd<Integer> nativeCreateSharedBuffer(
             ByteBuffer optionsBuffer, long numBytes);
 
     private native int nativeClose(int mojoHandle);
 
-    private native int nativeQueryHandleSignalsState(int mojoHandle, ByteBuffer signalsStateBuffer);
+    private native int nativeWait(ByteBuffer buffer, int mojoHandle, int signals, long deadline);
 
     private native int nativeWriteMessage(
             int mojoHandle, ByteBuffer bytes, int numBytes, ByteBuffer handlesBuffer, int flags);
 
     private native ResultAnd<MessagePipeHandle.ReadMessageResult> nativeReadMessage(
             int mojoHandle, ByteBuffer bytes, ByteBuffer handlesBuffer, int flags);
 
     private native ResultAnd<Integer> nativeReadData(
             int mojoHandle, ByteBuffer elements, int elementsSize, int flags);
 
@@ skipping 12 matching lines @@
 
     private native ResultAnd<Integer> nativeDuplicate(int mojoHandle, ByteBuffer optionsBuffer);
 
     private native ResultAnd<ByteBuffer> nativeMap(
             int mojoHandle, long offset, long numBytes, int flags);
 
     private native int nativeUnmap(ByteBuffer buffer);
 
     private native int nativeGetNativeBufferOffset(ByteBuffer buffer, int alignment);
 }