media/remoting/fake_remoter.cc

   1 // Copyright 2016 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 "media/remoting/fake_remoter.h"
   6
   7 #include <memory>
   8
   9 #include "base/functional/bind.h"
  10 #include "base/functional/callback.h"
  11 #include "base/functional/callback_helpers.h"
  12 #include "base/task/single_thread_task_runner.h"
  13 #include "build/buildflag.h"
  14 #include "media/cast/openscreen/decoder_buffer_reader.h"
  15 #include "media/media_buildflags.h"
  16 #include "media/remoting/renderer_controller.h"
  17 #include "mojo/public/cpp/bindings/self_owned_receiver.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19
  20 #if BUILDFLAG(ENABLE_MEDIA_REMOTING_RPC)
  21 #include "media/cast/openscreen/remoting_proto_utils.h"  // nogncheck
  22 #endif
  23
  24 namespace media {
  25 namespace remoting {
  26
  27 FakeRemotingDataStreamSender::FakeRemotingDataStreamSender(
  28     mojo::PendingReceiver<mojom::RemotingDataStreamSender> stream_sender,
  29     mojo::ScopedDataPipeConsumerHandle consumer_handle)
  30     : receiver_(this, std::move(stream_sender)),
  31       decoder_buffer_reader_(std::make_unique<media::cast::DecoderBufferReader>(
  32           base::BindRepeating(&FakeRemotingDataStreamSender::OnFrameRead,
  33                               base::Unretained(this)),
  34           std::move(consumer_handle))) {
  35   decoder_buffer_reader_->ReadBufferAsync();
  36 }
  37
  38 FakeRemotingDataStreamSender::~FakeRemotingDataStreamSender() = default;
  39
  40 void FakeRemotingDataStreamSender::ResetHistory() {
  41   send_frame_count_ = 0;
  42   cancel_in_flight_count_ = 0;
  43   received_frame_list_.clear();
  44 }
  45
  46 bool FakeRemotingDataStreamSender::ValidateFrameBuffer(size_t index,
  47                                                        size_t size,
  48                                                        bool key_frame,
  49                                                        int pts_ms) {
  50   if (index >= received_frame_list_.size()) {
  51     VLOG(1) << "There is no such frame";
  52     return false;
  53   }
  54
  55 #if BUILDFLAG(ENABLE_MEDIA_REMOTING_RPC)
  56   scoped_refptr<DecoderBuffer> media_buffer = received_frame_list_[index];
  57
  58   // Checks if pts is correct or not
  59   if (media_buffer->timestamp().InMilliseconds() != pts_ms) {
  60     VLOG(1) << "Pts should be:" << pts_ms << "("
  61             << media_buffer->timestamp().InMilliseconds() << ")";
  62     return false;
  63   }
  64
  65   // Checks if key frame is set correct or not
  66   if (media_buffer->is_key_frame() != key_frame) {
  67     VLOG(1) << "Key frame should be:" << key_frame << "("
  68             << media_buffer->is_key_frame() << ")";
  69     return false;
  70   }
  71
  72   // Checks if frame buffer size is correct or not
  73   if (media_buffer->data_size() != size) {
  74     VLOG(1) << "Buffer size should be:" << size << "("
  75             << media_buffer->data_size() << ")";
  76     return false;
  77   }
  78
  79   // Checks if frame buffer is correct or not.
  80   bool return_value = true;
  81   const uint8_t* buffer = media_buffer->data();
  82   for (size_t i = 0; i < media_buffer->data_size(); ++i) {
  83     uint32_t value = static_cast<uint32_t>(i & 0xFF);
  84     if (value != static_cast<uint32_t>(buffer[i])) {
  85       VLOG(1) << "buffer index: " << i << " should be "
  86               << static_cast<uint32_t>(value) << " ("
  87               << static_cast<uint32_t>(buffer[i]) << ")";
  88       return_value = false;
  89     }
  90   }
  91   return return_value;
  92 #else
  93   return true;
  94 #endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING_RPC)
  95 }
  96
  97 void FakeRemotingDataStreamSender::CloseDataPipe() {
  98   decoder_buffer_reader_.reset();
  99 }
 100
 101 void FakeRemotingDataStreamSender::SendFrame(
 102     media::mojom::DecoderBufferPtr buffer,
 103     SendFrameCallback callback) {
 104   if (!decoder_buffer_reader_) {
 105     std::move(callback).Run();
 106     return;
 107   }
 108
 109   DCHECK(!send_frame_callback_);
 110   send_frame_callback_ = std::move(callback);
 111   decoder_buffer_reader_->ProvideBuffer(std::move(buffer));
 112 }
 113
 114 void FakeRemotingDataStreamSender::OnFrameRead(
 115     scoped_refptr<media::DecoderBuffer> buffer) {
 116   DCHECK(decoder_buffer_reader_);
 117   DCHECK(send_frame_callback_);
 118
 119   decoder_buffer_reader_->ReadBufferAsync();
 120   std::move(send_frame_callback_).Run();
 121
 122   ++send_frame_count_;
 123   received_frame_list_.push_back(std::move(buffer));
 124 }
 125
 126 void FakeRemotingDataStreamSender::CancelInFlightData() {
 127   ++cancel_in_flight_count_;
 128 }
 129
 130 FakeRemoter::FakeRemoter(mojo::PendingRemote<mojom::RemotingSource> source,
 131                          bool start_will_fail)
 132     : source_(std::move(source)), start_will_fail_(start_will_fail) {}
 133
 134 FakeRemoter::~FakeRemoter() = default;
 135
 136 void FakeRemoter::Start() {
 137   if (start_will_fail_) {
 138     base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
 139         FROM_HERE,
 140         base::BindOnce(&FakeRemoter::StartFailed, weak_factory_.GetWeakPtr()));
 141   } else {
 142     base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
 143         FROM_HERE,
 144         base::BindOnce(&FakeRemoter::Started, weak_factory_.GetWeakPtr()));
 145   }
 146 }
 147
 148 void FakeRemoter::StartWithPermissionAlreadyGranted() {
 149   Start();
 150 }
 151
 152 void FakeRemoter::StartDataStreams(
 153     mojo::ScopedDataPipeConsumerHandle audio_pipe,
 154     mojo::ScopedDataPipeConsumerHandle video_pipe,
 155     mojo::PendingReceiver<mojom::RemotingDataStreamSender> audio_sender,
 156     mojo::PendingReceiver<mojom::RemotingDataStreamSender> video_sender) {
 157   if (audio_pipe.is_valid()) {
 158     VLOG(2) << "Has audio";
 159     audio_stream_sender_ = std::make_unique<FakeRemotingDataStreamSender>(
 160         std::move(audio_sender), std::move(audio_pipe));
 161   }
 162
 163   if (video_pipe.is_valid()) {
 164     VLOG(2) << "Has video";
 165     video_stream_sender_ = std::make_unique<FakeRemotingDataStreamSender>(
 166         std::move(video_sender), std::move(video_pipe));
 167   }
 168 }
 169
 170 void FakeRemoter::Stop(mojom::RemotingStopReason reason) {
 171   base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask(
 172       FROM_HERE, base::BindOnce(&FakeRemoter::Stopped,
 173                                 weak_factory_.GetWeakPtr(), reason));
 174 }
 175
 176 void FakeRemoter::SendMessageToSink(const std::vector<uint8_t>& message) {}
 177
 178 void FakeRemoter::EstimateTransmissionCapacity(
 179     mojom::Remoter::EstimateTransmissionCapacityCallback callback) {
 180   std::move(callback).Run(10000000 / 8.0);
 181 }
 182
 183 void FakeRemoter::Started() {
 184   source_->OnStarted();
 185 }
 186
 187 void FakeRemoter::StartFailed() {
 188   source_->OnStartFailed(mojom::RemotingStartFailReason::ROUTE_TERMINATED);
 189 }
 190
 191 void FakeRemoter::Stopped(mojom::RemotingStopReason reason) {
 192   source_->OnStopped(reason);
 193 }
 194
 195 FakeRemoterFactory::FakeRemoterFactory(bool start_will_fail)
 196     : start_will_fail_(start_will_fail) {}
 197
 198 FakeRemoterFactory::~FakeRemoterFactory() = default;
 199
 200 void FakeRemoterFactory::Create(
 201     mojo::PendingRemote<mojom::RemotingSource> source,
 202     mojo::PendingReceiver<mojom::Remoter> receiver) {
 203   mojo::MakeSelfOwnedReceiver(
 204       std::make_unique<FakeRemoter>(std::move(source), start_will_fail_),
 205       std::move(receiver));
 206 }
 207
 208 // static
 209 std::unique_ptr<RendererController> FakeRemoterFactory::CreateController(
 210     bool start_will_fail) {
 211   mojo::PendingRemote<mojom::RemotingSource> remoting_source;
 212   auto remoting_source_receiver =
 213       remoting_source.InitWithNewPipeAndPassReceiver();
 214   mojo::PendingRemote<mojom::Remoter> remoter;
 215   FakeRemoterFactory remoter_factory(start_will_fail);
 216   remoter_factory.Create(std::move(remoting_source),
 217                          remoter.InitWithNewPipeAndPassReceiver());
 218   return std::make_unique<RendererController>(
 219       std::move(remoting_source_receiver), std::move(remoter));
 220 }
 221
 222 }  // namespace remoting
 223 }  // namespace media