Add embedder::AsyncWait()

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 AddAwakableImplNoLock(Awakable* /*awakable*/,
+  MojoResult AddAwakableImplNoLock(Awakable* awakable,
                                    MojoHandleSignals /*signals*/,
                                    uint32_t /*context*/,
                                    HandleSignalsState* signals_state) override {
     info_->IncrementAddAwakableCallCount();
     lock().AssertAcquired();
     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*/,
                                 HandleSignalsState* signals_state) override {
     info_->IncrementRemoveAwakableCallCount();
     lock().AssertAcquired();
     if (signals_state)
       *signals_state = HandleSignalsState();
   }
@@ skipping 47 matching lines @@
       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_awakable_call_count_(0),
       remove_awakable_call_count_(0),
-      cancel_all_awakables_call_count_(0) {
+      cancel_all_awakables_call_count_(0),
+      add_awakable_allowed_(false) {
 }
 
 CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
   base::AutoLock locker(lock_);
   return ctor_call_count_;
 }
 
@@ skipping 55 matching lines @@
 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const {
   base::AutoLock locker(lock_);
   return remove_awakable_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetCancelAllAwakablesCallCount() const {
   base::AutoLock locker(lock_);
   return cancel_all_awakables_call_count_;
 }
 
+unsigned CoreTestBase_MockHandleInfo::GetAddedAwakableSize() const {
+  base::AutoLock locker(lock_);
+  return added_awakables_.size();
+}
+
+Awakable* CoreTestBase_MockHandleInfo::GetAddedAwakableAt(unsigned i) const {
+  base::AutoLock locker(lock_);
+  return added_awakables_[i];
+}
+
 void CoreTestBase_MockHandleInfo::IncrementCtorCallCount() {
   base::AutoLock locker(lock_);
   ctor_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementDtorCallCount() {
   base::AutoLock locker(lock_);
   dtor_call_count_++;
 }
 
@@ skipping 50 matching lines @@
 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() {
   base::AutoLock locker(lock_);
   remove_awakable_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementCancelAllAwakablesCallCount() {
   base::AutoLock locker(lock_);
   cancel_all_awakables_call_count_++;
 }
 
+void CoreTestBase_MockHandleInfo::AllowAddAwakable(bool alllow) {
+  base::AutoLock locker(lock_);
+  add_awakable_allowed_ = alllow;
+}
+
+bool CoreTestBase_MockHandleInfo::IsAddAwakableAllowed() const {
+  base::AutoLock locker(lock_);
+  return add_awakable_allowed_;
+}
+
+void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) {
+  base::AutoLock locker(lock_);
+  added_awakables_.push_back(awakable);
+}
+
 }  // namespace test
 }  // namespace system
 }  // namespace mojo