Move Liveness from DemuxerStreamProvider to DemuxerStream.

media/filters/renderer_impl_unittest.cc

 // Copyright 2014 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/run_loop.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 50 matching lines @@
         audio_renderer_(new StrictMock<MockAudioRenderer>()),
         renderer_impl_(
             new RendererImpl(message_loop_.message_loop_proxy(),
                              scoped_ptr<AudioRenderer>(audio_renderer_),
                              scoped_ptr<VideoRenderer>(video_renderer_))) {
     // SetDemuxerExpectations() adds overriding expectations for expected
     // non-NULL streams.
     DemuxerStream* null_pointer = NULL;
     EXPECT_CALL(*demuxer_, GetStream(_))
         .WillRepeatedly(Return(null_pointer));
-    EXPECT_CALL(*demuxer_, GetLiveness())
-        .WillRepeatedly(Return(Demuxer::LIVENESS_UNKNOWN));
   }
 
   virtual ~RendererImplTest() {
     renderer_impl_.reset();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   typedef std::vector<MockDemuxerStream*> MockDemuxerStreamVector;
 
@@ skipping 10 matching lines @@
                 Initialize(audio_stream_.get(), _,  _, _, _, _))
         .WillOnce(DoAll(SaveArg<3>(&audio_buffering_state_cb_),
                         SaveArg<4>(&audio_ended_cb_),
                         SaveArg<5>(&audio_error_cb_),
                         RunCallback<1>(status)));
   }
 
   // Sets up expectations to allow the video renderer to initialize.
   void SetVideoRendererInitializeExpectations(PipelineStatus status) {
     EXPECT_CALL(*video_renderer_,
-                Initialize(video_stream_.get(), _, _, _, _, _, _, _, _))
-        .WillOnce(DoAll(SaveArg<4>(&video_buffering_state_cb_),
-                        SaveArg<6>(&video_ended_cb_),
-                        RunCallback<2>(status)));
+                Initialize(video_stream_.get(), _, _, _, _, _, _, _))
+        .WillOnce(DoAll(SaveArg<3>(&video_buffering_state_cb_),
+                        SaveArg<5>(&video_ended_cb_),
+                        RunCallback<1>(status)));
   }
 
   void InitializeAndExpect(PipelineStatus start_status) {
     if (start_status != PIPELINE_OK)
       EXPECT_CALL(callbacks_, OnError(start_status));
 
     EXPECT_CALL(callbacks_, OnInitialize());
 
     if (start_status == PIPELINE_OK && audio_stream_) {
       EXPECT_CALL(*audio_renderer_, GetTimeSource())
@@ skipping 316 matching lines @@
   audio_error_cb_.Run(PIPELINE_ERROR_DECODE);
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(RendererImplTest, ErrorDuringInitialize) {
   CreateAudioAndVideoStream();
   SetAudioRendererInitializeExpectations(PIPELINE_OK);
 
   // Force an audio error to occur during video renderer initialization.
   EXPECT_CALL(*video_renderer_,
-              Initialize(video_stream_.get(), _, _, _, _, _, _, _, _))
+              Initialize(video_stream_.get(),  _, _, _, _, _, _, _))
       .WillOnce(DoAll(AudioError(&audio_error_cb_, PIPELINE_ERROR_DECODE),
-                      SaveArg<4>(&video_buffering_state_cb_),
-                      SaveArg<6>(&video_ended_cb_),
-                      RunCallback<2>(PIPELINE_OK)));
+                      SaveArg<3>(&video_buffering_state_cb_),
+                      SaveArg<5>(&video_ended_cb_),
+                      RunCallback<1>(PIPELINE_OK)));
 
   InitializeAndExpect(PIPELINE_ERROR_DECODE);
 }
 
 }  // namespace media