Index: media/gpu/ipc/service/gpu_jpeg_decode_accelerator_unittest.cc |
diff --git a/media/gpu/ipc/service/gpu_jpeg_decode_accelerator_unittest.cc b/media/gpu/ipc/service/gpu_jpeg_decode_accelerator_unittest.cc |
deleted file mode 100644 |
index 67fd1fdae43fec3a69cd85095b981fef3707469b..0000000000000000000000000000000000000000 |
--- a/media/gpu/ipc/service/gpu_jpeg_decode_accelerator_unittest.cc |
+++ /dev/null |
@@ -1,132 +0,0 @@ |
-// Copyright 2017 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 "media/gpu/ipc/service/gpu_jpeg_decode_accelerator.h" |
-#include "base/bind.h" |
-#include "base/run_loop.h" |
-#include "base/single_thread_task_runner.h" |
-#include "base/test/scoped_task_environment.h" |
-#include "base/threading/thread.h" |
-#include "gpu/ipc/service/gpu_channel.h" |
-#include "media/gpu/ipc/common/media_messages.h" |
-#include "testing/gmock/include/gmock/gmock.h" |
-#include "testing/gtest/include/gtest/gtest.h" |
- |
-using testing::_; |
-using testing::SaveArg; |
-using testing::InvokeWithoutArgs; |
-using testing::Return; |
- |
-namespace media { |
- |
-static const size_t kOutputFrameSizeInBytes = 1024; |
-static const gfx::Size kDummyFrameCodedSize(10, 10); |
- |
-class MockFilteredSender : public gpu::FilteredSender { |
- public: |
- MOCK_METHOD1(AddFilter, void(IPC::MessageFilter*)); |
- MOCK_METHOD1(RemoveFilter, void(IPC::MessageFilter*)); |
- MOCK_METHOD1(Send, bool(IPC::Message*)); |
-}; |
- |
-class MockJpegDecodeAccelerator : public media::JpegDecodeAccelerator { |
- public: |
- MOCK_METHOD1(Initialize, bool(Client*)); |
- MOCK_METHOD2(Decode, |
- void(const BitstreamBuffer&, |
- const scoped_refptr<media::VideoFrame>&)); |
- MOCK_METHOD0(IsSupported, bool()); |
-}; |
- |
-// Test fixture for the unit that is created via the constructor of |
-// class GpuJpegDecodeAccelerator. Uses a FakeJpegDecodeAccelerator to |
-// simulate the actual decoding without the need for special hardware. |
-class GpuJpegDecodeAcceleratorTest : public ::testing::Test { |
- public: |
- GpuJpegDecodeAcceleratorTest() : io_thread_("io") {} |
- ~GpuJpegDecodeAcceleratorTest() override{}; |
- |
- void SetUp() override { |
- output_frame_memory_.CreateAndMapAnonymous(kOutputFrameSizeInBytes); |
- io_thread_.Start(); |
- std::vector<GpuJpegDecodeAcceleratorFactoryProvider::CreateAcceleratorCB> |
- accelerator_factory_functions; |
- accelerator_factory_functions.push_back( |
- base::Bind(&GpuJpegDecodeAcceleratorTest::GetMockJpegDecodeAccelerator, |
- base::Unretained(this))); |
- system_under_test_ = base::MakeUnique<GpuJpegDecodeAccelerator>( |
- &gpu_channel_, io_thread_.task_runner(), accelerator_factory_functions); |
- } |
- |
- MOCK_METHOD1(GetMockJpegDecodeAccelerator, |
- std::unique_ptr<JpegDecodeAccelerator>( |
- scoped_refptr<base::SingleThreadTaskRunner>)); |
- |
- void SendStubFrame(IPC::MessageFilter* message_filter, int32_t route_id) { |
- AcceleratedJpegDecoderMsg_Decode_Params decode_params; |
- decode_params.output_video_frame_handle = output_frame_memory_.handle(); |
- decode_params.output_buffer_size = |
- static_cast<uint32_t>(kOutputFrameSizeInBytes); |
- decode_params.coded_size = kDummyFrameCodedSize; |
- AcceleratedJpegDecoderMsg_Decode message(route_id, decode_params); |
- message_filter->OnMessageReceived(message); |
- } |
- |
- protected: |
- base::Thread io_thread_; |
- MockFilteredSender gpu_channel_; |
- std::unique_ptr<GpuJpegDecodeAccelerator> system_under_test_; |
- base::SharedMemory output_frame_memory_; |
- |
- private: |
- // This is required to allow base::ThreadTaskRunnerHandle::Get() from the |
- // test execution thread. |
- base::test::ScopedTaskEnvironment scoped_task_environment_; |
-}; |
- |
-// Tests that the communication for decoding a frame between the caller of |
-// IPC:MessageFilter and the media::JpegDecodeAccelerator works as expected. |
-TEST_F(GpuJpegDecodeAcceleratorTest, DecodeFrameCallArrivesAtDecoder) { |
- static const int32_t kArbitraryRouteId = 123; |
- auto io_task_runner = io_thread_.task_runner(); |
- auto main_task_runner = base::ThreadTaskRunnerHandle::Get(); |
- auto decoder = base::MakeUnique<MockJpegDecodeAccelerator>(); |
- auto* decoder_ptr = decoder.get(); |
- ON_CALL(*decoder, Initialize(_)).WillByDefault(Return(true)); |
- |
- IPC::MessageFilter* message_filter = nullptr; |
- EXPECT_CALL(*this, GetMockJpegDecodeAccelerator(_)) |
- .WillOnce(InvokeWithoutArgs([&decoder]() { return std::move(decoder); })); |
- EXPECT_CALL(gpu_channel_, AddFilter(_)).WillOnce(SaveArg<0>(&message_filter)); |
- base::RunLoop run_loop; |
- auto response_cb = base::Bind( |
- [](base::RunLoop* run_loop, |
- scoped_refptr<base::SingleThreadTaskRunner> main_task_runner, |
- bool succeeded) { |
- EXPECT_TRUE(succeeded); |
- if (main_task_runner->BelongsToCurrentThread() == false) { |
- DLOG(INFO) << "Response arrived on thread other than main thread."; |
- main_task_runner->PostTask(FROM_HERE, run_loop->QuitClosure()); |
- return; |
- } |
- run_loop->Quit(); |
- }, |
- &run_loop, main_task_runner); |
- system_under_test_->AddClient(kArbitraryRouteId, response_cb); |
- run_loop.Run(); |
- ASSERT_TRUE(message_filter); |
- |
- // Send a AcceleratedJpegDecoderMsg_Decode to the |message_filter| on the |
- // io_thread. |
- base::RunLoop run_loop2; |
- EXPECT_CALL(*decoder_ptr, Decode(_, _)); |
- io_task_runner->PostTaskAndReply( |
- FROM_HERE, |
- base::Bind(&GpuJpegDecodeAcceleratorTest::SendStubFrame, |
- base::Unretained(this), message_filter, kArbitraryRouteId), |
- run_loop2.QuitClosure()); |
- run_loop2.Run(); |
-} |
- |
-} // namespace media |