RELAND: 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>
 
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/scoped_task_scheduler.h"
 #include "media/audio/clockless_audio_sink.h"
 #include "media/audio/null_audio_sink.h"
+#include "media/base/cdm_context.h"
+#include "media/base/content_decryption_module.h"
 #include "media/base/demuxer.h"
 #include "media/base/null_video_sink.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/text_track.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_frame.h"
+#include "media/filters/chunk_demuxer.h"
 #include "media/renderers/video_renderer_impl.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace media {
 
-class CdmContext;
+class AesDecryptor;
 
 // Empty MD5 hash string.  Used to verify empty video tracks.
 extern const char kNullVideoHash[];
 
 // Empty hash string.  Used to verify empty audio tracks.
 extern const char kNullAudioHash[];
 
+// Indicates that the whole file should be appended.
+extern const size_t kAppendWholeFile;
+
 // Dummy tick clock which advances extremely quickly (1 minute every time
 // NowTicks() is called).
 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(
+      CreateVideoDecodersCB prepend_video_decoders_cb = CreateVideoDecodersCB(),
+      CreateAudioDecodersCB prepend_audio_decoders_cb =
+          CreateAudioDecodersCB()) = 0;
+};
+
+// Helper class that emulates calls made on the ChunkDemuxer by the

[DaleCurtis, 2017/04/20 18:24:51]

Should be extracted to a mock_media_source.{h,cc} file instead if we're going to
move it.

[xjz, 2017/04/20 21:26:10]

Done.

+// Media Source API.
+class MockMediaSource {
+ public:
+  MockMediaSource(const std::string& filename,
+                  const std::string& mimetype,
+                  size_t initial_append_size);
+  ~MockMediaSource();
+
+  std::unique_ptr<Demuxer> GetDemuxer();
+  void set_encrypted_media_init_data_cb(
+      const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb);
+  void set_demuxer_failure_cb(const PipelineStatusCB& demuxer_failure_cb);
+  void Seek(base::TimeDelta seek_time,
+            size_t new_position,
+            size_t seek_append_size);
+  void Seek(base::TimeDelta seek_time);
+  void AppendData(size_t size);
+  bool AppendAtTime(base::TimeDelta timestamp_offset,
+                    const uint8_t* pData,
+                    int size);
+  void AppendAtTimeWithWindow(base::TimeDelta timestamp_offset,
+                              base::TimeDelta append_window_start,
+                              base::TimeDelta append_window_end,
+                              const uint8_t* pData,
+                              int size);
+  void SetMemoryLimits(size_t limit_bytes);
+  void EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize);
+  void RemoveRange(base::TimeDelta start, base::TimeDelta end);
+  void EndOfStream();
+  void Shutdown();
+  void DemuxerOpened();
+  void DemuxerOpenedTask();
+  ChunkDemuxer::Status AddId();
+  void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
+                                const std::vector<uint8_t>& init_data);
+  base::TimeDelta last_timestamp_offset() const;
+  void InitSegmentReceived(std::unique_ptr<MediaTracks> tracks);
+  MOCK_METHOD1(InitSegmentReceivedMock, void(std::unique_ptr<MediaTracks>&));
+
+ private:
+  MediaLog media_log_;
+  scoped_refptr<DecoderBuffer> file_data_;
+  size_t current_position_;
+  size_t initial_append_size_;
+  std::string mimetype_;
+  ChunkDemuxer* chunk_demuxer_;
+  std::unique_ptr<Demuxer> owned_chunk_demuxer_;
+  PipelineStatusCB demuxer_failure_cb_;
+  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb_;
+  base::TimeDelta last_timestamp_offset_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockMediaSource);
+};
+
+// Note: Tests using this class only exercise the DecryptingDemuxerStream path.

[DaleCurtis, 2017/04/20 18:24:51]

Ditto.

[xjz, 2017/04/20 21:26:10]

Done.

