media/mojo/services/mojo_demuxer_stream_adapter_unittest.cc

   1 // Copyright 2022 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <memory>
   6
   7 #include "base/run_loop.h"
   8 #include "base/task/sequenced_task_runner.h"
   9 #include "base/test/bind.h"
  10 #include "base/test/gmock_callback_support.h"
  11 #include "base/test/task_environment.h"
  12 #include "media/base/decoder_buffer.h"
  13 #include "media/base/demuxer_stream.h"
  14 #include "media/base/mock_filters.h"
  15 #include "media/base/test_helpers.h"
  16 #include "media/mojo/clients/mojo_demuxer_stream_impl.h"
  17 #include "media/mojo/services/mojo_demuxer_stream_adapter.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 using ::base::test::RunOnceCallback;
  21 using ::testing::_;
  22 using ::testing::Invoke;
  23
  24 namespace media {
  25
  26 // This test both MojoDemuxerStreamImpl and MojoDemuxerStreamAdapter.
  27 class MojoDemuxerStreamAdapterTest : public testing::Test {
  28  public:
  29   MojoDemuxerStreamAdapterTest() {
  30     task_runner_ = task_environment_.GetMainThreadTaskRunner();
  31   }
  32
  33   void Initialize(DemuxerStream::Type StreamType) {
  34     base::RunLoop init_loop;
  35     // wait initialize finish.
  36     auto init_done_cb = base::BindLambdaForTesting([&]() {
  37       is_stream_ready_ = true;
  38       init_loop.QuitWhenIdle();
  39     });
  40
  41     stream_ = std::make_unique<MockDemuxerStream>(StreamType);
  42     if (StreamType == DemuxerStream::Type::AUDIO)
  43       stream_->set_audio_decoder_config(TestAudioConfig::Normal());
  44     else if (StreamType == DemuxerStream::Type::VIDEO)
  45       stream_->set_video_decoder_config(TestVideoConfig::Normal());
  46
  47     mojo::PendingRemote<mojom::DemuxerStream> stream_remote;
  48     mojo_client_stream_ = std::make_unique<MojoDemuxerStreamImpl>(
  49         stream_.get(), stream_remote.InitWithNewPipeAndPassReceiver());
  50
  51     mojo_stream_adapter_ = std::make_unique<MojoDemuxerStreamAdapter>(
  52         std::move(stream_remote), std::move(init_done_cb));
  53     init_loop.Run();
  54   }
  55
  56   void ReadBuffer(int count, DemuxerStream::ReadCB done_cb) {
  57     EXPECT_TRUE(is_stream_ready_);
  58     EXPECT_GT(count, 0);
  59     mojo_stream_adapter_->Read(count, std::move(done_cb));
  60   }
  61
  62   base::test::TaskEnvironment task_environment_;
  63   scoped_refptr<base::SequencedTaskRunner> task_runner_;
  64   std::unique_ptr<MockDemuxerStream> stream_;
  65
  66   bool is_stream_ready_ = false;
  67   std::unique_ptr<MojoDemuxerStreamImpl> mojo_client_stream_;
  68   std::unique_ptr<MojoDemuxerStreamAdapter> mojo_stream_adapter_;
  69 };
  70
  71 TEST_F(MojoDemuxerStreamAdapterTest, InitializeAudioStream) {
  72   Initialize(DemuxerStream::Type::AUDIO);
  73
  74   mojo_stream_adapter_->audio_decoder_config();
  75   EXPECT_EQ(mojo_stream_adapter_->type(), DemuxerStream::Type::AUDIO);
  76   EXPECT_TRUE(mojo_stream_adapter_->SupportsConfigChanges());
  77 }
  78
  79 TEST_F(MojoDemuxerStreamAdapterTest, InitializeAudioStreamAndReadMultiBuffer) {
  80   Initialize(DemuxerStream::Type::AUDIO);
  81
  82   {
  83     base::RunLoop success_read_loop;
  84     DemuxerStream::DecoderBufferVector buffers;
  85     // Requested 200 but just return 100 buffer.
  86     for (int i = 0; i < 100; ++i) {
  87       buffers.emplace_back(base::MakeRefCounted<DecoderBuffer>(12));
  88     }
  89     EXPECT_CALL(*stream_, OnRead(_))
  90         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kOk, buffers));
  91
  92     auto done_cb = base::BindLambdaForTesting(
  93         [&](DemuxerStream::Status status,
  94             DemuxerStream::DecoderBufferVector buffers) {
  95           EXPECT_EQ(status, DemuxerStream::Status::kOk);
  96           EXPECT_EQ(buffers.size(), 100u);
  97           success_read_loop.QuitWhenIdle();
  98         });
  99     ReadBuffer(200, done_cb);
 100     success_read_loop.Run();
 101   }
 102
 103   {
 104     base::RunLoop config_changed_read_loop;
 105     EXPECT_CALL(*stream_, OnRead(_))
 106         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kConfigChanged,
 107                                      DemuxerStream::DecoderBufferVector()));
 108
 109     auto done_cb = base::BindLambdaForTesting(
 110         [&](DemuxerStream::Status status,
 111             DemuxerStream::DecoderBufferVector buffers) {
 112           EXPECT_EQ(status, DemuxerStream::Status::kConfigChanged);
 113           EXPECT_TRUE(buffers.empty());
 114           config_changed_read_loop.QuitWhenIdle();
 115         });
 116     ReadBuffer(200, done_cb);
 117     config_changed_read_loop.Run();
 118   }
 119
 120   {
 121     base::RunLoop abort_read_loop;
 122     EXPECT_CALL(*stream_, OnRead(_))
 123         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kAborted,
 124                                      DemuxerStream::DecoderBufferVector()));
 125
 126     auto done_cb = base::BindLambdaForTesting(
 127         [&](DemuxerStream::Status status,
 128             DemuxerStream::DecoderBufferVector buffers) {
 129           EXPECT_EQ(status, DemuxerStream::Status::kAborted);
 130           EXPECT_TRUE(buffers.empty());
 131           abort_read_loop.QuitWhenIdle();
 132         });
 133     ReadBuffer(200, done_cb);
 134     abort_read_loop.Run();
 135   }
 136 }
 137
 138 TEST_F(MojoDemuxerStreamAdapterTest, InitializeAudioStreamAndReadOneBuffer) {
 139   Initialize(DemuxerStream::Type::AUDIO);
 140
 141   {
 142     base::RunLoop success_read_loop;
 143     DemuxerStream::DecoderBufferVector buffers;
 144     buffers.emplace_back(base::MakeRefCounted<DecoderBuffer>(12));
 145     EXPECT_CALL(*stream_, OnRead(_))
 146         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kOk, buffers));
 147
 148     auto done_cb = base::BindLambdaForTesting(
 149         [&](DemuxerStream::Status status,
 150             DemuxerStream::DecoderBufferVector buffers) {
 151           EXPECT_EQ(status, DemuxerStream::Status::kOk);
 152           success_read_loop.QuitWhenIdle();
 153         });
 154     ReadBuffer(1, done_cb);
 155     success_read_loop.Run();
 156   }
 157
 158   {
 159     base::RunLoop config_changed_read_loop;
 160     EXPECT_CALL(*stream_, OnRead(_))
 161         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kConfigChanged,
 162                                      DemuxerStream::DecoderBufferVector()));
 163
 164     auto done_cb = base::BindLambdaForTesting(
 165         [&](DemuxerStream::Status status,
 166             DemuxerStream::DecoderBufferVector buffers) {
 167           EXPECT_EQ(status, DemuxerStream::Status::kConfigChanged);
 168           EXPECT_TRUE(buffers.empty());
 169           config_changed_read_loop.QuitWhenIdle();
 170         });
 171     ReadBuffer(1, done_cb);
 172     config_changed_read_loop.Run();
 173   }
 174
 175   {
 176     base::RunLoop abort_read_loop;
 177     EXPECT_CALL(*stream_, OnRead(_))
 178         .WillOnce(RunOnceCallback<0>(DemuxerStream::Status::kAborted,
 179                                      DemuxerStream::DecoderBufferVector()));
 180
 181     auto done_cb = base::BindLambdaForTesting(
 182         [&](DemuxerStream::Status status,
 183             DemuxerStream::DecoderBufferVector buffers) {
 184           EXPECT_EQ(status, DemuxerStream::Status::kAborted);
 185           EXPECT_TRUE(buffers.empty());
 186           abort_read_loop.QuitWhenIdle();
 187         });
 188     ReadBuffer(1, done_cb);
 189     abort_read_loop.Run();
 190   }
 191 }
 192
 193 TEST_F(MojoDemuxerStreamAdapterTest, InitializeVideoStream) {
 194   Initialize(DemuxerStream::Type::VIDEO);
 195
 196   mojo_stream_adapter_->video_decoder_config();
 197   EXPECT_EQ(mojo_stream_adapter_->type(), DemuxerStream::Type::VIDEO);
 198   EXPECT_TRUE(mojo_stream_adapter_->SupportsConfigChanges());
 199 }
 200
 201 TEST_F(MojoDemuxerStreamAdapterTest, EnableBitstreamConverter) {
 202   Initialize(DemuxerStream::Type::VIDEO);
 203
 204   base::RunLoop loop;
 205   EXPECT_CALL(*stream_, EnableBitstreamConverter());
 206   mojo_stream_adapter_->EnableBitstreamConverter();
 207   loop.RunUntilIdle();
 208 }
 209
 210 }  // namespace media