Mojo: More plumbing to support sending handles over MessagePipes.

mojo/system/message_pipe.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/system/message_pipe.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
@@ skipping 46 matching lines @@
     endpoints_[destination_port]->Close();
     endpoints_[destination_port].reset();
   }
 }
 
 // TODO(vtl): Support sending handles.
 // TODO(vtl): Handle flags.
 MojoResult MessagePipe::WriteMessage(
     unsigned port,
     const void* bytes, uint32_t num_bytes,
-    const std::vector<Dispatcher*>* /*dispatchers*/,
+    const std::vector<Dispatcher*>* dispatchers,
     MojoWriteMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
   return EnqueueMessage(
       GetPeerPort(port),
       MessageInTransit::Create(
           MessageInTransit::kTypeMessagePipeEndpoint,
           MessageInTransit::kSubtypeMessagePipeEndpointData,
-          bytes, num_bytes));
+          bytes, num_bytes),
+      dispatchers);
 }
 
 MojoResult MessagePipe::ReadMessage(
     unsigned port,
     void* bytes, uint32_t* num_bytes,
     uint32_t max_num_dispatchers,
     std::vector<scoped_refptr<Dispatcher> >* dispatchers,
     MojoReadMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port].get());
 
   return endpoints_[port]->ReadMessage(bytes, num_bytes,
-                                       NULL, NULL,
+                                       max_num_dispatchers, dispatchers,
                                        flags);
 }
 
 MojoResult MessagePipe::AddWaiter(unsigned port,
                                   Waiter* waiter,
                                   MojoWaitFlags flags,
                                   MojoResult wake_result) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port].get());
 
   return endpoints_[port]->AddWaiter(waiter, flags, wake_result);
 }
 
 void MessagePipe::RemoveWaiter(unsigned port, Waiter* waiter) {
   DCHECK(port == 0 || port == 1);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port].get());
 
   endpoints_[port]->RemoveWaiter(waiter);
 }
 
-MojoResult MessagePipe::EnqueueMessage(unsigned port,
-                                       MessageInTransit* message) {
+MojoResult MessagePipe::EnqueueMessage(
+    unsigned port,
+    MessageInTransit* message,
+    const std::vector<Dispatcher*>* dispatchers) {
   DCHECK(port == 0 || port == 1);
   DCHECK(message);
 
-  if (message->type() == MessageInTransit::kTypeMessagePipe)
+  if (message->type() == MessageInTransit::kTypeMessagePipe) {
+    DCHECK(!dispatchers);
     return HandleControlMessage(port, message);
+  }
 
   DCHECK_EQ(message->type(), MessageInTransit::kTypeMessagePipeEndpoint);
 
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[GetPeerPort(port)].get());
 
   // The destination port need not be open, unlike the source port.
   if (!endpoints_[port].get()) {
     message->Destroy();
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  return endpoints_[port]->EnqueueMessage(message);
+  return endpoints_[port]->EnqueueMessage(message, dispatchers);
 }
 
 void MessagePipe::Attach(unsigned port,
                          scoped_refptr<Channel> channel,
                          MessageInTransit::EndpointId local_id) {
   DCHECK(port == 0 || port == 1);
   DCHECK(channel.get());
   DCHECK_NE(local_id, MessageInTransit::kInvalidEndpointId);
 
   base::AutoLock locker(lock_);
@@ skipping 50 matching lines @@
       rv = MOJO_RESULT_UNKNOWN;
       break;
   }
 
   message->Destroy();
   return rv;
 }
 
 }  // namespace system
 }  // namespace mojo