Make the mojo::WaitMany() wrapper insist on std::vectors.

mojo/public/cpp/system/wait.h

 // Copyright 2016 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.
 
 #ifndef MOJO_PUBLIC_CPP_SYSTEM_WAIT_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_WAIT_H_
 
 #include <stdint.h>
 
-#include <cstddef>
+#include <vector>
 
 #include "mojo/public/c/system/handle.h"
 #include "mojo/public/c/system/result.h"
 #include "mojo/public/c/system/time.h"
 #include "mojo/public/c/system/wait.h"
 #include "mojo/public/cpp/system/handle.h"
 
 namespace mojo {
 
 inline MojoResult Wait(Handle handle,
@@ skipping 24 matching lines @@
   bool AreSignalsStatesValid() const {
     return result != MOJO_RESULT_INVALID_ARGUMENT &&
            result != MOJO_RESULT_RESOURCE_EXHAUSTED &&
            result != MOJO_RESULT_BUSY;
   }
 
   MojoResult result;
   uint32_t index;
 };
 
-// |HandleVectorType| and |FlagsVectorType| should be similar enough to
-// |std::vector<Handle>| and |std::vector<MojoHandleSignals>|, respectively:
-//  - They should have a (const) |size()| method that returns an unsigned type.
-//  - They must provide contiguous storage, with access via (const) reference to
-//    that storage provided by a (const) |operator[]()| (by reference).
-template <class HandleVectorType,
-          class FlagsVectorType,
-          class SignalsStateVectorType>
-inline WaitManyResult WaitMany(const HandleVectorType& handles,
-                               const FlagsVectorType& signals,
-                               MojoDeadline deadline,
-                               SignalsStateVectorType* signals_states) {
+// |HandleType| should be |Handle| or a "trivial" subclass thereof, like
+// |MessagePipeHandle|, etc.
+template <class HandleType>
+inline WaitManyResult WaitMany(
+    const std::vector<HandleType>& handles,

[vardhan, 2016/06/29 18:02:18]

I'm guessing it used to be templated so that it'd be possible to use WaitMany()
on a mojo::Array?

+    const std::vector<MojoHandleSignals>& signals,
+    MojoDeadline deadline,
+    std::vector<MojoHandleSignalsState>* signals_states) {
+  // We rely on being able to treat a vector of |HandleType|s as if it's an
+  // array of |MojoHandle|s.
+  static_assert(sizeof(HandleType) == sizeof(Handle),
+                "HandleType is not the same size as Handle");
+
   if (signals.size() != handles.size() ||
       (signals_states && signals_states->size() != signals.size()))
     return WaitManyResult(MOJO_RESULT_INVALID_ARGUMENT);
   if (handles.size() >= kInvalidWaitManyIndexValue)
     return WaitManyResult(MOJO_RESULT_RESOURCE_EXHAUSTED);
 
   if (handles.size() == 0) {
     return WaitManyResult(
         MojoWaitMany(nullptr, nullptr, 0, deadline, nullptr, nullptr));
   }
 
   uint32_t result_index = kInvalidWaitManyIndexValue;
-  const Handle& first_handle = handles[0];
-  const MojoHandleSignals& first_signals = signals[0];
-  MojoHandleSignalsState* first_state =
-      signals_states ? &(*signals_states)[0] : nullptr;
-  MojoResult result =
-      MojoWaitMany(reinterpret_cast<const MojoHandle*>(&first_handle),
-                   &first_signals, static_cast<uint32_t>(handles.size()),
-                   deadline, &result_index, first_state);
+  MojoResult result = MojoWaitMany(
+      &handles[0].value(), signals.data(),
+      static_cast<uint32_t>(handles.size()), deadline, &result_index,
+      signals_states ? signals_states->data() : nullptr);
   return WaitManyResult(result, result_index);
 }
 
-// C++ 4.10, regarding pointer conversion, says that an integral null pointer
-// constant can be converted to |std::nullptr_t|. The opposite direction is not
-// allowed.
-template <class HandleVectorType, class FlagsVectorType>
-inline WaitManyResult WaitMany(const HandleVectorType& handles,
-                               const FlagsVectorType& signals,
-                               MojoDeadline deadline,
-                               std::nullptr_t signals_states) {
-  if (signals.size() != handles.size())
-    return WaitManyResult(MOJO_RESULT_INVALID_ARGUMENT);
-  if (handles.size() >= kInvalidWaitManyIndexValue)
-    return WaitManyResult(MOJO_RESULT_RESOURCE_EXHAUSTED);
-
-  if (handles.size() == 0) {
-    return WaitManyResult(
-        MojoWaitMany(nullptr, nullptr, 0, deadline, nullptr, nullptr));
-  }
-
-  uint32_t result_index = kInvalidWaitManyIndexValue;
-  const Handle& first_handle = handles[0];
-  const MojoHandleSignals& first_signals = signals[0];
-  MojoResult result = MojoWaitMany(
-      reinterpret_cast<const MojoHandle*>(&first_handle), &first_signals,
-      static_cast<uint32_t>(handles.size()), deadline, &result_index, nullptr);
-  return WaitManyResult(result, result_index);
-}
-
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_WAIT_H_