EDK: wait sets: Implement WaitSetDispatcher::WaitSet{AddRemove}Impl().

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 94 matching lines @@
 
 MojoResult Dispatcher::Close() {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   CloseNoLock();
   return MOJO_RESULT_OK;
 }
 
-MojoResult Dispatcher::DuplicateDispatcher(
-    util::RefPtr<Dispatcher>* new_dispatcher) {
+MojoResult Dispatcher::DuplicateDispatcher(RefPtr<Dispatcher>* new_dispatcher) {
   MutexLocker locker(&mutex_);
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return DuplicateDispatcherImplNoLock(new_dispatcher);
 }
 
 MojoResult Dispatcher::WriteMessage(UserPointer<const void> bytes,
                                     uint32_t num_bytes,
                                     std::vector<HandleTransport>* transports,
@@ skipping 147 matching lines @@
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return MapBufferImplNoLock(offset, num_bytes, flags, mapping);
 }
 
 // Note: The following three wait set methods don't lock |mutex_|, and leave
 // everything for |WaitSet...Impl()| to do. (We could just make these methods
 // virtual, but we prefer to have a separate "impl" methods for consistency.)
 MojoResult Dispatcher::WaitSetAdd(
     UserPointer<const MojoWaitSetAddOptions> options,
-    Handle&& handle,
+    RefPtr<Dispatcher>&& dispatcher,
     MojoHandleSignals signals,
     uint64_t cookie) {
-  return WaitSetAddImpl(options, std::move(handle), signals, cookie);
+  return WaitSetAddImpl(options, std::move(dispatcher), signals, cookie);
 }
 
 MojoResult Dispatcher::WaitSetRemove(uint64_t cookie) {
   return WaitSetRemoveImpl(cookie);
 }
 
 MojoResult Dispatcher::WaitSetWait(MojoDeadline deadline,
                                    UserPointer<uint32_t> num_results,
                                    UserPointer<MojoWaitSetResult> results,
                                    UserPointer<uint32_t> max_results) {
@@ skipping 78 matching lines @@
 }
 
 void Dispatcher::CloseImplNoLock() {
   mutex_.AssertHeld();
   DCHECK(is_closed_);
   // This may not need to do anything. Dispatchers should override this to do
   // any actual close-time cleanup necessary.
 }
 
 MojoResult Dispatcher::DuplicateDispatcherImplNoLock(
-    util::RefPtr<Dispatcher>* new_dispatcher) {
+    RefPtr<Dispatcher>* new_dispatcher) {
   mutex_.AssertHeld();
   DCHECK(!is_closed_);
   // By default, this is not supported. However, this should only be reachable
   // if a handle has the |MOJO_HANDLE_RIGHT_DUPLICATE| right, which it should
   // only have if it is supported.
   NOTREACHED();
   return MOJO_RESULT_INTERNAL;
 }
 
 MojoResult Dispatcher::WriteMessageImplNoLock(
@@ skipping 134 matching lines @@
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 // Note that the following three methods are *not* called under |mutex_| and
 // |is_closed_| hasn't been checked. However, since we'll return
 // |MOJO_RESULT_INVALID_ARGUMENT| regardless of the value of |is_closed_| (these
 // methods are only needed for wait set dispatchers), we don't need to lock
 // |mutex_| and check |is_closed_|.
 MojoResult Dispatcher::WaitSetAddImpl(
     UserPointer<const MojoWaitSetAddOptions> /*options*/,
-    Handle&& /*handle*/,
+    RefPtr<Dispatcher>&& /*dispatcher*/,
     MojoHandleSignals /*signals*/,
     uint64_t /*cookie*/) {
   // See note above.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
 
 MojoResult Dispatcher::WaitSetRemoveImpl(uint64_t /*cookie*/) {
   // See note above |WaitSetAddImpl()|.
   return MOJO_RESULT_INVALID_ARGUMENT;
 }
@@ skipping 124 matching lines @@
   // want to remove or weaken).
   MutexLocker locker(&mutex_);
 #endif
 
   return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
                                         platform_handles);
 }
 
 }  // namespace system
 }  // namespace mojo