Rationalize AddAwakable...() and RemoveAwakable...() methods.

mojo/edk/system/wait_set_dispatcher.cc

 // Copyright 2016 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/wait_set_dispatcher.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "mojo/edk/system/configuration.h"
@@ skipping 106 matching lines @@
   // invasive changes in many other places. We really count on |Dispatcher| not
   // doing anything interesting after calling |CloseImplNoLock()|, and since
   // |CloseImplNoLock()| is allowed to do nothing all the lock invariants are
   // satisfied.
   DCHECK(is_closed_no_lock());
   mutex().Unlock();
 
   for (auto& p : entries) {
     const auto& entry = p.second;
     if (entry->dispatcher)
-      entry->dispatcher->RemoveAwakableWithContext(this, entry->cookie,
-                                                   nullptr);
+      entry->dispatcher->RemoveAwakable(true, this, entry->cookie, nullptr);
   }
 
   // The caller of |CloseImplNoLock()| expects |mutex()| to be locked, so we
   // have to re-lock it (even though it really should do nothing afterwards).
   mutex().Lock();
 }
 
 RefPtr<Dispatcher>
 WaitSetDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock(
     MessagePipe* /*message_pipe*/,
@@ skipping 24 matching lines @@
     if (entries_.size() >= GetConfiguration().max_wait_set_num_entries)
       return MOJO_RESULT_RESOURCE_EXHAUSTED;
     // Note: We'll have to set the entry's dispatcher later.
     entry = new Entry(signals, cookie);
     entries_[cookie] = std::unique_ptr<Entry>(entry);
 
     is_busy_ = true;
   }
 
   HandleSignalsState signals_state;
-  MojoResult result = dispatcher->AddAwakableUnconditional(
-      this, signals, cookie, &signals_state);
+  MojoResult result =
+      dispatcher->AddAwakable(this, cookie, true, signals, &signals_state);
 
   // Can't use |MutexLocker|, since we need to do some work outside the lock
   // in some code paths.
   mutex().Lock();
   DCHECK(is_busy_);
   is_busy_ = false;
 
   // Note: We may have been closed while |mutex()| was unlocked, so we have to
   // check again!
   if (is_closed_no_lock()) {
     // Warning: In this case, |entry| has been invalidated, since it was owned
     // by |entries_|.
     DCHECK(entries_.empty());
     mutex().Unlock();
     if (result == MOJO_RESULT_OK || result == MOJO_RESULT_ALREADY_EXISTS) {
       // We have to remove ourself from the target dispatcher's awakable list.
-      dispatcher->RemoveAwakableWithContext(this, cookie, nullptr);
+      dispatcher->RemoveAwakable(true, this, cookie, nullptr);
     }
     return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
   DCHECK(entries_.find(cookie) != entries_.end());
   DCHECK_EQ(entries_[cookie].get(), entry);
 
   if (result == MOJO_RESULT_ALREADY_EXISTS) {
     // It was added, but the wait condition is already satisfied.
     AddPossiblyTriggeredNoLock(entry, Entry::TriggerState::POSSIBLY_SATISFIED);
@@ skipping 34 matching lines @@
     dispatcher = std::move(entry->dispatcher);
 
     if (entry->trigger_state != Entry::TriggerState::NOT_TRIGGERED)
       RemovePossiblyTriggeredNoLock(entry);
 
     // Note: This invalidates |entry|.
     entries_.erase(it);
   }
 
   if (dispatcher)
-    dispatcher->RemoveAwakableWithContext(this, cookie, nullptr);
+    dispatcher->RemoveAwakable(true, this, cookie, nullptr);
   return MOJO_RESULT_OK;
 }
 
 MojoResult WaitSetDispatcher::WaitSetWaitImpl(
     MojoDeadline deadline,
     UserPointer<uint32_t> num_results,
     UserPointer<MojoWaitSetResult> results,
     UserPointer<uint32_t> max_results) {
   MutexLocker locker(&mutex());
   if (is_closed_no_lock())
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   // TODO(vtl)
   NOTIMPLEMENTED();
   return MOJO_RESULT_UNIMPLEMENTED;
 }
 
 bool WaitSetDispatcher::Awake(uint64_t context,
                               AwakeReason reason,
                               const HandleSignalsState& signals_state) {
   MutexLocker locker(&mutex());
 
   if (is_closed_no_lock()) {
     // See |CloseImplNoLock()|: This case may occur while we're unlocked in
     // |CloseImplNoLock()| (after that, we will have been removed from all the
     // awakable lists, so |Awake()| should no longer be called). We may as well
     // return false here, which will automatically remove ourselves from the
-    // awakable list (|CloseImplNoLock()| will call
-    // |RemoveAwakableWithContext()| anyway, but that's OK).
+    // awakable list (|CloseImplNoLock()| will call |RemoveAwakable()| anyway,
+    // but that's OK).
     return false;
   }
 
   auto it = entries_.find(context);
   DCHECK(it != entries_.end());
   const auto& entry = it->second;
   switch (reason) {
     case AwakeReason::SATISFIED:
       if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
         AddPossiblyTriggeredNoLock(entry.get(),
@@ skipping 81 matching lines @@
     entry->possibly_triggered_next->possibly_triggered_previous =
         entry->possibly_triggered_previous;
   }
 
   entry->possibly_triggered_previous = nullptr;
   entry->possibly_triggered_next = nullptr;
 }
 
 }  // namespace system
 }  // namespace mojo