Render inband text tracks in the media pipeline

media/base/pipeline_unittest.cc

 // Copyright (c) 2012 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 <vector>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 104 matching lines @@
                                base::Unretained(&callbacks_)));
     message_loop_.RunUntilIdle();
   }
 
  protected:
   // Sets up expectations to allow the demuxer to initialize.
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
   void InitializeDemuxer(MockDemuxerStreamVector* streams,
                          const base::TimeDelta& duration) {
     EXPECT_CALL(callbacks_, OnDurationChange());
-    EXPECT_CALL(*demuxer_, Initialize(_, _))
+    EXPECT_CALL(*demuxer_, Initialize(_, _, _))
         .WillOnce(DoAll(SetDemuxerProperties(duration),
                         RunCallback<1>(PIPELINE_OK)));
 
     // Configure the demuxer to return the streams.
     for (size_t i = 0; i < streams->size(); ++i) {
       DemuxerStream* stream = (*streams)[i];
       EXPECT_CALL(*demuxer_, GetStream(stream->type()))
           .WillRepeatedly(Return(stream));
     }
   }
@@ skipping 195 matching lines @@
 
   // Should always get set to zero.
   gfx::Size size(1, 1);
   pipeline_->GetNaturalVideoSize(&size);
   EXPECT_EQ(0, size.width());
   EXPECT_EQ(0, size.height());
 }
 
 TEST_F(PipelineTest, NeverInitializes) {
   // Don't execute the callback passed into Initialize().
-  EXPECT_CALL(*demuxer_, Initialize(_, _));
+  EXPECT_CALL(*demuxer_, Initialize(_, _, _));
 
   // This test hangs during initialization by never calling
   // InitializationComplete().  StrictMock<> will ensure that the callback is
   // never executed.
   pipeline_->Start(
         filter_collection_.Pass(),
         base::Bind(&CallbackHelper::OnEnded, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnError, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnStart, base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnBufferingState,
                    base::Unretained(&callbacks_)),
         base::Bind(&CallbackHelper::OnDurationChange,
                    base::Unretained(&callbacks_)));
   message_loop_.RunUntilIdle();
 
 
   // Because our callback will get executed when the test tears down, we'll
   // verify that nothing has been called, then set our expectation for the call
   // made during tear down.
   Mock::VerifyAndClear(&callbacks_);
   EXPECT_CALL(callbacks_, OnStart(PIPELINE_OK));
 }
 
 TEST_F(PipelineTest, URLNotFound) {
-  EXPECT_CALL(*demuxer_, Initialize(_, _))
+  EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_ERROR_URL_NOT_FOUND));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   InitializePipeline(PIPELINE_ERROR_URL_NOT_FOUND);
 }
 
 TEST_F(PipelineTest, NoStreams) {
-  EXPECT_CALL(*demuxer_, Initialize(_, _))
+  EXPECT_CALL(*demuxer_, Initialize(_, _, _))
       .WillOnce(RunCallback<1>(PIPELINE_OK));
   EXPECT_CALL(*demuxer_, Stop(_))
       .WillOnce(RunClosure<0>());
 
   InitializePipeline(PIPELINE_ERROR_COULD_NOT_RENDER);
 }
 
 TEST_F(PipelineTest, AudioStream) {
   CreateAudioStream();
   MockDemuxerStreamVector streams;
@@ skipping 530 matching lines @@
   }
 
   PipelineStatus SetInitializeExpectations(TeardownState state,
                                            StopOrError stop_or_error) {
     PipelineStatus status = PIPELINE_OK;
     base::Closure stop_cb = base::Bind(
         &CallbackHelper::OnStop, base::Unretained(&callbacks_));
 
     if (state == kInitDemuxer) {
       if (stop_or_error == kStop) {
-        EXPECT_CALL(*demuxer_, Initialize(_, _))
+        EXPECT_CALL(*demuxer_, Initialize(_, _, _))
             .WillOnce(DoAll(Stop(pipeline_.get(), stop_cb),
                             RunCallback<1>(PIPELINE_OK)));
         EXPECT_CALL(callbacks_, OnStop());
       } else {
         status = DEMUXER_ERROR_COULD_NOT_OPEN;
-        EXPECT_CALL(*demuxer_, Initialize(_, _))
+        EXPECT_CALL(*demuxer_, Initialize(_, _, _))
             .WillOnce(RunCallback<1>(status));
       }
 
       EXPECT_CALL(*demuxer_, Stop(_)).WillOnce(RunClosure<0>());
       return status;
     }
 
     CreateAudioStream();
     CreateVideoStream();
     MockDemuxerStreamVector streams;
@@ skipping 232 matching lines @@
 INSTANTIATE_TEARDOWN_TEST(Error, Pausing);
 INSTANTIATE_TEARDOWN_TEST(Error, Flushing);
 INSTANTIATE_TEARDOWN_TEST(Error, Seeking);
 INSTANTIATE_TEARDOWN_TEST(Error, Prerolling);
 INSTANTIATE_TEARDOWN_TEST(Error, Starting);
 INSTANTIATE_TEARDOWN_TEST(Error, Playing);
 
 INSTANTIATE_TEARDOWN_TEST(ErrorAndStop, Playing);
 
 }  // namespace media