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

media/base/composite_filter_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 "base/bind.h"
 #include "base/message_loop.h"
 #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;
@@ skipping 31 matching lines @@
                         base::TimeDelta seek_time);
 
   // Helper method that calls a filter method based on the value of
   // |method_to_call|.
   //
   // |method_to_call| - Indicates which method to call.
   // |filter| - The Filter to make the method call on.
   // |seek_time| - The time to pass to the Seek() call if |method_to_call|
   //               equals SEEK.
   // |callback| - The callback object to pass to the method.
+  // |expected_status| - Some filter methods use a FilterStatusCB instead of
+  //                     a FilterCallback. For these methods this function
+  //                     creates a FilterStatusCB that makes sure the status
+  //                     passed to the callback matches |expected_status| and
+  //                     then calls |callback|.
   void DoFilterCall(MethodToCall method_to_call, Filter* filter,
                     base::TimeDelta seek_time,
-                    FilterCallback* callback);
+                    FilterCallback* callback,
+                    PipelineStatus expected_status);
 
   // Creates an expectation sequence based on the value of method_to_call.
   //
   // |method_to_call| - Indicates which method we want a success sequence for.
   // |seek_time| - The time to pass in the Seek() call if |method_to_call|
   //               equals SEEK.
   void ExpectSuccess(MethodToCall method_to_call,
                      base::TimeDelta seek_time = base::TimeDelta());
 
   // Issue a Play(), Pause(), Flush(), Stop(), or Seek() on the composite and
   // verify all the expected calls on the filters.
   void DoPlay();
   void DoPause();
   void DoFlush();
   void DoStop();
   void DoSeek(base::TimeDelta time);
 
   // Issue a Play(), Pause(), Flush(), or Seek() and expect the calls to fail
   // with a PIPELINE_ERROR_INVALID_STATE error.
   //
   // |method_to_call| - Indicates whick method to call.
   // |seek_time| - The time to pass to the Seek() call if |method_to_call|
   //               equals SEEK.
   void ExpectInvalidStateFail(MethodToCall method_to_call,
                   base::TimeDelta seek_time = base::TimeDelta());
 
-  // Run the callback stored in |filter_1_callback_|.
+  // Returns whether |filter_1_callback_| or |filter_1_status_cb_| is set.
+  bool HasFilter1Callback() const;
+
+  // Run the callback stored in |filter_1_callback_| or |filter_2_status_cb_|.
   void RunFilter1Callback();
 
-  // Run the callback stored in |filter_2_callback_|.
+  // Returns whether |filter_2_callback_| or |filter_2_status_cb_| is set.
+  bool HasFilter2Callback() const;
+
+  // Run the callback stored in |filter_2_callback_| or |filter_2_status_cb_|.
   void RunFilter2Callback();
 
  protected:
   MessageLoop message_loop_;
 
   // The composite object being tested.
   scoped_refptr<CompositeFilter> composite_;
 
   // First filter added to the composite.
   scoped_refptr<StrictMock<MockFilter> > filter_1_;
 
   // Callback passed to |filter_1_| during last Play(), Pause(), Flush(),
-  // Stop(), or Seek() call.
+  // or Stop() call.
   FilterCallback* filter_1_callback_;
 
+  // Status to pass to |filter_1_status_cb_|.
+  PipelineStatus filter_1_status_;
+
+  // Callback passed to |filter_1_| during last Seek() call.
+  FilterStatusCB filter_1_status_cb_;
+
   // Second filter added to the composite.
   scoped_refptr<StrictMock<MockFilter> > filter_2_;
 
   // Callback passed to |filter_2_| during last Play(), Pause(), Flush(),
   // Stop(), or Seek() call.
   FilterCallback* filter_2_callback_;
 
+  // Status to pass to |filter_2_status_cb_|.
+  PipelineStatus filter_2_status_;
+
+  // Callback passed to |filter_2_| during last Seek() call.
+  FilterStatusCB filter_2_status_cb_;
+
   // FilterHost implementation passed to |composite_| via set_host().
   scoped_ptr<StrictMock<MockFilterHost> > mock_filter_host_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositeFilterTest);
 };
 
 CompositeFilterTest::CompositeFilterTest() :
     composite_(new CompositeFilter(&message_loop_)),
     filter_1_callback_(NULL),
+    filter_1_status_(PIPELINE_OK),
     filter_2_callback_(NULL),
