Create abstract interface for media::Pipeline.

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"
@@ skipping 23 matching lines @@
 using ::testing::SaveArg;
 
 namespace media {
 
 const char kNullVideoHash[] = "d41d8cd98f00b204e9800998ecf8427e";
 const char kNullAudioHash[] = "0.00,0.00,0.00,0.00,0.00,0.00,";
 
 PipelineIntegrationTestBase::PipelineIntegrationTestBase()
     : hashing_enabled_(false),
       clockless_playback_(false),
-      pipeline_(new Pipeline(message_loop_.task_runner(), new MediaLog())),
+      pipeline_(new PipelineImpl(message_loop_.task_runner(), new MediaLog())),
       ended_(false),
       pipeline_status_(PIPELINE_OK),
       last_video_frame_format_(PIXEL_FORMAT_UNKNOWN),
       last_video_frame_color_space_(COLOR_SPACE_UNSPECIFIED),
       hardware_config_(AudioParameters(), AudioParameters()) {
   base::MD5Init(&md5_context_);
 }
 
 PipelineIntegrationTestBase::~PipelineIntegrationTestBase() {
   if (!pipeline_->IsRunning())
     return;
 
   Stop();
 }
 
 void PipelineIntegrationTestBase::OnSeeked(base::TimeDelta seek_time,
                                            PipelineStatus status) {
   EXPECT_EQ(seek_time, pipeline_->GetMediaTime());
   pipeline_status_ = status;
 }
 
-void PipelineIntegrationTestBase::OnStatusCallback(
-    PipelineStatus status) {
+void PipelineIntegrationTestBase::OnStatusCallback(PipelineStatus status) {
   pipeline_status_ = status;
   message_loop_.PostTask(FROM_HERE, base::MessageLoop::QuitWhenIdleClosure());
 }
 
 void PipelineIntegrationTestBase::DemuxerEncryptedMediaInitDataCB(
     EmeInitDataType type,
     const std::vector<uint8_t>& init_data) {
   DCHECK(!init_data.empty());
   CHECK(!encrypted_media_init_data_cb_.is_null());
   encrypted_media_init_data_cb_.Run(type, init_data);
@@ skipping 139 matching lines @@
 
 bool PipelineIntegrationTestBase::WaitUntilCurrentTimeIsAfter(
     const base::TimeDelta& wait_time) {
   DCHECK(pipeline_->IsRunning());
   DCHECK_GT(pipeline_->GetPlaybackRate(), 0);
   DCHECK(wait_time <= pipeline_->GetMediaDuration());
 
   message_loop_.PostDelayedTask(
       FROM_HERE,
       base::Bind(&PipelineIntegrationTestBase::QuitAfterCurrentTimeTask,
-                 base::Unretained(this),
-                 wait_time),
+                 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?";
@@ skipping 39 matching lines @@
     clockless_audio_sink_ = new ClocklessAudioSink();
   }
 
   ScopedVector<AudioDecoder> audio_decoders;
 
 #if !defined(MEDIA_DISABLE_FFMPEG)
   audio_decoders.push_back(
       new FFmpegAudioDecoder(message_loop_.task_runner(), new MediaLog()));
 #endif
 
-  audio_decoders.push_back(
-      new OpusAudioDecoder(message_loop_.task_runner()));
+  audio_decoders.push_back(new OpusAudioDecoder(message_loop_.task_runner()));
 
   // Don't allow the audio renderer to resample buffers if hashing is enabled.
   if (!hashing_enabled_) {
     AudioParameters out_params(AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                               CHANNEL_LAYOUT_STEREO,
-                               44100,
-                               16,
-                               512);
+                               CHANNEL_LAYOUT_STEREO, 44100, 16, 512);
     hardware_config_.UpdateOutputConfig(out_params);
   }
 
   scoped_ptr<AudioRenderer> audio_renderer(new AudioRendererImpl(
       message_loop_.task_runner(),
       (clockless_playback_)
           ? static_cast<AudioRendererSink*>(clockless_audio_sink_.get())
           : audio_sink_.get(),
       std::move(audio_decoders), hardware_config_, new MediaLog()));
   if (hashing_enabled_) {
@@ skipping 47 matching lines @@
   DCHECK(clockless_playback_);
   return clockless_audio_sink_->render_time();
 }
 
 base::TimeTicks DummyTickClock::NowTicks() {
   now_ += base::TimeDelta::FromSeconds(60);
   return now_;
 }
 
 }  // namespace media