Mojo: Armed Watchers

mojo/public/c/system/thunks.h

 // 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.
 
 // Note: This header should be compilable as C.
 
 #ifndef MOJO_PUBLIC_C_SYSTEM_THUNKS_H_
 #define MOJO_PUBLIC_C_SYSTEM_THUNKS_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "mojo/public/c/system/core.h"
 #include "mojo/public/c/system/system_export.h"
 
-// The embedder needs to bind the basic Mojo Core functions of a DSO to those of
-// the embedder when loading a DSO that is dependent on mojo_system.
-// The typical usage would look like:
-// base::ScopedNativeLibrary app_library(
-//     base::LoadNativeLibrary(app_path_, &error));
-// typedef MojoResult (*MojoSetSystemThunksFn)(MojoSystemThunks*);
-// MojoSetSystemThunksFn mojo_set_system_thunks_fn =
-//     reinterpret_cast<MojoSetSystemThunksFn>(app_library.GetFunctionPointer(
-//         "MojoSetSystemThunks"));
-// MojoSystemThunks system_thunks = MojoMakeSystemThunks();
-// size_t expected_size = mojo_set_system_thunks_fn(&system_thunks);
-// if (expected_size > sizeof(MojoSystemThunks)) {
-//   LOG(ERROR)
-//       << "Invalid DSO. Expected MojoSystemThunks size: "
-//       << expected_size;
-//   break;
-// }
-
-// Structure used to bind the basic Mojo Core functions of a DSO to those of
-// the embedder.
-// This is the ABI between the embedder and the DSO. It can only have new
-// functions added to the end. No other changes are supported.
+// Structure used to bind the basic Mojo Core functions to an embedder
+// implementation. This is intended to eventually be used as a stable ABI
+// between a Mojo embedder and some loaded application code, but for now it is
+// still effectively safe to rearrange entries as needed.
 #pragma pack(push, 8)
 struct MojoSystemThunks {
   size_t size;  // Should be set to sizeof(MojoSystemThunks).
   MojoTimeTicks (*GetTimeTicksNow)();
   MojoResult (*Close)(MojoHandle handle);
   MojoResult (*Wait)(MojoHandle handle,
                      MojoHandleSignals signals,
                      MojoDeadline deadline,
                      struct MojoHandleSignalsState* signals_state);
   MojoResult (*WaitMany)(const MojoHandle* handles,
@@ skipping 60 matching lines @@
   MojoResult (*AddHandle)(MojoHandle wait_set,
                           MojoHandle handle,
                           MojoHandleSignals signals);
   MojoResult (*RemoveHandle)(MojoHandle wait_set,
                              MojoHandle handle);
   MojoResult (*GetReadyHandles)(MojoHandle wait_set,
                                 uint32_t* count,
                                 MojoHandle* handles,
                                 MojoResult* results,
                                 struct MojoHandleSignalsState* signals_states);
-  MojoResult (*Watch)(MojoHandle handle,
-                      MojoHandleSignals signals,
-                      MojoWatchCallback callback,
-                      uintptr_t context);
-  MojoResult (*CancelWatch)(MojoHandle handle, uintptr_t context);
+  MojoResult (*RegisterWatcher)(MojoHandle handle,
+                                MojoHandleSignals signals,
+                                MojoWatchCallback callback,
+                                uintptr_t context);
+  MojoResult (*ArmWatcher)(MojoHandle handle, uintptr_t context);
+  MojoResult (*UnregisterWatcher)(MojoHandle handle, uintptr_t context);
   MojoResult (*FuseMessagePipes)(MojoHandle handle0, MojoHandle handle1);
   MojoResult (*WriteMessageNew)(MojoHandle message_pipe_handle,
                                 MojoMessageHandle message,
                                 MojoWriteMessageFlags flags);
   MojoResult (*ReadMessageNew)(MojoHandle message_pipe_handle,
                                MojoMessageHandle* message,
                                uint32_t* num_bytes,
                                MojoHandle* handles,
                                uint32_t* num_handles,
                                MojoReadMessageFlags flags);
@@ skipping 36 matching lines @@
 // The contents of |system_thunks| are copied.
 typedef size_t (*MojoSetSystemThunksFn)(
     const struct MojoSystemThunks* system_thunks);
 
 // A function for setting up the embedder's own system thunks. This should only
 // be called by Mojo embedder code.
 MOJO_SYSTEM_EXPORT size_t MojoEmbedderSetSystemThunks(
     const struct MojoSystemThunks* system_thunks);
 
 #endif  // MOJO_PUBLIC_C_SYSTEM_THUNKS_H_