Revert of Update AudioRenderer API to fire changes in BufferingState.

media/base/pipeline_unittest.cc

Index: media/base/pipeline_unittest.cc
diff --git a/media/base/pipeline_unittest.cc b/media/base/pipeline_unittest.cc
index 47e5f0a44749c7a723736942f3d98ca865c88462..45cc73ba36fa7b1a46c5f19aed717b78da5be1fe 100644
--- a/media/base/pipeline_unittest.cc
+++ b/media/base/pipeline_unittest.cc
@@ -51,10 +51,6 @@
   pipeline->SetErrorForTesting(status);
 }
 
-ACTION_P2(SetBufferingState, cb, buffering_state) {
-  cb->Run(buffering_state);
-}
-
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
@@ -187,8 +183,7 @@
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(DemuxerStream* stream) {
     EXPECT_CALL(*audio_renderer_, Initialize(stream, _, _, _, _, _, _))
-        .WillOnce(DoAll(SaveArg<3>(&audio_time_cb_),
-                        SaveArg<4>(&audio_buffering_state_cb_),
+        .WillOnce(DoAll(SaveArg<4>(&audio_time_cb_),
                         RunCallback<1>(PIPELINE_OK)));
   }
 
@@ -210,9 +205,10 @@
       if (audio_stream_) {
         EXPECT_CALL(*audio_renderer_, SetPlaybackRate(0.0f));
         EXPECT_CALL(*audio_renderer_, SetVolume(1.0f));
-        EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
-            .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
-                                        BUFFERING_HAVE_ENOUGH));
+
+        // Startup sequence.
+        EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
+            .WillOnce(RunCallback<1>(PIPELINE_OK));
         EXPECT_CALL(*audio_renderer_, StartRendering());
       }
       EXPECT_CALL(callbacks_, OnPrerollCompleted());
@@ -258,21 +254,17 @@
     return text_stream_.get();
   }
 
-  void ExpectSeek(const base::TimeDelta& seek_time, bool underflowed) {
+  void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
     EXPECT_CALL(*demuxer_, Seek(seek_time, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (audio_stream_) {
-      if (!underflowed)
-        EXPECT_CALL(*audio_renderer_, StopRendering());
+      EXPECT_CALL(*audio_renderer_, StopRendering());
       EXPECT_CALL(*audio_renderer_, Flush(_))
-          .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
-                                            BUFFERING_HAVE_NOTHING),
-                          RunClosure<0>()));
-      EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
-          .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
-                                      BUFFERING_HAVE_ENOUGH));
+          .WillOnce(RunClosure<0>());
+      EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
+          .WillOnce(RunCallback<1>(PIPELINE_OK));
       EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
       EXPECT_CALL(*audio_renderer_, SetVolume(_));
       EXPECT_CALL(*audio_renderer_, StartRendering());
@@ -341,7 +333,6 @@
   scoped_ptr<StrictMock<MockDemuxerStream> > video_stream_;
   scoped_ptr<FakeTextTrackStream> text_stream_;
   AudioRenderer::TimeCB audio_time_cb_;
-  AudioRenderer::BufferingStateCB audio_buffering_state_cb_;
   VideoDecoderConfig video_decoder_config_;
   PipelineMetadata metadata_;
 
@@ -519,7 +510,7 @@
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
-  ExpectSeek(expected, false);
+  ExpectSeek(expected);
   DoSeek(expected);
 }
 
@@ -577,7 +568,7 @@
   EXPECT_EQ(kDuration / 8, pipeline_->GetBufferedTimeRanges().end(0));
 
   base::TimeDelta kSeekTime = kDuration / 2;
-  ExpectSeek(kSeekTime, false);
+  ExpectSeek(kSeekTime);
   DoSeek(kSeekTime);
 
   EXPECT_FALSE(pipeline_->DidLoadingProgress());
@@ -679,9 +670,7 @@
   // Preroll() isn't called as the demuxer errors out first.
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
-      .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
-                                        BUFFERING_HAVE_NOTHING),
-                      RunClosure<0>()));
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
@@ -735,9 +724,7 @@
   // Seek() isn't called as the demuxer errors out first.
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
-      .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
-                                        BUFFERING_HAVE_NOTHING),
-                      RunClosure<0>()));
+      .WillOnce(RunClosure<0>());
   EXPECT_CALL(*audio_renderer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
@@ -827,12 +814,9 @@
 
   EXPECT_CALL(*audio_renderer_, StopRendering());
   EXPECT_CALL(*audio_renderer_, Flush(_))
-      .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
-                                        BUFFERING_HAVE_NOTHING),
-                      RunClosure<0>()));
-  EXPECT_CALL(*audio_renderer_, StartPlayingFrom(seek_time))
-      .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
-                                  BUFFERING_HAVE_ENOUGH));
+      .WillOnce(RunClosure<0>());
+  EXPECT_CALL(*audio_renderer_, Preroll(seek_time, _))
+      .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*audio_renderer_, SetPlaybackRate(_));
   EXPECT_CALL(*audio_renderer_, SetVolume(_));
   EXPECT_CALL(*audio_renderer_, StartRendering());
