Revert of Mojo: Eliminate duplicate C API symbols

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() {
+MojoTimeTicks MojoGetTimeTicksNow() {
   return g_core->GetTimeTicksNow();
 }
 
-MojoResult MojoCloseImpl(MojoHandle handle) {
+MojoResult MojoClose(MojoHandle handle) {
   return g_core->Close(handle);
 }
 
-MojoResult MojoWaitImpl(MojoHandle handle,
-                        MojoHandleSignals signals,
-                        MojoDeadline deadline,
-                        MojoHandleSignalsState* signals_state) {
+MojoResult MojoWait(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) {
+MojoResult MojoWaitMany(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) {
+MojoResult MojoWatch(MojoHandle handle,
+                     MojoHandleSignals signals,
+                     MojoWatchCallback callback,
+                     uintptr_t context) {
   return g_core->Watch(handle, signals, callback, context);
 }
 
-MojoResult MojoCancelWatchImpl(MojoHandle handle, uintptr_t context) {
+MojoResult MojoCancelWatch(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) {
+MojoResult MojoAllocMessage(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) {
+MojoResult MojoFreeMessage(MojoMessageHandle message) {
   return g_core->FreeMessage(message);
 }
 
-MojoResult MojoGetMessageBufferImpl(MojoMessageHandle message, void** buffer) {
+MojoResult MojoGetMessageBuffer(MojoMessageHandle message, void** buffer) {
   return g_core->GetMessageBuffer(message, buffer);
 }
 
-MojoResult MojoCreateWaitSetImpl(MojoHandle* wait_set_handle) {
+MojoResult MojoCreateWaitSet(MojoHandle* wait_set_handle) {
   return g_core->CreateWaitSet(wait_set_handle);
 }
 
-MojoResult MojoAddHandleImpl(MojoHandle wait_set_handle,
-                             MojoHandle handle,
-                             MojoHandleSignals signals) {
+MojoResult MojoAddHandle(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) {
+MojoResult MojoRemoveHandle(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) {
+MojoResult MojoGetReadyHandles(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) {
+MojoResult MojoCreateMessagePipe(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) {
+MojoResult MojoWriteMessage(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) {
+MojoResult MojoWriteMessageNew(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) {
+MojoResult MojoReadMessage(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) {
+MojoResult MojoReadMessageNew(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) {
+MojoResult MojoFuseMessagePipes(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) {
+MojoResult MojoCreateDataPipe(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) {
+MojoResult MojoWriteData(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) {
+MojoResult MojoBeginWriteData(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) {
+MojoResult MojoEndWriteData(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) {
+MojoResult MojoReadData(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) {
+MojoResult MojoBeginReadData(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) {
+MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
+                           uint32_t num_elements_read) {
   return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
 }
 
-MojoResult MojoCreateSharedBufferImpl(
+MojoResult MojoCreateSharedBuffer(
     const struct MojoCreateSharedBufferOptions* options,
     uint64_t num_bytes,
     MojoHandle* shared_buffer_handle) {
   return g_core->CreateSharedBuffer(options, num_bytes, shared_buffer_handle);
 }
 
-MojoResult MojoDuplicateBufferHandleImpl(
+MojoResult MojoDuplicateBufferHandle(
     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) {
+MojoResult MojoMapBuffer(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) {
+MojoResult MojoUnmapBuffer(void* buffer) {
   return g_core->UnmapBuffer(buffer);
 }
 
-MojoResult MojoWrapPlatformHandleImpl(const MojoPlatformHandle* platform_handle,
-                                      MojoHandle* mojo_handle) {
+MojoResult MojoWrapPlatformHandle(const MojoPlatformHandle* platform_handle,
+                                  MojoHandle* mojo_handle) {
   return g_core->WrapPlatformHandle(platform_handle, mojo_handle);
 }
 
-MojoResult MojoUnwrapPlatformHandleImpl(MojoHandle mojo_handle,
-                                        MojoPlatformHandle* platform_handle) {
+MojoResult MojoUnwrapPlatformHandle(MojoHandle mojo_handle,
+                                    MojoPlatformHandle* platform_handle) {
   return g_core->UnwrapPlatformHandle(mojo_handle, platform_handle);
 }
 
-MojoResult MojoWrapPlatformSharedBufferHandleImpl(
+MojoResult MojoWrapPlatformSharedBufferHandle(
     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(
+MojoResult MojoUnwrapPlatformSharedBufferHandle(
     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