Add multiplexing of message pipes in the new EDK.

mojo/edk/system/message_in_transit.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_
 #define MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 85 matching lines @@
     }
     size_t transport_data_buffer_size() const {
       return total_size() - main_buffer_size();
     }
     size_t total_size() const { return header()->total_size; }
     uint32_t num_bytes() const { return header()->num_bytes; }
     const void* bytes() const {
       return static_cast<const char*>(buffer_) + sizeof(Header);
     }
     Type type() const { return header()->type; }
+    uint64_t route_id() const { return header()->route_id; }
 
    private:
     const Header* header() const { return static_cast<const Header*>(buffer_); }
 
     const void* const buffer_;
 
     // Though this struct is trivial, disallow copy and assign, since it doesn't
     // own its data. (If you're copying/assigning this, you're probably doing
     // something wrong.)
     MOJO_DISALLOW_COPY_AND_ASSIGN(View);
@@ skipping 48 matching lines @@
 
   // Gets the size of the message data.
   uint32_t num_bytes() const { return header()->num_bytes; }
 
   // Gets the message data (of size |num_bytes()| bytes).
   const void* bytes() const { return main_buffer_.get() + sizeof(Header); }
   void* bytes() { return main_buffer_.get() + sizeof(Header); }
 
   Type type() const { return header()->type; }
 
+  void set_route_id(uint64_t route_id) { header()->route_id = route_id; }
+  uint64_t route_id() const { return header()->route_id; }
+
   // Gets the dispatchers attached to this message; this may return null if
   // there are none. Note that the caller may mutate the set of dispatchers
   // (e.g., take ownership of all the dispatchers, leaving the vector empty).
   DispatcherVector* dispatchers() { return dispatchers_.get(); }
 
   // Returns true if this message has dispatchers attached.
   bool has_dispatchers() const {
     return dispatchers_ && !dispatchers_->empty();
   }
 
   // Rounds |n| up to a multiple of |kMessageAlignment|.
   static inline size_t RoundUpMessageAlignment(size_t n) {
     return (n + kMessageAlignment - 1) & ~(kMessageAlignment - 1);
   }
 
  private:
   // To allow us to make compile-assertions about |Header| in the .cc file.
   struct PrivateStructForCompileAsserts;
 
   // Header for the data (main buffer). Must be a multiple of
   // |kMessageAlignment| bytes in size. Must be POD.
   struct Header {
     // Total size of the message, including the header, the message data
     // ("bytes") including padding (to make it a multiple of |kMessageAlignment|
     // bytes), and serialized handle information. Note that this may not be the
     // correct value if dispatchers are attached but
     // |SerializeAndCloseDispatchers()| has not been called.
     uint32_t total_size;
     Type type;                         // 2 bytes.
-    Type unusedforalignment;           // 2 bytes.
+    uint16_t unusedforalignment;       // 2 bytes.
     uint32_t num_bytes;
     uint32_t unused;
+    uint64_t route_id;
   };
 
   const Header* header() const {
     return reinterpret_cast<const Header*>(main_buffer_.get());
   }
   Header* header() { return reinterpret_cast<Header*>(main_buffer_.get()); }
 
   void ConstructorHelper(Type type, uint32_t num_bytes);
   void UpdateTotalSize();
 
@@ skipping 15 matching lines @@
 MOJO_SYSTEM_IMPL_EXPORT inline std::ostream& operator<<(
     std::ostream& out,
     MessageInTransit::Type type) {
   return out << static_cast<uint16_t>(type);
 }
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_MESSAGE_IN_TRANSIT_H_