Plumb the handle signals state to Awakable::Awake().

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 243 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(MojoResult result, uint64_t context) {
+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).
     return false;
   }
 
   auto it = entries_.find(context);
   DCHECK(it != entries_.end());
   const auto& entry = it->second;
-  switch (result) {
-    case MOJO_RESULT_OK:
+  switch (reason) {
+    case AwakeReason::SATISFIED:
       if (entry->trigger_state == Entry::TriggerState::NOT_TRIGGERED) {
         AddPossiblyTriggeredNoLock(entry.get(),
                                    Entry::TriggerState::POSSIBLY_SATISFIED);
       }
       return true;
-    case MOJO_RESULT_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;
-    case MOJO_RESULT_FAILED_PRECONDITION:
+    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;
-    default:
-      NOTREACHED();
-      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;
   }
   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);
@@ skipping 39 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