mojo/edk/embedder/entrypoints.cc

// Copyright 2014 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/embedder/entrypoints.h"

#include <stdint.h>

#include "mojo/edk/embedder/embedder_internal.h"
#include "mojo/edk/system/core.h"
#include "mojo/public/c/system/buffer.h"
#include "mojo/public/c/system/data_pipe.h"
#include "mojo/public/c/system/functions.h"
#include "mojo/public/c/system/message_pipe.h"
#include "mojo/public/c/system/platform_handle.h"
#include "mojo/public/c/system/wait_set.h"

using mojo::edk::internal::g_core;

// Definitions of the system functions.
extern "C" {

MojoTimeTicks MojoGetTimeTicksNowImpl() {
  return g_core->GetTimeTicksNow();
}

MojoResult MojoCloseImpl(MojoHandle handle) {
  return g_core->Close(handle);
}

MojoResult MojoWaitImpl(MojoHandle handle,
                        MojoHandleSignals signals,
                        MojoDeadline deadline,
                        MojoHandleSignalsState* signals_state) {
  return g_core->Wait(handle, signals, deadline, signals_state);
}

MojoResult MojoWaitManyImpl(const MojoHandle* handles,
                            const MojoHandleSignals* signals,
                            uint32_t num_handles,
                            MojoDeadline deadline,
                            uint32_t* result_index,
                            MojoHandleSignalsState* signals_states) {
  return g_core->WaitMany(handles, signals, num_handles, deadline, result_index,
                          signals_states);
}

MojoResult MojoWatchImpl(MojoHandle handle,
                         MojoHandleSignals signals,
                         MojoWatchCallback callback,
                         uintptr_t context) {
  return g_core->Watch(handle, signals, callback, context);
}

MojoResult MojoCancelWatchImpl(MojoHandle handle, uintptr_t context) {
  return g_core->CancelWatch(handle, context);
}

MojoResult MojoAllocMessageImpl(uint32_t num_bytes,
                                const MojoHandle* handles,
                                uint32_t num_handles,
                                MojoAllocMessageFlags flags,
                                MojoMessageHandle* message) {
  return g_core->AllocMessage(num_bytes, handles, num_handles, flags, message);
}

MojoResult MojoFreeMessageImpl(MojoMessageHandle message) {
  return g_core->FreeMessage(message);
}

MojoResult MojoGetMessageBufferImpl(MojoMessageHandle message, void** buffer) {
  return g_core->GetMessageBuffer(message, buffer);
}

MojoResult MojoCreateWaitSetImpl(MojoHandle* wait_set_handle) {
  return g_core->CreateWaitSet(wait_set_handle);
}

MojoResult MojoAddHandleImpl(MojoHandle wait_set_handle,
                             MojoHandle handle,
                             MojoHandleSignals signals) {
  return g_core->AddHandle(wait_set_handle, handle, signals);
}

MojoResult MojoRemoveHandleImpl(MojoHandle wait_set_handle, MojoHandle handle) {
  return g_core->RemoveHandle(wait_set_handle, handle);
}

MojoResult MojoGetReadyHandlesImpl(
    MojoHandle wait_set_handle,
    uint32_t* count,
    MojoHandle* handles,
    MojoResult* results,
    struct MojoHandleSignalsState* signals_states) {
  return g_core->GetReadyHandles(wait_set_handle, count, handles, results,
                                 signals_states);
}

MojoResult MojoCreateMessagePipeImpl(
    const MojoCreateMessagePipeOptions* options,
    MojoHandle* message_pipe_handle0,
    MojoHandle* message_pipe_handle1) {
  return g_core->CreateMessagePipe(options, message_pipe_handle0,
                                   message_pipe_handle1);
}

MojoResult MojoWriteMessageImpl(MojoHandle message_pipe_handle,
                                const void* bytes,
                                uint32_t num_bytes,
                                const MojoHandle* handles,
                                uint32_t num_handles,
                                MojoWriteMessageFlags flags) {
  return g_core->WriteMessage(message_pipe_handle, bytes, num_bytes, handles,
                              num_handles, flags);
}

MojoResult MojoWriteMessageNewImpl(MojoHandle message_pipe_handle,
                                   MojoMessageHandle message,
                                   MojoWriteMessageFlags flags) {
  return g_core->WriteMessageNew(message_pipe_handle, message, flags);
}

MojoResult MojoReadMessageImpl(MojoHandle message_pipe_handle,
                               void* bytes,
                               uint32_t* num_bytes,
                               MojoHandle* handles,
                               uint32_t* num_handles,
                               MojoReadMessageFlags flags) {
  return g_core->ReadMessage(
      message_pipe_handle, bytes, num_bytes, handles, num_handles, flags);
}

MojoResult MojoReadMessageNewImpl(MojoHandle message_pipe_handle,
                                  MojoMessageHandle* message,
                                  uint32_t* num_bytes,
                                  MojoHandle* handles,
                                  uint32_t* num_handles,
                                  MojoReadMessageFlags flags) {
  return g_core->ReadMessageNew(
      message_pipe_handle, message, num_bytes, handles, num_handles, flags);
}

MojoResult MojoFuseMessagePipesImpl(MojoHandle handle0, MojoHandle handle1) {
  return g_core->FuseMessagePipes(handle0, handle1);
}

MojoResult MojoCreateDataPipeImpl(const MojoCreateDataPipeOptions* options,
                                  MojoHandle* data_pipe_producer_handle,
                                  MojoHandle* data_pipe_consumer_handle) {
  return g_core->CreateDataPipe(options, data_pipe_producer_handle,
                                data_pipe_consumer_handle);
}

MojoResult MojoWriteDataImpl(MojoHandle data_pipe_producer_handle,
                             const void* elements,
                             uint32_t* num_elements,
                             MojoWriteDataFlags flags) {
  return g_core->WriteData(data_pipe_producer_handle, elements, num_elements,
                           flags);
}

MojoResult MojoBeginWriteDataImpl(MojoHandle data_pipe_producer_handle,
                                  void** buffer,
                                  uint32_t* buffer_num_elements,
                                  MojoWriteDataFlags flags) {
  return g_core->BeginWriteData(data_pipe_producer_handle, buffer,
                                buffer_num_elements, flags);
}

MojoResult MojoEndWriteDataImpl(MojoHandle data_pipe_producer_handle,
                                uint32_t num_elements_written) {
  return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written);
}

