Adding callback support to media filter Initialize() and Seek().

media/base/pipeline_impl_unittest.cc

 // Copyright (c) 2006-2009 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/waitable_event.h"
 #include "media/base/pipeline_impl.h"
 #include "media/base/media_format.h"
 #include "media/base/filters.h"
 #include "media/base/factory.h"
 #include "media/base/filter_host.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::DoAll;
+using ::testing::Invoke;
 using ::testing::Mock;
+using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace media {
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
@@ skipping 28 matching lines @@
     // Expect a stop callback if we were started.
     EXPECT_CALL(callbacks_, OnStop());
     pipeline_.Stop(NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                                &CallbackHelper::OnStop));
     message_loop_.RunAllPending();
   }
 
  protected:
   // Sets up expectations to allow the data source to initialize.
   void InitializeDataSource() {
-    EXPECT_CALL(*mocks_->data_source(), Initialize(""))
-        .WillOnce(DoAll(InitializationComplete(mocks_->data_source()),
-                        Return(true)));
+    EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
+        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->data_source(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->data_source(), Stop());
   }
 
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams) {
-    EXPECT_CALL(*mocks_->demuxer(), Initialize(mocks_->data_source()))
-        .WillOnce(DoAll(InitializationComplete(mocks_->demuxer()),
-                        Return(true)));
+    EXPECT_CALL(*mocks_->demuxer(),
+                Initialize(mocks_->data_source(), NotNull()))
+        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
         .WillRepeatedly(Return(streams->size()));
     EXPECT_CALL(*mocks_->demuxer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->demuxer(), Stop());
 
     // 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(i))
           .WillRepeatedly(Return(stream));
     }
   }
 
   // Sets up expectations to allow the video decoder to initialize.
   void InitializeVideoDecoder(MockDemuxerStream* stream) {
-    EXPECT_CALL(*mocks_->video_decoder(), Initialize(stream))
-        .WillOnce(DoAll(InitializationComplete(mocks_->video_decoder()),
-                        Return(true)));
+    EXPECT_CALL(*mocks_->video_decoder(), Initialize(stream, NotNull()))
+        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->video_decoder(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_decoder(), Stop());
   }
 
   // Sets up expectations to allow the audio decoder to initialize.
   void InitializeAudioDecoder(MockDemuxerStream* stream) {
-    EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream))
-        .WillOnce(DoAll(InitializationComplete(mocks_->audio_decoder()),
-                        Return(true)));
+    EXPECT_CALL(*mocks_->audio_decoder(), Initialize(stream, NotNull()))
+        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->audio_decoder(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->audio_decoder(), Stop());
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void InitializeVideoRenderer() {
-    EXPECT_CALL(*mocks_->video_renderer(), Initialize(mocks_->video_decoder()))
-        .WillOnce(DoAll(InitializationComplete(mocks_->video_renderer()),
-                        Return(true)));
+    EXPECT_CALL(*mocks_->video_renderer(),
+                Initialize(mocks_->video_decoder(), NotNull()))
+        .WillOnce(Invoke(&RunFilterCallback));
     EXPECT_CALL(*mocks_->video_renderer(), SetPlaybackRate(0.0f));
     EXPECT_CALL(*mocks_->video_renderer(), Stop());
   }
 
   // Sets up expectations to allow the audio renderer to initialize.
   void InitializeAudioRenderer() {
-    EXPECT_CALL(*mocks_->audio_renderer(), Initialize(mocks_->audio_decoder()))
-        .WillOnce(DoAll(InitializationComplete(mocks_->audio_renderer()),
-                        Return(true)));
+    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(), Stop());
   }
 
   // Sets up expectations on the callback and initializes the pipeline.  Called
   // after tests have set expectations any filters they wish to use.
   void InitializePipeline() {
     // Expect an initialization callback.
     EXPECT_CALL(callbacks_, OnStart());
@@ skipping 60 matching lines @@
   size_t width = 1u;
   size_t height = 1u;
   pipeline_.GetVideoSize(&width, &height);
   EXPECT_EQ(0u, width);
   EXPECT_EQ(0u, height);
 
   EXPECT_EQ(PIPELINE_OK, pipeline_.GetError());
 }
 
 TEST_F(PipelineImplTest, NeverInitializes) {
-  EXPECT_CALL(*mocks_->data_source(), Initialize(""))
-      .WillOnce(Return(true));
+  EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
+      .WillOnce(Invoke(&DestroyFilterCallback));
   EXPECT_CALL(*mocks_->data_source(), Stop());
 
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_.Start(mocks_, "",
                   NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                               &CallbackHelper::OnStart));
   message_loop_.RunAllPending();
 