+    filter_2_status_(PIPELINE_OK),
     mock_filter_host_(new StrictMock<MockFilterHost>()) {
 }
 
 CompositeFilterTest::~CompositeFilterTest() {}
 
 void CompositeFilterTest::SetupAndAdd2Filters() {
   mock_filter_host_.reset(new StrictMock<MockFilterHost>());
   composite_ = new CompositeFilter(&message_loop_);
   composite_->set_host(mock_filter_host_.get());
 
   // Setup |filter_1_| and arrange for methods to set
   // |filter_1_callback_| when they are called.
   filter_1_ = new StrictMock<MockFilter>();
   filter_1_callback_ = NULL;
+  filter_1_status_ = PIPELINE_OK;
+  filter_1_status_cb_.Reset();
   ON_CALL(*filter_1_, Play(_))
       .WillByDefault(SaveArg<0>(&filter_1_callback_));
   ON_CALL(*filter_1_, Pause(_))
       .WillByDefault(SaveArg<0>(&filter_1_callback_));
   ON_CALL(*filter_1_, Flush(_))
       .WillByDefault(SaveArg<0>(&filter_1_callback_));
   ON_CALL(*filter_1_, Stop(_))
       .WillByDefault(SaveArg<0>(&filter_1_callback_));
   ON_CALL(*filter_1_, Seek(_,_))
-      .WillByDefault(SaveArg<1>(&filter_1_callback_));
+      .WillByDefault(SaveArg<1>(&filter_1_status_cb_));
 
   // Setup |filter_2_| and arrange for methods to set
   // |filter_2_callback_| when they are called.
   filter_2_ = new StrictMock<MockFilter>();
   filter_2_callback_ = NULL;
+  filter_2_status_ = PIPELINE_OK;
+  filter_2_status_cb_.Reset();
   ON_CALL(*filter_2_, Play(_))
       .WillByDefault(SaveArg<0>(&filter_2_callback_));
   ON_CALL(*filter_2_, Pause(_))
       .WillByDefault(SaveArg<0>(&filter_2_callback_));
   ON_CALL(*filter_2_, Flush(_))
       .WillByDefault(SaveArg<0>(&filter_2_callback_));
   ON_CALL(*filter_2_, Stop(_))
       .WillByDefault(SaveArg<0>(&filter_2_callback_));
   ON_CALL(*filter_2_, Seek(_,_))
-      .WillByDefault(SaveArg<1>(&filter_2_callback_));
+      .WillByDefault(SaveArg<1>(&filter_2_status_cb_));
 
   composite_->AddFilter(filter_1_);
   composite_->AddFilter(filter_2_);
 }
 
 void CompositeFilterTest::ExpectFilterCall(MethodToCall method_to_call,
                                            MockFilter* filter,
                                            base::TimeDelta seek_time) {
   switch(method_to_call) {
     case PLAY:
       EXPECT_CALL(*filter, Play(_));
       break;
     case PAUSE:
       EXPECT_CALL(*filter, Pause(_));
       break;
     case FLUSH:
       EXPECT_CALL(*filter, Flush(_));
       break;
     case STOP:
       EXPECT_CALL(*filter, Stop(_));
       break;
     case SEEK:
       EXPECT_CALL(*filter, Seek(seek_time, _));
       break;
   };
 }
 
+void OnStatusCB(PipelineStatus expected_status, FilterCallback* callback,
+                PipelineStatus status) {
+  EXPECT_EQ(status, expected_status);
+
+  callback->Run();
+  delete callback;
+}
+
 void CompositeFilterTest::DoFilterCall(MethodToCall method_to_call,
                                        Filter* filter,
                                        base::TimeDelta seek_time,
-                                       FilterCallback* callback) {
+                                       FilterCallback* callback,
+                                       PipelineStatus expected_status) {
+  filter_1_status_ = expected_status;
+  filter_2_status_ = expected_status;
+
   switch(method_to_call) {
     case PLAY:
       filter->Play(callback);
       break;
     case PAUSE:
       filter->Pause(callback);
       break;
     case FLUSH:
       filter->Flush(callback);
       break;
     case STOP:
       filter->Stop(callback);
       break;
     case SEEK:
-      filter->Seek(seek_time, callback);
+      filter->Seek(seek_time, base::Bind(&OnStatusCB, expected_status,
+                                         callback));
       break;
   };
 }
 
 void CompositeFilterTest::ExpectSuccess(MethodToCall method_to_call,
                                         base::TimeDelta seek_time) {
   InSequence seq;
 
   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.
   StrictMock<MockCallback>* callback = new StrictMock<MockCallback>();
-  DoFilterCall(method_to_call, composite_.get(), seek_time, callback);
+  DoFilterCall(method_to_call, composite_.get(), seek_time, callback,
+               PIPELINE_OK);
 
   if (is_parallel_call) {
     // Make sure both filters have their callbacks set.
-    EXPECT_TRUE(filter_1_callback_ != NULL);
-    EXPECT_TRUE(filter_2_callback_ != NULL);
+    EXPECT_TRUE(HasFilter1Callback());
+    EXPECT_TRUE(HasFilter2Callback());
 
     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_);
+    EXPECT_TRUE(HasFilter1Callback());
+    EXPECT_FALSE(HasFilter2Callback());
 
     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_TRUE(HasFilter2Callback());
   }
 
   callback->ExpectRunAndDelete();
 
   RunFilter2Callback();
 }
 
 void CompositeFilterTest::DoPlay() {
   ExpectSuccess(PLAY);
 }