MojoResult MojoReadDataImpl(MojoHandle data_pipe_consumer_handle,
                            void* elements,
                            uint32_t* num_elements,
                            MojoReadDataFlags flags) {
  return g_core->ReadData(data_pipe_consumer_handle, elements, num_elements,
                          flags);
}

MojoResult MojoBeginReadDataImpl(MojoHandle data_pipe_consumer_handle,
                                 const void** buffer,
                                 uint32_t* buffer_num_elements,
                                 MojoReadDataFlags flags) {
  return g_core->BeginReadData(data_pipe_consumer_handle, buffer,
                               buffer_num_elements, flags);
}

MojoResult MojoEndReadDataImpl(MojoHandle data_pipe_consumer_handle,
                               uint32_t num_elements_read) {
  return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
}

MojoResult MojoCreateSharedBufferImpl(
    const struct MojoCreateSharedBufferOptions* options,
    uint64_t num_bytes,
    MojoHandle* shared_buffer_handle) {
  return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
}

MojoResult MojoDuplicateBufferHandleImpl(
    MojoHandle buffer_handle,
    const struct MojoDuplicateBufferHandleOptions* options,
    MojoHandle* new_buffer_handle) {
  return g_core->DuplicateBufferHandle(buffer_handle, options,
                                       new_buffer_handle);
}

MojoResult MojoMapBufferImpl(MojoHandle buffer_handle,
                             uint64_t offset,
                             uint64_t num_bytes,
                             void** buffer,
                             MojoMapBufferFlags flags) {
  return g_core->MapBuffer(buffer_handle, offset, num_bytes, buffer, flags);
}

MojoResult MojoUnmapBufferImpl(void* buffer) {
  return g_core->UnmapBuffer(buffer);
}

MojoResult MojoWrapPlatformHandleImpl(const MojoPlatformHandle* platform_handle,
                                      MojoHandle* mojo_handle) {
  return g_core->WrapPlatformHandle(platform_handle, mojo_handle);
}

MojoResult MojoUnwrapPlatformHandleImpl(MojoHandle mojo_handle,
                                        MojoPlatformHandle* platform_handle) {
  return g_core->UnwrapPlatformHandle(mojo_handle, platform_handle);
}

MojoResult MojoWrapPlatformSharedBufferHandleImpl(
    const MojoPlatformHandle* platform_handle,
    size_t num_bytes,
    MojoPlatformSharedBufferHandleFlags flags,
    MojoHandle* mojo_handle) {
  return g_core->WrapPlatformSharedBufferHandle(platform_handle, num_bytes,
                                                flags, mojo_handle);
}

MojoResult MojoUnwrapPlatformSharedBufferHandleImpl(
    MojoHandle mojo_handle,
    MojoPlatformHandle* platform_handle,
    size_t* num_bytes,
    MojoPlatformSharedBufferHandleFlags* flags) {
  return g_core->UnwrapPlatformSharedBufferHandle(mojo_handle, platform_handle,
                                                  num_bytes, flags);
}

}  // extern "C"

namespace mojo {
namespace edk {

MojoSystemThunks MakeSystemThunks() {
  MojoSystemThunks system_thunks = {sizeof(MojoSystemThunks),
                                    MojoGetTimeTicksNowImpl,
                                    MojoCloseImpl,
                                    MojoWaitImpl,
                                    MojoWaitManyImpl,
                                    MojoCreateMessagePipeImpl,
                                    MojoWriteMessageImpl,
                                    MojoReadMessageImpl,
                                    MojoCreateDataPipeImpl,
                                    MojoWriteDataImpl,
                                    MojoBeginWriteDataImpl,
                                    MojoEndWriteDataImpl,
                                    MojoReadDataImpl,
                                    MojoBeginReadDataImpl,
                                    MojoEndReadDataImpl,
                                    MojoCreateSharedBufferImpl,
                                    MojoDuplicateBufferHandleImpl,
                                    MojoMapBufferImpl,
                                    MojoUnmapBufferImpl,
                                    MojoCreateWaitSetImpl,
                                    MojoAddHandleImpl,
                                    MojoRemoveHandleImpl,
                                    MojoGetReadyHandlesImpl,
                                    MojoWatchImpl,
                                    MojoCancelWatchImpl,
                                    MojoFuseMessagePipesImpl,
                                    MojoWriteMessageNewImpl,
                                    MojoReadMessageNewImpl,
                                    MojoAllocMessageImpl,
                                    MojoFreeMessageImpl,
                                    MojoGetMessageBufferImpl,
                                    MojoWrapPlatformHandleImpl,
                                    MojoUnwrapPlatformHandleImpl,
                                    MojoWrapPlatformSharedBufferHandleImpl,
                                    MojoUnwrapPlatformSharedBufferHandleImpl};
  return system_thunks;
}

}  // namespace edk
}  // namespace mojo