Mojo: Factor MessageInTransit secondary buffer stuff out into a separate class.

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 "mojo/system/channel.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_in_transit.h"
@@ skipping 54 matching lines @@
 }
 
 // TODO(vtl): Handle flags.
 MojoResult MessagePipe::WriteMessage(
     unsigned port,
     const void* bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
   DCHECK(port == 0 || port == 1);
-  uint32_t num_handles =
-      transports ? static_cast<uint32_t>(transports->size()) : 0;
   return EnqueueMessageInternal(
       GetPeerPort(port),
       make_scoped_ptr(new MessageInTransit(
           MessageInTransit::kTypeMessagePipeEndpoint,
           MessageInTransit::kSubtypeMessagePipeEndpointData,
-          num_bytes, num_handles, bytes)),
+          num_bytes,
+          bytes)),
       transports);
 }
 
 MojoResult MessagePipe::ReadMessage(
     unsigned port,
     void* bytes,
     uint32_t* num_bytes,
     std::vector<scoped_refptr<Dispatcher> >* dispatchers,
     uint32_t* num_dispatchers,
     MojoReadMessageFlags flags) {
@@ skipping 126 matching lines @@
   // The destination port need not be open, unlike the source port.
   if (!endpoints_[port].get())
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   if (transports) {
     MojoResult result = AttachTransportsNoLock(port, message.get(), transports);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
-  if (message->has_dispatchers())
-    DCHECK_EQ(message->dispatchers()->size(), message->num_handles());
-
   // The endpoint's |EnqueueMessage()| may not report failure.
   endpoints_[port]->EnqueueMessage(message.Pass());
   return MOJO_RESULT_OK;
 }
 
 MojoResult MessagePipe::AttachTransportsNoLock(
     unsigned port,
     MessageInTransit* message,
     std::vector<DispatcherTransport>* transports) {
   DCHECK(!message->has_dispatchers());
-  DCHECK_EQ(transports->size(), message->num_handles());
 
   // You're not allowed to send either handle to a message pipe over the message
   // pipe, so check for this. (The case of trying to write a handle to itself is
   // taken care of by |Core|. That case kind of makes sense, but leads to
   // complications if, e.g., both sides try to do the same thing with their
   // respective handles simultaneously. The other case, of trying to write the
   // peer handle to a handle, doesn't make sense -- since no handle will be
   // available to read the message from.)
   for (size_t i = 0; i < transports->size(); i++) {
     if (!(*transports)[i].is_valid())
@@ skipping 30 matching lines @@
 MojoResult MessagePipe::HandleControlMessage(
     unsigned /*port*/,
     scoped_ptr<MessageInTransit> message) {
   LOG(WARNING) << "Unrecognized MessagePipe control message subtype "
                << message->subtype();
   return MOJO_RESULT_UNKNOWN;
 }
 
 }  // namespace system
 }  // namespace mojo