Changing SpawnChild to return a struct.

mojo/edk/system/channel.h

 // 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.
 
 #ifndef MOJO_EDK_SYSTEM_CHANNEL_H_
 #define MOJO_EDK_SYSTEM_CHANNEL_H_
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/process/process_handle.h"
 #include "base/task_runner.h"
+#include "mojo/edk/embedder/connection_param.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 
 namespace mojo {
 namespace edk {
 
 const size_t kChannelMessageAlignment = 8;
 
 constexpr bool IsAlignedForChannelMessage(size_t n) {
   return n % kChannelMessageAlignment == 0;
@@ skipping 72 matching lines @@
                     "mach_port_t must be no larger than uint32_t");
     };
     static_assert(sizeof(MachPortsEntry) == 6,
                   "sizeof(MachPortsEntry) must be 6 bytes");
 
     // Structure of the extra header field when present on OSX.
     struct MachPortsExtraHeader {
       // Actual number of Mach ports encoded in the extra header.
       uint16_t num_ports;
 
-      // Array of encoded Mach ports. If |num_ports| > 0, |entires[0]| through
+      // Array of encoded Mach ports. If |num_ports| > 0, |entries[0]| through
       // to |entries[num_ports-1]| inclusive are valid.
       MachPortsEntry entries[0];
     };
     static_assert(sizeof(MachPortsExtraHeader) == 2,
                   "sizeof(MachPortsExtraHeader) must be 2 bytes");
 #elif defined(OS_WIN)
     struct HandleEntry {
       // The windows HANDLE. HANDLEs are guaranteed to fit inside 32-bits.
       // See: https://msdn.microsoft.com/en-us/library/aa384203(VS.85).aspx
       uint32_t handle;
     };
     static_assert(sizeof(HandleEntry) == 4,
                   "sizeof(HandleEntry) must be 4 bytes");
+#elif defined(OS_ANDROID)
+    struct ParcelableEntry {
+      // Index of the parcelable in the original vector of PlatformHandles.
+      uint16_t index;
+
+      // The ID of a parcelable sent through the side channel.
+      uint32_t id;
+    };
+    static_assert(sizeof(ParcelableEntry) == 6,
+                  "sizeof(ParcelableEntry) must be 6 bytes");
+
+    // Structure of the extra header field when present on Android.
+    struct ParcelableExtraHeader {
+      // Actual number of parcelables encoded in the extra header.
+      uint16_t num_parcelables;
+
+      // Array of parcelable IDs. If |num_ports| > 0, |entries[0]| through
+      // to |entries[num_ports-1]| inclusive are valid.
+      ParcelableEntry entries[0];
+    };
+    static_assert(sizeof(ParcelableExtraHeader) == 2,
+                  "sizeof(ParcelableExtraHeader) must be 2 bytes");
 #endif
 #pragma pack(pop)
 
     // Allocates and owns a buffer for message data with enough capacity for
     // |payload_size| bytes plus a header, plus |max_handles| platform handles.
     Message(size_t payload_size, size_t max_handles);
     Message(size_t payload_size, size_t max_handles, MessageType message_type);
     ~Message();
 
     // Constructs a Message from serialized message data.
@@ skipping 23 matching lines @@
     // Note: SetHandles() and TakeHandles() invalidate any previous value of
     // handles().
     void SetHandles(ScopedPlatformHandleVectorPtr new_handles);
     ScopedPlatformHandleVectorPtr TakeHandles();
     // Version of TakeHandles that returns a vector of platform handles suitable
     // for transfer over an underlying OS mechanism. i.e. file descriptors over
     // a unix domain socket. Any handle that cannot be transferred this way,
     // such as Mach ports, will be removed.
     ScopedPlatformHandleVectorPtr TakeHandlesForTransport();
 
+#if defined(OS_ANDROID)
+    using IDAndParcelableVector = std::vector<
+        std::pair<uint32_t, base::android::ScopedJavaLocalRef<jobject>>>;
+    IDAndParcelableVector TakeParcelablesForTransport();
+#endif
+
 #if defined(OS_WIN)
     // Prepares the handles in this message for use in a different process.
     // Upon calling this the handles should belong to |from_process|; after the
     // call they'll belong to |to_process|. The source handles are always
     // closed by this call. Returns false iff one or more handles failed
     // duplication.
     static bool RewriteHandles(base::ProcessHandle from_process,
                                base::ProcessHandle to_process,
                                PlatformHandleVector* handles);
 #endif
 
     void SetVersionForTest(uint16_t version_number);
 
    private:
     size_t size_ = 0;
     size_t max_handles_ = 0;
     char* data_ = nullptr;
 
     ScopedPlatformHandleVectorPtr handle_vector_;
 
 #if defined(OS_WIN)
     // On Windows, handles are serialised into the extra header section.
     HandleEntry* handles_ = nullptr;
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
     // On OSX, handles are serialised into the extra header section.
     MachPortsExtraHeader* mach_ports_header_ = nullptr;
+#elif defined(OS_ANDROID)
+    // On Android, handles for parcelable are sent on a side channel, IDs are
+    // sent on the mian channel.
+    ParcelableExtraHeader* parcelable_header_ = nullptr;
 #endif
 
     DISALLOW_COPY_AND_ASSIGN(Message);
   };
 
   // Delegate methods are called from the I/O task runner with which the Channel
   // was created (see Channel::Create).
   class Delegate {
    public:
     virtual ~Delegate() {}
 
     // Notify of a received message. |payload| is not owned and must not be
     // retained; it will be null if |payload_size| is 0. |handles| are
     // transferred to the callee.
     virtual void OnChannelMessage(const void* payload,
                                   size_t payload_size,
                                   ScopedPlatformHandleVectorPtr handles) = 0;
 
     // Notify that an error has occured and the Channel will cease operation.
     virtual void OnChannelError() = 0;
   };
 
   // Creates a new Channel around a |platform_handle|, taking ownership of the
   // handle. All I/O on the handle will be performed on |io_task_runner|.
   // Note that ShutDown() MUST be called on the Channel some time before
   // |delegate| is destroyed.
   static scoped_refptr<Channel> Create(
       Delegate* delegate,
-      ScopedPlatformHandle platform_handle,
+      ConnectionParam connection_param,
       scoped_refptr<base::TaskRunner> io_task_runner);
 
   // Request that the channel be shut down. This should always be called before
   // releasing the last reference to a Channel to ensure that it's cleaned up
   // on its I/O task runner's thread.
   //
   // Delegate methods will no longer be invoked after this call.
   void ShutDown();
 
   // Begin processing I/O events. Delegate methods must only be invoked after
@@ skipping 66 matching lines @@
   Delegate* delegate_;
   const std::unique_ptr<ReadBuffer> read_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(Channel);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHANNEL_H_