Changing SpawnChild to return a struct.

mojo/edk/system/core.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/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 18 matching lines @@
 #include "mojo/edk/system/message_for_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/ports/name.h"
 #include "mojo/edk/system/ports/node.h"
 #include "mojo/edk/system/request_context.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 #include "mojo/edk/system/wait_set_dispatcher.h"
 #include "mojo/edk/system/waiter.h"
 
+#if defined(OS_ANDROID)
+#include "base/android/jni_android.h"
+#endif
+
 namespace mojo {
 namespace edk {
 
 namespace {
 
 // This is an unnecessarily large limit that is relatively easy to enforce.
 const uint32_t kMaxHandlesPerMessage = 1024 * 1024;
 
 // TODO(rockot): Maybe we could negotiate a debugging pipe ID for cross-process
 // pipes too; for now we just use a constant. This only affects bootstrap pipes.
@@ skipping 33 matching lines @@
       handle.port = static_cast<mach_port_t>(platform_handle->value);
       break;
 #endif
 
 #if defined(OS_WIN)
     case MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE:
       handle.handle = reinterpret_cast<HANDLE>(platform_handle->value);
       break;
 #endif
 
+#if defined(OS_ANDROID)
+    case MOJO_PLATFORM_HANDLE_TYPE_PARCELABLE:
+      handle.type = PlatformHandle::Type::PARCELABLE;
+      handle.parcelable.Reset(
+          base::android::AttachCurrentThread(),
+          reinterpret_cast<jobject>(platform_handle->value));
+      break;
+#endif
+
     default:
       return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
   out_handle->reset(handle);
   return MOJO_RESULT_OK;
 }
 
 MojoResult ScopedPlatformHandleToMojoPlatformHandle(
     ScopedPlatformHandle handle,
@@ skipping 13 matching lines @@
       platform_handle->value = static_cast<uint64_t>(handle.release().handle);
       break;
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
     case PlatformHandle::Type::MACH:
       platform_handle->type = MOJO_PLATFORM_HANDLE_TYPE_MACH_PORT;
       platform_handle->value = static_cast<uint64_t>(handle.release().port);
       break;
 #endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
+#if defined(OS_ANDROID)
+    case PlatformHandle::Type::PARCELABLE:
+      platform_handle->type = MOJO_PLATFORM_HANDLE_TYPE_PARCELABLE;
+      platform_handle->value =
+          reinterpret_cast<uint64_t>(handle.release().parcelable.Release());
+      break;
+#endif  // defined(OS_ANDROID)
+
     default:
       return MOJO_RESULT_INVALID_ARGUMENT;
   }
 #elif defined(OS_WIN)
   platform_handle->type = MOJO_PLATFORM_HANDLE_TYPE_WINDOWS_HANDLE;
   platform_handle->value = reinterpret_cast<uint64_t>(handle.release().handle);
 #endif  // defined(OS_WIN)
 
   return MOJO_RESULT_OK;
 }
@@ skipping 30 matching lines @@
   base::AutoLock lock(handles_lock_);
   return handles_.GetDispatcher(handle);
 }
 
 void Core::SetDefaultProcessErrorCallback(
     const ProcessErrorCallback& callback) {
   default_process_error_callback_ = callback;
 }
 
 void Core::AddChild(base::ProcessHandle process_handle,
-                    ScopedPlatformHandle platform_handle,
+                    ConnectionParam connection_param,
                     const std::string& child_token,
                     const ProcessErrorCallback& process_error_callback) {
   GetNodeController()->ConnectToChild(process_handle,
-                                      std::move(platform_handle),
-                                      child_token,
+                                      std::move(connection_param), child_token,
                                       process_error_callback);
 }
 
 void Core::ChildLaunchFailed(const std::string& child_token) {
   RequestContext request_context;
   GetNodeController()->CloseChildPorts(child_token);
 }
 
 ScopedMessagePipeHandle Core::ConnectToPeerProcess(
     ScopedPlatformHandle pipe_handle,
     const std::string& peer_token) {
   RequestContext request_context;
   ports::PortRef port0, port1;
   GetNodeController()->node()->CreatePortPair(&port0, &port1);
   MojoHandle handle = AddDispatcher(new MessagePipeDispatcher(
       GetNodeController(), port0, kUnknownPipeIdForDebug, 0));
-  GetNodeController()->ConnectToPeer(std::move(pipe_handle), port1, peer_token);
+  ConnectionParam connection_param(std::move(pipe_handle));
+  GetNodeController()->ConnectToPeer(std::move(connection_param), port1,
+                                     peer_token);
   return ScopedMessagePipeHandle(MessagePipeHandle(handle));
 }
 
 void Core::ClosePeerConnection(const std::string& peer_token) {
   GetNodeController()->ClosePeerConnection(peer_token);
 }
 
-void Core::InitChild(ScopedPlatformHandle platform_handle) {
-  GetNodeController()->ConnectToParent(std::move(platform_handle));
+void Core::InitChild(ConnectionParam connection_param) {
+  GetNodeController()->ConnectToParent(std::move(connection_param));
 }
 
 void Core::SetMachPortProvider(base::PortProvider* port_provider) {
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   GetNodeController()->CreateMachPortRelay(port_provider);
 #endif
 }
 
 MojoHandle Core::AddDispatcher(scoped_refptr<Dispatcher> dispatcher) {
   base::AutoLock lock(handles_lock_);
@@ skipping 463 matching lines @@
                              uint32_t* num_bytes,
                              MojoHandle* handles,
                              uint32_t* num_handles,
                              MojoReadMessageFlags flags) {
   CHECK((!num_handles || !*num_handles || handles) &&
         (!num_bytes || !*num_bytes || bytes));
   RequestContext request_context;
   auto dispatcher = GetDispatcher(message_pipe_handle);
   if (!dispatcher)
     return MOJO_RESULT_INVALID_ARGUMENT;
+
   std::unique_ptr<MessageForTransit> message;
   MojoResult rv =
       dispatcher->ReadMessage(&message, num_bytes, handles, num_handles, flags,
                               false /* ignore_num_bytes */);
   if (rv != MOJO_RESULT_OK)
     return rv;
 
   if (message && message->num_bytes())
     memcpy(bytes, message->bytes(), message->num_bytes());
 
@@ skipping 469 matching lines @@
     std::unique_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo