Media Remoting: End to end integration tests.

media/test/pipeline_integration_test_base.h

 // Copyright (c) 2012 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.
 
 #ifndef MEDIA_TEST_PIPELINE_INTEGRATION_TEST_BASE_H_
 #define MEDIA_TEST_PIPELINE_INTEGRATION_TEST_BASE_H_
 
 #include <stdint.h>
 #include <memory>
 
@@ skipping 30 matching lines @@
 class DummyTickClock : public base::TickClock {
  public:
   DummyTickClock() : now_() {}
   ~DummyTickClock() override {}
   base::TimeTicks NowTicks() override;
 
  private:
   base::TimeTicks now_;
 };
 
+class PipelineTestRendererFactory {
+ public:
+  virtual ~PipelineTestRendererFactory() {}
+  // Creates and returns a Renderer.
+  virtual std::unique_ptr<Renderer> CreateRenderer(
+      ScopedVector<VideoDecoder> prepend_video_decoders =
+          ScopedVector<VideoDecoder>(),
+      ScopedVector<AudioDecoder> prepend_audio_decoders =
+          ScopedVector<AudioDecoder>()) = 0;
+};
+
+enum PipelineType {
+  Media,          // Test the general media pipeline.
+  MediaRemoting,  // Test Media Remoting pipeline.
+};
+
 // Integration tests for Pipeline. Real demuxers, real decoders, and
 // base renderer implementations are used to verify pipeline functionality. The
 // renderers used in these tests rely heavily on the AudioRendererBase &
 // VideoRendererImpl implementations which contain a majority of the code used
 // in the real AudioRendererImpl & SkCanvasVideoRenderer implementations used in
 // the browser. The renderers in this test don't actually write data to a
 // display or audio device. Both of these devices are simulated since they have
 // little effect on verifying pipeline behavior and allow tests to run faster
 // than real-time.
 class PipelineIntegrationTestBase : public Pipeline::Client {
@@ skipping 61 matching lines @@
   // Pipeline must have been started with clockless playback enabled.
   base::TimeDelta GetAudioTime();
 
   // Sets a callback to handle EME "encrypted" event. Must be called to test
   // potentially encrypted media.
   void set_encrypted_media_init_data_cb(
       const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) {
     encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   }
 
+  std::unique_ptr<Renderer> CreateRenderer(
+      ScopedVector<VideoDecoder> prepend_video_decoders,
+      ScopedVector<AudioDecoder> prepend_audio_decoders);
+
  protected:
-  base::MessageLoop message_loop_;
-  base::MD5Context md5_context_;
-  bool hashing_enabled_;
-  bool clockless_playback_;
-
-  // TaskScheduler is used only for FFmpegDemuxer.
-  std::unique_ptr<base::test::ScopedTaskScheduler> task_scheduler_;
-  std::unique_ptr<Demuxer> demuxer_;
-  std::unique_ptr<DataSource> data_source_;
-  std::unique_ptr<PipelineImpl> pipeline_;
-  scoped_refptr<NullAudioSink> audio_sink_;
-  scoped_refptr<ClocklessAudioSink> clockless_audio_sink_;
-  std::unique_ptr<NullVideoSink> video_sink_;
-  bool ended_;
-  PipelineStatus pipeline_status_;
-  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
-  VideoPixelFormat last_video_frame_format_;
-  ColorSpace last_video_frame_color_space_;
-  DummyTickClock dummy_clock_;
-  PipelineMetadata metadata_;
-  scoped_refptr<VideoFrame> last_frame_;
-  base::TimeDelta current_duration_;
-
   PipelineStatus StartInternal(
       std::unique_ptr<DataSource> data_source,
       CdmContext* cdm_context,
       uint8_t test_type,
       ScopedVector<VideoDecoder> prepend_video_decoders =
           ScopedVector<VideoDecoder>(),
       ScopedVector<AudioDecoder> prepend_audio_decoders =
           ScopedVector<AudioDecoder>());
 
   PipelineStatus StartWithFile(
@@ skipping 10 matching lines @@
   void DemuxerEncryptedMediaInitDataCB(EmeInitDataType type,
                                        const std::vector<uint8_t>& init_data);
 
   void DemuxerMediaTracksUpdatedCB(std::unique_ptr<MediaTracks> tracks);
 
   void QuitAfterCurrentTimeTask(const base::TimeDelta& quit_time);
 
   // Creates Demuxer and sets |demuxer_|.
   void CreateDemuxer(std::unique_ptr<DataSource> data_source);
 
-  // Creates and returns a Renderer.
-  virtual std::unique_ptr<Renderer> CreateRenderer(
-      ScopedVector<VideoDecoder> prepend_video_decoders =
-          ScopedVector<VideoDecoder>(),
-      ScopedVector<AudioDecoder> prepend_audio_decoders =
-          ScopedVector<AudioDecoder>());
-
   void OnVideoFramePaint(const scoped_refptr<VideoFrame>& frame);
 
   void CheckDuration();
 
   // Return the media start time from |demuxer_|.
   base::TimeDelta GetStartTime();
 
+#if BUILDFLAG(ENABLE_MEDIA_REMOTING)
+  // Proxy all control and data flows through a media remoting RPC pipeline, to
+  // test that an end-to-end media remoting pipeline works the same as a normal,
+  // local pipeline.
+  void SetUpRemotingPipeline();
+#endif  // BUILDFLAG(ENABLE_MEDIA_REMOTING)
+
   MOCK_METHOD1(DecryptorAttached, void(bool));
   // Pipeline::Client overrides.
   void OnError(PipelineStatus status) override;
   void OnEnded() override;
   MOCK_METHOD1(OnMetadata, void(PipelineMetadata));
   MOCK_METHOD1(OnBufferingStateChange, void(BufferingState));
   MOCK_METHOD0(OnDurationChange, void());
   MOCK_METHOD2(OnAddTextTrack,
                void(const TextTrackConfig& config,
                     const AddTextTrackDoneCB& done_cb));
   MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
   MOCK_METHOD1(OnVideoNaturalSizeChange, void(const gfx::Size&));
   MOCK_METHOD1(OnVideoOpacityChange, void(bool));
   MOCK_METHOD0(OnVideoAverageKeyframeDistanceUpdate, void());
+
+  base::MessageLoop message_loop_;
+  base::MD5Context md5_context_;
+  bool hashing_enabled_;
+  bool clockless_playback_;
+
+  // TaskScheduler is used only for FFmpegDemuxer.
+  std::unique_ptr<base::test::ScopedTaskScheduler> task_scheduler_;
+  std::unique_ptr<Demuxer> demuxer_;
+  std::unique_ptr<DataSource> data_source_;
+  std::unique_ptr<PipelineImpl> pipeline_;
+  scoped_refptr<NullAudioSink> audio_sink_;
+  scoped_refptr<ClocklessAudioSink> clockless_audio_sink_;
+  std::unique_ptr<NullVideoSink> video_sink_;
+  bool ended_;
+  PipelineStatus pipeline_status_;
+  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
+  VideoPixelFormat last_video_frame_format_;
+  ColorSpace last_video_frame_color_space_;
+  DummyTickClock dummy_clock_;
+  PipelineMetadata metadata_;
+  scoped_refptr<VideoFrame> last_frame_;
+  base::TimeDelta current_duration_;
+  std::unique_ptr<PipelineTestRendererFactory> renderer_factory_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PipelineIntegrationTestBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_TEST_PIPELINE_INTEGRATION_TEST_BASE_H_