media: Update PipelineIntegrationTestBase to support MemoryDataSource.

media/test/pipeline_integration_test_base.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 "media/test/pipeline_integration_test_base.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/scoped_vector.h"
 #include "media/base/cdm_context.h"
 #include "media/base/media_log.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/chunk_demuxer.h"
 #if !defined(MEDIA_DISABLE_FFMPEG)
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #endif
 #include "media/filters/file_data_source.h"
+#include "media/filters/memory_data_source.h"
 #include "media/filters/opus_audio_decoder.h"
 #include "media/renderers/audio_renderer_impl.h"
 #include "media/renderers/renderer_impl.h"
 #if !defined(MEDIA_DISABLE_LIBVPX)
 #include "media/filters/vpx_video_decoder.h"
 #endif
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::AtLeast;
@@ skipping 19 matching lines @@
   base::MD5Init(&md5_context_);
 }
 
 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() {
   if (!pipeline_->IsRunning())
     return;
 
   Stop();
 }
 
+// TODO(xhwang): Method definitions in this file needs to be reordered.
+
 void PipelineIntegrationTestBase::OnSeeked(base::TimeDelta seek_time,
                                            PipelineStatus status) {
   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   pipeline_status_ = status;
 }
 
 void PipelineIntegrationTestBase::OnStatusCallback(PipelineStatus status) {
   pipeline_status_ = status;
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
@@ skipping 27 matching lines @@
   message_loop_.Run();
   return pipeline_status_;
 }
 
 void PipelineIntegrationTestBase::OnError(PipelineStatus status) {
   DCHECK_NE(status, PIPELINE_OK);
   pipeline_status_ = status;
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
-PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename) {
-  return Start(filename, nullptr);
-}
+PipelineStatus PipelineIntegrationTestBase::StartInternal(
+    scoped_ptr<DataSource> data_source,
+    CdmContext* cdm_context,
+    uint8_t test_type) {
+  hashing_enabled_ = test_type & kHashed;
+  clockless_playback_ = test_type & kClockless;
 
-PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
-                                                  CdmContext* cdm_context) {
   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());
-  CreateDemuxer(filename);
+  CreateDemuxer(std::move(data_source));
 
   if (cdm_context) {
     EXPECT_CALL(*this, DecryptorAttached(true));
     pipeline_->SetCdm(
         cdm_context, base::Bind(&PipelineIntegrationTestBase::DecryptorAttached,
                                 base::Unretained(this)));
   }
 
   // Should never be called as the required decryption keys for the encrypted
   // media files are provided in advance.
@@ skipping 10 matching lines @@
       base::Bind(&PipelineIntegrationTestBase::OnBufferingStateChanged,
                  base::Unretained(this)),
       base::Closure(), base::Bind(&PipelineIntegrationTestBase::OnAddTextTrack,
                                   base::Unretained(this)),
       base::Bind(&PipelineIntegrationTestBase::OnWaitingForDecryptionKey,
                  base::Unretained(this)));
   message_loop_.Run();
   return pipeline_status_;
 }
 
+PipelineStatus PipelineIntegrationTestBase::StartWithFile(
+    const std::string& filename,
+    CdmContext* cdm_context,
+    uint8_t test_type) {
+  scoped_ptr<FileDataSource> file_data_source(new FileDataSource());
+  base::FilePath file_path(GetTestDataFilePath(filename));
+  CHECK(file_data_source->Initialize(file_path)) << "Is " << file_path.value()
+                                                 << " missing?";
+  return StartInternal(std::move(file_data_source), cdm_context, test_type);
+}
+
+PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename) {
+  return StartWithFile(filename, nullptr, kNormal);
+}
+
+PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
+                                                  CdmContext* cdm_context) {
+  return StartWithFile(filename, cdm_context, kNormal);
+}
+
 PipelineStatus PipelineIntegrationTestBase::Start(const std::string& filename,
                                                   uint8_t test_type) {
-  hashing_enabled_ = test_type & kHashed;
-  clockless_playback_ = test_type & kClockless;
-  return Start(filename);
+  return StartWithFile(filename, nullptr, test_type);
+}
+
+PipelineStatus PipelineIntegrationTestBase::Start(const uint8_t* data,
+                                                  size_t size,
+                                                  uint8_t test_type) {
+  return StartInternal(make_scoped_ptr(new MemoryDataSource(data, size)),
+                       nullptr, test_type);
 }
 
 void PipelineIntegrationTestBase::Play() {
   pipeline_->SetPlaybackRate(1);
 }
 
 void PipelineIntegrationTestBase::Pause() {
   pipeline_->SetPlaybackRate(0);
 }
 
@@ skipping 56 matching lines @@
 
   message_loop_.PostDelayedTask(
       FROM_HERE,
       base::Bind(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
                  base::Unretained(this), wait_time),
       base::TimeDelta::FromMilliseconds(10));
   message_loop_.Run();
   return (pipeline_status_ == PIPELINE_OK);
 }
 
-void PipelineIntegrationTestBase::CreateDemuxer(const std::string& filename) {
-  FileDataSource* file_data_source = new FileDataSource();
-  base::FilePath file_path(GetTestDataFilePath(filename));
-  CHECK(file_data_source->Initialize(file_path)) << "Is " << file_path.value()
-                                                 << " missing?";
-  data_source_.reset(file_data_source);
-
-  Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb =
-      base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
-                 base::Unretained(this));
+void PipelineIntegrationTestBase::CreateDemuxer(
+    scoped_ptr<DataSource> data_source) {
+  data_source_ = std::move(data_source);
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
-  demuxer_ = scoped_ptr<Demuxer>(
-      new FFmpegDemuxer(message_loop_.task_runner(), data_source_.get(),
-                        encrypted_media_init_data_cb, new MediaLog()));
+  demuxer_ = scoped_ptr<Demuxer>(new FFmpegDemuxer(
+      message_loop_.task_runner(), data_source_.get(),
+      base::Bind(&PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB,
+                 base::Unretained(this)),
+      new MediaLog()));
 #endif
 }
 
 scoped_ptr<Renderer> PipelineIntegrationTestBase::CreateRenderer() {
   ScopedVector<VideoDecoder> video_decoders;
 #if !defined(MEDIA_DISABLE_LIBVPX)
   video_decoders.push_back(new VpxVideoDecoder());
 #endif  // !defined(MEDIA_DISABLE_LIBVPX)
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
@@ skipping 92 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media