src/mojo/public/system/core_private.h

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef MOJO_PUBLIC_SYSTEM_CORE_PRIVATE_H_
   6 #define MOJO_PUBLIC_SYSTEM_CORE_PRIVATE_H_
   7
   8 #include "mojo/public/system/core.h"
   9
  10 namespace mojo {
  11
  12 // Implementors of the core APIs can use this interface to install their
  13 // implementation into the mojo_system dynamic library. Mojo clients should not
  14 // call these functions directly.
  15 class MOJO_SYSTEM_EXPORT Core {
  16  public:
  17   virtual ~Core();
  18
  19   static void Init(Core* core);
  20   static Core* Get();
  21   static void Reset();
  22
  23   virtual MojoTimeTicks GetTimeTicksNow() = 0;
  24   virtual MojoResult Close(MojoHandle handle) = 0;
  25   virtual MojoResult Wait(MojoHandle handle,
  26                           MojoWaitFlags flags,
  27                           MojoDeadline deadline) = 0;
  28   virtual MojoResult WaitMany(const MojoHandle* handles,
  29                               const MojoWaitFlags* flags,
  30                               uint32_t num_handles,
  31                               MojoDeadline deadline) = 0;
  32   virtual MojoResult CreateMessagePipe(MojoHandle* message_pipe_handle0,
  33                                        MojoHandle* message_pipe_handle1) = 0;
  34   virtual MojoResult WriteMessage(MojoHandle message_pipe_handle,
  35                                   const void* bytes,
  36                                   uint32_t num_bytes,
  37                                   const MojoHandle* handles,
  38                                   uint32_t num_handles,
  39                                   MojoWriteMessageFlags flags) = 0;
  40   virtual MojoResult ReadMessage(MojoHandle message_pipe_handle,
  41                                  void* bytes,
  42                                  uint32_t* num_bytes,
  43                                  MojoHandle* handles,
  44                                  uint32_t* num_handles,
  45                                  MojoReadMessageFlags flags) = 0;
  46   virtual MojoResult CreateDataPipe(const MojoCreateDataPipeOptions* options,
  47                                     MojoHandle* data_pipe_producer_handle,
  48                                     MojoHandle* data_pipe_consumer_handle) = 0;
  49   virtual MojoResult WriteData(MojoHandle data_pipe_producer_handle,
  50                                const void* elements,
  51                                uint32_t* num_elements,
  52                                MojoWriteDataFlags flags) = 0;
  53   virtual MojoResult BeginWriteData(MojoHandle data_pipe_producer_handle,
  54                                     void** buffer,
  55                                     uint32_t* buffer_num_elements,
  56                                     MojoWriteDataFlags flags) = 0;
  57   virtual MojoResult EndWriteData(MojoHandle data_pipe_producer_handle,
  58                                   uint32_t num_elements_written) = 0;
  59   virtual MojoResult ReadData(MojoHandle data_pipe_consumer_handle,
  60                               void* elements,
  61                               uint32_t* num_elements,
  62                               MojoReadDataFlags flags) = 0;
  63   virtual MojoResult BeginReadData(MojoHandle data_pipe_consumer_handle,
  64                                    const void** buffer,
  65                                    uint32_t* buffer_num_elements,
  66                                    MojoReadDataFlags flags) = 0;
  67   virtual MojoResult EndReadData(MojoHandle data_pipe_consumer_handle,
  68                                  uint32_t num_elements_read) = 0;
  69   virtual MojoResult CreateSharedBuffer(
  70       const MojoCreateSharedBufferOptions* options,
  71       uint64_t* num_bytes,
  72       MojoHandle* shared_buffer_handle) = 0;
  73   virtual MojoResult DuplicateBufferHandle(
  74       MojoHandle buffer_handle,
  75       const MojoDuplicateBufferHandleOptions* options,
  76       MojoHandle* new_buffer_handle) = 0;
  77   virtual MojoResult MapBuffer(MojoHandle buffer_handle,
  78                                uint64_t offset,
  79                                uint64_t num_bytes,
  80                                void** buffer,
  81                                MojoMapBufferFlags flags) = 0;
  82   virtual MojoResult UnmapBuffer(void* buffer) = 0;
  83 };
  84
  85 }  // namespace mojo
  86
  87 #endif  // MOJO_PUBLIC_SYSTEM_CORE_PRIVATE_H_