Mojo: Wrap the satisfied/unsatisfied wait flags state in a single object.

mojo/system/data_pipe.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/system/data_pipe.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 93 matching lines @@
   if (!consumer_open_no_lock())
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   // Returning "busy" takes priority over "invalid argument".
   if (*num_bytes % element_num_bytes_ != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  MojoWaitFlags old_consumer_satisfied_flags = ConsumerSatisfiedFlagsNoLock();
+  WaitFlagsState old_consumer_state = ConsumerGetWaitFlagsStateNoLock();
   MojoResult rv = ProducerWriteDataImplNoLock(elements, num_bytes, all_or_none);
-  if (ConsumerSatisfiedFlagsNoLock() != old_consumer_satisfied_flags)
+  WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  if (!new_consumer_state.equals(old_consumer_state))
     AwakeConsumerWaitersForStateChangeNoLock();
   return rv;
 }
 
 MojoResult DataPipe::ProducerBeginWriteData(void** buffer,
                                             uint32_t* buffer_num_bytes,
                                             bool all_or_none) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
@@ skipping 19 matching lines @@
 
 MojoResult DataPipe::ProducerEndWriteData(uint32_t num_bytes_written) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
   if (!producer_in_two_phase_write_no_lock())
     return MOJO_RESULT_FAILED_PRECONDITION;
   // Note: Allow successful completion of the two-phase write even if the
   // consumer has been closed.
 
-  MojoWaitFlags old_consumer_satisfied_flags = ConsumerSatisfiedFlagsNoLock();
+  WaitFlagsState old_consumer_state = ConsumerGetWaitFlagsStateNoLock();
   MojoResult rv;
   if (num_bytes_written > producer_two_phase_max_num_bytes_written_ ||
       num_bytes_written % element_num_bytes_ != 0) {
     rv = MOJO_RESULT_INVALID_ARGUMENT;
     producer_two_phase_max_num_bytes_written_ = 0;
   } else {
     rv = ProducerEndWriteDataImplNoLock(num_bytes_written);
   }
   // Two-phase write ended even on failure.
   DCHECK(!producer_in_two_phase_write_no_lock());
   // If we're now writable, we *became* writable (since we weren't writable
   // during the two-phase write), so awake producer waiters.
-  if ((ProducerSatisfiedFlagsNoLock() & MOJO_WAIT_FLAG_WRITABLE))
+  if (ProducerGetWaitFlagsStateNoLock().satisfies(MOJO_WAIT_FLAG_WRITABLE))
     AwakeProducerWaitersForStateChangeNoLock();
-  if (ConsumerSatisfiedFlagsNoLock() != old_consumer_satisfied_flags)
+  WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  if (!new_consumer_state.equals(old_consumer_state))
     AwakeConsumerWaitersForStateChangeNoLock();
   return rv;
 }
 
 MojoResult DataPipe::ProducerAddWaiter(Waiter* waiter,
                                        MojoWaitFlags flags,
                                        MojoResult wake_result) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
 
-  if ((flags & ProducerSatisfiedFlagsNoLock()))
+  WaitFlagsState producer_state = ProducerGetWaitFlagsStateNoLock();
+  if (producer_state.satisfies(flags))
     return MOJO_RESULT_ALREADY_EXISTS;
-  if (!(flags & ProducerSatisfiableFlagsNoLock()))
+  if (!producer_state.can_satisfy(flags))
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   producer_waiter_list_->AddWaiter(waiter, flags, wake_result);
   return MOJO_RESULT_OK;
 }
 
 void DataPipe::ProducerRemoveWaiter(Waiter* waiter) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_producer_no_lock());
   producer_waiter_list_->RemoveWaiter(waiter);
