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

mojo/system/dispatcher.cc

Index: mojo/system/dispatcher.cc
diff --git a/mojo/system/dispatcher.cc b/mojo/system/dispatcher.cc
index d2fb6b5a1de7fd033afa1090dfb43b3dc23a8bae..8b0d71f955a1521cdc6850617e2e58f5c2fc55b3 100644
--- a/mojo/system/dispatcher.cc
+++ b/mojo/system/dispatcher.cc
@@ -40,21 +40,25 @@ DispatcherTransport Dispatcher::HandleTableAccess::TryStartTransport(
 }
 
 // static
-size_t Dispatcher::MessageInTransitAccess::GetMaximumSerializedSize(
-    const Dispatcher* dispatcher,
-    const Channel* channel) {
+void Dispatcher::MessageInTransitAccess::StartSerialize(
+    Dispatcher* dispatcher,
+    Channel* channel,
+    size_t* max_size,
+    size_t* max_platform_handles) {
   DCHECK(dispatcher);
-  return dispatcher->GetMaximumSerializedSize(channel);
+  dispatcher->StartSerialize(channel, max_size, max_platform_handles);
 }
 
 // static
-bool Dispatcher::MessageInTransitAccess::SerializeAndClose(
+bool Dispatcher::MessageInTransitAccess::EndSerializeAndClose(
     Dispatcher* dispatcher,
     Channel* channel,
     void* destination,
-    size_t* actual_size) {
+    size_t* actual_size,
+    std::vector<embedder::PlatformHandle>* platform_handles) {
   DCHECK(dispatcher);
-  return dispatcher->SerializeAndClose(channel, destination, actual_size);
+  return dispatcher->EndSerializeAndClose(channel, destination, actual_size,
+                                          platform_handles);
 }
 
 // static
@@ -351,22 +355,25 @@ void Dispatcher::RemoveWaiterImplNoLock(Waiter* /*waiter*/) {
   // will do something nontrivial.
 }
 
-size_t Dispatcher::GetMaximumSerializedSizeImplNoLock(
-      const Channel* /*channel*/) const {
+void Dispatcher::StartSerializeImplNoLock(Channel* /*channel*/,
+                                          size_t* max_size,
+                                          size_t* max_platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
-  // By default, serializing isn't supported.
-  return 0;
+  *max_size = 0;
+  *max_platform_handles = 0;
 }
 
-bool Dispatcher::SerializeAndCloseImplNoLock(Channel* /*channel*/,
-                                             void* /*destination*/,
-                                             size_t* /*actual_size*/) {
+bool Dispatcher::EndSerializeAndCloseImplNoLock(
+    Channel* /*channel*/,
+    void* /*destination*/,
+    size_t* /*actual_size*/,
+    std::vector<embedder::PlatformHandle>* /*platform_handles*/) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(is_closed_);
   // By default, serializing isn't supported, so just close.
   CloseImplNoLock();
-  return 0;
+  return false;
 }
 
 bool Dispatcher::IsBusyNoLock() const {
@@ -396,41 +403,42 @@ Dispatcher::CreateEquivalentDispatcherAndCloseNoLock() {
   return CreateEquivalentDispatcherAndCloseImplNoLock();
 }
 
-size_t Dispatcher::GetMaximumSerializedSize(const Channel* channel) const {
+void Dispatcher::StartSerialize(Channel* channel,
+                                size_t* max_size,
+                                size_t* max_platform_handles) {
   DCHECK(channel);
+  DCHECK(max_size);
+  DCHECK(max_platform_handles);
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
-  return GetMaximumSerializedSizeImplNoLock(channel);
+  StartSerializeImplNoLock(channel, max_size, max_platform_handles);
 }
 
-bool Dispatcher::SerializeAndClose(Channel* channel,
-                                   void* destination,
-                                   size_t* actual_size) {
-  DCHECK(destination);
+bool Dispatcher::EndSerializeAndClose(
+    Channel* channel,
+    void* destination,
+    size_t* actual_size,
+    std::vector<embedder::PlatformHandle>* platform_handles) {
   DCHECK(channel);
   DCHECK(actual_size);
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
   DCHECK(!is_closed_);
 
-  // We have to call |GetMaximumSerializedSizeImplNoLock()| first, because we
-  // leave it to |SerializeAndCloseImplNoLock()| to close the thing.
-#if DCHECK_IS_ON
-  size_t max_size = GetMaximumSerializedSizeImplNoLock(channel);
-#else
-  size_t max_size = static_cast<size_t>(-1);
-#endif
-
   // Like other |...Close()| methods, we mark ourselves as closed before calling
   // the impl.
   is_closed_ = true;
   // No need to cancel waiters: we shouldn't have any (and shouldn't be in
   // |Core|'s handle table.
 
-  if (!SerializeAndCloseImplNoLock(channel, destination, actual_size))
-    return false;
+#if !defined(NDEBUG)
+  // See the comment above |EndSerializeAndCloseImplNoLock()|. In brief: Locking
+  // isn't actually needed, but we need to satisfy assertions (which we don't
+  // want to remove or weaken).
+  base::AutoLock locker(lock_);
+#endif
 
-  DCHECK_LE(*actual_size, max_size);
-  return true;
+  return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
+                                        platform_handles);
 }
 
 // DispatcherTransport ---------------------------------------------------------