Revert of Remove Has{Audio,Video}(), GetInitialNaturalSize() from media::Pipeline. (https://codereview.chromium.org/211313004/)

Reason for revert:
This CL breaks Linux Clang (dbg) Build

http://build.chromium.org/p/chromium.linux/builders/Linux%20Clang%20%28dbg%29/builds/57597
http://build.chromium.org/p/chromium.linux/builders/Linux%20Clang%20%28dbg%29/builds/57598

from thakis: the problem is probably that ffmpeg_regression_tests doesn't link in gfx_geometry and you're missing a dep on that

Original issue's description:
> Remove Has{Audio,Video}(), GetInitialNaturalSize() from media::Pipeline.
> 
> This splits PipelineBufferingStateCB in two: PipelineMetadataCB, which
> includes the available tracks and natural size in a PipelineMetadata
> struct; and PipelinePrerollCompleted, with no parameters. Now
> WebMediaPlayerImpl can cache the metadata and the accessors are not
> required.
> 
> This was previously committed as r259154.
> 
> BUG=148541
> 
> Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=259385

TBR=scherkus@chromium.org,dalecurtis@chromium.org,sandersd@chromium.org
NOTREECHECKS=true
NOTRY=true
BUG=148541

Review URL: https://codereview.chromium.org/209043005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@259402 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 147 insertions, 93 deletions

diff --git a/media/base/pipeline.cc b/media/base/pipeline.cc
index 8c0ca54..824585f 100644
--- a/media/base/pipeline.cc
+++ b/media/base/pipeline.cc
@@ -45,6 +45,8 @@ Pipeline::Pipeline(
       clock_(new Clock(&default_tick_clock_)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
+      has_audio_(false),
+      has_video_(false),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
@@ -72,29 +74,16 @@ void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const base::Closure& ended_cb,
                      const PipelineStatusCB& error_cb,
                      const PipelineStatusCB& seek_cb,
-                     const PipelineMetadataCB& metadata_cb,
-                     const base::Closure& preroll_completed_cb,
+                     const BufferingStateCB& buffering_state_cb,
                      const base::Closure& duration_change_cb) {
-  DCHECK(!ended_cb.is_null());
-  DCHECK(!error_cb.is_null());
-  DCHECK(!seek_cb.is_null());
-  DCHECK(!metadata_cb.is_null());
-  DCHECK(!preroll_completed_cb.is_null());
-
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
-  running_ = true;
-
-  filter_collection_ = collection.Pass();
-  ended_cb_ = ended_cb;
-  error_cb_ = error_cb;
-  seek_cb_ = seek_cb;
-  metadata_cb_ = metadata_cb;
-  preroll_completed_cb_ = preroll_completed_cb;
-  duration_change_cb_ = duration_change_cb;
+  DCHECK(!buffering_state_cb.is_null());
 
-  task_runner_->PostTask(
-      FROM_HERE, base::Bind(&Pipeline::StartTask, base::Unretained(this)));
+  running_ = true;
+  task_runner_->PostTask(FROM_HERE, base::Bind(
+      &Pipeline::StartTask, base::Unretained(this), base::Passed(&collection),
+      ended_cb, error_cb, seek_cb, buffering_state_cb, duration_change_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
@@ -119,6 +108,16 @@ bool Pipeline::IsRunning() const {
   return running_;
 }
 
+bool Pipeline::HasAudio() const {
+  base::AutoLock auto_lock(lock_);
+  return has_audio_;
+}
+
+bool Pipeline::HasVideo() const {
+  base::AutoLock auto_lock(lock_);
+  return has_video_;
+}
+
 float Pipeline::GetPlaybackRate() const {
   base::AutoLock auto_lock(lock_);
   return playback_rate_;
@@ -189,6 +188,11 @@ int64 Pipeline::GetTotalBytes() const {
   return total_bytes_;
 }
 
+gfx::Size Pipeline::GetInitialNaturalSize() const {
+  base::AutoLock auto_lock(lock_);
+  return initial_natural_size_;
+}
+
 bool Pipeline::DidLoadingProgress() const {
   base::AutoLock auto_lock(lock_);
   bool ret = did_loading_progress_;
@@ -329,9 +333,8 @@ void Pipeline::OnAudioTimeUpdate(TimeDelta time, TimeDelta max_time) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
-  if (audio_disabled_)
+  if (!has_audio_)
     return;
-
   if (waiting_for_clock_update_ && time < clock_->Elapsed())
     return;
 
@@ -348,7 +351,7 @@ void Pipeline::OnVideoTimeUpdate(TimeDelta max_time) {
   DCHECK(IsRunning());
   base::AutoLock auto_lock(lock_);
 
-  if (audio_renderer_ && !audio_disabled_)
+  if (has_audio_)
     return;
 
   // TODO(scherkus): |state_| should only be accessed on pipeline thread, see
@@ -459,21 +462,20 @@ void Pipeline::StateTransitionTask(PipelineStatus status) {
         // We do not want to start the clock running. We only want to set the
         // base media time so our timestamp calculations will be correct.
         clock_->SetTime(demuxer_->GetStartTime(), demuxer_->GetStartTime());
+
+        // TODO(scherkus): |has_audio_| should be true no matter what --
+        // otherwise people with muted/disabled sound cards will make our
+        // default controls look as if every video doesn't contain an audio
+        // track.
+        has_audio_ = audio_renderer_ != NULL && !audio_disabled_;
+        has_video_ = video_renderer_ != NULL;
       }
       if (!audio_renderer_ && !video_renderer_) {
         done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
         return;
       }
 
-      {
-        PipelineMetadata metadata;
-        metadata.has_audio = audio_renderer_;
-        metadata.has_video = video_renderer_;
-        DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
-        if (stream)
-          metadata.natural_size = stream->video_decoder_config().natural_size();
-        metadata_cb_.Run(metadata);
-      }
+      buffering_state_cb_.Run(kHaveMetadata);
 
       return DoInitialPreroll(done_cb);
 
@@ -486,7 +488,7 @@ void Pipeline::StateTransitionTask(PipelineStatus status) {
         // We use audio stream to update the clock. So if there is such a
         // stream, we pause the clock until we receive a valid timestamp.
         waiting_for_clock_update_ = true;
-        if (!audio_renderer_ || audio_disabled_) {
+        if (!has_audio_) {
           clock_->SetMaxTime(clock_->Duration());
           StartClockIfWaitingForTimeUpdate_Locked();
         }
@@ -498,7 +500,7 @@ void Pipeline::StateTransitionTask(PipelineStatus status) {
       // Fire canplaythrough immediately after playback begins because of
       // crbug.com/106480.
       // TODO(vrk): set ready state to HaveFutureData when bug above is fixed.
-      preroll_completed_cb_.Run();
+      buffering_state_cb_.Run(kPrerollCompleted);
       return base::ResetAndReturn(&seek_cb_).Run(PIPELINE_OK);
 
     case kStopping:
@@ -729,11 +731,23 @@ void Pipeline::OnUpdateStatistics(const PipelineStatistics& stats) {
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
-void Pipeline::StartTask() {
+void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
+                         const base::Closure& ended_cb,
+                         const PipelineStatusCB& error_cb,
+                         const PipelineStatusCB& seek_cb,
+                         const BufferingStateCB& buffering_state_cb,
+                         const base::Closure& duration_change_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
+  filter_collection_ = filter_collection.Pass();
+  ended_cb_ = ended_cb;
+  error_cb_ = error_cb;
+  seek_cb_ = seek_cb;
+  buffering_state_cb_ = buffering_state_cb;
+  duration_change_cb_ = duration_change_cb;
+
   text_renderer_ = filter_collection_->GetTextRenderer();
 
   if (text_renderer_) {
@@ -911,6 +925,7 @@ void Pipeline::AudioDisabledTask() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   base::AutoLock auto_lock(lock_);
+  has_audio_ = false;
   audio_disabled_ = true;
 
   // Notify our demuxer that we're no longer rendering audio.
@@ -959,9 +974,23 @@ void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
 void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
+  // Get an initial natural size so we have something when we signal
+  // the kHaveMetadata buffering state.
+  //
+  // TODO(acolwell): We have to query demuxer outside of the lock to prevent a
+  // deadlock between ChunkDemuxer and Pipeline. See http://crbug.com/334325 for
+  // ideas on removing locking from ChunkDemuxer.
+  DemuxerStream* stream = demuxer_->GetStream(DemuxerStream::VIDEO);
+  gfx::Size initial_natural_size =
+      stream->video_decoder_config().natural_size();
+  {
+    base::AutoLock l(lock_);
+    initial_natural_size_ = initial_natural_size;
+  }
+
   video_renderer_ = filter_collection_->GetVideoRenderer();
   video_renderer_->Initialize(
-      demuxer_->GetStream(DemuxerStream::VIDEO),
+      stream,
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, base::Unretained(this)),
       base::Bind(&Pipeline::OnVideoTimeUpdate, base::Unretained(this)),
diff --git a/media/base/pipeline.h b/media/base/pipeline.h
index 4b78eb7..9b0ebdf 100644
--- a/media/base/pipeline.h
+++ b/media/base/pipeline.h
@@ -34,17 +34,6 @@ class TextRenderer;
 class TextTrackConfig;
 class VideoRenderer;
 
-// Metadata describing a pipeline once it has been initialized.
-struct PipelineMetadata {
-  PipelineMetadata() : has_audio(false), has_video(false) {}
-
-  bool has_audio;
-  bool has_video;
-  gfx::Size natural_size;
-};
-
-typedef base::Callback<void(PipelineMetadata)> PipelineMetadataCB;
-
 // Pipeline runs the media pipeline.  Filters are created and called on the
 // task runner injected into this object. Pipeline works like a state
 // machine to perform asynchronous initialization, pausing, seeking and playing.
@@ -78,6 +67,21 @@ typedef base::Callback<void(PipelineMetadata)> PipelineMetadataCB;
 // "Stopped" state.
 class MEDIA_EXPORT Pipeline : public DemuxerHost {
  public:
+  // Buffering states the pipeline transitions between during playback.
+  // kHaveMetadata:
+  //   Indicates that the following things are known:
+  //   content duration, container video size, start time, and whether the
+  //   content has audio and/or video in supported formats.
+  // kPrerollCompleted:
+  //   All renderers have buffered enough data to satisfy preroll and are ready
+  //   to start playback.
+  enum BufferingState {
+    kHaveMetadata,
+    kPrerollCompleted,
+  };
+
+  typedef base::Callback<void(BufferingState)> BufferingStateCB;
+
   // Constructs a media pipeline that will execute on |task_runner|.
   Pipeline(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
            MediaLog* media_log);
@@ -93,23 +97,18 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // The following permanent callbacks will be executed as follows up until
   // Stop() has completed:
   //   |ended_cb| will be executed whenever the media reaches the end.
-  //   |error_cb| will be executed whenever an error occurs but hasn't been
-  //              reported already through another callback.
-  //   |metadata_cb| will be executed when the content duration, container video
-  //                 size, start time, and whether the content has audio and/or
-  //                 video in supported formats are known.
-  //   |preroll_completed_cb| will be executed when all renderers have buffered
-  //                          enough data to satisfy preroll and are ready to
-  //                          start playback.
-  //   |duration_change_cb| optional callback that will be executed whenever the
+  //   |error_cb| will be executed whenever an error occurs but hasn't
+  //              been reported already through another callback.
+  //   |buffering_state_cb| Optional callback that will be executed whenever the
+  //                    pipeline's buffering state changes.
+  //   |duration_change_cb| Optional callback that will be executed whenever the
   //                        presentation duration changes.
   // It is an error to call this method after the pipeline has already started.
   void Start(scoped_ptr<FilterCollection> filter_collection,
              const base::Closure& ended_cb,
              const PipelineStatusCB& error_cb,
              const PipelineStatusCB& seek_cb,
-             const PipelineMetadataCB& metadata_cb,
-             const base::Closure& preroll_completed_cb,
+             const BufferingStateCB& buffering_state_cb,
              const base::Closure& duration_change_cb);
 
   // Asynchronously stops the pipeline, executing |stop_cb| when the pipeline
@@ -135,6 +134,12 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // the pipeline.
   bool IsRunning() const;
 
+  // Returns true if the media has audio.
+  bool HasAudio() const;
+
+  // Returns true if the media has video.
+  bool HasVideo() const;
+
   // Gets the current playback rate of the pipeline.  When the pipeline is
   // started, the playback rate will be 0.0f.  A rate of 1.0f indicates
   // that the pipeline is rendering the media at the standard rate.  Valid
@@ -173,6 +178,10 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // determined or can not be determined, this value is 0.
   int64 GetTotalBytes() const;
 
+  // Get the video's initial natural size as reported by the container. Note
+  // that the natural size can change during playback.
+  gfx::Size GetInitialNaturalSize() const;
+
   // Return true if loading progress has been made since the last time this
   // method was called.
   bool DidLoadingProgress() const;
@@ -253,7 +262,12 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // The following "task" methods correspond to the public methods, but these
   // methods are run as the result of posting a task to the Pipeline's
   // task runner.
-  void StartTask();
+  void StartTask(scoped_ptr<FilterCollection> filter_collection,
+                 const base::Closure& ended_cb,
+                 const PipelineStatusCB& error_cb,
+                 const PipelineStatusCB& seek_cb,
+                 const BufferingStateCB& buffering_state_cb,
+                 const base::Closure& duration_change_cb);
 
   // Stops and destroys all filters, placing the pipeline in the kStopped state.
   void StopTask(const base::Closure& stop_cb);
@@ -356,6 +370,9 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // Total size of the media.  Set by filters.
   int64 total_bytes_;
 
+  // The initial natural size of the video as reported by the container.
+  gfx::Size initial_natural_size_;
+
   // Current volume level (from 0.0f to 1.0f).  This value is set immediately
   // via SetVolume() and a task is dispatched on the task runner to notify the
   // filters.
@@ -385,6 +402,13 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // reset the pipeline state, and restore this to PIPELINE_OK.
   PipelineStatus status_;
 
+  // Whether the media contains rendered audio or video streams.
+  // TODO(fischman,scherkus): replace these with checks for
+  // {audio,video}_decoder_ once extraction of {Audio,Video}Decoder from the
+  // Filter heirarchy is done.
+  bool has_audio_;
+  bool has_video_;
+
   // The following data members are only accessed by tasks posted to
   // |task_runner_|.
 
@@ -408,8 +432,7 @@ class MEDIA_EXPORT Pipeline : public DemuxerHost {
   // Permanent callbacks passed in via Start().
   base::Closure ended_cb_;
   PipelineStatusCB error_cb_;
-  PipelineMetadataCB metadata_cb_;
-  base::Closure preroll_completed_cb_;
+  BufferingStateCB buffering_state_cb_;
   base::Closure duration_change_cb_;
 
   // Contains the demuxer and renderers to use when initializing.
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 6e51802..3264226 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -66,8 +66,7 @@ class CallbackHelper {
   MOCK_METHOD0(OnStop, void());
   MOCK_METHOD0(OnEnded, void());
   MOCK_METHOD1(OnError, void(PipelineStatus));
-  MOCK_METHOD1(OnMetadata, void(PipelineMetadata));
-  MOCK_METHOD0(OnPrerollCompleted, void());
+  MOCK_METHOD1(OnBufferingState, void(Pipeline::BufferingState));
   MOCK_METHOD0(OnDurationChange, void());
 
  private:
@@ -204,7 +203,7 @@ class PipelineTest : public ::testing::Test {
     EXPECT_CALL(callbacks_, OnStart(start_status));
 
     if (start_status == PIPELINE_OK) {
-      EXPECT_CALL(callbacks_, OnMetadata(_)).WillOnce(SaveArg<0>(&metadata_));
+      EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
 
       if (audio_stream_) {
         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
@@ -216,7 +215,7 @@ class PipelineTest : public ::testing::Test {
         EXPECT_CALL(*audio_renderer_, Play(_))
             .WillOnce(RunClosure<0>());
       }
-      EXPECT_CALL(callbacks_, OnPrerollCompleted());
+      EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
     }
 
     pipeline_->Start(
@@ -224,8 +223,7 @@ class PipelineTest : public ::testing::Test {
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnPrerollCompleted,
+        base::Bind(&CallbackHelper::OnBufferingState,
                    base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnDurationChange,
                    base::Unretained(&callbacks_)));
@@ -288,7 +286,7 @@ class PipelineTest : public ::testing::Test {
           .WillOnce(RunClosure<0>());
     }
 
-    EXPECT_CALL(callbacks_, OnPrerollCompleted());
+    EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
@@ -342,7 +340,6 @@ class PipelineTest : public ::testing::Test {
   scoped_ptr<FakeTextTrackStream> text_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
   VideoDecoderConfig video_decoder_config_;
-  PipelineMetadata metadata_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PipelineTest);
@@ -354,6 +351,8 @@ TEST_F(PipelineTest, NotStarted) {
   const base::TimeDelta kZero;
 
   EXPECT_FALSE(pipeline_->IsRunning());
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_FALSE(pipeline_->HasVideo());
 
   // Setting should still work.
   EXPECT_EQ(0.0f, pipeline_->GetPlaybackRate());
@@ -374,6 +373,11 @@ TEST_F(PipelineTest, NotStarted) {
   EXPECT_TRUE(kZero == pipeline_->GetMediaDuration());
 
   EXPECT_EQ(0, pipeline_->GetTotalBytes());
+
+  // Should always be zero.
+  gfx::Size size = pipeline_->GetInitialNaturalSize();
+  EXPECT_EQ(0, size.width());
+  EXPECT_EQ(0, size.height());
 }
 
 TEST_F(PipelineTest, NeverInitializes) {
@@ -388,8 +392,7 @@ TEST_F(PipelineTest, NeverInitializes) {
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnPrerollCompleted,
+        base::Bind(&CallbackHelper::OnBufferingState,
                    base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnDurationChange,
                    base::Unretained(&callbacks_)));
@@ -430,8 +433,8 @@ TEST_F(PipelineTest, AudioStream) {
   InitializeAudioRenderer(audio_stream(), false);
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(metadata_.has_audio);
-  EXPECT_FALSE(metadata_.has_video);
+  EXPECT_TRUE(pipeline_->HasAudio());
+  EXPECT_FALSE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, VideoStream) {
@@ -443,8 +446,8 @@ TEST_F(PipelineTest, VideoStream) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_FALSE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, AudioVideoStream) {
@@ -459,8 +462,8 @@ TEST_F(PipelineTest, AudioVideoStream) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_TRUE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 }
 
 TEST_F(PipelineTest, VideoTextStream) {
@@ -473,8 +476,8 @@ TEST_F(PipelineTest, VideoTextStream) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_FALSE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   AddTextStream();
   message_loop_.RunUntilIdle();
@@ -493,8 +496,8 @@ TEST_F(PipelineTest, VideoAudioTextStream) {
   InitializeAudioRenderer(audio_stream(), false);
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_TRUE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   AddTextStream();
   message_loop_.RunUntilIdle();
@@ -620,8 +623,8 @@ TEST_F(PipelineTest, DisableAudioRenderer) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_TRUE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_CALL(*demuxer_, OnAudioRendererDisabled());
   pipeline_->OnAudioDisabled();
@@ -645,8 +648,8 @@ TEST_F(PipelineTest, DisableAudioRendererDuringInit) {
   EXPECT_CALL(*demuxer_, OnAudioRendererDisabled());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_TRUE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   // Verify that ended event is fired when video ends.
   EXPECT_CALL(callbacks_, OnEnded());
@@ -828,8 +831,8 @@ TEST_F(PipelineTest, StartTimeIsZero) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_FALSE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(base::TimeDelta(), pipeline_->GetMediaTime());
 }
@@ -849,8 +852,8 @@ TEST_F(PipelineTest, StartTimeIsNonZero) {
   InitializeVideoRenderer(video_stream());
 
   InitializePipeline(PIPELINE_OK);
-  EXPECT_FALSE(metadata_.has_audio);
-  EXPECT_TRUE(metadata_.has_video);
+  EXPECT_FALSE(pipeline_->HasAudio());
+  EXPECT_TRUE(pipeline_->HasVideo());
 
   EXPECT_EQ(kStartTime, pipeline_->GetMediaTime());
 }
@@ -902,7 +905,7 @@ TEST_F(PipelineTest, AudioTimeUpdateDuringSeek) {
   EXPECT_CALL(*audio_renderer_, Play(_))
       .WillOnce(RunClosure<0>());
 
-  EXPECT_CALL(callbacks_, OnPrerollCompleted());
+  EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   DoSeek(seek_time);
 
@@ -996,8 +999,7 @@ class PipelineTeardownTest : public PipelineTest {
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnMetadata, base::Unretained(&callbacks_)),
-        base::Bind(&CallbackHelper::OnPrerollCompleted,
+        base::Bind(&CallbackHelper::OnBufferingState,
                    base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnDurationChange,
                    base::Unretained(&callbacks_)));
@@ -1074,7 +1076,7 @@ class PipelineTeardownTest : public PipelineTest {
     EXPECT_CALL(*video_renderer_, Initialize(_, _, _, _, _, _, _, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
-    EXPECT_CALL(callbacks_, OnMetadata(_));
+    EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kHaveMetadata));
 
     // If we get here it's a successful initialization.
     EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
@@ -1092,7 +1094,7 @@ class PipelineTeardownTest : public PipelineTest {
         .WillOnce(RunClosure<0>());
 
     if (status == PIPELINE_OK)
-      EXPECT_CALL(callbacks_, OnPrerollCompleted());
+      EXPECT_CALL(callbacks_, OnBufferingState(Pipeline::kPrerollCompleted));
 
     return status;
   }