Give AwakableList's wake-up method the old state in addition to the new state.

mojo/edk/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/edk/system/data_pipe.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 272 matching lines @@
 MojoResult DataPipe::ProducerSetOptions(uint32_t write_threshold_num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_producer_no_lock());
 
   if (write_threshold_num_bytes % element_num_bytes() != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   HandleSignalsState old_producer_state =
       impl_->ProducerGetHandleSignalsState();
   producer_write_threshold_num_bytes_ = write_threshold_num_bytes;
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
   return MOJO_RESULT_OK;
 }
 
 void DataPipe::ProducerGetOptions(uint32_t* write_threshold_num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_producer_no_lock());
   *write_threshold_num_bytes = producer_write_threshold_num_bytes_;
 }
 
 MojoResult DataPipe::ProducerWriteData(UserPointer<const void> elements,
@@ skipping 14 matching lines @@
 
   if (max_num_bytes_to_write == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
   uint32_t min_num_bytes_to_write = all_or_none ? max_num_bytes_to_write : 0;
 
   HandleSignalsState old_consumer_state =
       impl_->ConsumerGetHandleSignalsState();
   MojoResult rv = impl_->ProducerWriteData(
       elements, num_bytes, max_num_bytes_to_write, min_num_bytes_to_write);
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
   return rv;
 }
 
 MojoResult DataPipe::ProducerBeginWriteData(
     UserPointer<void*> buffer,
     UserPointer<uint32_t> buffer_num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_producer_no_lock());
 
   if (producer_in_two_phase_write_no_lock())
@@ skipping 16 matching lines @@
   MutexLocker locker(&mutex_);
   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.
 
   HandleSignalsState old_consumer_state =
       impl_->ConsumerGetHandleSignalsState();
+  HandleSignalsState old_producer_state =
+      impl_->ProducerGetHandleSignalsState();
   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 = impl_->ProducerEndWriteData(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 awakables.
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (new_producer_state.satisfies(MOJO_HANDLE_SIGNAL_WRITABLE))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
   return rv;
 }
 
 HandleSignalsState DataPipe::ProducerGetHandleSignalsState() {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_producer_no_lock());
   return impl_->ProducerGetHandleSignalsState();
 }
 
 MojoResult DataPipe::ProducerAddAwakable(Awakable* awakable,
@@ skipping 83 matching lines @@
 MojoResult DataPipe::ConsumerSetOptions(uint32_t read_threshold_num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_consumer_no_lock());
 
   if (read_threshold_num_bytes % element_num_bytes() != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   HandleSignalsState old_consumer_state =
       impl_->ConsumerGetHandleSignalsState();
   consumer_read_threshold_num_bytes_ = read_threshold_num_bytes;
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
   return MOJO_RESULT_OK;
 }
 
 void DataPipe::ConsumerGetOptions(uint32_t* read_threshold_num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_consumer_no_lock());
   *read_threshold_num_bytes = consumer_read_threshold_num_bytes_;
 }
 
 MojoResult DataPipe::ConsumerReadData(UserPointer<void> elements,
@@ skipping 12 matching lines @@
 
   if (max_num_bytes_to_read == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
   uint32_t min_num_bytes_to_read = all_or_none ? max_num_bytes_to_read : 0;
 
   HandleSignalsState old_producer_state =
       impl_->ProducerGetHandleSignalsState();
   MojoResult rv = impl_->ConsumerReadData(
       elements, num_bytes, max_num_bytes_to_read, min_num_bytes_to_read, peek);
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
   return rv;
 }
 
 MojoResult DataPipe::ConsumerDiscardData(UserPointer<uint32_t> num_bytes,
                                          bool all_or_none) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_consumer_no_lock());
 
   if (consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_BUSY;
 
   uint32_t max_num_bytes_to_discard = num_bytes.Get();
   if (max_num_bytes_to_discard % element_num_bytes() != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (max_num_bytes_to_discard == 0)
     return MOJO_RESULT_OK;  // Nothing to do.
 
   uint32_t min_num_bytes_to_discard =
       all_or_none ? max_num_bytes_to_discard : 0;
 
   HandleSignalsState old_producer_state =
       impl_->ProducerGetHandleSignalsState();
   MojoResult rv = impl_->ConsumerDiscardData(
       num_bytes, max_num_bytes_to_discard, min_num_bytes_to_discard);
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
   return rv;
 }
 
 MojoResult DataPipe::ConsumerQueryData(UserPointer<uint32_t> num_bytes) {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_consumer_no_lock());
 
   if (consumer_in_two_phase_read_no_lock())
     return MOJO_RESULT_BUSY;
 
@@ skipping 33 matching lines @@
       num_bytes_read % element_num_bytes() != 0) {
     rv = MOJO_RESULT_INVALID_ARGUMENT;
     consumer_two_phase_max_num_bytes_read_ = 0;
   } else {
     rv = impl_->ConsumerEndReadData(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 awakables.
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
   return rv;
 }
 
 HandleSignalsState DataPipe::ConsumerGetHandleSignalsState() {
   MutexLocker locker(&mutex_);
   DCHECK(has_local_consumer_no_lock());
   return impl_->ConsumerGetHandleSignalsState();
 }
 
 MojoResult DataPipe::ConsumerAddAwakable(Awakable* awakable,
@@ skipping 146 matching lines @@
 void DataPipe::SetConsumerClosedNoLock() {
   mutex_.AssertHeld();
   DCHECK(!has_local_consumer_no_lock());
   DCHECK(consumer_open_);
   consumer_open_ = false;
 }
 
 void DataPipe::ProducerCloseNoLock() {
   mutex_.AssertHeld();
   DCHECK(producer_open_);
+  HandleSignalsState old_consumer_state =
+      impl_->ConsumerGetHandleSignalsState();
   producer_open_ = false;
   if (has_local_producer_no_lock()) {
     ProducerCancelAllStateNoLock();
     producer_awakable_list_.reset();
     impl_->ProducerClose();
-    AwakeConsumerAwakablesForStateChangeNoLock(
-        impl_->ConsumerGetHandleSignalsState());
   }
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
 }
 
 void DataPipe::ConsumerCloseNoLock() {
   mutex_.AssertHeld();
   DCHECK(consumer_open_);
+  HandleSignalsState old_producer_state =
+      impl_->ProducerGetHandleSignalsState();
   consumer_open_ = false;
   if (has_local_consumer_no_lock()) {
     ConsumerCancelAllStateNoLock();
     consumer_awakable_list_.reset();
     impl_->ConsumerClose();
-    AwakeProducerAwakablesForStateChangeNoLock(
-        impl_->ProducerGetHandleSignalsState());
   }
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
 }
 
 bool DataPipe::OnReadMessage(unsigned port, MessageInTransit* message) {
   MutexLocker locker(&mutex_);
   DCHECK(!has_local_producer_no_lock() || !has_local_consumer_no_lock());
 
   HandleSignalsState old_producer_state =
       impl_->ProducerGetHandleSignalsState();
   HandleSignalsState old_consumer_state =
       impl_->ConsumerGetHandleSignalsState();
 
   bool rv = impl_->OnReadMessage(port, message);
 
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
 
   return rv;
 }
 
 void DataPipe::OnDetachFromChannel(unsigned port) {
   MutexLocker locker(&mutex_);
   DCHECK(!has_local_producer_no_lock() || !has_local_consumer_no_lock());
 
   HandleSignalsState old_producer_state =
       impl_->ProducerGetHandleSignalsState();
   HandleSignalsState old_consumer_state =
       impl_->ConsumerGetHandleSignalsState();
 
   impl_->OnDetachFromChannel(port);
 
-  HandleSignalsState new_producer_state =
-      impl_->ProducerGetHandleSignalsState();
-  if (!new_producer_state.equals(old_producer_state))
-    AwakeProducerAwakablesForStateChangeNoLock(new_producer_state);
-  HandleSignalsState new_consumer_state =
-      impl_->ConsumerGetHandleSignalsState();
-  if (!new_consumer_state.equals(old_consumer_state))
-    AwakeConsumerAwakablesForStateChangeNoLock(new_consumer_state);
+  OnProducerMaybeStateChange(old_producer_state,
+                             impl_->ProducerGetHandleSignalsState());
+  OnConsumerMaybeStateChange(old_consumer_state,
+                             impl_->ConsumerGetHandleSignalsState());
 }
 
-void DataPipe::AwakeProducerAwakablesForStateChangeNoLock(
+void DataPipe::OnProducerMaybeStateChange(
+    const HandleSignalsState& old_producer_state,
     const HandleSignalsState& new_producer_state) {
   mutex_.AssertHeld();
-  if (!has_local_producer_no_lock())
-    return;
-  producer_awakable_list_->AwakeForStateChange(new_producer_state);
+  if (!new_producer_state.equals(old_producer_state) &&
+      has_local_producer_no_lock()) {
+    producer_awakable_list_->OnStateChange(old_producer_state,
+                                           new_producer_state);
+  }
 }
 
-void DataPipe::AwakeConsumerAwakablesForStateChangeNoLock(
+void DataPipe::OnConsumerMaybeStateChange(
+    const HandleSignalsState& old_consumer_state,
     const HandleSignalsState& new_consumer_state) {
   mutex_.AssertHeld();
-  if (!has_local_consumer_no_lock())
-    return;
-  consumer_awakable_list_->AwakeForStateChange(new_consumer_state);
+  if (!new_consumer_state.equals(old_consumer_state) &&
+      has_local_consumer_no_lock()) {
+    consumer_awakable_list_->OnStateChange(old_consumer_state,
+                                           new_consumer_state);
+  }
 }
 
 void DataPipe::SetProducerClosed() {
   MutexLocker locker(&mutex_);
   SetProducerClosedNoLock();
 }
 
 void DataPipe::SetConsumerClosed() {
   MutexLocker locker(&mutex_);
   SetConsumerClosedNoLock();
 }
 
 }  // namespace system
 }  // namespace mojo