Add Dispatcher methods for wait sets.

mojo/edk/system/dispatcher.cc

 // 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.
 
 #include "mojo/edk/system/dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
@@ skipping 73 matching lines @@
       return nullptr;
     case Type::MESSAGE_PIPE:
       return MessagePipeDispatcher::Deserialize(channel, source, size);
     case Type::DATA_PIPE_PRODUCER:
       return DataPipeProducerDispatcher::Deserialize(channel, source, size);
     case Type::DATA_PIPE_CONSUMER:
       return DataPipeConsumerDispatcher::Deserialize(channel, source, size);
     case Type::SHARED_BUFFER:
       return SharedBufferDispatcher::Deserialize(channel, source, size,
                                                  platform_handles);
+    case Type::WAIT_SET:
+      // Wait sets aren't transferrable.
+      LOG(WARNING) << "Received wait set handle";
+      return nullptr;
     case Type::PLATFORM_HANDLE:
       return PlatformHandleDispatcher::Deserialize(channel, source, size,
                                                    platform_handles);
   }
   LOG(WARNING) << "Unknown dispatcher type " << type;
   return nullptr;
 }
 
 MojoResult Dispatcher::Close() {
   MutexLocker locker(&mutex_);
@@ skipping 161 matching lines @@
     uint64_t num_bytes,
     MojoMapBufferFlags flags,
     std::unique_ptr<PlatformSharedBufferMapping>* mapping) {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return MapBufferImplNoLock(offset, num_bytes, flags, mapping);
 }
 
