Replace MockFilterCallback with MockCallback and simplify unit tests.

media/base/composite_filter_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "media/base/composite_filter.h"
+#include "media/base/mock_callback.h"
 #include "media/base/mock_filter_host.h"
 #include "media/base/mock_filters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 
@@ skipping 186 matching lines @@
     case SEEK:
       filter->Seek(seek_time, callback);
       break;
   };
 }
 
 void CompositeFilterTest::ExpectSuccess(MethodToCall method_to_call,
                                         base::TimeDelta seek_time) {
   InSequence seq;
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   bool is_parallel_call = (method_to_call == FLUSH);
 
   ExpectFilterCall(method_to_call, filter_1_.get(), seek_time);
 
   if (is_parallel_call) {
     ExpectFilterCall(method_to_call, filter_2_.get(), seek_time);
   }
 
   // Make method call on the composite.
-  DoFilterCall(method_to_call, composite_.get(), seek_time,
-               mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  DoFilterCall(method_to_call, composite_.get(), seek_time, callback);
 
   if (is_parallel_call) {
     // Make sure both filters have their callbacks set.
     EXPECT_TRUE(filter_1_callback_ != NULL);
     EXPECT_TRUE(filter_2_callback_ != NULL);
 
     RunFilter1Callback();
   } else {
     // Make sure that only |filter_1_| has its callback set.
     EXPECT_TRUE(filter_1_callback_ != NULL);
     EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 
     ExpectFilterCall(method_to_call, filter_2_.get(), seek_time);
 
     RunFilter1Callback();
 
     // Verify that |filter_2_| was called by checking the callback pointer.
     EXPECT_TRUE(filter_2_callback_ != NULL);
   }
 
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));

[acolwell GONE FROM CHROMIUM, 2011/01/14 19:29:14]

Perhaps create a ExpectRunAndDestroy() method on the mock so these 2 lines don't
have to be copied everywhere a deferred call is expected.

[scherkus (not reviewing), 2011/01/15 02:11:09]

I like it!  Done.

+  EXPECT_CALL(*callback, Destructor());
 
   RunFilter2Callback();
 }
 
 void CompositeFilterTest::DoPlay() {
   ExpectSuccess(PLAY);
 }
 
 void CompositeFilterTest::DoPause() {
   ExpectSuccess(PAUSE);
 }
 
 void CompositeFilterTest::DoFlush() {
   ExpectSuccess(FLUSH);
 }
 
 void CompositeFilterTest::DoStop() {
   ExpectSuccess(STOP);
 }
 
 void CompositeFilterTest::DoSeek(base::TimeDelta time) {
   ExpectSuccess(SEEK, time);
 }
 
 void CompositeFilterTest::ExpectInvalidStateFail(MethodToCall method_to_call,
                                      base::TimeDelta seek_time) {
   InSequence seq;
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
 
   EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_INVALID_STATE))
       .WillOnce(Return());
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
 
