Mojo: Armed Watchers

mojo/public/c/system/watcher.h

Index: mojo/public/c/system/watcher.h
diff --git a/mojo/public/c/system/watcher.h b/mojo/public/c/system/watcher.h
new file mode 100644
index 0000000000000000000000000000000000000000..f152c50a11cf91578d08a1bcd6649f8d0769410b
--- /dev/null
+++ b/mojo/public/c/system/watcher.h
@@ -0,0 +1,183 @@
+// Copyright 2017 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.
+
+#ifndef MOJO_PUBLIC_C_SYSTEM_WATCHER_H_
+#define MOJO_PUBLIC_C_SYSTEM_WATCHER_H_
+
+#include <stdint.h>
+
+#include "mojo/public/c/system/system_export.h"
+#include "mojo/public/c/system/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// A callback used to notify watchers about events on their watched handles.
+//
+// See documentation for |MojoWatcherNotificationFlags| for details regarding
+// the possible values of |flags|.
+//
+// See documentation for |MojoWatch()| for details regarding the other arguments
+// this callback receives when called.
+typedef void (*MojoWatcherCallback)(uintptr_t context,
+                                    MojoResult result,
+                                    struct MojoHandleSignalsState signals_state,
+                                    MojoWatcherNotificationFlags flags);
+
+// Creates a new watcher.
+//
+// Watchers are used to trigger arbitrary code execution when one or more
+// handles change state to meet certain conditions.
+//
+// A newly registered watcher is initially disarmed and may be armed using
+// |MojoArmWatcher()|. A watcher is also always disarmed immediately before any
+// invocation of one or more notification callbacks in response to a single
+// handle's state changing in some relevant way.
+//
+// Parameters:
+//   |callback|: The |MojoWatcherCallback| to invoke any time the watcher is
+//       notified of an event. See |MojoWatch()| for details regarding arguments
+//       passed to the callback. Note that this may be called from any arbitrary
+//       thread.
+//   |watcher_handle|: The address at which to store the MojoHandle
+//       corresponding to the new watcher if successfully created.
+//
+// Returns:
+//   |MOJO_RESULT_OK| if the watcher has been successfully created.
+//   |MOJO_RESULT_RESOURCE_EXHAUSTED| if a handle could not be allocated for
+//       this watcher.
+MOJO_SYSTEM_EXPORT MojoResult MojoCreateWatcher(MojoWatcherCallback callback,
+                                                MojoHandle* watcher_handle);
+
+// Adds a watch to a watcher. This allows the watcher to fire notifications
+// regarding state changes on the handle corresponding to the arguments given.
+//
+// Note that notifications for a given watch context are guaranteed to be
+// mutually exclusive in execution: the callback will never be entered for a
+// given context while another invocation of the callback is still executing for
+// the same context. As a result it is generally a good idea to ensure that
+// callbacks do as little work as necessary in order to process the
+// notification.
+//
+// Parameters:
+//   |watcher_handle|: The watcher to which |handle| is to be added.
+//   |handle|: The handle to add to the watcher.
+//   |signals|: The signals to watch for on |handle|.
+//   |context|: An arbitrary context value given to any invocation of the
+//       watcher's callback when invoked as a result of some state change
+//       relevant to this combination of |handle| and |signals|. Must be
+//       unique within any given watcher.
+//
+// Callback parameters (see |MojoWatcherNotificationCallback| above):
+//   When the watcher invokes its callback as a result of some notification
+//   relevant to this watch operation, |context| receives the value given here
+//   and |signals_state| receives the last known signals state of this handle.
+//
+//   |result| is one of the following:
+//     |MOJO_RESULT_OK| if at least one of the watched signals is satisfied. The
+//         watcher must be armed for this notification to fire.
+//     |MOJO_RESULT_FAILED_PRECONDITION| if all of the watched signals are
+//         permanently unsatisfiable. The watcher must be armed for this
+//         notification to fire.
+//     |MOJO_RESULT_CANCELLED| if the watch has been cancelled. The may occur if
+//         the watcher has been closed, the watched handle has been closed, or
+//         the watch for |context| has been explicitly cancelled. This is always
+//         the last result received for any given context, and it is guaranteed
+//         to be received exactly once per watch, regardless of how the watch
+//         was cancelled.
+//
+// Returns:
+//   |MOJO_RESULT_OK| if the handle is now being watched by the watcher.
+//   |MOJO_RESULT_INVALID_ARGUMENT| if |watcher_handle| is not a watcher handle,
+//       |handle| is not a valid message pipe or data pipe handle.
+//   |MOJO_RESULT_ALREADY_EXISTS| if the watcher already has a watch registered
+//       for the given value of |context| or for the given |handle|.
+MOJO_SYSTEM_EXPORT MojoResult MojoWatch(MojoHandle watcher_handle,
+                                        MojoHandle handle,
+                                        MojoHandleSignals signals,
+                                        uintptr_t context);
+
+// Removes a watch from a watcher.
+//
+// This ensures that the watch is cancelled as soon as possible. Cancellation
+// may be deferred (or may even block) an aritrarily long time if the watch is
+// already dispatching one or more notifications.
+//
+// When cancellation is complete, the watcher's callback is invoked one final
+// time for |context|, with the result |MOJO_RESULT_CANCELLED|.
+//
+// The same behavior can be elicted by either closing the watched handle
+// associated with this context, or by closing |watcher_handle| itself. In the
+// lastter case, all registered contexts on the watcher are implicitly cancelled
+// in a similar fashion.
+//
+// Parameters:
+//   |watcher_handle|: The handle of the watcher from which to remove a watch.
+//   |context|: The context of the watch to be removed.
+//
+// Returns:
+//   |MOJO_RESULT_OK| if the watch has been cancelled.
+//   |MOJO_RESULT_INVALID_ARGUMENT| if |watcher_handle| is not a watcher handle.
+//   |MOJO_RESULT_NOT_FOUND| if there is no watch registered on this watcher for
+//       the given value of |context|.
+MOJO_SYSTEM_EXPORT MojoResult MojoCancelWatch(MojoHandle watcher_handle,
+                                              uintptr_t context);
+
+// Arms a watcher, enabling a single future event on one of the watched handles
+// to trigger a single notification for each relevant watch context associated
+// with that handle.
+//
+// Parameters:
+//   |watcher_handle|: The handle of the watcher.
+//   |num_ready_contexts|: An address pointing to the number of elements
+//       available for storage in the remaining output buffers. Optional and
+//       only used on failure. See |MOJO_RESULT_FAILED_PRECONDITION| below for
+//       more details.
+//   |ready_contexts|: An output buffer for contexts corresponding to the
+//       watches which would have notified if the watcher were armed. Optional
+//       and only uesd on failure. See |MOJO_RESULT_FAILED_PRECONDITION| below
+//       for more details.
+//   |ready_results|: An output buffer for MojoResult values corresponding to
+//       each context in |ready_contexts|. Optional and only used on failure.
+//       See |MOJO_RESULT_FAILED_PRECONDITION| below for more details.
+//   |ready_signals_states|: An output buffer for |MojoHandleSignalsState|
+//       structures corresponding to each context in |ready_contexts|. Optional
+//       and only used on failure. See |MOJO_RESULT_FAILED_PRECONDITION| below
+//       for more details.
+//
+// Returns:
+//   |MOJO_RESULT_OK| if the watcher has been successfully armed. All arguments
+//       other than |watcher_handle| are ignored in this case.
+//   |MOJO_RESULT_NOT_FOUND| if the watcher does not have any registered watch
+//       contexts. All arguments other than |watcher_handle| are ignored in this
+//       case.
+//   |MOJO_RESULT_INVALID_ARGUMENT| if |watcher_handle| is not a valid watcher
+//       handle, or if |num_ready_contexts| is non-null but any of the output
+//       buffer paramters is null.
+//   |MOJO_RESULT_FAILED_PRECONDITION| if one or more watches would have
+//       notified immediately upon arming the watcher. If |num_handles| is
+//       non-null, this assumes there is enough space for |*num_handles| entries
+//       in each of the subsequent output buffer arguments.
+//
+//       At most that many entries are placed in the output buffers,
+//       corresponding to the watches which would have signalled if the watcher
+//       had been armed successfully. The actual number of entries placed in the
+//       output buffers is written to |*num_ready_contexts| before returning.
+//
+//       If more than (input) |*num_ready_contexts| watch contexts were ready to
+//       notify, the subset presented in output buffers is arbitrary and
+//       implementation-defined.
+MOJO_SYSTEM_EXPORT MojoResult
+MojoArmWatcher(MojoHandle watcher_handle,
+               uint32_t* num_ready_contexts,
+               uintptr_t* ready_contexts,
+               MojoResult* ready_results,
+               struct MojoHandleSignalsState* ready_signals_states);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // MOJO_PUBLIC_C_SYSTEM_WATCHER_H_