Extract Awakable from Waiter

mojo/edk/system/core_test_base.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/core_test_base.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
@@ skipping 105 matching lines @@
     lock().AssertAcquired();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
   MojoResult EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) override {
     info_->IncrementEndReadDataCallCount();
     lock().AssertAcquired();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
-  MojoResult AddWaiterImplNoLock(Waiter* /*waiter*/,
-                                 MojoHandleSignals /*signals*/,
-                                 uint32_t /*context*/,
-                                 HandleSignalsState* signals_state) override {
-    info_->IncrementAddWaiterCallCount();
+  MojoResult AddAwakableImplNoLock(Awakable* /*awakable*/,
+                                   MojoHandleSignals /*signals*/,
+                                   uint32_t /*context*/,
+                                   HandleSignalsState* signals_state) override {
+    info_->IncrementAddAwakableCallCount();
     lock().AssertAcquired();
     if (signals_state)
       *signals_state = HandleSignalsState();
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  void RemoveWaiterImplNoLock(Waiter* /*waiter*/,
-                              HandleSignalsState* signals_state) override {
-    info_->IncrementRemoveWaiterCallCount();
+  void RemoveAwakableImplNoLock(Awakable* /*awakable*/,
+                                HandleSignalsState* signals_state) override {
+    info_->IncrementRemoveAwakableCallCount();
     lock().AssertAcquired();
     if (signals_state)
       *signals_state = HandleSignalsState();
   }
 
-  void CancelAllWaitersNoLock() override {
-    info_->IncrementCancelAllWaitersCallCount();
+  void CancelAllAwakablesNoLock() override {
+    info_->IncrementCancelAllAwakablesCallCount();
     lock().AssertAcquired();
   }
 
   scoped_refptr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock()
       override {
     return scoped_refptr<Dispatcher>(new MockDispatcher(info_));
   }
 
   CoreTestBase::MockHandleInfo* const info_;
 
@@ skipping 32 matching lines @@
       dtor_call_count_(0),
       close_call_count_(0),
       write_message_call_count_(0),
       read_message_call_count_(0),
       write_data_call_count_(0),
       begin_write_data_call_count_(0),
       end_write_data_call_count_(0),
       read_data_call_count_(0),
       begin_read_data_call_count_(0),
       end_read_data_call_count_(0),
-      add_waiter_call_count_(0),
-      remove_waiter_call_count_(0),
-      cancel_all_waiters_call_count_(0) {
+      add_awakable_call_count_(0),
+      remove_awakable_call_count_(0),
+      cancel_all_awakables_call_count_(0) {
 }
 
 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
   base::AutoLock locker(lock_);
   return ctor_call_count_;
 }
 
@@ skipping 40 matching lines @@
 unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const {
   base::AutoLock locker(lock_);
   return begin_read_data_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const {
   base::AutoLock locker(lock_);
   return end_read_data_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetAddWaiterCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const {
   base::AutoLock locker(lock_);
-  return add_waiter_call_count_;
+  return add_awakable_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetRemoveWaiterCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const {
   base::AutoLock locker(lock_);
-  return remove_waiter_call_count_;
+  return remove_awakable_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetCancelAllWaitersCallCount() const {
+unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const {
   base::AutoLock locker(lock_);
-  return cancel_all_waiters_call_count_;
+  return cancel_all_awakables_call_count_;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
   base::AutoLock locker(lock_);
   ctor_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() {
   base::AutoLock locker(lock_);
   dtor_call_count_++;
@@ skipping 37 matching lines @@
 void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() {
   base::AutoLock locker(lock_);
   begin_read_data_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() {
   base::AutoLock locker(lock_);
   end_read_data_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementAddWaiterCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() {
   base::AutoLock locker(lock_);
-  add_waiter_call_count_++;
+  add_awakable_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementRemoveWaiterCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() {
   base::AutoLock locker(lock_);
-  remove_waiter_call_count_++;
+  remove_awakable_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::IncrementCancelAllWaitersCallCount() {
+void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() {
   base::AutoLock locker(lock_);
-  cancel_all_waiters_call_count_++;
+  cancel_all_awakables_call_count_++;
 }
 
 }  // namespace test
 }  // namespace system
 }  // namespace mojo