gpu_memory_buffer_virtual_device_mojo_adapter_unittest.cc 4.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "services/video_capture/gpu_memory_buffer_virtual_device_mojo_adapter.h"
  5. #include "base/run_loop.h"
  6. #include "base/test/task_environment.h"
  7. #include "mojo/public/cpp/bindings/pending_remote.h"
  8. #include "services/video_capture/public/cpp/mock_video_frame_handler.h"
  9. #include "services/video_capture/public/mojom/video_frame_handler.mojom.h"
  10. #include "testing/gmock/include/gmock/gmock.h"
  11. #include "testing/gtest/include/gtest/gtest.h"
  12. using testing::_;
  13. using testing::InvokeWithoutArgs;
  14. namespace video_capture {
  15. class GpuMemoryBufferVirtualDeviceMojoAdapterTest : public ::testing::Test {
  16. public:
  17. GpuMemoryBufferVirtualDeviceMojoAdapterTest() = default;
  18. void SetUp() override {
  19. mock_video_frame_handler_1_ = std::make_unique<MockVideoFrameHandler>(
  20. video_frame_handler_1_.InitWithNewPipeAndPassReceiver());
  21. mock_video_frame_handler_2_ = std::make_unique<MockVideoFrameHandler>(
  22. video_frame_handler_2_.InitWithNewPipeAndPassReceiver());
  23. adapter_ = std::make_unique<GpuMemoryBufferVirtualDeviceMojoAdapter>();
  24. }
  25. protected:
  26. void ProducerSharesBufferHandle(int32_t buffer_id) {
  27. gfx::GpuMemoryBufferHandle dummy_buffer_handle;
  28. adapter_->OnNewGpuMemoryBufferHandle(buffer_id,
  29. std::move(dummy_buffer_handle));
  30. }
  31. void ProducerRetiresBufferHandle(int32_t buffer_id) {
  32. adapter_->OnBufferRetired(buffer_id);
  33. }
  34. void Receiver1Connects() {
  35. const media::VideoCaptureParams kArbitraryRequestedSettings;
  36. adapter_->Start(kArbitraryRequestedSettings,
  37. std::move(video_frame_handler_1_));
  38. }
  39. void Receiver2Connects() {
  40. const media::VideoCaptureParams kArbitraryRequestedSettings;
  41. adapter_->Start(kArbitraryRequestedSettings,
  42. std::move(video_frame_handler_2_));
  43. }
  44. void Receiver1Disconnects() {
  45. base::RunLoop wait_loop;
  46. adapter_->SetReceiverDisconnectedCallback(wait_loop.QuitClosure());
  47. mock_video_frame_handler_1_.reset();
  48. wait_loop.Run();
  49. }
  50. std::unique_ptr<MockVideoFrameHandler> mock_video_frame_handler_1_;
  51. std::unique_ptr<MockVideoFrameHandler> mock_video_frame_handler_2_;
  52. private:
  53. base::test::TaskEnvironment task_environment_;
  54. std::unique_ptr<GpuMemoryBufferVirtualDeviceMojoAdapter> adapter_;
  55. mojo::PendingRemote<mojom::VideoFrameHandler> video_frame_handler_1_;
  56. mojo::PendingRemote<mojom::VideoFrameHandler> video_frame_handler_2_;
  57. };
  58. // Tests that when buffer handles are shared by the producer before a receiver
  59. // has connected, these buffer handles get shared with the receiver as soon as
  60. // it connects.
  61. TEST_F(GpuMemoryBufferVirtualDeviceMojoAdapterTest,
  62. BufferHandlesAreSharedWithReceiverConnectingLate) {
  63. const int kArbitraryBufferId1 = 1;
  64. const int kArbitraryBufferId2 = 2;
  65. ProducerSharesBufferHandle(kArbitraryBufferId1);
  66. ProducerSharesBufferHandle(kArbitraryBufferId2);
  67. base::RunLoop wait_loop;
  68. int buffer_received_count = 0;
  69. EXPECT_CALL(*mock_video_frame_handler_1_,
  70. DoOnNewBuffer(kArbitraryBufferId1, _))
  71. .WillOnce(InvokeWithoutArgs([&wait_loop, &buffer_received_count]() {
  72. buffer_received_count++;
  73. if (buffer_received_count == 2)
  74. wait_loop.Quit();
  75. }));
  76. EXPECT_CALL(*mock_video_frame_handler_1_,
  77. DoOnNewBuffer(kArbitraryBufferId2, _))
  78. .WillOnce(InvokeWithoutArgs([&wait_loop, &buffer_received_count]() {
  79. buffer_received_count++;
  80. if (buffer_received_count == 2)
  81. wait_loop.Quit();
  82. }));
  83. Receiver1Connects();
  84. wait_loop.Run();
  85. }
  86. // Tests that when a receiver disconnects and a new receiver connects, the
  87. // virtual device adapter shares all valid buffer handles with it.
  88. TEST_F(GpuMemoryBufferVirtualDeviceMojoAdapterTest,
  89. BufferHandlesAreSharedWithSecondReceiver) {
  90. const int kArbitraryBufferId1 = 1;
  91. const int kArbitraryBufferId2 = 2;
  92. Receiver1Connects();
  93. ProducerSharesBufferHandle(kArbitraryBufferId1);
  94. ProducerSharesBufferHandle(kArbitraryBufferId2);
  95. Receiver1Disconnects();
  96. ProducerRetiresBufferHandle(kArbitraryBufferId1);
  97. base::RunLoop wait_loop;
  98. EXPECT_CALL(*mock_video_frame_handler_2_,
  99. DoOnNewBuffer(kArbitraryBufferId2, _))
  100. .WillOnce(InvokeWithoutArgs([&wait_loop]() { wait_loop.Quit(); }));
  101. Receiver2Connects();
  102. wait_loop.Run();
  103. }
  104. } // namespace video_capture