Mojo: (Theoretically) implement the read side of platform handle passing.

mojo/system/transport_data.h

Index: mojo/system/transport_data.h
diff --git a/mojo/system/transport_data.h b/mojo/system/transport_data.h
index 0f03c810da1df7a46c5e9ed2904d73313116d39e..7f8aa218d9938ba5cc2f6995d0b7da3f23c31829 100644
--- a/mojo/system/transport_data.h
+++ b/mojo/system/transport_data.h
@@ -79,6 +79,12 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData {
   // dispatcher.
   static const size_t kMaxSerializedDispatcherPlatformHandles = 2;
 
+  // The maximum possible size of a valid transport data buffer.
+  static const size_t kMaxBufferSize;
+
+  // The maximum total number of platform handles that may be attached.
+  static const size_t kMaxPlatformHandles;
+
   TransportData(scoped_ptr<DispatcherVector> dispatchers, Channel* channel);
   ~TransportData();
 
@@ -108,7 +114,15 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData {
   // validity of the handle table entries (i.e., does range checking), but does
   // not check that the validity of the actual serialized dispatcher
   // information.
-  static const char* ValidateBuffer(const void* buffer, size_t buffer_size);
+  static const char* ValidateBuffer(size_t serialized_platform_handle_size,

[yzshen1, 2014/05/11 07:16:59]

I don't think I have understood the whole design of handle passing (I only read
the comments above this class declaration).

I think the serialized platform handle size is raw-channel-specific: the same
for all messages passed over a raw channel, instead of platform-specific or
variable-length-for-each-message. Right? Otherwise, we would either use a const
platform-specific value, or encode the size information in the message.

Would you please tell me more about the design? Have we already got the platform
handle de/serialization code? If yes, please point me to it. Thanks!

[viettrungluu, 2014/05/12 17:33:28]

It is so RawChannel-specific, that it may vary between instances, even on the
same platform.
We have it on Linux, but not on Windows. On Windows, depending on the situation,
you may simply be able to DuplicateHandle() into the target process (in which
case the information is just a HANDLE[*]), or you may have to talk to a broker
(in which case the information is whatever information is needed retrieve the
handle from the broker).

[*] Possibly plus an enum value indicating what situation we're in.

+                                    const void* buffer,
+                                    size_t buffer_size);
+
+  // Gets the platform handle table from a (valid) |TransportData| buffer (which
+  // should have been validated using |ValidateBuffer()| first).
+  static void GetPlatformHandleTable(const void* transport_data_buffer,
+                                     size_t* num_platform_handles,
+                                     const void** platform_handle_table);
 
   // Deserializes dispatchers from the given (serialized) transport data buffer
   // (typically from a |MessageInTransit::View|). |buffer| should be non-null
@@ -140,12 +154,6 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData {
     uint32_t unused;
   };
 
-  // The maximum possible size of a valid transport data buffer.
-  static const size_t kMaxBufferSize;
-
-  // The maximum total number of platform handles that may be attached.
-  static const size_t kMaxPlatformHandles;
-
   const Header* header() const {
     return reinterpret_cast<const Header*>(buffer_.get());
   }