Add Core methods for wait set.

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 152 matching lines @@
       uint64_t /*offset*/,
       uint64_t /*num_bytes*/,
       MojoMapBufferFlags /*flags*/,
       std::unique_ptr<platform::PlatformSharedBufferMapping>* /*mapping*/)
       override {
     info_->IncrementMapBufferCallCount();
     mutex().AssertHeld();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
+  MojoResult WaitSetAddImpl(
+      RefPtr<Dispatcher>&& /*dispatcher*/,
+      MojoHandleSignals /*signals*/,
+      uint64_t /*cookie*/,
+      UserPointer<const MojoWaitSetAddOptions> /*options*/) override {
+    info_->IncrementWaitSetAddCallCount();
+    // Note: |mutex()| is *not* held.
+    return MOJO_RESULT_UNIMPLEMENTED;
+  }
+
+  MojoResult WaitSetRemoveImpl(uint64_t /*cookie*/) override {
+    info_->IncrementWaitSetRemoveCallCount();
+    // Note: |mutex()| is *not* held.
+    return MOJO_RESULT_UNIMPLEMENTED;
+  }
+
+  MojoResult WaitSetWaitImpl(MojoDeadline /*deadline*/,
+                             UserPointer<uint32_t> /*num_results*/,
+                             UserPointer<MojoWaitSetResult> /*results*/,
+                             UserPointer<uint32_t> /*max_results*/) override {
+    info_->IncrementWaitSetWaitCallCount();
+    // Note: |mutex()| is *not* held.
+    return MOJO_RESULT_UNIMPLEMENTED;
+  }
+
   MojoResult AddAwakableImplNoLock(Awakable* awakable,
                                    uint64_t /*context*/,
                                    bool /*persistent*/,
                                    MojoHandleSignals /*signals*/,
                                    HandleSignalsState* signals_state) override {
     info_->IncrementAddAwakableCallCount();
     mutex().AssertHeld();
     if (signals_state)
       *signals_state = HandleSignalsState();
     if (info_->IsAddAwakableAllowed()) {
@@ skipping 142 matching lines @@
 unsigned CoreTestBase_MockHandleInfo::GetGetBufferInformationCallCount() const {
   MutexLocker locker(&mutex_);
   return get_buffer_information_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetMapBufferCallCount() const {
   MutexLocker locker(&mutex_);
   return map_buffer_call_count_;
 }
 
+unsigned CoreTestBase_MockHandleInfo::GetWaitSetAddCallCount() const {
+  MutexLocker locker(&mutex_);
+  return wait_set_add_call_count_;
+}
+
+unsigned CoreTestBase_MockHandleInfo::GetWaitSetRemoveCallCount() const {
+  MutexLocker locker(&mutex_);
+  return wait_set_remove_call_count_;
+}
+
+unsigned CoreTestBase_MockHandleInfo::GetWaitSetWaitCallCount() const {
+  MutexLocker locker(&mutex_);
+  return wait_set_wait_call_count_;
+}
+
 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_;
 }
 
@@ skipping 80 matching lines @@
 void CoreTestBase_MockHandleInfo::IncrementGetBufferInformationCallCount() {
   MutexLocker locker(&mutex_);
   get_buffer_information_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementMapBufferCallCount() {
   MutexLocker locker(&mutex_);
   map_buffer_call_count_++;
 }
 
+void CoreTestBase_MockHandleInfo::IncrementWaitSetAddCallCount() {
+  MutexLocker locker(&mutex_);
+  wait_set_add_call_count_++;
+}
+
+void CoreTestBase_MockHandleInfo::IncrementWaitSetRemoveCallCount() {
+  MutexLocker locker(&mutex_);
+  wait_set_remove_call_count_++;
+}
+
+void CoreTestBase_MockHandleInfo::IncrementWaitSetWaitCallCount() {
+  MutexLocker locker(&mutex_);
+  wait_set_wait_call_count_++;
+}
+
 void CoreTestBase_MockHandleInfo::IncrementAddAwakableCallCount() {
   MutexLocker locker(&mutex_);
   add_awakable_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementRemoveAwakableCallCount() {
   MutexLocker locker(&mutex_);
   remove_awakable_call_count_++;
 }
 
@@ skipping 13 matching lines @@
 }
 
 void CoreTestBase_MockHandleInfo::AwakableWasAdded(Awakable* awakable) {
   MutexLocker locker(&mutex_);
   added_awakables_.push_back(awakable);
 }
 
 }  // namespace test
 }  // namespace system
 }  // namespace mojo