+MojoResult Dispatcher::WaitSetAdd(
+    UserPointer<const MojoWaitSetAddOptions> options,
+    Handle&& handle,
+    MojoHandleSignals signals,
+    uint64_t cookie) {
+  MutexLocker locker(&mutex_);
+  if (is_closed_)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return WaitSetAddImplNoLock(options, std::move(handle), signals, cookie);
+}
+
+MojoResult Dispatcher::WaitSetRemove(uint64_t cookie) {
+  MutexLocker locker(&mutex_);
+  if (is_closed_)
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return WaitSetRemoveImplNoLock(cookie);
+}
+
+MojoResult Dispatcher::WaitSetWait(MojoDeadline deadline,
+                                   UserPointer<uint32_t> num_results,
+                                   UserPointer<MojoWaitSetResult> results,
+                                   UserPointer<uint32_t> max_results) {
+  // Note: This doesn't lock |mutex_|, and leaves everything for
+  // |WaitSetWaitImpl()| to do. (We could just make this method virtual, but we
+  // prefer to have a separate "impl" method for consistency.)
+  return WaitSetWaitImpl(deadline, num_results, results, max_results);
+}
+
 HandleSignalsState Dispatcher::GetHandleSignalsState() const {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return HandleSignalsState();
 
   return GetHandleSignalsStateImplNoLock();
 }
 
 MojoResult Dispatcher::AddAwakable(Awakable* awakable,
                                    MojoHandleSignals signals,
@@ skipping 73 matching lines @@
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, not supported. Only needed for message pipe dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::SetDataPipeProducerOptionsImplNoLock(
     UserPointer<const MojoDataPipeProducerOptions> /*options*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
+  // By default, not supported. Only needed for data pipe producer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::GetDataPipeProducerOptionsImplNoLock(
     UserPointer<MojoDataPipeProducerOptions> /*options*/,
     uint32_t /*options_num_bytes*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
+  // By default, not supported. Only needed for data pipe producer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::WriteDataImplNoLock(UserPointer<const void> /*elements*/,
                                            UserPointer<uint32_t> /*num_bytes*/,
                                            MojoWriteDataFlags /*flags*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
+  // By default, not supported. Only needed for data pipe producer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::BeginWriteDataImplNoLock(
     UserPointer<void*> /*buffer*/,
     UserPointer<uint32_t> /*buffer_num_bytes*/,
     MojoWriteDataFlags /*flags*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
+  // By default, not supported. Only needed for data pipe producer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::EndWriteDataImplNoLock(uint32_t /*num_bytes_written*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
+  // By default, not supported. Only needed for data pipe producer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
-MojoResult Dispatcher::ReadDataImplNoLock(UserPointer<void> /*elements*/,
-                                          UserPointer<uint32_t> /*num_bytes*/,
-                                          MojoReadDataFlags /*flags*/) {
-  mutex_.AssertHeld();
-  DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
-  return MOJO_RESULT_INVALID_ARGUMENT;
-}
-
 MojoResult Dispatcher::SetDataPipeConsumerOptionsImplNoLock(
     UserPointer<const MojoDataPipeConsumerOptions> /*options*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
+  // By default, not supported. Only needed for data pipe consumer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::GetDataPipeConsumerOptionsImplNoLock(
     UserPointer<MojoDataPipeConsumerOptions> /*options*/,
     uint32_t /*options_num_bytes*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
+  // By default, not supported. Only needed for data pipe consumer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
+MojoResult Dispatcher::ReadDataImplNoLock(UserPointer<void> /*elements*/,
+                                          UserPointer<uint32_t> /*num_bytes*/,
+                                          MojoReadDataFlags /*flags*/) {
+  mutex_.AssertHeld();
+  DCHECK(!is_closed_);
+  // By default, not supported. Only needed for data pipe consumer dispatchers.
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
 MojoResult Dispatcher::BeginReadDataImplNoLock(
     UserPointer<const void*> /*buffer*/,
     UserPointer<uint32_t> /*buffer_num_bytes*/,
     MojoReadDataFlags /*flags*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
+  // By default, not supported. Only needed for data pipe consumer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
-  // By default, not supported. Only needed for data pipe dispatchers.
+  // By default, not supported. Only needed for data pipe consumer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::DuplicateBufferHandleImplNoLock(
     UserPointer<const MojoDuplicateBufferHandleOptions> /*options*/,
     RefPtr<Dispatcher>* /*new_dispatcher*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, not supported. Only needed for buffer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
@@ skipping 12 matching lines @@
     uint64_t /*offset*/,
     uint64_t /*num_bytes*/,
     MojoMapBufferFlags /*flags*/,
     std::unique_ptr<PlatformSharedBufferMapping>* /*mapping*/) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, not supported. Only needed for buffer dispatchers.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
+MojoResult Dispatcher::WaitSetAddImplNoLock(
+    UserPointer<const MojoWaitSetAddOptions> /*options*/,
+    Handle&& /*handle*/,
+    MojoHandleSignals /*signals*/,
+    uint64_t /*cookie*/) {
+  mutex_.AssertHeld();
+  DCHECK(!is_closed_);
+  // By default, not supported. Only needed for wait set dispatchers.
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
+MojoResult Dispatcher::WaitSetRemoveImplNoLock(uint64_t /*cookie*/) {
+  mutex_.AssertHeld();
+  DCHECK(!is_closed_);
+  // By default, not supported. Only needed for wait set dispatchers.
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
+MojoResult Dispatcher::WaitSetWaitImpl(
+    MojoDeadline /*deadline*/,
+    UserPointer<uint32_t> /*num_results*/,
+    UserPointer<MojoWaitSetResult> /*results*/,
+    UserPointer<uint32_t> /*max_results*/) {
+  // Note that this is *not* called under |mutex_| and |is_closed_| hasn't been
+  // checked. But since we'll return |MOJO_RESULT_INVALID_ARGUMENT| in either
+  // case (by default, this is not supported: it's only needed for wait set
+  // dispatchers), we don't need to lock |mutex_| and check |is_closed_|.
+  return MOJO_RESULT_INVALID_ARGUMENT;
+}
+
 HandleSignalsState Dispatcher::GetHandleSignalsStateImplNoLock() const {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, waiting isn't supported. Only dispatchers that can be waited on
   // will do something nontrivial.
   return HandleSignalsState();
 }
 
 MojoResult Dispatcher::AddAwakableImplNoLock(
     Awakable* /*awakable*/,
@@ skipping 91 matching lines @@
   // want to remove or weaken).
   MutexLocker locker(&mutex_);
 #endif
 
   return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
                                         platform_handles);
 }
 
 }  // namespace system
 }  // namespace mojo