+// They do not exercise the Decrypting{Audio|Video}Decoder path.
+class FakeEncryptedMedia {
+ public:
+  // Defines the behavior of the "app" that responds to EME events.
+  class AppBase {
+   public:
+    virtual ~AppBase() {}
+
+    virtual void OnSessionMessage(
+        const std::string& session_id,
+        ContentDecryptionModule::MessageType message_type,
+        const std::vector<uint8_t>& message,
+        AesDecryptor* decryptor) = 0;
+
+    virtual void OnSessionClosed(const std::string& session_id) = 0;
+
+    virtual void OnSessionKeysChange(const std::string& session_id,
+                                     bool has_additional_usable_key,
+                                     CdmKeysInfo keys_info) = 0;
+
+    virtual void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
+                                          const std::vector<uint8_t>& init_data,
+                                          AesDecryptor* decryptor) = 0;
+  };
+
+  FakeEncryptedMedia(AppBase* app);
+  ~FakeEncryptedMedia();
+  CdmContext* GetCdmContext();
+  // Callbacks for firing session events. Delegate to |app_|.
+  void OnSessionMessage(const std::string& session_id,
+                        ContentDecryptionModule::MessageType message_type,
+                        const std::vector<uint8_t>& message);
+  void OnSessionClosed(const std::string& session_id);
+  void OnSessionKeysChange(const std::string& session_id,
+                           bool has_additional_usable_key,
+                           CdmKeysInfo keys_info);
+  void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
+                                const std::vector<uint8_t>& init_data);
+
+ private:
+  class TestCdmContext : public CdmContext {
+   public:
+    TestCdmContext(Decryptor* decryptor);
+    Decryptor* GetDecryptor() final;
+    int GetCdmId() const final;
+
+   private:
+    Decryptor* decryptor_;
+  };
+
+  scoped_refptr<AesDecryptor> decryptor_;
+  TestCdmContext cdm_context_;
+  std::unique_ptr<AppBase> app_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeEncryptedMedia);
+};
+
 // 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(
+      CreateVideoDecodersCB prepend_video_decoders_cb,
+      CreateAudioDecodersCB prepend_audio_decoders_cb);
+
  protected:
   MediaLog media_log_;
   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_;
 
   PipelineStatus StartInternal(
       std::unique_ptr<DataSource> data_source,
       CdmContext* cdm_context,
       uint8_t test_type,
       CreateVideoDecodersCB prepend_video_decoders_cb = CreateVideoDecodersCB(),
       CreateAudioDecodersCB prepend_audio_decoders_cb =
           CreateAudioDecodersCB());
 
   PipelineStatus StartWithFile(
       const std::string& filename,
       CdmContext* cdm_context,
       uint8_t test_type,
       CreateVideoDecodersCB prepend_video_decoders_cb = CreateVideoDecodersCB(),
       CreateAudioDecodersCB prepend_audio_decoders_cb =
           CreateAudioDecodersCB());
 
+  PipelineStatus StartPipelineWithMediaSource(MockMediaSource* source);
+  PipelineStatus StartPipelineWithEncryptedMedia(
+      MockMediaSource* source,
+      FakeEncryptedMedia* encrypted_media);
+  PipelineStatus StartPipelineWithMediaSource(
+      MockMediaSource* source,
+      uint8_t test_type,
+      FakeEncryptedMedia* encrypted_media);
+
   void OnSeeked(base::TimeDelta seek_time, PipelineStatus status);
   void OnStatusCallback(PipelineStatus status);
   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(
-      CreateVideoDecodersCB prepend_video_decoders_cb = CreateVideoDecodersCB(),
-      CreateAudioDecodersCB prepend_audio_decoders_cb =
-          CreateAudioDecodersCB());
-
   void OnVideoFramePaint(const scoped_refptr<VideoFrame>& frame);
 
   void CheckDuration();
 
   // Return the media start time from |demuxer_|.
   base::TimeDelta GetStartTime();
 
+  bool TestSeekDuringRead(const std::string& filename,

[DaleCurtis, 2017/04/20 18:24:51]

This should be on the normal PIT since you can drop these tests from your side.

[xjz, 2017/04/20 21:26:10]

Done.

+                          const std::string& mimetype,
+                          int initial_append_size,
+                          base::TimeDelta start_seek_time,
+                          base::TimeDelta seek_time,
+                          int seek_file_position,
+                          int seek_append_size);
+
   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());
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PipelineIntegrationTestBase);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_TEST_PIPELINE_INTEGRATION_TEST_BASE_H_