Changing SpawnChild to return a struct.

mojo/edk/system/channel.cc

 // Copyright 2016 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/edk/system/channel.h"
 
 #include <stddef.h>
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/process/process_handle.h"
 #include "mojo/edk/embedder/platform_handle.h"
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 #include "base/mac/mach_logging.h"
+#elif defined(OS_ANDROID)
+#include "base/rand_util.h"
 #elif defined(OS_WIN)
 #include "base/win/win_util.h"
 #endif
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
 static_assert(
@@ skipping 43 matching lines @@
   extra_header_size = max_handles_ * sizeof(HandleEntry);
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   // On OSX, some of the platform handles may be mach ports, which are
   // serialised into the message buffer. Since there could be a mix of fds and
   // mach ports, we store the mach ports as an <index, port> pair (of uint32_t),
   // so that the original ordering of handles can be re-created.
   if (max_handles) {
     extra_header_size =
         sizeof(MachPortsExtraHeader) + (max_handles * sizeof(MachPortsEntry));
   }
+#elif defined(OS_ANDROID)
+  if (max_handles) {
+    extra_header_size =
+        sizeof(ParcelableExtraHeader) + (max_handles * sizeof(ParcelableEntry));
+  }
 #endif
   // Pad extra header data to be aliged to |kChannelMessageAlignment| bytes.
   if (!IsAlignedForChannelMessage(extra_header_size)) {
     extra_header_size += kChannelMessageAlignment -
                          (extra_header_size % kChannelMessageAlignment);
   }
   DCHECK(IsAlignedForChannelMessage(extra_header_size));
   const size_t header_size =
       is_legacy_message ? sizeof(LegacyHeader) : sizeof(Header);
   DCHECK(extra_header_size == 0 || !is_legacy_message);
@@ skipping 30 matching lines @@
       handles_[i].handle = base::win::HandleToUint32(INVALID_HANDLE_VALUE);
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
     mach_ports_header_ =
         reinterpret_cast<MachPortsExtraHeader*>(mutable_extra_header());
     mach_ports_header_->num_ports = 0;
     // Initialize all handles to invalid values.
     for (size_t i = 0; i < max_handles_; ++i) {
       mach_ports_header_->entries[i] =
           {0, static_cast<uint32_t>(MACH_PORT_NULL)};
     }
+#elif defined(OS_ANDROID)
+    parcelable_header_ =
+        reinterpret_cast<ParcelableExtraHeader*>(mutable_extra_header());
+    parcelable_header_->num_parcelables = 0;
+    memset(parcelable_header_->entries, 0,
+           sizeof(ParcelableEntry) * max_handles_);
 #endif
   }
 }
 
 Channel::Message::~Message() {
   base::AlignedFree(data_);
 }
 
 // static
 Channel::MessagePtr Channel::Message::Deserialize(const void* data,
@@ skipping 38 matching lines @@
       extra_header_size < sizeof(MachPortsExtraHeader)) {
     DLOG(ERROR) << "Decoding invalid message: " << extra_header_size << " < "
                 << sizeof(MachPortsExtraHeader);
     return nullptr;
   }
   uint32_t max_handles =
       extra_header_size == 0
           ? 0
           : (extra_header_size - sizeof(MachPortsExtraHeader)) /
                 sizeof(MachPortsEntry);
+#elif defined(OS_ANDROID)
+  if (extra_header_size < sizeof(ParcelableExtraHeader)) {
+    DLOG(ERROR) << "Decoding invalid message: " << extra_header_size << " < "
+                << sizeof(ParcelableExtraHeader);
+    return nullptr;
+  }
+  uint32_t max_handles = (extra_header_size - sizeof(ParcelableExtraHeader)) /
+                         sizeof(ParcelableEntry);
 #else
   const uint32_t max_handles = 0;
 #endif  // defined(OS_WIN)
 
   const uint16_t num_handles =
       header ? header->num_handles : legacy_header->num_handles;
   if (num_handles > max_handles || max_handles > kMaxAttachedHandles) {
     DLOG(ERROR) << "Decoding invalid message: " << num_handles << " > "
                 << max_handles;
     return nullptr;
@@ skipping 117 matching lines @@
   }
 
   if (max_handles_ == 0) {
     CHECK(!new_handles || new_handles->size() == 0);
     return;
   }
 
   CHECK(new_handles && new_handles->size() <= max_handles_);
   header()->num_handles = static_cast<uint16_t>(new_handles->size());
   std::swap(handle_vector_, new_handles);
+
 #if defined(OS_WIN)
   memset(handles_, 0, extra_header_size());
   for (size_t i = 0; i < handle_vector_->size(); i++)
     handles_[i].handle = base::win::HandleToUint32((*handle_vector_)[i].handle);
 #endif  // defined(OS_WIN)
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   size_t mach_port_index = 0;
   if (mach_ports_header_) {
     for (size_t i = 0; i < max_handles_; ++i) {
       mach_ports_header_->entries[i] =
           {0, static_cast<uint32_t>(MACH_PORT_NULL)};
     }
     for (size_t i = 0; i < handle_vector_->size(); i++) {
       if ((*handle_vector_)[i].type == PlatformHandle::Type::MACH ||
           (*handle_vector_)[i].type == PlatformHandle::Type::MACH_NAME) {
         mach_port_t port = (*handle_vector_)[i].port;
         mach_ports_header_->entries[mach_port_index].index = i;
         mach_ports_header_->entries[mach_port_index].mach_port = port;
         mach_port_index++;
       }
     }
     mach_ports_header_->num_ports = static_cast<uint16_t>(mach_port_index);
   }
 #endif
