media/remoting/fake_remoter.h

   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 #ifndef MEDIA_REMOTING_FAKE_REMOTER_H_
   6 #define MEDIA_REMOTING_FAKE_REMOTER_H_
   7
   8 #include "base/memory/scoped_refptr.h"
   9 #include "media/base/decoder_buffer.h"
  10 #include "media/mojo/common/mojo_data_pipe_read_write.h"
  11 #include "media/mojo/mojom/remoting.mojom.h"
  12 #include "mojo/public/cpp/bindings/pending_receiver.h"
  13 #include "mojo/public/cpp/bindings/pending_remote.h"
  14 #include "mojo/public/cpp/bindings/receiver.h"
  15 #include "mojo/public/cpp/bindings/remote.h"
  16
  17 namespace media::cast {
  18 class DecoderBufferReader;
  19 }  // namespace media::cast
  20
  21 namespace media::remoting {
  22
  23 class RendererController;
  24
  25 class FakeRemotingDataStreamSender : public mojom::RemotingDataStreamSender {
  26  public:
  27   FakeRemotingDataStreamSender(
  28       mojo::PendingReceiver<mojom::RemotingDataStreamSender> receiver,
  29       mojo::ScopedDataPipeConsumerHandle consumer_handle);
  30
  31   FakeRemotingDataStreamSender(const FakeRemotingDataStreamSender&) = delete;
  32   FakeRemotingDataStreamSender& operator=(const FakeRemotingDataStreamSender&) =
  33       delete;
  34
  35   ~FakeRemotingDataStreamSender() override;
  36
  37   uint32_t send_frame_count() const { return send_frame_count_; }
  38   uint32_t cancel_in_flight_count() const { return cancel_in_flight_count_; }
  39   void ResetHistory();
  40   bool ValidateFrameBuffer(size_t index,
  41                            size_t size,
  42                            bool key_frame,
  43                            int pts_ms);
  44   void CloseDataPipe();
  45
  46  private:
  47   // mojom::RemotingDataStreamSender implementation.
  48   void SendFrame(media::mojom::DecoderBufferPtr buffer,
  49                  SendFrameCallback callback) final;
  50   void CancelInFlightData() final;
  51
  52   void OnFrameRead(scoped_refptr<media::DecoderBuffer> buffer);
  53
  54   mojo::Receiver<RemotingDataStreamSender> receiver_;
  55   std::unique_ptr<media::cast::DecoderBufferReader> decoder_buffer_reader_;
  56   SendFrameCallback send_frame_callback_;
  57
  58   std::vector<scoped_refptr<media::DecoderBuffer>> received_frame_list_;
  59   uint32_t send_frame_count_ = 0;
  60   uint32_t cancel_in_flight_count_ = 0;
  61 };
  62
  63 class FakeRemoter final : public mojom::Remoter {
  64  public:
  65   // |start_will_fail| indicates whether starting remoting will fail.
  66   FakeRemoter(mojo::PendingRemote<mojom::RemotingSource> source,
  67               bool start_will_fail);
  68
  69   FakeRemoter(const FakeRemoter&) = delete;
  70   FakeRemoter& operator=(const FakeRemoter&) = delete;
  71
  72   ~FakeRemoter() override;
  73
  74   // mojom::Remoter implementations.
  75   void Start() override;
  76   void StartWithPermissionAlreadyGranted() override;
  77   void StartDataStreams(mojo::ScopedDataPipeConsumerHandle audio_pipe,
  78                         mojo::ScopedDataPipeConsumerHandle video_pipe,
  79                         mojo::PendingReceiver<mojom::RemotingDataStreamSender>
  80                             audio_sender_receiver,
  81                         mojo::PendingReceiver<mojom::RemotingDataStreamSender>
  82                             video_sender_receiver) override;
  83   void Stop(mojom::RemotingStopReason reason) override;
  84   void SendMessageToSink(const std::vector<uint8_t>& message) override;
  85   void EstimateTransmissionCapacity(
  86       mojom::Remoter::EstimateTransmissionCapacityCallback callback) override;
  87
  88  private:
  89   void Started();
  90   void StartFailed();
  91   void Stopped(mojom::RemotingStopReason reason);
  92
  93   mojo::Remote<mojom::RemotingSource> source_;
  94   bool start_will_fail_;
  95
  96   std::unique_ptr<FakeRemotingDataStreamSender> audio_stream_sender_;
  97   std::unique_ptr<FakeRemotingDataStreamSender> video_stream_sender_;
  98
  99   base::WeakPtrFactory<FakeRemoter> weak_factory_{this};
 100 };
 101
 102 class FakeRemoterFactory final : public mojom::RemoterFactory {
 103  public:
 104   // |start_will_fail| indicates whether starting remoting will fail.
 105   explicit FakeRemoterFactory(bool start_will_fail);
 106
 107   FakeRemoterFactory(const FakeRemoterFactory&) = delete;
 108   FakeRemoterFactory& operator=(const FakeRemoterFactory&) = delete;
 109
 110   ~FakeRemoterFactory() override;
 111
 112   // mojom::RemoterFactory implementation.
 113   void Create(mojo::PendingRemote<mojom::RemotingSource> source,
 114               mojo::PendingReceiver<mojom::Remoter> receiver) override;
 115
 116   static std::unique_ptr<RendererController> CreateController(
 117       bool start_will_fail);
 118
 119  private:
 120   bool start_will_fail_;
 121 };
 122
 123 }  // namespace media::remoting
 124
 125 #endif  // MEDIA_REMOTING_FAKE_REMOTER_H_