@@ skipping 10 matching lines @@
 TEST_F(PipelineImplTest, RequiredFilterMissing) {
   mocks_->set_creation_successful(false);
 
   InitializePipeline();
   EXPECT_FALSE(pipeline_.IsInitialized());
   EXPECT_EQ(PIPELINE_ERROR_REQUIRED_FILTER_MISSING,
             pipeline_.GetError());
 }
 
 TEST_F(PipelineImplTest, URLNotFound) {
-  EXPECT_CALL(*mocks_->data_source(), Initialize(""))
+  EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
       .WillOnce(DoAll(Error(mocks_->data_source(),
                             PIPELINE_ERROR_URL_NOT_FOUND),
-                      Return(false)));
+                      Invoke(&RunFilterCallback)));
   EXPECT_CALL(*mocks_->data_source(), Stop());
 
   InitializePipeline();
   EXPECT_FALSE(pipeline_.IsInitialized());
   EXPECT_EQ(PIPELINE_ERROR_URL_NOT_FOUND, pipeline_.GetError());
 }
 
 TEST_F(PipelineImplTest, NoStreams) {
   // Manually set these expecations because SetPlaybackRate() is not called if
   // we cannot fully initialize the pipeline.
-  EXPECT_CALL(*mocks_->data_source(), Initialize(""))
-      .WillOnce(DoAll(InitializationComplete(mocks_->data_source()),
-                      Return(true)));
+  EXPECT_CALL(*mocks_->data_source(), Initialize("", NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
   EXPECT_CALL(*mocks_->data_source(), Stop());
 
-  EXPECT_CALL(*mocks_->demuxer(), Initialize(mocks_->data_source()))
-      .WillOnce(DoAll(InitializationComplete(mocks_->demuxer()),
-                      Return(true)));
+  EXPECT_CALL(*mocks_->demuxer(), Initialize(mocks_->data_source(), NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
   EXPECT_CALL(*mocks_->demuxer(), GetNumberOfStreams())
       .WillRepeatedly(Return(0));
   EXPECT_CALL(*mocks_->demuxer(), Stop());
 
   InitializePipeline();
   EXPECT_FALSE(pipeline_.IsInitialized());
   EXPECT_EQ(PIPELINE_ERROR_COULD_NOT_RENDER, pipeline_.GetError());
 }
 
 TEST_F(PipelineImplTest, AudioStream) {
@@ skipping 66 matching lines @@
 
   InitializeDataSource();
   InitializeDemuxer(&streams);
   InitializeAudioDecoder(audio_stream);
   InitializeAudioRenderer();
   InitializeVideoDecoder(video_stream);
   InitializeVideoRenderer();
 
   // Every filter should receive a call to Seek().
   base::TimeDelta expected = base::TimeDelta::FromSeconds(2000);
-  EXPECT_CALL(*mocks_->data_source(), Seek(expected));
-  EXPECT_CALL(*mocks_->demuxer(), Seek(expected));
-  EXPECT_CALL(*mocks_->audio_decoder(), Seek(expected));
-  EXPECT_CALL(*mocks_->audio_renderer(), Seek(expected));
-  EXPECT_CALL(*mocks_->video_decoder(), Seek(expected));
-  EXPECT_CALL(*mocks_->video_renderer(), Seek(expected));
+  EXPECT_CALL(*mocks_->data_source(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
+  EXPECT_CALL(*mocks_->demuxer(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
+  EXPECT_CALL(*mocks_->audio_decoder(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
+  EXPECT_CALL(*mocks_->audio_renderer(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
+  EXPECT_CALL(*mocks_->video_decoder(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
+  EXPECT_CALL(*mocks_->video_renderer(), Seek(expected, NotNull()))
+      .WillOnce(Invoke(&RunFilterCallback));
 
   // We expect a successful seek callback.
   EXPECT_CALL(callbacks_, OnSeek());
 
   // Initialize then seek!
   InitializePipeline();
   pipeline_.Seek(expected,
                  NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
                              &CallbackHelper::OnSeek));
   message_loop_.RunAllPending();
@@ skipping 13 matching lines @@
   // The audio renderer should receive a call to SetVolume().
   float expected = 0.5f;
   EXPECT_CALL(*mocks_->audio_renderer(), SetVolume(expected));
 
   // Initialize then set volume!
   InitializePipeline();
   pipeline_.SetVolume(expected);
 }
 
 }  // namespace media