@@ skipping 11 matching lines @@
 }
 
 void CompositeFilterTest::DoSeek(base::TimeDelta time) {
   ExpectSuccess(SEEK, time);
 }
 
 void CompositeFilterTest::ExpectInvalidStateFail(MethodToCall method_to_call,
                                      base::TimeDelta seek_time) {
   InSequence seq;
 
-  EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_INVALID_STATE))
-      .WillOnce(Return());
+  if (method_to_call != SEEK) {
+    EXPECT_CALL(*mock_filter_host_, SetError(PIPELINE_ERROR_INVALID_STATE))
+        .WillOnce(Return());
+  }
 
-  DoFilterCall(method_to_call, composite_, seek_time, NewExpectedCallback());
+  DoFilterCall(method_to_call, composite_, seek_time, NewExpectedCallback(),
+               PIPELINE_ERROR_INVALID_STATE);
 
   // 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_);
+  EXPECT_FALSE(HasFilter1Callback());
+  EXPECT_FALSE(HasFilter2Callback());
+}
+
+bool CompositeFilterTest::HasFilter1Callback() const {
+  CHECK(!(filter_1_callback_ && !filter_1_status_cb_.is_null()));
+  return filter_1_callback_ != NULL || !filter_1_status_cb_.is_null();
 }
 
 void CompositeFilterTest::RunFilter1Callback() {
+  EXPECT_TRUE(HasFilter1Callback());
+
+  if (!filter_1_status_cb_.is_null()) {
+    ResetAndRunCB(&filter_1_status_cb_, filter_1_status_);
+    filter_1_status_ = PIPELINE_OK;
+    return;
+  }
+
   EXPECT_TRUE(filter_1_callback_ != NULL);
   FilterCallback* callback = filter_1_callback_;
   filter_1_callback_ = NULL;
   callback->Run();
   delete callback;
 }
 
+bool CompositeFilterTest::HasFilter2Callback() const {
+  CHECK(!(filter_2_callback_ && !filter_2_status_cb_.is_null()));
+  return filter_2_callback_ != NULL || !filter_2_status_cb_.is_null();
+}
+
 void CompositeFilterTest::RunFilter2Callback() {
+  EXPECT_TRUE(HasFilter2Callback());
+
+  if (!filter_2_status_cb_.is_null()) {
+    ResetAndRunCB(&filter_2_status_cb_, filter_2_status_);
+    filter_2_status_ = PIPELINE_OK;
+    return;
+  }
+
   EXPECT_TRUE(filter_2_callback_ != NULL);
   FilterCallback* callback = filter_2_callback_;
   filter_2_callback_ = NULL;
   callback->Run();
   delete callback;
 }
 
 // Test AddFilter() failure cases.
 TEST_F(CompositeFilterTest, TestAddFilterFailCases) {
   // Test adding a null pointer.
@@ skipping 28 matching lines @@
   DoPlay();
 
   // At this point we are now in the kPlaying state.
 
   // 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.
   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_);
+  EXPECT_FALSE(HasFilter1Callback());
+  EXPECT_FALSE(HasFilter2Callback());
 
   // Stop playback.
   DoStop();
 
   // At this point we should be in the kStopped state.
 
   // Try calling Stop() again to make sure neither filter is called.
   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_);
+  EXPECT_FALSE(HasFilter1Callback());
+  EXPECT_FALSE(HasFilter2Callback());
 
   // 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();
@@ skipping 45 matching lines @@
   // 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.
   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_);
+  EXPECT_FALSE(HasFilter1Callback());
+  EXPECT_FALSE(HasFilter2Callback());
 
   // Verify that we can transition pack to the play state.
   DoPlay();
 
   // Go back to the pause state.
   DoPause();
 
   // Transition to the stop state.
   DoStop();
 
@@ skipping 20 matching lines @@
   // 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));
   callback->ExpectRunAndDelete();
 
   RunFilter1Callback();
 
   // Make sure |filter_2_callback_| was not set.
-  EXPECT_EQ((FilterCallback*)NULL, filter_2_callback_);
+  EXPECT_FALSE(HasFilter2Callback());
 
   // 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();
 }
@@ skipping 233 matching lines @@
   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());
+                   NewExpectedStatusCB(PIPELINE_OK));
 
   // Issue a Play() and expect no errors.
   composite_->Play(NewExpectedCallback());
 
   // Issue a Stop() and expect no errors.
   composite_->Stop(NewExpectedCallback());
 }
 
 }  // namespace media