Add different behavior to AwakableList for "persistent" vs "one-shot" awakables.

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 179 matching lines @@
       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);
+    AddPossiblyTriggeredNoLock(entry, Entry::TriggerState::SATISFIED);
   } else if (result == MOJO_RESULT_FAILED_PRECONDITION) {
-    // The condition is never-satisfiable. Leave a zombie entry (i.e., leave
-    // |dispatcher| null).
-    mutex().Unlock();
-    return MOJO_RESULT_OK;
+    AddPossiblyTriggeredNoLock(entry, Entry::TriggerState::UNSATISFIABLE);
   } else if (result != MOJO_RESULT_OK) {
     size_t num_erased = entries_.erase(cookie);
     DCHECK_EQ(num_erased, 1u);
     mutex().Unlock();
     return result;
   }
 
   // Update the entry to actually have the dispatcher.
   entry->dispatcher = std::move(dispatcher);
 
@@ skipping 37 matching lines @@
     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,
+void 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 |RemoveAwakable()| anyway,
-    // but that's OK).
-    return false;
+    // awakable lists, so |Awake()| should no longer be called).
+    return;
   }
 
   auto it = entries_.find(context);
   DCHECK(it != entries_.end());
   const auto& entry = it->second;
+  // We should only ever get at most one "closed" (cancelled).
+  DCHECK_NE(static_cast<int>(entry->trigger_state),
+            static_cast<int>(Entry::TriggerState::CLOSED));
   switch (reason) {
     case AwakeReason::SATISFIED:
-      if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
-        AddPossiblyTriggeredNoLock(entry.get(),
-                                   Entry::TriggerState::POSSIBLY_SATISFIED);
+    case AwakeReason::UNSATISFIABLE:
+      // We shouldn't see these since we're used as a persistent |Awakable|.
+      NOTREACHED();
+    // Fall through.
+    case AwakeReason::CHANGED:
+      if (signals_state.satisfies(entry->signals)) {
+        if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
+          AddPossiblyTriggeredNoLock(entry.get(),
+                                     Entry::TriggerState::SATISFIED);
+        } else {
+          entry->trigger_state = Entry::TriggerState::SATISFIED;
+        }
+      } else if (!signals_state.can_satisfy(entry->signals)) {
+        if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
+          AddPossiblyTriggeredNoLock(entry.get(),
+                                     Entry::TriggerState::UNSATISFIABLE);
+        } else {
+          entry->trigger_state = Entry::TriggerState::UNSATISFIABLE;
+        }
+      } else {
+        if (entry->trigger_state != Entry::TriggerState::NOT_TRIGGERED)
+          RemovePossiblyTriggeredNoLock(entry.get());
       }
-      return true;
-    case AwakeReason::UNSATISFIABLE:
-      // Never satisfiable.
-      if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
-        AddPossiblyTriggeredNoLock(entry.get(),
-                                   Entry::TriggerState::NEVER_SATISFIABLE);
-      } else {
-        if (entry->trigger_state == Entry::TriggerState::POSSIBLY_SATISFIED) {
-          entry->trigger_state = Entry::TriggerState::NEVER_SATISFIABLE;
-        } else {
-          // It's possible to get repeated "never satisfiable" triggers, but we
-          // shouldn't get anything after "closed".
-          DCHECK_NE(static_cast<int>(entry->trigger_state),
-                    static_cast<int>(Entry::TriggerState::CLOSED));
-        }
-      }
-      // Due to some action on some other thread, it may become satisfiable
-      // again, so continue to be awoken.
-      return true;
+      break;
     case AwakeReason::CANCELLED:
       if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
         AddPossiblyTriggeredNoLock(entry.get(), Entry::TriggerState::CLOSED);
       } else {
-        // We should only ever get at most one "closed".
-        DCHECK_NE(static_cast<int>(entry->trigger_state),
-                  static_cast<int>(Entry::TriggerState::CLOSED));
         entry->trigger_state = Entry::TriggerState::CLOSED;
       }
       entry->dispatcher = nullptr;
-      return false;
+      break;
   }
-  return false;
 }
 
 void WaitSetDispatcher::AddPossiblyTriggeredNoLock(
     Entry* entry,
     Entry::TriggerState new_trigger_state) {
   DCHECK_EQ(static_cast<int>(entry->trigger_state),
             static_cast<int>(Entry::TriggerState::NOT_TRIGGERED));
   DCHECK(!entry->possibly_triggered_previous);
   DCHECK(!entry->possibly_triggered_next);
   DCHECK_NE(static_cast<int>(new_trigger_state),
@@ skipping 37 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