Rationalize AddAwakable...() and RemoveAwakable...() methods.

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 <utility>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 153 matching lines @@
       uint64_t /*num_bytes*/,
       MojoMapBufferFlags /*flags*/,
       std::unique_ptr<platform::PlatformSharedBufferMapping>* /*mapping*/)
       override {
     info_->IncrementMapBufferCallCount();
     mutex().AssertHeld();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
   MojoResult AddAwakableImplNoLock(Awakable* awakable,
+                                   uint64_t /*context*/,
+                                   bool /*force*/,
                                    MojoHandleSignals /*signals*/,
-                                   bool /*force*/,
-                                   uint64_t /*context*/,
                                    HandleSignalsState* signals_state) override {
     info_->IncrementAddAwakableCallCount();
     mutex().AssertHeld();
     if (signals_state)
       *signals_state = HandleSignalsState();
     if (info_->IsAddAwakableAllowed()) {
       info_->AwakableWasAdded(awakable);
       return MOJO_RESULT_OK;
     }
 
     return MOJO_RESULT_FAILED_PRECONDITION;
   }
 
-  void RemoveAwakableImplNoLock(Awakable* /*awakable*/,
+  void RemoveAwakableImplNoLock(bool /*match_context*/,
+                                Awakable* /*awakable*/,
+                                uint64_t /*context*/,
                                 HandleSignalsState* signals_state) override {
     info_->IncrementRemoveAwakableCallCount();
     mutex().AssertHeld();
     if (signals_state)
       *signals_state = HandleSignalsState();
   }
 
-  void RemoveAwakableWithContextImplNoLock(
-      Awakable* /*awakable*/,
-      uint64_t /*context*/,
-      HandleSignalsState* signals_state) override {
-    info_->IncrementRemoveAwakableWithContextCallCount();
-    mutex().AssertHeld();
-    if (signals_state)
-      *signals_state = HandleSignalsState();
-  }
-
   void CancelAllStateNoLock() override {
     info_->IncrementCancelAllStateCallCount();
     mutex().AssertHeld();
   }
 
   RefPtr<Dispatcher> CreateEquivalentDispatcherAndCloseImplNoLock(
       MessagePipe* /*message_pipe*/,
       unsigned /*port*/) override {
     CancelAllStateNoLock();
     return Create(info_);
@@ skipping 125 matching lines @@
 unsigned CoreTestBase_MockHandleInfo::GetAddAwakableCallCount() const {
   MutexLocker locker(&mutex_);
   return add_awakable_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const {
   MutexLocker locker(&mutex_);
   return remove_awakable_call_count_;
 }
 
-unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableWithContextCallCount()
-    const {
-  MutexLocker locker(&mutex_);
-  return remove_awakable_with_context_call_count_;
-}
-
 unsigned CoreTestBase_MockHandleInfo::GetCancelAllStateCallCount() const {
   MutexLocker locker(&mutex_);
   return cancel_all_awakables_call_count_;
 }
 
 size_t CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const {
   MutexLocker locker(&mutex_);
   return added_awakables_.size();
 }
 
@@ skipping 80 matching lines @@
 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() {
   MutexLocker locker(&mutex_);
   add_awakable_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() {
   MutexLocker locker(&mutex_);
   remove_awakable_call_count_++;
 }
 
-void CoreTestBase_MockHandleInfo::
-    IncrementRemoveAwakableWithContextCallCount() {
-  MutexLocker locker(&mutex_);
-  remove_awakable_with_context_call_count_++;
-}
-
 void CoreTestBase_MockHandleInfo::IncrementCancelAllStateCallCount() {
   MutexLocker locker(&mutex_);
   cancel_all_awakables_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) {
   MutexLocker locker(&mutex_);
   add_awakable_allowed_ = alllow;
 }
 
 bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const {
   MutexLocker locker(&mutex_);
   return add_awakable_allowed_;
 }
 
 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) {
   MutexLocker locker(&mutex_);
   added_awakables_.push_back(awakable);
 }
 
 }  // namespace test
 }  // namespace system
 }  // namespace mojo