-  DoFilterCall(method_to_call, composite_, seek_time,
-               mock_callback->NewCallback());
+  DoFilterCall(method_to_call, composite_, seek_time, NewExpectedCallback());
 
   // Make sure that neither of the filters were called by
   // verifying that the callback pointers weren't set.
   EXPECT_EQ((FilterCallback*)NULL, filter_1_callback_);
   EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 }
 
 void CompositeFilterTest::RunFilter1Callback() {
   EXPECT_TRUE(filter_1_callback_ != NULL);
   FilterCallback* callback = filter_1_callback_;
@@ skipping 64 matching lines @@
 
 TEST_F(CompositeFilterTest, TestPlay) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
   // Verify successful call to Play().
   DoPlay();
 
   // At this point we are now in the kPlaying state.
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
 
   // Try calling Play() again to make sure that we simply get a callback.
   // We are already in the Play() state so there is no point calling the
   // filters.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-
-  composite_->Play(mock_callback->NewCallback());
+  composite_->Play(NewExpectedCallback());
 
   // Verify that neither of the filter callbacks were set.
   EXPECT_EQ((FilterCallback*)NULL, filter_1_callback_);
   EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 
   // Stop playback.
   DoStop();
 
   // At this point we should be in the kStopped state.
 
   // Try calling Stop() again to make sure neither filter is called.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-
-  composite_->Stop(mock_callback->NewCallback());
+  composite_->Stop(NewExpectedCallback());
 
   // Verify that neither of the filter callbacks were set.
   EXPECT_EQ((FilterCallback*)NULL, filter_1_callback_);
   EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 
   // Try calling Play() again to make sure we get an error.
   ExpectInvalidStateFail(PLAY);
 }
 
 // Test errors in the middle of a serial call sequence like Play().
 TEST_F(CompositeFilterTest, TestPlayErrors) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   EXPECT_CALL(*filter_1_, Play(_));
 
   // Call Play() on the composite.
-  composite_->Play(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Play(callback);
 
   EXPECT_CALL(*filter_2_, Play(_));
 
   // Run callback to indicate that |filter_1_|'s Play() has completed.
   RunFilter1Callback();
 
   // At this point Play() has been called on |filter_2_|. Simulate an
   // error by calling SetError() on its FilterHost interface.
   filter_2_->host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
 
   // Expect error to be reported and "play done" callback to be called.
   EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_OUT_OF_MEMORY));
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   // Run callback to indicate that |filter_2_|'s Play() has completed.
   RunFilter2Callback();
 
   // Verify that Play/Pause/Flush/Seek fail now that an error occured.
   ExpectInvalidStateFail(PLAY);
   ExpectInvalidStateFail(PAUSE);
   ExpectInvalidStateFail(FLUSH);
   ExpectInvalidStateFail(SEEK);
 
   // Make sure you can still Stop().
   DoStop();
 }
 
 TEST_F(CompositeFilterTest, TestPause) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   // Try calling Pause() to make sure we get an error because we aren't in
   // the playing state.
   ExpectInvalidStateFail(PAUSE);
 
   // Transition to playing state.
   DoPlay();
 
   // Issue a successful Pause().
   DoPause();
 
   // At this point we are paused.
 
   // Try calling Pause() again to make sure that the filters aren't called
   // because we are already in the paused state.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-
-  composite_->Pause(mock_callback->NewCallback());
+  composite_->Pause(NewExpectedCallback());
 
   // Verify that neither of the filter callbacks were set.
   EXPECT_EQ((FilterCallback*)NULL, filter_1_callback_);
   EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 
   // Verify that we can transition pack to the play state.
   DoPlay();
 
   // Go back to the pause state.
   DoPause();
 
   // Transition to the stop state.
   DoStop();
 
   // Try calling Pause() to make sure we get an error because we aren't in
   // the playing state.
   ExpectInvalidStateFail(PAUSE);
 }
 
 // Test errors in the middle of a serial call sequence like Pause().
 TEST_F(CompositeFilterTest, TestPauseErrors) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
   DoPlay();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   EXPECT_CALL(*filter_1_, Pause(_));
 
   // Call Pause() on the composite.
-  composite_->Pause(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Pause(callback);
 
   // Simulate an error by calling SetError() on |filter_1_|'s FilterHost
   // interface.
   filter_1_->host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
 
   // Expect error to be reported and "pause done" callback to be called.
   EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_OUT_OF_MEMORY));
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   RunFilter1Callback();
 
   // Make sure |filter_2_callback_| was not set.
   EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
 
   // Verify that Play/Pause/Flush/Seek fail now that an error occured.
   ExpectInvalidStateFail(PLAY);
   ExpectInvalidStateFail(PAUSE);
   ExpectInvalidStateFail(FLUSH);
   ExpectInvalidStateFail(SEEK);
 
   // Make sure you can still Stop().
   DoStop();
 }
 
 TEST_F(CompositeFilterTest, TestFlush) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   // Make sure Flush() works before calling Play().
   DoFlush();
 
   // Transition to playing state.
   DoPlay();
 
   // Call Flush() to make sure we get an error because we are in
   // the playing state.
   ExpectInvalidStateFail(FLUSH);
 
