Mojo: Allow dispatchers to attach PlatformHandles to the MessageInTransit on serialization.

mojo/system/message_in_transit.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_in_transit.h"
 
 #include <string.h>
 
 #include <new>
 
@@ skipping 37 matching lines @@
     MessageInTransit::kTypeChannel;
 STATIC_CONST_MEMBER_DEFINITION const MessageInTransit::Subtype
     MessageInTransit::kSubtypeMessagePipeEndpointData;
 STATIC_CONST_MEMBER_DEFINITION const MessageInTransit::Subtype
     MessageInTransit::kSubtypeMessagePipePeerClosed;
 STATIC_CONST_MEMBER_DEFINITION const MessageInTransit::EndpointId
     MessageInTransit::kInvalidEndpointId;
 STATIC_CONST_MEMBER_DEFINITION const size_t MessageInTransit::kMessageAlignment;
 STATIC_CONST_MEMBER_DEFINITION const size_t
     MessageInTransit::kMaxSerializedDispatcherSize;
+STATIC_CONST_MEMBER_DEFINITION const size_t
+    MessageInTransit::kMaxSerializedDispatcherPlatformHandles;
 
 // For each attached (Mojo) handle, there'll be a handle table entry and
 // serialized dispatcher data.
 // static
 const size_t MessageInTransit::kMaxSecondaryBufferSize = kMaxMessageNumHandles *
     (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize);
 
+const size_t MessageInTransit::kMaxPlatformHandles =
+    kMaxMessageNumHandles * kMaxSerializedDispatcherPlatformHandles;
+
 MessageInTransit::View::View(size_t message_size, const void* buffer)
     : buffer_(buffer) {
   size_t next_message_size = 0;
   DCHECK(MessageInTransit::GetNextMessageSize(buffer_, message_size,
                                               &next_message_size));
   DCHECK_EQ(message_size, next_message_size);
   // This should be equivalent.
   DCHECK_EQ(message_size, total_size());
 }
 
@@ skipping 134 matching lines @@
   CHECK_EQ(num_handles(),
            dispatchers_ ? dispatchers_->size() : static_cast<size_t>(0));
 
   if (!num_handles())
     return;
 
   size_t handle_table_size = num_handles() * sizeof(HandleTableEntry);
   // The size of the secondary buffer. We'll start with the size of the handle
   // table, and add to it as we go along.
   size_t size = handle_table_size;
-  for (size_t i = 0; i < dispatchers_->size(); i++) {
+  size_t num_platform_handles = 0;
+#if DCHECK_IS_ON
+  std::vector<size_t> all_max_sizes(num_handles());
+  std::vector<size_t> all_max_platform_handles(num_handles());
+#endif
+  for (size_t i = 0; i < num_handles(); i++) {
     if (Dispatcher* dispatcher = (*dispatchers_)[i].get()) {
-      size_t max_serialized_size =
-          Dispatcher::MessageInTransitAccess::GetMaximumSerializedSize(
-              dispatcher, channel);
-      DCHECK_LE(max_serialized_size, kMaxSerializedDispatcherSize);
-      size += RoundUpMessageAlignment(max_serialized_size);
+      size_t max_size = 0;
+      size_t max_platform_handles = 0;
+      Dispatcher::MessageInTransitAccess::StartSerialize(
+              dispatcher, channel, &max_size, &max_platform_handles);
+
+      DCHECK_LE(max_size, kMaxSerializedDispatcherSize);
+      size += RoundUpMessageAlignment(max_size);
       DCHECK_LE(size, kMaxSecondaryBufferSize);
+
+      DCHECK_LE(max_platform_handles,
+                kMaxSerializedDispatcherPlatformHandles);
+      num_platform_handles += max_platform_handles;
+      DCHECK_LE(num_platform_handles, kMaxPlatformHandles);
+
+#if DCHECK_IS_ON
+      all_max_sizes[i] = max_size;
+      all_max_platform_handles[i] = max_platform_handles;
+#endif
     }
   }
 
   secondary_buffer_ = base::AlignedAlloc(size, kMessageAlignment);
   secondary_buffer_size_ = static_cast<uint32_t>(size);
   // Entirely clear out the secondary buffer, since then we won't have to worry
   // about clearing padding or unused space (e.g., if a dispatcher fails to
   // serialize).
   memset(secondary_buffer_, 0, size);
 
+  if (num_platform_handles > 0) {
+    DCHECK(!platform_handles_);
+    platform_handles_.reset(new std::vector<embedder::PlatformHandle>());
+  }
+
   HandleTableEntry* handle_table =
       static_cast<HandleTableEntry*>(secondary_buffer_);
   size_t current_offset = handle_table_size;
-  for (size_t i = 0; i < dispatchers_->size(); i++) {
+  for (size_t i = 0; i < num_handles(); i++) {
     Dispatcher* dispatcher = (*dispatchers_)[i].get();
     if (!dispatcher) {
       COMPILE_ASSERT(Dispatcher::kTypeUnknown == 0,
                      value_of_Dispatcher_kTypeUnknown_must_be_zero);
       continue;
     }
 
+#if DCHECK_IS_ON
+    size_t old_platform_handles_size =
+        platform_handles_ ? platform_handles_->size() : 0;
+#endif
+
     void* destination = static_cast<char*>(secondary_buffer_) + current_offset;
     size_t actual_size = 0;
-    if (Dispatcher::MessageInTransitAccess::SerializeAndClose(
-            dispatcher, channel, destination, &actual_size)) {
+    if (Dispatcher::MessageInTransitAccess::EndSerializeAndClose(
+            dispatcher, channel, destination, &actual_size,
+            platform_handles_.get())) {
       handle_table[i].type = static_cast<int32_t>(dispatcher->GetType());
       handle_table[i].offset = static_cast<uint32_t>(current_offset);
       handle_table[i].size = static_cast<uint32_t>(actual_size);
+
+#if DCHECK_IS_ON
+      DCHECK_LE(actual_size, all_max_sizes[i]);
+      DCHECK_LE(platform_handles_ ? (platform_handles_->size() -
+                                         old_platform_handles_size) : 0,
+                all_max_platform_handles[i]);
+#endif
     } else {
       // Nothing to do on failure, since |secondary_buffer_| was cleared, and
       // |kTypeUnknown| is zero. The handle was simply closed.
       LOG(ERROR) << "Failed to serialize handle to remote message pipe";
     }
 
     current_offset += RoundUpMessageAlignment(actual_size);
     DCHECK_LE(current_offset, size);
+    DCHECK_LE(platform_handles_ ? platform_handles_->size() : 0,
+              num_platform_handles);
   }
 
   UpdateTotalSize();
 }
 
 // Note: The message's secondary buffer should have been checked by calling
 // |View::IsValid()| (on the |View|) first.
 void MessageInTransit::DeserializeDispatchers(Channel* channel) {
   DCHECK(!dispatchers_);
 
@@ skipping 80 matching lines @@
 
 void MessageInTransit::UpdateTotalSize() {
   DCHECK_EQ(main_buffer_size_ % kMessageAlignment, 0u);
   DCHECK_EQ(secondary_buffer_size_ % kMessageAlignment, 0u);
   header()->total_size =
       static_cast<uint32_t>(main_buffer_size_ + secondary_buffer_size_);
 }
 
 }  // namespace system
 }  // namespace mojo