Create abstract interface for media::Pipeline.

media/test/pipeline_integration_test.cc

 // 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.
 
 #include <stddef.h>
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 87 matching lines @@
 #if defined(USE_PROPRIETARY_CODECS)
 const char kADTS[] = "audio/aac";
 const char kMP4[] = "video/mp4; codecs=\"avc1.4D4041,mp4a.40.2\"";
 const char kMP4VideoAVC3[] = "video/mp4; codecs=\"avc3.64001f\"";
 const char kMP4Video[] = "video/mp4; codecs=\"avc1.4D4041\"";
 const char kMP4Audio[] = "audio/mp4; codecs=\"mp4a.40.2\"";
 const char kMP3[] = "audio/mpeg";
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Key used to encrypt test files.
-const uint8_t kSecretKey[] = {
-  0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
-  0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c
-};
+const uint8_t kSecretKey[] = {0xeb, 0xdd, 0x62, 0xf1, 0x68, 0x14, 0xd2, 0x7b,
+                              0x68, 0xef, 0x12, 0x2a, 0xfc, 0xe4, 0xae, 0x3c};
 
 // The key ID for all encrypted files.
-const uint8_t kKeyId[] = {
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
-  0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35
-};
+const uint8_t kKeyId[] = {0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
+                          0x38, 0x39, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35};
 
 const size_t kAppendWholeFile = std::numeric_limits<size_t>::max();
 
 // Constants for the Media Source config change tests.
 const int kAppendTimeSec = 1;
 const int kAppendTimeMs = kAppendTimeSec * 1000;
 const int k320WebMFileDurationMs = 2736;
 const int k320EncWebMFileDurationMs = 2737;
 const int k640WebMFileDurationMs = 2749;
 const int kOpusEndTrimmingWebMFileDurationMs = 2741;
@@ skipping 164 matching lines @@
  public:
   KeyProvidingApp() {}
 
   void OnResolveWithSession(PromiseResult expected,
                             const std::string& session_id) {
     EXPECT_EQ(expected, RESOLVED);
     EXPECT_GT(session_id.length(), 0ul);
     current_session_id_ = session_id;
   }
 
-  void OnResolve(PromiseResult expected) {
-    EXPECT_EQ(expected, RESOLVED);
-  }
+  void OnResolve(PromiseResult expected) { EXPECT_EQ(expected, RESOLVED); }
 
   void OnReject(PromiseResult expected,
                 media::MediaKeys::Exception exception_code,
                 uint32_t system_code,
                 const std::string& error_message) {
     EXPECT_EQ(expected, REJECTED) << error_message;
   }
 
   scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
     scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
