Convert Filter::Seek() to use new callback system.

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/callback.h"
 #include "base/stl_util-inl.h"
 #include "base/threading/simple_thread.h"
 #include "media/base/pipeline_impl.h"
@@ skipping 83 matching lines @@
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
     mocks_->demuxer()->SetTotalAndBufferedBytesAndDuration(
         kTotalBytes, kBufferedBytes, duration);
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->demuxer(), SetPreload(AUTO));
-    EXPECT_CALL(*mocks_->demuxer(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->demuxer(), Seek(base::TimeDelta(), _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
     EXPECT_CALL(*mocks_->demuxer(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       scoped_refptr<DemuxerStream> stream((*streams)[i]);
       EXPECT_CALL(*mocks_->demuxer(), GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
 
   StrictMock<MockDemuxerStream>* CreateStream(DemuxerStream::Type type) {
     StrictMock<MockDemuxerStream>* stream =
         new StrictMock<MockDemuxerStream>();
     EXPECT_CALL(*stream, type())
         .WillRepeatedly(Return(type));
     return stream;
   }
 
   // Sets up expectations to allow the video decoder to initialize.
   void InitializeVideoDecoder(MockDemuxerStream* stream) {
     EXPECT_CALL(*mocks_->video_decoder(),
                 Initialize(stream, NotNull(), NotNull()))
         .WillOnce(DoAll(Invoke(&RunFilterCallback3), DeleteArg<2>()));
     EXPECT_CALL(*mocks_->video_decoder(), SetPlaybackRate(0.0f));
-    EXPECT_CALL(*mocks_->video_decoder(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->video_decoder(), Seek(base::TimeDelta(), _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
     EXPECT_CALL(*mocks_->video_decoder(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations to allow the audio decoder to initialize.
   void InitializeAudioDecoder(MockDemuxerStream* stream) {
     EXPECT_CALL(*mocks_->audio_decoder(),
                 Initialize(stream, NotNull(), NotNull()))
         .WillOnce(DoAll(Invoke(&RunFilterCallback3), DeleteArg<2>()));
     EXPECT_CALL(*mocks_->audio_decoder(), SetPlaybackRate(0.0f));
-    EXPECT_CALL(*mocks_->audio_decoder(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->audio_decoder(), Seek(base::TimeDelta(), _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
     EXPECT_CALL(*mocks_->audio_decoder(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer() {
     EXPECT_CALL(*mocks_->video_renderer(),
                 Initialize(mocks_->video_decoder(), NotNull(), NotNull()))
         .WillOnce(DoAll(Invoke(&RunFilterCallback3), DeleteArg<2>()));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
-    EXPECT_CALL(*mocks_->video_renderer(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->video_renderer(), Seek(base::TimeDelta(), _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
     EXPECT_CALL(*mocks_->video_renderer(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer(bool disable_after_init_callback = false) {
     if (disable_after_init_callback) {
       EXPECT_CALL(*mocks_->audio_renderer(),
                   Initialize(mocks_->audio_decoder(), NotNull()))
           .WillOnce(DoAll(Invoke(&RunFilterCallback),
                           DisableAudioRenderer(mocks_->audio_renderer())));
     } else {
       EXPECT_CALL(*mocks_->audio_renderer(),
                   Initialize(mocks_->audio_decoder(), NotNull()))
           .WillOnce(Invoke(&RunFilterCallback));
     }
     EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(1.0f));
-    EXPECT_CALL(*mocks_->audio_renderer(), Seek(base::TimeDelta(), NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->audio_renderer(), Seek(base::TimeDelta(), _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
     EXPECT_CALL(*mocks_->audio_renderer(), Stop(NotNull()))
         .WillOnce(Invoke(&RunStopFilterCallback));
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline() {
     InitializePipeline(PIPELINE_OK);
   }
   // Most tests can expect the |filter_collection|'s |build_status| to get
@@ skipping 39 matching lines @@
   MockDemuxerStream* audio_stream() {
     return audio_stream_;
   }
 
   MockDemuxerStream* video_stream() {
     return video_stream_;
   }
 
   void ExpectSeek(const base::TimeDelta& seek_time) {
     // Every filter should receive a call to Seek().
-    EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, NotNull()))
-        .WillOnce(Invoke(&RunFilterCallback));
+    EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
+        .WillOnce(Invoke(&RunFilterStatusCB));
 
     if (audio_stream_) {
-      EXPECT_CALL(*mocks_->audio_decoder(), Seek(seek_time, NotNull()))
-          .WillOnce(Invoke(&RunFilterCallback));
-      EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, NotNull()))
-          .WillOnce(Invoke(&RunFilterCallback));
+      EXPECT_CALL(*mocks_->audio_decoder(), Seek(seek_time, _))
+          .WillOnce(Invoke(&RunFilterStatusCB));
+      EXPECT_CALL(*mocks_->audio_renderer(), Seek(seek_time, _))
+          .WillOnce(Invoke(&RunFilterStatusCB));
     }
 
     if (video_stream_) {
-      EXPECT_CALL(*mocks_->video_decoder(), Seek(seek_time, NotNull()))
-          .WillOnce(Invoke(&RunFilterCallback));
-      EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, NotNull()))
-          .WillOnce(Invoke(&RunFilterCallback));
+      EXPECT_CALL(*mocks_->video_decoder(), Seek(seek_time, _))
+          .WillOnce(Invoke(&RunFilterStatusCB));
+      EXPECT_CALL(*mocks_->video_renderer(), Seek(seek_time, _))
+          .WillOnce(Invoke(&RunFilterStatusCB));
     }
 
     // We expect a successful seek callback.
     EXPECT_CALL(callbacks_, OnSeek(PIPELINE_OK));
   }
 
   void DoSeek(const base::TimeDelta& seek_time) {
     pipeline_->Seek(seek_time,
                     NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                 &CallbackHelper::OnSeek));
@@ skipping 498 matching lines @@
 
   // Signal end of video stream and make sure OnEnded() callback occurs.
   EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
       .WillOnce(Return(true));
   EXPECT_CALL(callbacks_, OnEnded(PIPELINE_OK));
   host->NotifyEnded();
 }
 
+void SendReadErrorToCB(::testing::Unused, const FilterStatusCB& cb) {
+  cb.Run(PIPELINE_ERROR_READ);
+}
+
 TEST_F(PipelineImplTest, ErrorDuringSeek) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
   streams.push_back(audio_stream());
 
   InitializeDemuxer(&streams, base::TimeDelta::FromSeconds(10));
   InitializeAudioDecoder(audio_stream());
   InitializeAudioRenderer();
   InitializePipeline(PIPELINE_OK);
 
   float playback_rate = 1.0f;
   EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_decoder(), SetPlaybackRate(playback_rate));
   EXPECT_CALL(*mocks_->audio_renderer(), SetPlaybackRate(playback_rate));
   pipeline_->SetPlaybackRate(playback_rate);
   message_loop_.RunAllPending();
 
   InSequence s;
 
   base::TimeDelta seek_time = base::TimeDelta::FromSeconds(5);
 
-  EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, NotNull()))
-      .WillOnce(DoAll(SetError(mocks_->demuxer(),
-                               PIPELINE_ERROR_READ),
-                      Invoke(&RunFilterCallback)));
+  EXPECT_CALL(*mocks_->demuxer(), Seek(seek_time, _))
+      .WillOnce(Invoke(&SendReadErrorToCB));
 
   pipeline_->Seek(seek_time, NewCallback(
       reinterpret_cast<CallbackHelper*>(&callbacks_), &CallbackHelper::OnSeek));
   EXPECT_CALL(callbacks_, OnSeek(PIPELINE_ERROR_READ));
   EXPECT_CALL(callbacks_, OnError(PIPELINE_ERROR_READ));
   message_loop_.RunAllPending();
 }
 
 class FlexibleCallbackRunner : public base::DelegateSimpleThread::Delegate {
  public:
@@ skipping 40 matching lines @@
   TestPipelineStatusNotification(0);
 }
 
 // Test that different-thread, some-delay callback (the expected common case)
 // works correctly.
 TEST(PipelineStatusNotificationTest, DelayedCallback) {
   TestPipelineStatusNotification(20);
 }
 
 }  // namespace media