+
+#if defined(OS_ANDROID)
+  size_t parcelable_index = 0;
+  if (parcelable_header_) {
+    memset(parcelable_header_->entries, 0,
+           sizeof(ParcelableEntry) * max_handles_);
+    for (size_t i = 0; i < handle_vector_->size(); i++) {
+      if ((*handle_vector_)[i].type == PlatformHandle::Type::PARCELABLE) {
+        // jobject parcelable = (*handle_vector_)[i].parcelable;
+        // TODO: WHERE DOES THE PARCELABLE GO?
+        parcelable_header_->entries[parcelable_index].index = i;
+        parcelable_header_->entries[parcelable_index].id = i;
+        parcelable_index++;
+      }
+    }
+    parcelable_header_->num_parcelables =
+        static_cast<uint16_t>(parcelable_index);
+  }
+#endif
 }
 
 ScopedPlatformHandleVectorPtr Channel::Message::TakeHandles() {
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   if (mach_ports_header_) {
     for (size_t i = 0; i < max_handles_; ++i) {
       mach_ports_header_->entries[i] =
           {0, static_cast<uint32_t>(MACH_PORT_NULL)};
     }
     mach_ports_header_->num_ports = 0;
@@ skipping 18 matching lines @@
           it->type == PlatformHandle::Type::MACH_NAME) {
         // For Mach port names, we can can just leak them. They're not real
         // ports anyways. For real ports, they're leaked because this is a child
         // process and the remote process will take ownership.
         it = handle_vector_->erase(it);
       } else {
         ++it;
       }
     }
   }
+#elif defined(OS_ANDROID)
+  if (handle_vector_) {
+    for (auto it = handle_vector_->begin(); it != handle_vector_->end();) {
+      if (it->type == PlatformHandle::Type::PARCELABLE) {
+        it = handle_vector_->erase(it);
+      } else {
+        ++it;
+      }
+    }
+  }
+#endif
   return std::move(handle_vector_);
-#else
-  return std::move(handle_vector_);
+}
+
+#if defined(OS_ANDROID)
+Channel::Message::IDAndParcelableVector
+Channel::Message::TakeParcelablesForTransport() {
+  IDAndParcelableVector ids_and_parcelables;
+  if (parcelable_header_) {
+    memset(parcelable_header_->entries, 0,
+           sizeof(ParcelableEntry) * max_handles_);
+    size_t parcelable_index = 0;
+    for (auto iter = handle_vector_->begin(); iter != handle_vector_->end();
+         ++iter) {
+      if (iter->type == PlatformHandle::Type::PARCELABLE) {
+        uint32_t parcelable_id = static_cast<uint32_t>(base::RandUint64());
+        parcelable_header_->entries[parcelable_index].index = parcelable_index;
+        parcelable_header_->entries[parcelable_index].id = parcelable_id;
+        parcelable_index++;
+        ids_and_parcelables.push_back(std::make_pair(
+            parcelable_id,
+            base::android::ScopedJavaLocalRef<jobject>(iter->parcelable)));
+      }
+    }
+    parcelable_header_->num_parcelables =
+        static_cast<uint16_t>(parcelable_index);
+  }
+
+  return std::move(ids_and_parcelables);
+}
 #endif
-}
 
 #if defined(OS_WIN)
 // static
 bool Channel::Message::RewriteHandles(base::ProcessHandle from_process,
                                       base::ProcessHandle to_process,
                                       PlatformHandleVector* handles) {
   bool success = true;
   for (size_t i = 0; i < handles->size(); ++i) {
     if (!(*handles)[i].is_valid()) {
       DLOG(ERROR) << "Refusing to duplicate invalid handle.";
@@ skipping 226 matching lines @@
     }
 
     const uint16_t num_handles =
         header ? header->num_handles : legacy_header->num_handles;
     ScopedPlatformHandleVectorPtr handles;
     if (num_handles > 0) {
       if (!GetReadPlatformHandles(num_handles, extra_header, extra_header_size,
                                   &handles)) {
         return false;
       }
-
       if (!handles) {
         // Not enough handles available for this message.
         break;
       }
     }
 
     // We've got a complete message! Dispatch it and try another.
     if (legacy_header->message_type != Message::MessageType::NORMAL_LEGACY &&
         legacy_header->message_type != Message::MessageType::NORMAL) {
       if (!OnControlMessage(legacy_header->message_type, payload, payload_size,
                             std::move(handles))) {
         return false;
       }
       did_dispatch_message = true;
     } else if (delegate_) {
+      ((handles) ? handles->size() : 0);
       delegate_->OnChannelMessage(payload, payload_size, std::move(handles));
       did_dispatch_message = true;
     }
 
     read_buffer_->Discard(legacy_header->num_bytes);
   }
 
   *next_read_size_hint = did_dispatch_message ? 0 : kReadBufferSize;
   return true;
 }
 
 void Channel::OnError() {
   if (delegate_)
     delegate_->OnChannelError();
 }
 
 bool Channel::OnControlMessage(Message::MessageType message_type,
                                const void* payload,
                                size_t payload_size,
                                ScopedPlatformHandleVectorPtr handles) {
   return false;
 }
 
 }  // namespace edk
 }  // namespace mojo