EDK: Plumb Handle/HandleVector one more layer down.

mojo/edk/system/local_message_pipe_endpoint.cc

 // Copyright 2013 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/system/local_message_pipe_endpoint.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 52 matching lines @@
 }
 
 void LocalMessagePipeEndpoint::CancelAllAwakables() {
   DCHECK(is_open_);
   awakable_list_.CancelAll();
 }
 
 MojoResult LocalMessagePipeEndpoint::ReadMessage(
     UserPointer<void> bytes,
     UserPointer<uint32_t> num_bytes,
-    DispatcherVector* dispatchers,
-    uint32_t* num_dispatchers,
+    HandleVector* handles,
+    uint32_t* num_handles,
     MojoReadMessageFlags flags) {
   DCHECK(is_open_);
-  DCHECK(!dispatchers || dispatchers->empty());
+  DCHECK(!handles || handles->empty());
 
   const uint32_t max_bytes = num_bytes.IsNull() ? 0 : num_bytes.Get();
-  const uint32_t max_num_dispatchers = num_dispatchers ? *num_dispatchers : 0;
+  const uint32_t max_num_handles = num_handles ? *num_handles : 0;
 
   if (message_queue_.IsEmpty()) {
     return is_peer_open_ ? MOJO_RESULT_SHOULD_WAIT
                          : MOJO_RESULT_FAILED_PRECONDITION;
   }
 
   // TODO(vtl): If |flags & MOJO_READ_MESSAGE_FLAG_MAY_DISCARD|, we could pop
   // and release the lock immediately.
   bool enough_space = true;
   MessageInTransit* message = message_queue_.PeekMessage();
   if (!num_bytes.IsNull())
     num_bytes.Put(message->num_bytes());
   if (message->num_bytes() <= max_bytes)
     bytes.PutArray(message->bytes(), message->num_bytes());
   else
     enough_space = false;
 
   if (DispatcherVector* queued_dispatchers = message->dispatchers()) {
-    if (num_dispatchers)
-      *num_dispatchers = static_cast<uint32_t>(queued_dispatchers->size());
+    if (num_handles)
+      *num_handles = static_cast<uint32_t>(queued_dispatchers->size());
     if (enough_space) {
       if (queued_dispatchers->empty()) {
         // Nothing to do.
-      } else if (queued_dispatchers->size() <= max_num_dispatchers) {
-        DCHECK(dispatchers);
-        dispatchers->swap(*queued_dispatchers);
+      } else if (queued_dispatchers->size() <= max_num_handles) {
+        DCHECK(handles);
+        // TODO(vtl): The rest of this code in this block is temporary, until I
+        // plumb |Handle|s into |MessageInTransit|. This should really just be
+        // something like:
+        //   handles->swap(*queued_handles);
+        handles->reserve(queued_dispatchers->size());
+        for (size_t i = 0; i < queued_dispatchers->size(); i++) {
+          // We're not enforcing handle rights yet, so "none" is OK.
+          handles->push_back(Handle(std::move(queued_dispatchers->at(i)),
+                                    MOJO_HANDLE_RIGHT_NONE));
+        }
       } else {
         enough_space = false;
       }
     }
   } else {
-    if (num_dispatchers)
-      *num_dispatchers = 0;
+    if (num_handles)
+      *num_handles = 0;
   }
 
   message = nullptr;
 
   if (enough_space || (flags & MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)) {
     message_queue_.DiscardMessage();
 
     // Now it's empty, thus no longer readable.
     if (message_queue_.IsEmpty()) {
       // It's currently not possible to wait for non-readability, but we should
@@ skipping 52 matching lines @@
     Awakable* awakable,
     HandleSignalsState* signals_state) {
   DCHECK(is_open_);
   awakable_list_.Remove(awakable);
   if (signals_state)
     *signals_state = GetHandleSignalsState();
 }
 
 }  // namespace system
 }  // namespace mojo