go/bindings/cgo: allocate C structs on C side

mojo/public/platform/native_cgo/system_cgo.go

 // Copyright 2015 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.
 
 package native_cgo
 
 //#include "mojo/public/c/system/core.h"
+// // These functions are used to 8-byte align C structs.
+// MojoResult CreateSharedBuffer(struct MojoCreateSharedBufferOptions* options,
+//     uint64_t num_bytes, MojoHandle* handle) {
+//   struct MojoCreateSharedBufferOptions aligned_options = *options;
+//   return MojoCreateSharedBuffer(&aligned_options, num_bytes, handle);
+// }
+//
+// MojoResult DuplicateBufferHandle(MojoHandle handle,
+//     struct MojoDuplicateBufferHandleOptions* options, MojoHandle* duplicate) {
+//   struct MojoDuplicateBufferHandleOptions aligned_options = *options;
+//   return MojoDuplicateBufferHandle(handle, &aligned_options, duplicate);
+// }
+//
+// MojoResult CreateDataPipe(struct MojoCreateDataPipeOptions* options,
+//     MojoHandle* producer, MojoHandle* consumer) {
+//   struct MojoCreateDataPipeOptions aligned_options = *options;
+//   return MojoCreateDataPipe(&aligned_options, producer, consumer);
+// }
+//
+// MojoResult CreateMessagePipe(struct MojoCreateMessagePipeOptions* options,
+//     MojoHandle* handle0, MojoHandle* handle1) {
+//   struct MojoCreateMessagePipeOptions aligned_options = *options;
+//   return MojoCreateMessagePipe(&aligned_options, handle0, handle1);
+// }
+//
 import "C"
 import (
         "reflect"
         "unsafe"
 )
 
 // CGoSystem provides an implementation of the system.System interface based on CGO
 type CGoSystem struct{}
 
 func (c *CGoSystem) CreateSharedBuffer(flags uint32, numBytes uint64) (int32, uint32) {
         var opts *C.struct_MojoCreateSharedBufferOptions
         opts = &C.struct_MojoCreateSharedBufferOptions{
                 C.uint32_t(unsafe.Sizeof(*opts)),
                 C.MojoCreateSharedBufferOptionsFlags(flags),
         }
         var cHandle C.MojoHandle
-        r := C.MojoCreateSharedBuffer(opts, C.uint64_t(numBytes), &cHandle)
+        r := C.CreateSharedBuffer(opts, C.uint64_t(numBytes), &cHandle)
         return int32(r), uint32(cHandle)
 }
 
 func (c *CGoSystem) DuplicateBufferHandle(handle uint32, flags uint32) (int32, uint32) {
         var opts *C.struct_MojoDuplicateBufferHandleOptions
         opts = &C.struct_MojoDuplicateBufferHandleOptions{
                 C.uint32_t(unsafe.Sizeof(*opts)),
                 C.MojoDuplicateBufferHandleOptionsFlags(flags),
         }
         var cDuplicateHandle C.MojoHandle
-        r := C.MojoDuplicateBufferHandle(C.MojoHandle(handle), opts, &cDuplicateHandle)
+        r := C.DuplicateBufferHandle(C.MojoHandle(handle), opts, &cDuplicateHandle)
         return int32(r), uint32(cDuplicateHandle)
 }
 
 func (c *CGoSystem) MapBuffer(handle uint32, offset, numBytes uint64, flags uint32) (result int32, buf []byte) {
         var bufPtr unsafe.Pointer
         r := C.MojoMapBuffer(C.MojoHandle(handle), C.uint64_t(offset), C.uint64_t(numBytes), &bufPtr, C.MojoMapBufferFlags(flags))
         if r != C.MOJO_RESULT_OK {
                 return int32(r), nil
         }
         return int32(r), unsafeByteSlice(bufPtr, int(numBytes))
 }
 
 func (c *CGoSystem) UnmapBuffer(buf []byte) (result int32) {
         return int32(C.MojoUnmapBuffer(unsafe.Pointer(&buf[0])))
 }
 
 func createDataPipeWithCOptions(opts *C.struct_MojoCreateDataPipeOptions) (result int32, producerHandle, consumerHandle uint32) {
         var cProducerHandle, cConsumerHandle C.MojoHandle
-        r := C.MojoCreateDataPipe(opts, &cProducerHandle, &cConsumerHandle)
+        r := C.CreateDataPipe(opts, &cProducerHandle, &cConsumerHandle)
         return int32(r), uint32(cProducerHandle), uint32(cConsumerHandle)
 }
 
 func (c *CGoSystem) CreateDataPipe(flags, elementNumBytes, capacityNumBytes uint32) (result int32, producerHandle, consumerHandle uint32) {
         var opts *C.struct_MojoCreateDataPipeOptions
         opts = &C.struct_MojoCreateDataPipeOptions{
                 C.uint32_t(unsafe.Sizeof(*opts)),
                 C.MojoCreateDataPipeOptionsFlags(flags),
                 C.uint32_t(elementNumBytes),
                 C.uint32_t(capacityNumBytes),
@@ skipping 90 matching lines @@
         return int32(r), int(int32(index)), satisfied, satisfiable
 }
 
 func (c *CGoSystem) CreateMessagePipe(flags uint32) (int32, uint32, uint32) {
         var handle0, handle1 C.MojoHandle
         var opts *C.struct_MojoCreateMessagePipeOptions
         opts = &C.struct_MojoCreateMessagePipeOptions{
                 C.uint32_t(unsafe.Sizeof(*opts)),
                 C.MojoCreateMessagePipeOptionsFlags(flags),
         }
-        r := C.MojoCreateMessagePipe(opts, &handle0, &handle1)
+        r := C.CreateMessagePipe(opts, &handle0, &handle1)
         return int32(r), uint32(handle0), uint32(handle1)
 }
 
 func (c *CGoSystem) WriteMessage(handle uint32, bytes []byte, handles []uint32, flags uint32) (result int32) {
         var bytesPtr unsafe.Pointer
         if len(bytes) != 0 {
                 bytesPtr = unsafe.Pointer(&bytes[0])
         }
         var handlesPtr *C.MojoHandle
         if len(handles) != 0 {
@@ skipping 28 matching lines @@
                 Data: uintptr(ptr),
                 Len:  length,
                 Cap:  length,
         }
         return unsafe.Pointer(header)
 }
 
 func unsafeByteSlice(ptr unsafe.Pointer, length int) []byte {
         return *(*[]byte)(newUnsafeSlice(ptr, length))
 }