@@ skipping 12 matching lines @@
   // Try calling Flush() to make sure we get an error because we are stopped.
   ExpectInvalidStateFail(FLUSH);
 }
 
 // Test errors in the middle of a parallel call sequence like Flush().
 TEST_F(CompositeFilterTest, TestFlushErrors) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   EXPECT_CALL(*filter_1_, Flush(_));
   EXPECT_CALL(*filter_2_, Flush(_));
 
   // Call Flush() on the composite.
-  composite_->Flush(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Flush(callback);
 
   // Simulate an error by calling SetError() on |filter_1_|'s FilterHost
   // interface.
   filter_1_->host()->SetError(PIPELINE_ERROR_OUT_OF_MEMORY);
 
   RunFilter1Callback();
 
   // Expect error to be reported and "pause done" callback to be called.
   EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_OUT_OF_MEMORY));
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   RunFilter2Callback();
 
   // Verify that Play/Pause/Flush/Seek fail now that an error occured.
   ExpectInvalidStateFail(PLAY);
   ExpectInvalidStateFail(PAUSE);
   ExpectInvalidStateFail(FLUSH);
   ExpectInvalidStateFail(SEEK);
 
   // Make sure you can still Stop().
   DoStop();
 }
 
 TEST_F(CompositeFilterTest, TestSeek) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
   // Verify that seek is allowed to be called before a Play() call.
   DoSeek(base::TimeDelta::FromSeconds(5));
 
   // Verify we can issue a Play() after the Seek().
   DoPlay();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
-
   // Try calling Seek() while playing to make sure we get an error.
   ExpectInvalidStateFail(SEEK);
 
   // Transition to paused state.
   DoPause();
 
   // Verify that seek is allowed after pausing.
   DoSeek(base::TimeDelta::FromSeconds(5));
 
   // Verify we can still play again.
   DoPlay();
 
   // Stop playback.
   DoStop();
 
   // Try calling Seek() to make sure we get an error.
   ExpectInvalidStateFail(SEEK);
 }
 
 TEST_F(CompositeFilterTest, TestStop) {
   InSequence sequence;
 
   // Test Stop() before any other call.
   SetupAndAdd2Filters();
   DoStop();
 
   // Test error during Stop() sequence.
   SetupAndAdd2Filters();
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
 
   EXPECT_CALL(*filter_1_, Stop(_));
 
-  composite_->Stop(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Stop(callback);
 
   // Have |filter_1_| signal an error.
   filter_1_->host()->SetError(PIPELINE_ERROR_READ);
 
   EXPECT_CALL(*filter_2_, Stop(_));
 
   RunFilter1Callback();
 
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   RunFilter2Callback();
 }
 
 // Test stopping in the middle of a serial call sequence.
 TEST_F(CompositeFilterTest, TestStopWhilePlayPending) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>());
-
   EXPECT_CALL(*filter_1_, Play(_));
 
-  composite_->Play(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Play(callback);
 
   // Note: Play() is pending on |filter_1_| right now.
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback_2(
-      new StrictMock<MockFilterCallback>(false));
+  EXPECT_CALL(*callback, Destructor());
 
-  EXPECT_CALL(*mock_callback, OnCallbackDestroyed());
-
-  composite_->Stop(mock_callback_2->NewCallback());
+  callback = new StrictMock<MockCallback>();
+  composite_->Stop(callback);
 
   EXPECT_CALL(*filter_1_, Stop(_));
 
   // Run |filter_1_|'s callback again to indicate Play() has completed.
   RunFilter1Callback();
 
   EXPECT_CALL(*filter_2_, Stop(_));
 
   // Run |filter_1_|'s callback again to indicate Stop() has completed.
   RunFilter1Callback();
 
-  EXPECT_CALL(*mock_callback_2, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   // Run |filter_2_|'s callback to indicate Stop() has completed.
   RunFilter2Callback();
 }
 
 // Test stopping in the middle of a parallel call sequence.
 TEST_F(CompositeFilterTest, TestStopWhileFlushPending) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>());
