Dart: Merge message pipe query and read into one native call.

mojo/dart/embedder/mojo_natives.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 <stdio.h>
 #include <string.h>
 #include <set>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
   V(MojoDataPipe_Create, 3)                \
   V(MojoDataPipe_WriteData, 4)             \
   V(MojoDataPipe_BeginWriteData, 3)        \
   V(MojoDataPipe_EndWriteData, 2)          \
   V(MojoDataPipe_ReadData, 4)              \
   V(MojoDataPipe_BeginReadData, 3)         \
   V(MojoDataPipe_EndReadData, 2)           \
   V(MojoMessagePipe_Create, 1)             \
   V(MojoMessagePipe_Write, 5)              \
   V(MojoMessagePipe_Read, 5)               \
+  V(MojoMessagePipe_QueryAndRead, 2)       \
   V(Mojo_GetTimeTicksNow, 0)               \
   V(MojoHandle_Close, 1)                   \
   V(MojoHandle_Wait, 3)                    \
   V(MojoHandle_Register, 2)                \
   V(MojoHandle_WaitMany, 3)                \
   V(MojoHandleWatcher_GrowStateArrays, 1)  \
   V(MojoHandleWatcher_WaitMany, 2)         \
   V(MojoHandleWatcher_SendControlData, 4)  \
   V(MojoHandleWatcher_RecvControlData, 1)  \
   V(MojoHandleWatcher_SetControlHandle, 1) \
@@ skipping 682 matching lines @@
   std::vector<uint32_t> signals;
   std::vector<uint32_t> out_index;
   std::vector<MojoHandleSignalsState> out_signals;
 
   static MojoWaitManyState* GetInstance();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoWaitManyState);
 };
 
+void MojoMessagePipe_QueryAndRead(Dart_NativeArguments arguments) {
+  int64_t dart_handle;
+  int64_t flags = 0;
+  CHECK_INTEGER_ARGUMENT(arguments, 0, &dart_handle, Null);
+  CHECK_INTEGER_ARGUMENT(arguments, 1, &flags, Null);
+
+  // Query the number of bytes and handles available.
+  uint32_t blen = 0;
+  uint32_t hlen = 0;
+  MojoResult res =
+      MojoReadMessage(static_cast<MojoHandle>(dart_handle), nullptr, &blen,
+                      nullptr, &hlen, static_cast<MojoReadMessageFlags>(flags));
+
+  if ((res != MOJO_RESULT_OK) && (res != MOJO_RESULT_RESOURCE_EXHAUSTED)) {
+    Dart_Handle list = Dart_NewList(3);
+    Dart_ListSetAt(list, 0, Dart_NewInteger(res));
+    Dart_SetReturnValue(arguments, list);
+    return;
+  }
+
+  Dart_Handle data = Dart_Null();
+  if (blen > 0) {
+    data = Dart_NewTypedData(Dart_TypedData_kByteData, blen);
+  }
+
+  Dart_Handle handles = Dart_Null();
+  if (hlen > 0) {
+    handles = Dart_NewTypedData(Dart_TypedData_kUint32, hlen);
+  }
+
+  Dart_TypedData_Type typ;
+  void* bytes = nullptr;
+  intptr_t byte_data_len = 0;
+  if (blen > 0) {
+    Dart_TypedDataAcquireData(data, &typ, &bytes, &byte_data_len);
+  }
+
+  void* handle_bytes = nullptr;
+  intptr_t handle_bytes_len = 0;
+  if (hlen > 0) {
+    Dart_TypedDataAcquireData(handles, &typ, &handle_bytes, &handle_bytes_len);
+  }
+
+  res = MojoReadMessage(static_cast<MojoHandle>(dart_handle), bytes, &blen,
+                        reinterpret_cast<MojoHandle*>(handle_bytes), &hlen,
+                        static_cast<MojoReadMessageFlags>(flags));
+
+  if (byte_data_len > 0) {
+    Dart_TypedDataReleaseData(data);
+  }
+
+  if (handle_bytes_len > 0) {
+    Dart_TypedDataReleaseData(handles);
+  }
+
+  Dart_Handle list = Dart_NewList(3);
+  Dart_ListSetAt(list, 0, Dart_NewInteger(res));
+  Dart_ListSetAt(list, 1, data);
+  Dart_ListSetAt(list, 2, handles);
+  Dart_SetReturnValue(arguments, list);
+}
+
 // This global is safe because it is only accessed by the single handle watcher
 // isolate. If multiple handle watcher isolates are ever needed, it will need
 // to be replicated.
 MojoWaitManyState* MojoWaitManyState::GetInstance() {
   static MojoWaitManyState* state = new MojoWaitManyState;
   return state;
 }
 
 void MojoHandleWatcher_GrowStateArrays(Dart_NativeArguments arguments) {
   int64_t new_length;
@@ skipping 148 matching lines @@
   mojo_control_handle = control_handle;
   Dart_SetIntegerReturnValue(arguments, static_cast<int64_t>(MOJO_RESULT_OK));
 }
 
 void MojoHandleWatcher_GetControlHandle(Dart_NativeArguments arguments) {
   Dart_SetIntegerReturnValue(arguments, mojo_control_handle);
 }
 
 }  // namespace dart
 }  // namespace mojo