Implemented end-of-stream callback for media::PipelineImpl.

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::InSequence;
 using ::testing::Invoke;
 using ::testing::Mock;
 using ::testing::NotNull;
 using ::testing::Return;
 using ::testing::StrictMock;
 
 namespace {
 
 // Total bytes of the data source.
 const int kTotalBytes = 1024;
 
 // Buffered bytes of the data source.
 const int kBufferedBytes = 1024;
 
 }  // namespace
 
 namespace media {
 
 // Used for setting expectations on pipeline callbacks.  Using a StrictMock
 // also lets us test for missing callbacks.
 class CallbackHelper {
  public:
   CallbackHelper() {}
   virtual ~CallbackHelper() {}
 
   MOCK_METHOD0(OnStart, void());
   MOCK_METHOD0(OnSeek, void());
   MOCK_METHOD0(OnStop, void());
+  MOCK_METHOD0(OnEnded, void());
   MOCK_METHOD0(OnError, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CallbackHelper);
 };
 
 // TODO(scherkus): even though some filters are initialized on separate
 // threads these test aren't flaky... why?  It's because filters' Initialize()
 // is executed on |message_loop_| and the mock filters instantly call
 // InitializationComplete(), which keeps the pipeline humming along.  If
@@ skipping 418 matching lines @@
   EXPECT_CALL(*mocks_->audio_renderer(),
               OnReceivedMessage(kMsgDisableAudio));
   EXPECT_CALL(*mocks_->video_decoder(),
               OnReceivedMessage(kMsgDisableAudio));
   EXPECT_CALL(*mocks_->video_renderer(),
               OnReceivedMessage(kMsgDisableAudio));
 
   mocks_->audio_renderer()->SetPlaybackRate(1.0f);
 }
 
+TEST_F(PipelineImplTest, EndedCallback) {
+  scoped_refptr<StrictMock<MockDemuxerStream> > audio_stream =
+      new StrictMock<MockDemuxerStream>("audio/x-foo");
+  scoped_refptr<StrictMock<MockDemuxerStream> > video_stream =
+      new StrictMock<MockDemuxerStream>("video/x-foo");
+  MockDemuxerStreamVector streams;
+  streams.push_back(audio_stream);
+  streams.push_back(video_stream);
+
+  // Set our ended callback.
+  pipeline_->SetPipelineEndedCallback(
+      NewCallback(reinterpret_cast<CallbackHelper*>(&callbacks_),
+                  &CallbackHelper::OnEnded));
+
+  InitializeDataSource();
+  InitializeDemuxer(&streams, base::TimeDelta());
+  InitializeAudioDecoder(audio_stream);
+  InitializeAudioRenderer();
+  InitializeVideoDecoder(video_stream);
+  InitializeVideoRenderer();
+  InitializePipeline();
+
+  // For convenience to simulate filters calling the methods.
+  FilterHost* host = pipeline_;
+
+  // Due to short circuit evaluation we only need to test a subset of cases.
+  InSequence s;
+  EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
+      .WillOnce(Return(false));
+  host->NotifyEnded();
+
+  EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
+      .WillOnce(Return(false));
+  host->NotifyEnded();
+
+  EXPECT_CALL(*mocks_->audio_renderer(), HasEnded())
+      .WillOnce(Return(true));
+  EXPECT_CALL(*mocks_->video_renderer(), HasEnded())
+      .WillOnce(Return(true));
+  EXPECT_CALL(callbacks_, OnEnded());
+  host->NotifyEnded();
+}
+
 }  // namespace media