-
   EXPECT_CALL(*filter_1_, Flush(_));
   EXPECT_CALL(*filter_2_, Flush(_));
 
-  composite_->Flush(mock_callback->NewCallback());
+  StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
+  composite_->Flush(callback);
 
   // Note: |filter_1_| and |filter_2_| have pending Flush() calls at this point.
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback_2(
-      new StrictMock<MockFilterCallback>(false));
+  EXPECT_CALL(*callback, Destructor());
 
-  EXPECT_CALL(*mock_callback, OnCallbackDestroyed());
-
-  composite_->Stop(mock_callback_2->NewCallback());
+  callback = new StrictMock<MockCallback>();
+  composite_->Stop(callback);
 
   // Run callback to indicate that |filter_1_|'s Flush() has completed.
   RunFilter1Callback();
 
   EXPECT_CALL(*filter_1_, Stop(_));
 
   // Run callback to indicate that |filter_2_|'s Flush() has completed.
   RunFilter2Callback();
 
   EXPECT_CALL(*filter_2_, Stop(_));
 
   // Run callback to indicate that |filter_1_|'s Stop() has completed.
   RunFilter1Callback();
 
-  EXPECT_CALL(*mock_callback_2, OnFilterCallback());
+  EXPECT_CALL(*callback, RunWithParams(_));
+  EXPECT_CALL(*callback, Destructor());
 
   // Run callback to indicate that |filter_2_|'s Stop() has completed.
   RunFilter2Callback();
 }
 
 TEST_F(CompositeFilterTest, TestErrorWhilePlaying) {
   InSequence sequence;
 
   SetupAndAdd2Filters();
 
@@ skipping 21 matching lines @@
   filter_2_->host()->SetError(PIPELINE_ERROR_NETWORK);
 }
 
 // Make sure that state transitions act as expected even
 // if the composite doesn't contain any filters.
 TEST_F(CompositeFilterTest, TestEmptyComposite) {
   InSequence sequence;
 
   composite_->set_host(mock_filter_host_.get());
 
-  scoped_ptr<StrictMock<MockFilterCallback> > mock_callback(
-      new StrictMock<MockFilterCallback>(false));
+  // Issue a Play() and expect no errors.
+  composite_->Play(NewExpectedCallback());
+
+  // Issue a Pause() and expect no errors.
+  composite_->Pause(NewExpectedCallback());
+
+  // Issue a Flush() and expect no errors.
+  composite_->Flush(NewExpectedCallback());
+
+  // Issue a Seek() and expect no errors.
+  composite_->Seek(base::TimeDelta::FromSeconds(5),
+                   NewExpectedCallback());
 
   // Issue a Play() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Play(mock_callback->NewCallback());
-
-  // Issue a Pause() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Pause(mock_callback->NewCallback());
-
-  // Issue a Flush() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Flush(mock_callback->NewCallback());
-
-  // Issue a Seek() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Seek(base::TimeDelta::FromSeconds(5),
-                   mock_callback->NewCallback());
-
-  // Issue a Play() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Play(mock_callback->NewCallback());
+  composite_->Play(NewExpectedCallback());
 
   // Issue a Stop() and expect no errors.
-  EXPECT_CALL(*mock_callback, OnFilterCallback());
-  composite_->Stop(mock_callback->NewCallback());
+  composite_->Stop(NewExpectedCallback());
 }
 
 }  // namespace media