@@ -868,28 +852,6 @@
   Pipeline* pipeline = pipeline_.get();
   pipeline->Stop(base::Bind(&DeletePipeline, base::Passed(&pipeline_)));
   message_loop_.RunUntilIdle();
-}
-
-TEST_F(PipelineTest, Underflow) {
-  CreateAudioStream();
-  CreateVideoStream();
-  MockDemuxerStreamVector streams;
-  streams.push_back(audio_stream());
-  streams.push_back(video_stream());
-
-  InitializeDemuxer(&streams);
-  InitializeAudioRenderer(audio_stream());
-  InitializeVideoRenderer(video_stream());
-  InitializePipeline(PIPELINE_OK);
-
-  // Simulate underflow.
-  EXPECT_CALL(*audio_renderer_, StopRendering());
-  audio_buffering_state_cb_.Run(BUFFERING_HAVE_NOTHING);
-
-  // Seek while underflowed. We shouldn't call StopRendering() again.
-  base::TimeDelta expected = base::TimeDelta::FromSeconds(5);
-  ExpectSeek(expected, true);
-  DoSeek(expected);
 }
 
 class PipelineTeardownTest : public PipelineTest {
@@ -1004,8 +966,7 @@
     }
 
     EXPECT_CALL(*audio_renderer_, Initialize(_, _, _, _, _, _, _))
-        .WillOnce(DoAll(SaveArg<4>(&audio_buffering_state_cb_),
-                        RunCallback<1>(PIPELINE_OK)));
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
 
     if (state == kInitVideoRenderer) {
       if (stop_or_error == kStop) {
@@ -1031,9 +992,8 @@
     EXPECT_CALL(callbacks_, OnMetadata(_));
 
     // If we get here it's a successful initialization.
-    EXPECT_CALL(*audio_renderer_, StartPlayingFrom(base::TimeDelta()))
-        .WillOnce(SetBufferingState(&audio_buffering_state_cb_,
-                                    BUFFERING_HAVE_ENOUGH));
+    EXPECT_CALL(*audio_renderer_, Preroll(base::TimeDelta(), _))
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Preroll(base::TimeDelta(), _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));
 
@@ -1080,26 +1040,17 @@
     if (state == kFlushing) {
       if (stop_or_error == kStop) {
         EXPECT_CALL(*audio_renderer_, Flush(_))
-            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
-                            SetBufferingState(&audio_buffering_state_cb_,
-                                              BUFFERING_HAVE_NOTHING),
-                            RunClosure<0>()));
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb), RunClosure<0>()));
       } else {
         status = PIPELINE_ERROR_READ;
         EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(
-            DoAll(SetError(pipeline_.get(), status),
-                  SetBufferingState(&audio_buffering_state_cb_,
-                                    BUFFERING_HAVE_NOTHING),
-                  RunClosure<0>()));
+            DoAll(SetError(pipeline_.get(), status), RunClosure<0>()));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*audio_renderer_, Flush(_))
-        .WillOnce(DoAll(SetBufferingState(&audio_buffering_state_cb_,
-                                          BUFFERING_HAVE_NOTHING),
-                        RunClosure<0>()));
+    EXPECT_CALL(*audio_renderer_, Flush(_)).WillOnce(RunClosure<0>());
     EXPECT_CALL(*video_renderer_, Flush(_)).WillOnce(RunClosure<0>());
 
     if (state == kSeeking) {
@@ -1121,18 +1072,20 @@
 
     if (state == kPrerolling) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_))
-            .WillOnce(Stop(pipeline_.get(), stop_cb));
+        EXPECT_CALL(*audio_renderer_, Preroll(_, _))
+            .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
+                            RunCallback<1>(PIPELINE_OK)));
       } else {
         status = PIPELINE_ERROR_READ;
-        EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_))
-            .WillOnce(SetError(pipeline_.get(), status));
+        EXPECT_CALL(*audio_renderer_, Preroll(_, _))
+            .WillOnce(RunCallback<1>(status));
       }
 
       return status;
     }
 
-    EXPECT_CALL(*audio_renderer_, StartPlayingFrom(_));
+    EXPECT_CALL(*audio_renderer_, Preroll(_, _))
+        .WillOnce(RunCallback<1>(PIPELINE_OK));
     EXPECT_CALL(*video_renderer_, Preroll(_, _))
         .WillOnce(RunCallback<1>(PIPELINE_OK));