@@ skipping 32 matching lines @@
 
   if (consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_BUSY;
 
   if (*num_bytes % element_num_bytes_ != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  MojoWaitFlags old_producer_satisfied_flags = ProducerSatisfiedFlagsNoLock();
+  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
   MojoResult rv = ConsumerReadDataImplNoLock(elements, num_bytes, all_or_none);
-  if (ProducerSatisfiedFlagsNoLock() != old_producer_satisfied_flags)
+  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock();
   return rv;
 }
 
 MojoResult DataPipe::ConsumerDiscardData(uint32_t* num_bytes,
                                          bool all_or_none) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
   if (consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_BUSY;
 
   if (*num_bytes % element_num_bytes_ != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (*num_bytes == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
-  MojoWaitFlags old_producer_satisfied_flags = ProducerSatisfiedFlagsNoLock();
+  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
   MojoResult rv = ConsumerDiscardDataImplNoLock(num_bytes, all_or_none);
-  if (ProducerSatisfiedFlagsNoLock() != old_producer_satisfied_flags)
+  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock();
   return rv;
 }
 
 MojoResult DataPipe::ConsumerQueryData(uint32_t* num_bytes) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
   if (consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_BUSY;
@@ skipping 22 matching lines @@
   return MOJO_RESULT_OK;
 }
 
 MojoResult DataPipe::ConsumerEndReadData(uint32_t num_bytes_read) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
   if (!consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_FAILED_PRECONDITION;
 
-  MojoWaitFlags old_producer_satisfied_flags = ProducerSatisfiedFlagsNoLock();
+  WaitFlagsState old_producer_state = ProducerGetWaitFlagsStateNoLock();
   MojoResult rv;
   if (num_bytes_read > consumer_two_phase_max_num_bytes_read_ ||
       num_bytes_read % element_num_bytes_ != 0) {
     rv = MOJO_RESULT_INVALID_ARGUMENT;
     consumer_two_phase_max_num_bytes_read_ = 0;
   } else {
     rv = ConsumerEndReadDataImplNoLock(num_bytes_read);
   }
   // Two-phase read ended even on failure.
   DCHECK(!consumer_in_two_phase_read_no_lock());
   // If we're now readable, we *became* readable (since we weren't readable
   // during the two-phase read), so awake consumer waiters.
-  if ((ConsumerSatisfiedFlagsNoLock() & MOJO_WAIT_FLAG_READABLE))
+  WaitFlagsState new_consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  if (new_consumer_state.satisfies(MOJO_WAIT_FLAG_READABLE))
     AwakeConsumerWaitersForStateChangeNoLock();
-  if (ProducerSatisfiedFlagsNoLock() != old_producer_satisfied_flags)
+  WaitFlagsState new_producer_state = ProducerGetWaitFlagsStateNoLock();
+  if (!new_producer_state.equals(old_producer_state))
     AwakeProducerWaitersForStateChangeNoLock();
   return rv;
 }
 
 MojoResult DataPipe::ConsumerAddWaiter(Waiter* waiter,
                                        MojoWaitFlags flags,
                                        MojoResult wake_result) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
 
-  if ((flags & ConsumerSatisfiedFlagsNoLock()))
+  WaitFlagsState consumer_state = ConsumerGetWaitFlagsStateNoLock();
+  if (consumer_state.satisfies(flags))
     return MOJO_RESULT_ALREADY_EXISTS;
-  if (!(flags & ConsumerSatisfiableFlagsNoLock()))
+  if (!consumer_state.can_satisfy(flags))
     return MOJO_RESULT_FAILED_PRECONDITION;
 
   consumer_waiter_list_->AddWaiter(waiter, flags, wake_result);
   return MOJO_RESULT_OK;
 }
 
 void DataPipe::ConsumerRemoveWaiter(Waiter* waiter) {
   base::AutoLock locker(lock_);
   DCHECK(has_local_consumer_no_lock());
   consumer_waiter_list_->RemoveWaiter(waiter);
@@ skipping 28 matching lines @@
   DCHECK(!consumer_open_);
   DCHECK(!producer_waiter_list_);
   DCHECK(!consumer_waiter_list_);
 }
 
 void DataPipe::AwakeProducerWaitersForStateChangeNoLock() {
   lock_.AssertAcquired();
   if (!has_local_producer_no_lock())
     return;
   producer_waiter_list_->AwakeWaitersForStateChange(
-      ProducerSatisfiedFlagsNoLock(), ProducerSatisfiableFlagsNoLock());
+      ProducerGetWaitFlagsStateNoLock());
 }
 
 void DataPipe::AwakeConsumerWaitersForStateChangeNoLock() {
   lock_.AssertAcquired();
   if (!has_local_consumer_no_lock())
     return;
   consumer_waiter_list_->AwakeWaitersForStateChange(
-      ConsumerSatisfiedFlagsNoLock(), ConsumerSatisfiableFlagsNoLock());
+      ConsumerGetWaitFlagsStateNoLock());
 }
 
 }  // namespace system
 }  // namespace mojo