Implement MojoGetBufferInformation(), part 2. This adds Core::GetBufferInformation() and hooks it up to Dispatchers. (But thunks still need to be taken care of.) Also backfills a bunch of missing testing. R=vardhan@google.com Review URL: https://codereview.chromium.org/1781513002 .
diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc index 4a57e04..f9bcadc 100644 --- a/mojo/edk/system/core.cc +++ b/mojo/edk/system/core.cc
@@ -518,6 +518,16 @@ return MOJO_RESULT_OK; } +MojoResult Core::GetBufferInformation(MojoHandle buffer_handle, + UserPointer<MojoBufferInformation> info, + uint32_t info_num_bytes) { + RefPtr<Dispatcher> dispatcher(GetDispatcher(buffer_handle)); + if (!dispatcher) + return MOJO_RESULT_INVALID_ARGUMENT; + + return dispatcher->GetBufferInformation(info, info_num_bytes); +} + MojoResult Core::MapBuffer(MojoHandle buffer_handle, uint64_t offset, uint64_t num_bytes,
diff --git a/mojo/edk/system/core.h b/mojo/edk/system/core.h index 7217888..ab154b1 100644 --- a/mojo/edk/system/core.h +++ b/mojo/edk/system/core.h
@@ -152,6 +152,9 @@ MojoHandle buffer_handle, UserPointer<const MojoDuplicateBufferHandleOptions> options, UserPointer<MojoHandle> new_buffer_handle); + MojoResult GetBufferInformation(MojoHandle buffer_handle, + UserPointer<MojoBufferInformation> info, + uint32_t info_num_bytes); MojoResult MapBuffer(MojoHandle buffer_handle, uint64_t offset, uint64_t num_bytes,
diff --git a/mojo/edk/system/core_test_base.cc b/mojo/edk/system/core_test_base.cc index 70213da..542eadb 100644 --- a/mojo/edk/system/core_test_base.cc +++ b/mojo/edk/system/core_test_base.cc
@@ -130,6 +130,33 @@ 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*/, @@ -197,26 +224,9 @@ // 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_); @@ -273,6 +283,22 @@ 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_; @@ -353,6 +379,21 @@ 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_++;
diff --git a/mojo/edk/system/core_test_base.h b/mojo/edk/system/core_test_base.h index c562ab5..852365e 100644 --- a/mojo/edk/system/core_test_base.h +++ b/mojo/edk/system/core_test_base.h
@@ -67,6 +67,9 @@ unsigned GetReadDataCallCount() const; unsigned GetBeginReadDataCallCount() const; unsigned GetEndReadDataCallCount() const; + unsigned GetDuplicateBufferHandleCallCount() const; + unsigned GetGetBufferInformationCallCount() const; + unsigned GetMapBufferCallCount() const; unsigned GetAddAwakableCallCount() const; unsigned GetRemoveAwakableCallCount() const; unsigned GetCancelAllAwakablesCallCount() const; @@ -86,6 +89,9 @@ void IncrementReadDataCallCount(); void IncrementBeginReadDataCallCount(); void IncrementEndReadDataCallCount(); + void IncrementDuplicateBufferHandleCallCount(); + void IncrementGetBufferInformationCallCount(); + void IncrementMapBufferCallCount(); void IncrementAddAwakableCallCount(); void IncrementRemoveAwakableCallCount(); void IncrementCancelAllAwakablesCallCount(); @@ -96,22 +102,25 @@ private: mutable util::Mutex mutex_; - unsigned ctor_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned dtor_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned close_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned write_message_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned read_message_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned write_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned begin_write_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned end_write_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned read_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned begin_read_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned end_read_data_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned add_awakable_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned remove_awakable_call_count_ MOJO_GUARDED_BY(mutex_); - unsigned cancel_all_awakables_call_count_ MOJO_GUARDED_BY(mutex_); + unsigned ctor_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned dtor_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned close_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned write_message_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned read_message_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned write_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned begin_write_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned end_write_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned read_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned begin_read_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned end_read_data_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned duplicate_buffer_handle_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned get_buffer_information_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned map_buffer_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned add_awakable_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned remove_awakable_call_count_ MOJO_GUARDED_BY(mutex_) = 0; + unsigned cancel_all_awakables_call_count_ MOJO_GUARDED_BY(mutex_) = 0; - bool add_awakable_allowed_ MOJO_GUARDED_BY(mutex_); + bool add_awakable_allowed_ MOJO_GUARDED_BY(mutex_) = false; std::vector<Awakable*> added_awakables_ MOJO_GUARDED_BY(mutex_); MOJO_DISALLOW_COPY_AND_ASSIGN(CoreTestBase_MockHandleInfo);
diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc index 268aadb..ead68e6 100644 --- a/mojo/edk/system/core_unittest.cc +++ b/mojo/edk/system/core_unittest.cc
@@ -99,6 +99,23 @@ EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, core()->EndReadData(h, 0)); EXPECT_EQ(1u, info.GetEndReadDataCallCount()); + EXPECT_EQ(0u, info.GetDuplicateBufferHandleCallCount()); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->DuplicateBufferHandle(h, NullUserPointer(), NullUserPointer())); + EXPECT_EQ(1u, info.GetDuplicateBufferHandleCallCount()); + + EXPECT_EQ(0u, info.GetGetBufferInformationCallCount()); + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, + core()->GetBufferInformation(h, NullUserPointer(), 0)); + EXPECT_EQ(1u, info.GetGetBufferInformationCallCount()); + + EXPECT_EQ(0u, info.GetMapBufferCallCount()); + EXPECT_EQ( + MOJO_RESULT_UNIMPLEMENTED, + core()->MapBuffer(h, 0, 0, NullUserPointer(), MOJO_MAP_BUFFER_FLAG_NONE)); + EXPECT_EQ(1u, info.GetMapBufferCallCount()); + EXPECT_EQ(0u, info.GetAddAwakableCallCount()); EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE, @@ -320,8 +337,20 @@ EXPECT_EQ(MOJO_RESULT_OK, core()->Close(handles[1])); } - // |CreateMessagePipe()|: Nothing to check (apart from things that cause - // death). + // |CreateMessagePipe()|: + { + // Invalid options: unknown flag. + const MojoCreateMessagePipeOptions kOptions = { + static_cast<uint32_t>(sizeof(MojoCreateMessagePipeOptions)), + ~MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE}; + MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID}; + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, + core()->CreateMessagePipe(MakeUserPointer(&kOptions), + MakeUserPointer(&handles[0]), + MakeUserPointer(&handles[1]))); + EXPECT_EQ(MOJO_HANDLE_INVALID, handles[0]); + EXPECT_EQ(MOJO_HANDLE_INVALID, handles[1]); + } // |WriteMessage()|: // Only check arguments checked by |Core|, namely |handle|, |handles|, and @@ -443,6 +472,82 @@ EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); } + + // |CreateDataPipe()|: + { + // Invalid options: unknown flag. + const MojoCreateDataPipeOptions kOptions = { + static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)), + ~MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE, 1u, 0u}; + MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID}; + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, + core()->CreateDataPipe(MakeUserPointer(&kOptions), + MakeUserPointer(&handles[0]), + MakeUserPointer(&handles[1]))); + EXPECT_EQ(MOJO_HANDLE_INVALID, handles[0]); + EXPECT_EQ(MOJO_HANDLE_INVALID, handles[1]); + } + + // |WriteData()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->WriteData(MOJO_HANDLE_INVALID, NullUserPointer(), + NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); + + // |BeginWriteData()|: + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + core()->BeginWriteData(MOJO_HANDLE_INVALID, NullUserPointer(), + NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE)); + + // |EndWriteData()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->EndWriteData(MOJO_HANDLE_INVALID, 0u)); + + // |ReadData()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->ReadData(MOJO_HANDLE_INVALID, NullUserPointer(), + NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); + + // |BeginReadData()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->BeginReadData(MOJO_HANDLE_INVALID, NullUserPointer(), + NullUserPointer(), MOJO_READ_DATA_FLAG_NONE)); + + // |EndReadData()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->EndReadData(MOJO_HANDLE_INVALID, 0u)); + + // |CreateSharedBuffer()|: + { + // Invalid options: unknown flag. + const MojoCreateSharedBufferOptions kOptions = { + static_cast<uint32_t>(sizeof(MojoCreateSharedBufferOptions)), + ~MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE}; + MojoHandle handle = MOJO_HANDLE_INVALID; + EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED, + core()->CreateSharedBuffer(MakeUserPointer(&kOptions), 4096u, + MakeUserPointer(&handle))); + EXPECT_EQ(MOJO_HANDLE_INVALID, handle); + } + + // |DuplicateBufferHandle()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->DuplicateBufferHandle( + MOJO_HANDLE_INVALID, NullUserPointer(), NullUserPointer())); + + // |GetBufferInformation()|: + EXPECT_EQ( + MOJO_RESULT_INVALID_ARGUMENT, + core()->GetBufferInformation(MOJO_HANDLE_INVALID, NullUserPointer(), 0u)); + + // |MapBuffer()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->MapBuffer(MOJO_HANDLE_INVALID, 0u, 0u, NullUserPointer(), + MOJO_MAP_BUFFER_FLAG_NONE)); + + // |UnmapBuffer()|: + EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, + core()->UnmapBuffer(NullUserPointer())); } // These test invalid arguments that should cause death if we're being paranoid @@ -521,6 +626,8 @@ EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h)); } + + // TODO(vtl): Missing a bunch here. } // TODO(vtl): test |Wait()| and |WaitMany()| properly