Implement MojoGetBufferInformation(), part 2.

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/logging.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
@@ skipping 112 matching lines @@
     mutex().AssertHeld();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
   MojoResult EndReadDataImplNoLock(uint32_t /*num_bytes_read*/) override {
     info_->IncrementEndReadDataCallCount();
     mutex().AssertHeld();
     return MOJO_RESULT_UNIMPLEMENTED;
   }
 
+  MojoResult DuplicateBufferHandleImplNoLock(
+      UserPointer<const MojoDuplicateBufferHandleOptions> /*options*/,
+      RefPtr<Dispatcher>* /*new_dispatcher*/) override {
+    info_->IncrementDuplicateBufferHandleCallCount();
+    mutex().AssertHeld();
+    return MOJO_RESULT_UNIMPLEMENTED;
+  }
+
+  MojoResult GetBufferInformationImplNoLock(
+      UserPointer<MojoBufferInformation> /*info*/,
+      uint32_t /*info_num_bytes*/) override {
+    info_->IncrementGetBufferInformationCallCount();
+    mutex().AssertHeld();
+    return MOJO_RESULT_UNIMPLEMENTED;
+  }
+
+  MojoResult MapBufferImplNoLock(
+      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 AddAwakableImplNoLock(Awakable* awakable,
                                    MojoHandleSignals /*signals*/,
                                    uint32_t /*context*/,
                                    HandleSignalsState* signals_state) override {
     info_->IncrementAddAwakableCallCount();
     mutex().AssertHeld();
     if (signals_state)
       *signals_state = HandleSignalsState();
     if (info_->IsAddAwakableAllowed()) {
       info_->AwakableWasAdded(awakable);
@@ skipping 47 matching lines @@
 MojoHandle CoreTestBase::CreateMockHandle(CoreTestBase::MockHandleInfo* info) {
   CHECK(core_);
   auto dispatcher = MockDispatcher::Create(info);
   MojoHandle rv = core_->AddDispatcher(dispatcher.get());
   CHECK_NE(rv, MOJO_HANDLE_INVALID);
   return rv;
 }
 
 // CoreTestBase_MockHandleInfo -------------------------------------------------
 
-CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo()
-    : ctor_call_count_(0),
-      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_awakable_call_count_(0),
-      remove_awakable_call_count_(0),
-      cancel_all_awakables_call_count_(0),
-      add_awakable_allowed_(false) {
-}
+CoreTestBase_MockHandleInfo::CoreTestBase_MockHandleInfo() {}
 
-CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {
-}
+CoreTestBase_MockHandleInfo::~CoreTestBase_MockHandleInfo() {}
 
 unsigned CoreTestBase_MockHandleInfo::GetCtorCallCount() const {
   MutexLocker locker(&mutex_);
   return ctor_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetDtorCallCount() const {
   MutexLocker locker(&mutex_);
   return dtor_call_count_;
 }
@@ skipping 36 matching lines @@
 unsigned CoreTestBase_MockHandleInfo::GetBeginReadDataCallCount() const {
   MutexLocker locker(&mutex_);
   return begin_read_data_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetEndReadDataCallCount() const {
   MutexLocker locker(&mutex_);
   return end_read_data_call_count_;
 }
 
+unsigned CoreTestBase_MockHandleInfo::GetDuplicateBufferHandleCallCount()
+    const {
+  MutexLocker locker(&mutex_);
+  return duplicate_buffer_handle_call_count_;
+}
+
+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::GetAddAwakableCallCount() const {
   MutexLocker locker(&mutex_);
   return add_awakable_call_count_;
 }
 
 unsigned CoreTestBase_MockHandleInfo::GetRemoveAwakableCallCount() const {
   MutexLocker locker(&mutex_);
   return remove_awakable_call_count_;
 }
 
@@ skipping 60 matching lines @@
 void CoreTestBase_MockHandleInfo::IncrementBeginReadDataCallCount() {
   MutexLocker locker(&mutex_);
   begin_read_data_call_count_++;
 }
 
 void CoreTestBase_MockHandleInfo::IncrementEndReadDataCallCount() {
   MutexLocker locker(&mutex_);
   end_read_data_call_count_++;
 }
 
+void CoreTestBase_MockHandleInfo::IncrementDuplicateBufferHandleCallCount() {
+  MutexLocker locker(&mutex_);
+  duplicate_buffer_handle_call_count_++;
+}
+
+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::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