Add Dispatcher methods for wait sets.

mojo/edk/system/dispatcher.h

 // Copyright 2013 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_EDK_SYSTEM_DISPATCHER_H_
 #define MOJO_EDK_SYSTEM_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <ostream>
 #include <vector>
 
 #include "mojo/edk/platform/scoped_platform_handle.h"
 #include "mojo/edk/system/entrypoint_class.h"
 #include "mojo/edk/system/handle.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/util/mutex.h"
 #include "mojo/edk/util/ref_counted.h"
 #include "mojo/edk/util/ref_ptr.h"
 #include "mojo/edk/util/thread_annotations.h"
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
 #include "mojo/public/c/system/handle.h"
 #include "mojo/public/c/system/message_pipe.h"
 #include "mojo/public/c/system/result.h"
+#include "mojo/public/c/system/wait_set.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 
 namespace platform {
 class PlatformSharedBufferMapping;
 }
 
 namespace system {
 
@@ skipping 27 matching lines @@
  public:
   // Types of dispatchers. Note that these are not necessarily a one-to-one with
   // implementations of |Dispatcher|: multiple implementations may share the
   // same type.
   enum class Type {
     UNKNOWN = 0,
     MESSAGE_PIPE,
     DATA_PIPE_PRODUCER,
     DATA_PIPE_CONSUMER,
     SHARED_BUFFER,
+    WAIT_SET,
 
     // "Private" types (not exposed via the public interface):
     PLATFORM_HANDLE = -1
   };
 
   // Gets the type of the dispatcher; see |Type| above.
   virtual Type GetType() const = 0;
 
   // Gets whether the given entrypoint class is supported; see the definition of
   // |EntrypointClass|. This is ONLY called when a rights check has failed, to
@@ skipping 74 matching lines @@
       UserPointer<const MojoDuplicateBufferHandleOptions> options,
       util::RefPtr<Dispatcher>* new_dispatcher);
   MojoResult GetBufferInformation(UserPointer<MojoBufferInformation> info,
                                   uint32_t info_num_bytes);
   MojoResult MapBuffer(
       uint64_t offset,
       uint64_t num_bytes,
       MojoMapBufferFlags flags,
       std::unique_ptr<platform::PlatformSharedBufferMapping>* mapping);
 
+  // |EntrypointClass::WAIT_SET|:
+  MojoResult WaitSetAdd(UserPointer<const MojoWaitSetAddOptions> options,
+                        Handle&& handle,
+                        MojoHandleSignals signals,
+                        uint64_t cookie);
+  MojoResult WaitSetRemove(uint64_t cookie);
+  // Note: This will likely block the calling thread (so, e.g., no mutexes
+  // should be held when it's called).
+  MojoResult WaitSetWait(MojoDeadline deadline,
+                         UserPointer<uint32_t> num_results,
+                         UserPointer<MojoWaitSetResult> results,
+                         UserPointer<uint32_t> max_results);
+
   // Gets the current handle signals state. (The default implementation simply
   // returns a default-constructed |HandleSignalsState|, i.e., no signals
   // satisfied or satisfiable.) Note: The state is subject to change from other
   // threads.
   HandleSignalsState GetHandleSignalsState() const;
 
   // Adds an awakable to this dispatcher, which will be woken up when this
   // object changes state to satisfy |signals| with context |context|. It will
   // also be woken up when it becomes impossible for the object to ever satisfy
   // |signals| with a suitable error status.