-        base::Bind(
-            &KeyProvidingApp::OnResolve, base::Unretained(this), expected),
-        base::Bind(
-            &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
+        base::Bind(&KeyProvidingApp::OnResolve, base::Unretained(this),
+                   expected),
+        base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
+                   expected)));
     return promise;
   }
 
   scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
       PromiseResult expected) {
     scoped_ptr<media::NewSessionCdmPromise> promise(
         new media::CdmCallbackPromise<std::string>(
             base::Bind(&KeyProvidingApp::OnResolveWithSession,
-                       base::Unretained(this),
-                       expected),
-            base::Bind(
-                &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
+                       base::Unretained(this), expected),
+            base::Bind(&KeyProvidingApp::OnReject, base::Unretained(this),
+                       expected)));
     return promise;
   }
 
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
                         const std::vector<uint8_t>& message,
                         const GURL& legacy_destination_url,
                         AesDecryptor* decryptor) override {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
@@ skipping 172 matching lines @@
   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;
   }
 
   void Seek(base::TimeDelta seek_time,
             size_t new_position,
             size_t seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
 
-    chunk_demuxer_->ResetParserState(
-        kSourceId,
-        base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_);
+    chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(),
+                                     kInfiniteDuration(),
+                                     &last_timestamp_offset_);
 
     DCHECK_LT(new_position, file_data_->data_size());
     current_position_ = new_position;
 
     AppendData(seek_append_size);
   }
 
   void Seek(base::TimeDelta seek_time) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
   }
 
   void AppendData(size_t size) {
     DCHECK(chunk_demuxer_);
     DCHECK_LT(current_position_, file_data_->data_size());
     DCHECK_LE(current_position_ + size, file_data_->data_size());
 
     chunk_demuxer_->AppendData(
         kSourceId, file_data_->data() + current_position_, size,
         base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_,
         base::Bind(&MockMediaSource::InitSegmentReceived,
                    base::Unretained(this)));
     current_position_ += size;
   }
 
   void AppendAtTime(base::TimeDelta timestamp_offset,
                     const uint8_t* pData,
                     int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
-    chunk_demuxer_->AppendData(kSourceId, pData, size,
-                               base::TimeDelta(), kInfiniteDuration(),
-                               &timestamp_offset,
+    chunk_demuxer_->AppendData(kSourceId, pData, size, base::TimeDelta(),
+                               kInfiniteDuration(), &timestamp_offset,
                                base::Bind(&MockMediaSource::InitSegmentReceived,
                                           base::Unretained(this)));
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void AppendAtTimeWithWindow(base::TimeDelta timestamp_offset,
                               base::TimeDelta append_window_start,
                               base::TimeDelta append_window_end,
                               const uint8_t* pData,
                               int size) {
     CHECK(!chunk_demuxer_->IsParsingMediaSegment(kSourceId));
-    chunk_demuxer_->AppendData(kSourceId,
-                               pData,
-                               size,
-                               append_window_start,
-                               append_window_end,
-                               &timestamp_offset,
+    chunk_demuxer_->AppendData(kSourceId, pData, size, append_window_start,
+                               append_window_end, &timestamp_offset,
                                base::Bind(&MockMediaSource::InitSegmentReceived,
                                           base::Unretained(this)));
     last_timestamp_offset_ = timestamp_offset;
   }
 
   void SetMemoryLimits(size_t limit_bytes) {
     chunk_demuxer_->SetMemoryLimits(DemuxerStream::AUDIO, limit_bytes);
     chunk_demuxer_->SetMemoryLimits(DemuxerStream::VIDEO, limit_bytes);
   }
 
   void EvictCodedFrames(base::TimeDelta currentMediaTime, size_t newDataSize) {
     chunk_demuxer_->EvictCodedFrames(kSourceId, currentMediaTime, newDataSize);
   }
 
   void RemoveRange(base::TimeDelta start, base::TimeDelta end) {
     chunk_demuxer_->Remove(kSourceId, start, end);
   }
 
-  void EndOfStream() {
-    chunk_demuxer_->MarkEndOfStream(PIPELINE_OK);
-  }
+  void EndOfStream() { chunk_demuxer_->MarkEndOfStream(PIPELINE_OK); }
 
   void Shutdown() {
     if (!chunk_demuxer_)
       return;
-    chunk_demuxer_->ResetParserState(
-        kSourceId,
-        base::TimeDelta(), kInfiniteDuration(), &last_timestamp_offset_);
+    chunk_demuxer_->ResetParserState(kSourceId, base::TimeDelta(),
+                                     kInfiniteDuration(),
+                                     &last_timestamp_offset_);
     chunk_demuxer_->Shutdown();
     chunk_demuxer_ = NULL;
   }
 
   void DemuxerOpened() {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&MockMediaSource::DemuxerOpenedTask,
                               base::Unretained(this)));
   }
 
   void DemuxerOpenedTask() {
     // This code assumes that |mimetype_| is one of the following forms.
     // 1. audio/mpeg
     // 2. video/webm;codec="vorbis,vp8".
     size_t semicolon = mimetype_.find(";");
     std::string type = mimetype_;
     std::vector<std::string> codecs;
     if (semicolon != std::string::npos) {
       type = mimetype_.substr(0, semicolon);
       size_t codecs_param_start = mimetype_.find("codecs=\"", semicolon);
 
       CHECK_NE(codecs_param_start, std::string::npos);
 
-      codecs_param_start += 8; // Skip over the codecs=".
+      codecs_param_start += 8;  // Skip over the codecs=".
 
       size_t codecs_param_end = mimetype_.find("\"", codecs_param_start);
 
       CHECK_NE(codecs_param_end, std::string::npos);
 
-      std::string codecs_param =
-          mimetype_.substr(codecs_param_start,
-                           codecs_param_end - codecs_param_start);
-      codecs = base::SplitString(
-          codecs_param, ",", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+      std::string codecs_param = mimetype_.substr(
+          codecs_param_start, codecs_param_end - codecs_param_start);
+      codecs = base::SplitString(codecs_param, ",", base::KEEP_WHITESPACE,
+                                 base::SPLIT_WANT_NONEMPTY);
     }
 
     CHECK_EQ(chunk_demuxer_->AddId(kSourceId, type, codecs), ChunkDemuxer::kOk);
 
     AppendData(initial_append_size_);
   }
 
   void OnEncryptedMediaInitData(EmeInitDataType init_data_type,
                                 const std::vector<uint8_t>& init_data) {
     DCHECK(!init_data.empty());
@@ skipping 86 matching lines @@
     hashing_enabled_ = true;
     StartPipelineWithMediaSource(source);
   }
 
   void StartHashedClocklessPipelineWithMediaSource(MockMediaSource* source) {
     hashing_enabled_ = true;
     clockless_playback_ = true;
     StartPipelineWithMediaSource(source);
   }
 
-  void StartPipelineWithEncryptedMedia(
-      MockMediaSource* source,
-      FakeEncryptedMedia* encrypted_media) {
+  void StartPipelineWithEncryptedMedia(MockMediaSource* source,
+                                       FakeEncryptedMedia* encrypted_media) {
     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
     EXPECT_CALL(*this, DecryptorAttached(true));
 
@@ skipping 245 matching lines @@
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(k320WebMFileDurationMs,
             pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   ASSERT_TRUE(WaitUntilOnEnded());
 
-  EXPECT_EQ(kLiveTimelineOffset(),
-            demuxer_->GetTimelineOffset());
+  EXPECT_EQ(kLiveTimelineOffset(), demuxer_->GetTimelineOffset());
   source.Shutdown();
   Stop();
 }
 
 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_VP9_WebM) {
   MockMediaSource source("bear-vp9.webm", kWebMVP9, 67504);
   StartPipelineWithMediaSource(&source);
   source.EndOfStream();
 
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
@@ skipping 265 matching lines @@
   EXPECT_EQ(325, source.last_timestamp_offset().InMilliseconds());
 
   // Trim off multiple frames off the beginning of the segment which will cause
   // the first decoded frame to be incorrect if preroll isn't implemented.
   const base::TimeDelta adts_preroll_duration =
       base::TimeDelta::FromSecondsD(2.5 * 1024 / 44100);
   const base::TimeDelta append_time =
       source.last_timestamp_offset() - adts_preroll_duration;
 
   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.adts");
-  source.AppendAtTimeWithWindow(append_time,
-                                append_time + adts_preroll_duration,
-                                kInfiniteDuration(),
-                                second_file->data(),
-                                second_file->data_size());
+  source.AppendAtTimeWithWindow(
+      append_time, append_time + adts_preroll_duration, kInfiniteDuration(),
+      second_file->data(), second_file->data_size());
   source.EndOfStream();
 
   EXPECT_EQ(592, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(592, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
   EXPECT_TRUE(WaitUntilOnEnded());
@@ skipping 109 matching lines @@
   EXPECT_EQ(313, source.last_timestamp_offset().InMilliseconds());
 
   // There are 576 silent frames at the start of this mp3.  The second append
   // should trim them off.
   const base::TimeDelta mp3_preroll_duration =
       base::TimeDelta::FromSecondsD(576.0 / 44100);
   const base::TimeDelta append_time =
       source.last_timestamp_offset() - mp3_preroll_duration;
 
   scoped_refptr<DecoderBuffer> second_file = ReadTestDataFile("sfx.mp3");
-  source.AppendAtTimeWithWindow(append_time,
-                                append_time + mp3_preroll_duration,
-                                kInfiniteDuration(),
-                                second_file->data(),
+  source.AppendAtTimeWithWindow(append_time, append_time + mp3_preroll_duration,
+                                kInfiniteDuration(), second_file->data(),
                                 second_file->data_size());
   source.EndOfStream();
 
   EXPECT_EQ(613, source.last_timestamp_offset().InMilliseconds());
   EXPECT_EQ(1u, pipeline_->GetBufferedTimeRanges().size());
   EXPECT_EQ(0, pipeline_->GetBufferedTimeRanges().start(0).InMilliseconds());
   EXPECT_EQ(613, pipeline_->GetBufferedTimeRanges().end(0).InMilliseconds());
 
   Play();
 
@@ skipping 426 matching lines @@
 
 TEST_F(PipelineIntegrationTest, Rotated_Metadata_270) {
   ASSERT_EQ(PIPELINE_OK, Start("bear_rotate_270.mp4"));
   ASSERT_EQ(VIDEO_ROTATION_270, metadata_.video_rotation);
 }
 #endif  // defined(USE_PROPRIETARY_CODECS)
 
 // Verify audio decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_AudioOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-audio-only.webm", kAudioOnlyWebM,
-                                 16384,
-                                 base::TimeDelta::FromMilliseconds(464),
-                                 base::TimeDelta::FromMilliseconds(617),
-                                 0x10CA, 19730));
+                                 16384, base::TimeDelta::FromMilliseconds(464),
+                                 base::TimeDelta::FromMilliseconds(617), 0x10CA,
+                                 19730));
 }
 
 // Verify video decoder & renderer can handle aborted demuxer reads.
 TEST_F(PipelineIntegrationTest, ChunkDemuxerAbortRead_VideoOnly) {
   ASSERT_TRUE(TestSeekDuringRead("bear-320x240-video-only.webm", kVideoOnlyWebM,
-                                 32768,
-                                 base::TimeDelta::FromMilliseconds(167),
+                                 32768, base::TimeDelta::FromMilliseconds(167),
                                  base::TimeDelta::FromMilliseconds(1668),
                                  0x1C896, 65536));
 }
 
 // Verify that Opus audio in WebM containers can be played back.
 TEST_F(PipelineIntegrationTest, BasicPlayback_AudioOnly_Opus_WebM) {
   ASSERT_EQ(PIPELINE_OK, Start("bear-opus-end-trimming.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
@@ skipping 74 matching lines @@
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
 }
 
 // Verify that OPUS audio in a webm which reports a 44.1kHz sample rate plays
 // correctly at 48kHz
 TEST_F(PipelineIntegrationTest, BasicPlayback_Opus441kHz) {
   ASSERT_EQ(PIPELINE_OK, Start("sfx-opus-441.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
-  EXPECT_EQ(48000,
-            demuxer_->GetStream(DemuxerStream::AUDIO)
-                ->audio_decoder_config()
-                .samples_per_second());
+  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
+                       ->audio_decoder_config()
+                       .samples_per_second());
 }
 
 // Same as above but using MediaSource.
 TEST_F(PipelineIntegrationTest, BasicPlayback_MediaSource_Opus441kHz) {
-  MockMediaSource source(
-      "sfx-opus-441.webm", kOpusAudioOnlyWebM, kAppendWholeFile);
+  MockMediaSource source("sfx-opus-441.webm", kOpusAudioOnlyWebM,
+                         kAppendWholeFile);
   StartPipelineWithMediaSource(&source);
   source.EndOfStream();
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   source.Shutdown();
   Stop();
-  EXPECT_EQ(48000,
-            demuxer_->GetStream(DemuxerStream::AUDIO)
-                ->audio_decoder_config()
-                .samples_per_second());
+  EXPECT_EQ(48000, demuxer_->GetStream(DemuxerStream::AUDIO)
+                       ->audio_decoder_config()
+                       .samples_per_second());
 }
 
 // Ensures audio-only playback with missing or negative timestamps works.  Tests
 // the common live-streaming case for chained ogg.  See http://crbug.com/396864.
 TEST_F(PipelineIntegrationTest, BasicPlaybackChainedOgg) {
   ASSERT_EQ(PIPELINE_OK, Start("double-sfx.ogg"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta(), demuxer_->GetStartTime());
 }
@@ skipping 29 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media