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

mojo/system/transport_data.h

 // Copyright 2014 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_SYSTEM_TRANSPORT_DATA_H_
 #define MOJO_SYSTEM_TRANSPORT_DATA_H_
 
 #include <stdint.h>
 
 #include <vector>
@@ skipping 61 matching lines @@
 class MOJO_SYSTEM_IMPL_EXPORT TransportData {
  public:
   // The maximum size of a single serialized dispatcher. This must be a multiple
   // of |kMessageAlignment|.
   static const size_t kMaxSerializedDispatcherSize = 10000;
 
   // The maximum number of platform handles to attach for a single serialized
   // 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();
 
   const void* buffer() const { return buffer_.get(); }
   void* buffer() { return buffer_.get(); }
   size_t buffer_size() const { return buffer_size_; }
 
   uint32_t platform_handle_table_offset() const {
     return header()->platform_handle_table_offset;
   }
 
   // Gets attached platform-specific handles; this may return null if there are
   // none. Note that the caller may mutate the set of platform-specific handles.
   const std::vector<embedder::PlatformHandle>* platform_handles() const {
     return platform_handles_.get();
   }
   std::vector<embedder::PlatformHandle>* platform_handles() {
     return platform_handles_.get();
   }
 
   // Receive-side functions:
 
   // Checks if the given buffer (from the "wire") looks like a valid
   // |TransportData| buffer. (Should only be called if |buffer_size| is
   // nonzero.) Returns null if valid, and a pointer to a human-readable error
   // message (for debug/logging purposes) on error. Note: This checks the
   // 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
   // and |buffer_size| should be nonzero.
   static scoped_ptr<DispatcherVector> DeserializeDispatchersFromBuffer(
       const void* buffer,
       size_t buffer_size,
       Channel* channel);
 
  private:
@@ skipping 11 matching lines @@
     uint32_t unused;
   };
 
   struct HandleTableEntry {
     int32_t type;  // From |Dispatcher::Type| (|kTypeUnknown| for "invalid").
     uint32_t offset;  // Relative to the start of the "secondary buffer".
     uint32_t size;  // (Not including any padding.)
     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());
   }
 
   size_t buffer_size_;
   scoped_ptr<char, base::AlignedFreeDeleter> buffer_;  // Never null.
 
   // Any platform-specific handles attached to this message (for inter-process
   // transport). The vector (if any) owns the handles that it contains (and is
   // responsible for closing them).
   // TODO(vtl): With C++11, change it to a vector of |ScopedPlatformHandles|.
   scoped_ptr<std::vector<embedder::PlatformHandle> > platform_handles_;
 
   DISALLOW_COPY_AND_ASSIGN(TransportData);
 };
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_SYSTEM_TRANSPORT_DATA_H_