@@ skipping 133 matching lines @@
   virtual MojoResult WriteDataImplNoLock(UserPointer<const void> elements,
                                          UserPointer<uint32_t> num_bytes,
                                          MojoWriteDataFlags flags)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult BeginWriteDataImplNoLock(
       UserPointer<void*> buffer,
       UserPointer<uint32_t> buffer_num_bytes,
       MojoWriteDataFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult EndWriteDataImplNoLock(uint32_t num_bytes_written)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
-  virtual MojoResult ReadDataImplNoLock(UserPointer<void> elements,
-                                        UserPointer<uint32_t> num_bytes,
-                                        MojoReadDataFlags flags)
-      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult SetDataPipeConsumerOptionsImplNoLock(
       UserPointer<const MojoDataPipeConsumerOptions> options)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult GetDataPipeConsumerOptionsImplNoLock(
       UserPointer<MojoDataPipeConsumerOptions> options,
       uint32_t options_num_bytes) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  virtual MojoResult ReadDataImplNoLock(UserPointer<void> elements,
+                                        UserPointer<uint32_t> num_bytes,
+                                        MojoReadDataFlags flags)
+      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult BeginReadDataImplNoLock(
       UserPointer<const void*> buffer,
       UserPointer<uint32_t> buffer_num_bytes,
       MojoReadDataFlags flags) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult EndReadDataImplNoLock(uint32_t num_bytes_read)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult DuplicateBufferHandleImplNoLock(
       UserPointer<const MojoDuplicateBufferHandleOptions> options,
       util::RefPtr<Dispatcher>* new_dispatcher)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult GetBufferInformationImplNoLock(
       UserPointer<MojoBufferInformation> info,
       uint32_t info_num_bytes) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual MojoResult MapBufferImplNoLock(
       uint64_t offset,
       uint64_t num_bytes,
       MojoMapBufferFlags flags,
       std::unique_ptr<platform::PlatformSharedBufferMapping>* mapping)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  virtual MojoResult WaitSetAddImplNoLock(
+      UserPointer<const MojoWaitSetAddOptions> options,
+      Handle&& handle,
+      MojoHandleSignals signals,
+      uint64_t cookie) MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  virtual MojoResult WaitSetRemoveImplNoLock(uint64_t cookie)
+      MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  // WARNING: Unlike the others, this method is *not* called under |mutex_| and
+  // |is_closed_| is *not* checked. Thus any override must lock |mutex()| and
+  // check |is_closed_no_lock()| (returning |MOJO_RESULT_INVALID_ARGUMENT| if it
+  // is true).
+  virtual MojoResult WaitSetWaitImpl(MojoDeadline deadline,
+                                     UserPointer<uint32_t> num_results,
+                                     UserPointer<MojoWaitSetResult> results,
+                                     UserPointer<uint32_t> max_results);
   virtual HandleSignalsState GetHandleSignalsStateImplNoLock() const
       MOJO_SHARED_LOCKS_REQUIRED(mutex_);
   virtual MojoResult AddAwakableImplNoLock(Awakable* awakable,
                                            MojoHandleSignals signals,
                                            uint64_t context,
                                            HandleSignalsState* signals_state)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
   virtual void RemoveAwakableImplNoLock(Awakable* awakable,
                                         HandleSignalsState* signals_state)
       MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
@@ skipping 18 matching lines @@
       MOJO_NOT_THREAD_SAFE;
   virtual bool EndSerializeAndCloseImplNoLock(
       Channel* channel,
       void* destination,
       size_t* actual_size,
       std::vector<platform::ScopedPlatformHandle>* platform_handles)
       MOJO_NOT_THREAD_SAFE;
 
   util::Mutex& mutex() const MOJO_LOCK_RETURNED(mutex_) { return mutex_; }
 
+  bool is_closed_no_lock() const MOJO_SHARED_LOCKS_REQUIRED(mutex_) {
+    return is_closed_;
+  }
+
  private:
   FRIEND_REF_COUNTED_THREAD_SAFE(Dispatcher);
   friend class HandleTransport;
 
   // Closes the dispatcher. This must be done under lock, and unlike |Close()|,
   // the dispatcher must not be closed already. (This is the "equivalent" of
   // |CreateEquivalentDispatcherAndCloseNoLock()|, for situations where the
   // dispatcher must be disposed of instead of "transferred".)
   void CloseNoLock() MOJO_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
 
@@ skipping 60 matching lines @@
 
 // So logging macros and |DCHECK_EQ()|, etc. work.
 inline std::ostream& operator<<(std::ostream& out, Dispatcher::Type type) {
   return out << static_cast<int>(type);
 }
 
 }  // namespace system
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_DISPATCHER_H_