Plumb the handle signals state out of Waiter::Wait().

mojo/edk/system/waiter.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/waiter.h"
 
 #include "base/logging.h"
 #include "mojo/edk/platform/time_ticks.h"
 
 using mojo::platform::GetTimeTicks;
 using mojo::util::MutexLocker;
 
 namespace mojo {
 namespace system {
 
 Waiter::Waiter()
     :
 #ifndef NDEBUG
       initialized_(false),
 #endif
       awoken_(false),
-      awake_result_(MOJO_RESULT_INTERNAL),
+      awake_reason_(AwakeReason::CANCELLED),
       awake_context_(static_cast<uint64_t>(-1)) {
 }
 
 Waiter::~Waiter() {}
 
 void Waiter::Init() {
 #ifndef NDEBUG
   initialized_ = true;
 #endif
   awoken_ = false;
-  // NOTE(vtl): If performance ever becomes an issue, we can disable the setting
-  // of |awake_result_| (except the first one in |Awake()|) in Release builds.

[vardhan, 2016/06/21 07:49:01]

weird

-  awake_result_ = MOJO_RESULT_INTERNAL;
 }
 
 // TODO(vtl): Fast-path the |deadline == 0| case?
-MojoResult Waiter::Wait(MojoDeadline deadline, uint64_t* context) {
+MojoResult Waiter::Wait(MojoDeadline deadline,
+                        uint64_t* context,
+                        HandleSignalsState* signals_state) {
   MutexLocker locker(&mutex_);
 
 #ifndef NDEBUG
   DCHECK(initialized_);
   // It'll need to be re-initialized after this.
   initialized_ = false;
 #endif
 
   // Fast-path the already-awoken case:
   if (awoken_) {
-    DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
     if (context)
       *context = awake_context_;
-    return awake_result_;
+    if (signals_state)
+      *signals_state = signals_state_;
+    return MojoResultForAwakeReason(awake_reason_);
   }
 
   if (deadline == MOJO_DEADLINE_INDEFINITE) {
     do {
       cv_.Wait(&mutex_);
     } while (!awoken_);
   } else {
     // We may get spurious wakeups, so record the start time and track the
     // remaining timeout.
     uint64_t wait_remaining = deadline;
@@ skipping 14 matching lines @@
       uint64_t elapsed = static_cast<uint64_t>(now - start);
       // It's possible that the deadline has passed anyway.
       if (elapsed >= deadline)
         return MOJO_RESULT_DEADLINE_EXCEEDED;
 
       // Otherwise, recalculate the amount that we have left to wait.
       wait_remaining = deadline - elapsed;
     }
   }
 
-  DCHECK_NE(awake_result_, MOJO_RESULT_INTERNAL);
   if (context)
     *context = awake_context_;
-  return awake_result_;
+  if (signals_state)
+    *signals_state = signals_state_;
+  return MojoResultForAwakeReason(awake_reason_);
 }
 
 bool Waiter::Awake(uint64_t context,
                    AwakeReason reason,
                    const HandleSignalsState& signals_state) {
   MutexLocker locker(&mutex_);
 
   if (awoken_)
     return true;
 
   awoken_ = true;
-  awake_result_ = MojoResultForAwakeReason(reason);
+  awake_reason_ = reason;
+  signals_state_ = signals_state;
   awake_context_ = context;
   cv_.Signal();
   // |cv_.Wait()|/|cv_.WaitWithTimeout()| will return after |mutex_| is
   // released.
   return true;
 }
 
 }  // namespace system
 }  // namespace mojo