Let only seeks reset Android MSE stream playback completion

media/base/android/media_source_player_unittest.cc

 // Copyright 2013 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/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 347 matching lines @@
     EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
     player_.SeekTo(seek_time);
     EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
     EXPECT_EQ(1, demuxer_->num_data_requests());
     EXPECT_EQ(0, demuxer_->num_seek_requests());
   }
 
   // Seek, including simulated receipt of |kAborted| read between SeekTo()
-  // and OnDemuxerSeekDone(). Use this helper method only when the player
-  // already has created the decoder job.
-  void SeekPlayer(bool is_audio, const base::TimeDelta& seek_time) {
+  // and OnDemuxerSeekDone() if |abort| is true. Use this helper method only
+  // when the player already has created the decoder job. If |abort| is false,
+  // |is_audio| is ignored. |expected_new_data_requests| is compared to the
+  // actual increase in data request count due to the seek.
+  void SeekPlayer(bool is_audio, const base::TimeDelta& seek_time, bool abort,
+                  int expected_new_data_requests) {
     EXPECT_TRUE(GetMediaDecoderJob(is_audio));
 
     int original_num_seeks = demuxer_->num_seek_requests();
     int original_num_data_requests = demuxer_->num_data_requests();
 
     // Initiate a seek. Skip the round-trip of requesting seek from renderer.
     // Instead behave as if the renderer has asked us to seek.
     player_.SeekTo(seek_time);
 
-    // Verify that the seek does not occur until previously outstanding data
-    // request is satisfied.
-    EXPECT_EQ(original_num_seeks, demuxer_->num_seek_requests());
+    if (abort) {
+      // Verify that the seek does not occur until previously outstanding data
+      // request is satisfied.
+      EXPECT_EQ(original_num_seeks, demuxer_->num_seek_requests());
 
-    // Simulate seeking causes the demuxer to abort the outstanding read caused
-    // by the seek.
-    player_.OnDemuxerDataAvailable(CreateAbortedAck(is_audio));
+      // Simulate seeking causes the demuxer to abort the outstanding read
+      // caused by the seek.
+      player_.OnDemuxerDataAvailable(CreateAbortedAck(is_audio));
+    }
 
-    // Verify that the seek is requested now that the outstanding read is
-    // completed by aborted access unit.
+    // Verify that the seek is requested.
     EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
 
     // Send back the seek done notification. This should trigger the player to
     // call OnReadFromDemuxer() again.
     EXPECT_EQ(original_num_data_requests, demuxer_->num_data_requests());
     player_.OnDemuxerSeekDone(kNoTimestamp());
-    EXPECT_EQ(original_num_data_requests + 1, demuxer_->num_data_requests());
+    EXPECT_EQ(original_num_data_requests + expected_new_data_requests,
+              demuxer_->num_data_requests());
 
     // No other seek should have been requested.
     EXPECT_EQ(original_num_seeks + 1, demuxer_->num_seek_requests());
   }
 
   DemuxerData CreateReadFromDemuxerAckWithConfigChanged(bool is_audio,
                                                         int config_unit_index) {
     DemuxerData data;
     data.type = is_audio ? DemuxerStream::AUDIO : DemuxerStream::VIDEO;
     data.access_units.resize(config_unit_index + 1);
@@ skipping 259 matching lines @@
   EXPECT_EQ(0, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ReadFromDemuxerAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will resend a ReadFromDemuxer request after seek.
   StartAudioDecoderJob();
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
-  SeekPlayer(true, base::TimeDelta());
+  SeekPlayer(true, base::TimeDelta(), true, 1);
   EXPECT_EQ(2, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SetSurfaceWhileSeeking) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test SetVideoSurface() will not cause an extra seek while the player is
   // waiting for demuxer to indicate seek is done.
   StartVideoDecoderJob();
   // Player is still waiting for SetVideoSurface(), so no request is sent.
@@ skipping 223 matching lines @@
 
   // Send new data to the decoder so it can finish prefetching. This should
   // reset the start time ticks.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   EXPECT_TRUE(StartTimeTicks() != base::TimeTicks());
 
   base::TimeTicks current = StartTimeTicks();
   EXPECT_LE(100.0, (current - previous).InMillisecondsF());
 }
 
-TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterInputEOS) {
+TEST_F(MediaSourcePlayerTest, SecondVideoDataIsEOSAndSeekPlusStartResumesPlay) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  // Test MediaSourcePlayer will not request for new data after input EOS is
-  // reached.
+  // Test MediaSourcePlayer can replay video after input EOS is reached.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
+
   // Player should not seek the demuxer on setting initial surface.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   EXPECT_EQ(1, demuxer_->num_data_requests());
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   message_loop_.Run();
   EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Send EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));
-  message_loop_.Run();
-  // No more request for data should be made.
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-
-  // Reconfirm no seek request has occurred.
-  EXPECT_EQ(0, demuxer_->num_seek_requests());
-}
-
-TEST_F(MediaSourcePlayerTest, ReplayAfterInputEOS) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // Test MediaSourcePlayer can replay after input EOS is
-  // reached.
-  CreateNextTextureAndSetVideoSurface();
+  EXPECT_FALSE(manager_.playback_completed());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // Playback should resume with further data request following seek and start.
+  SeekPlayer(false, base::TimeDelta(), false, 0);
   StartVideoDecoderJob();
-
-  // Player should not seek the demuxer on setting initial surface.
-  EXPECT_EQ(0, demuxer_->num_seek_requests());
-
-  EXPECT_EQ(1, demuxer_->num_data_requests());
-  // Send the first input chunk.
-  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
-  message_loop_.Run();
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-
-  // Send EOS.
-  player_.OnDemuxerDataAvailable(CreateEOSAck(false));
-  message_loop_.Run();
-  // No more request for data should be made.
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-
-  // Initiate a seek. Skip requesting element seek of renderer.
-  // Instead behave as if the renderer has asked us to seek.
-  player_.SeekTo(base::TimeDelta());
-  StartVideoDecoderJob();
-  EXPECT_EQ(1, demuxer_->num_seek_requests());
-  player_.OnDemuxerSeekDone(kNoTimestamp());
-  // Seek/Play after EOS should request more data.
-  EXPECT_EQ(3, demuxer_->num_data_requests());
-
-  // Reconfirm only 1 seek request has occurred.
-  EXPECT_EQ(1, demuxer_->num_seek_requests());
-}
-
-TEST_F(MediaSourcePlayerTest, FirstDataIsEOS) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // Test decode of EOS buffer without any prior decode. See also
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, FirstAudioDataIsEOSAndSeekPlusStartResumesPlay) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test decode of audio EOS buffer without any prior decode. See also
   // http://b/11696552.
+  // Also tests that seeking+Start() after completing audio playback resumes
+  // playback.
   Start(CreateAudioDemuxerConfigs(kCodecAAC));
   EXPECT_TRUE(GetMediaDecoderJob(true));
 
   EXPECT_EQ(1, demuxer_->num_data_requests());
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));
   EXPECT_FALSE(manager_.playback_completed());
-
   message_loop_.Run();
   EXPECT_TRUE(manager_.playback_completed());
   EXPECT_EQ(1, demuxer_->num_data_requests());
-}
-
-TEST_F(MediaSourcePlayerTest, FirstDataAfterSeekIsEOS) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // Test decode of EOS buffer, just after seeking, without any prior decode
-  // (other than the simulated |kAborted| resulting from the seek process.)
-  // See also http://b/11696552.
+
+  // Playback should resume with further data request following seek and start.
+  SeekPlayer(true, base::TimeDelta(), false, 0);
+  Start(CreateAudioDemuxerConfigs(kCodecAAC));
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, FirstVideoDataAfterSeekIsEOS) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test decode of video EOS buffer, just after seeking, without any prior
+  // decode (other than the simulated |kAborted| resulting from the seek
+  // process.)
+  CreateNextTextureAndSetVideoSurface();
+  StartVideoDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(false));
+
+  SeekPlayer(false, base::TimeDelta(), true, 1);
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateEOSAck(false));
+  EXPECT_FALSE(manager_.playback_completed());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, FirstAudioDataAfterSeekIsEOS) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test decode of audio EOS buffer, just after seeking, without any prior
+  // decode (other than the simulated |kAborted| resulting from the seek
+  // process.) See also http://b/11696552.
   Start(CreateAudioDemuxerConfigs(kCodecAAC));
   EXPECT_TRUE(GetMediaDecoderJob(true));
 
-  SeekPlayer(true, base::TimeDelta());
+  SeekPlayer(true, base::TimeDelta(), true, 1);
   EXPECT_EQ(2, demuxer_->num_data_requests());
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));
   EXPECT_FALSE(manager_.playback_completed());
-
-  message_loop_.Run();
-  EXPECT_TRUE(manager_.playback_completed());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, AV_PlaybackCompletionAcrossConfigChange) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if one stream (audio) has completed decode of EOS and the other
+  // stream (video) processes config change, that subsequent video EOS completes
+  // A/V playback.
+  // Also tests that seeking+Start() after completing playback resumes playback.
+  Start(CreateAudioVideoDemuxerConfigs());
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(GetMediaDecoderJob(true) && GetMediaDecoderJob(false));
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
+  EXPECT_EQ(0, demuxer_->num_config_requests());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
+      false, 0));  // Video |kConfigChanged| as first unit.
+
+  while (GetMediaDecoderJob(true)->is_decoding() ||
+         GetMediaDecoderJob(false)->is_decoding()) {
+    message_loop_.RunUntilIdle();
+  }
+
+  EXPECT_EQ(1, demuxer_->num_config_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerConfigsAvailable(CreateAudioVideoDemuxerConfigs());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+
+  // At no time after completing audio EOS decode, above, should the
+  // audio decoder job resume decoding.
+  EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+  player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
+  EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+
+  // Decode the video EOS. Spot-check that audio decode doesn't resume.
+  EXPECT_FALSE(manager_.playback_completed());
+  do {
+    message_loop_.RunUntilIdle();
+    EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+  } while (GetMediaDecoderJob(false)->is_decoding());
+
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+
+  // Playback should resume with further data requests following seek and start.
+  SeekPlayer(true /* ignored */, base::TimeDelta(), false, 0);
+  Start(CreateAudioVideoDemuxerConfigs());
+  EXPECT_EQ(5, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, VA_PlaybackCompletionAcrossConfigChange) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if one stream (video) has completed decode of EOS and the other
+  // stream (audio) processes config change, that subsequent audio EOS completes
+  // A/V playback.
+  // Also tests that seeking+Start() after completing playback resumes playback.
+  Start(CreateAudioVideoDemuxerConfigs());
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(GetMediaDecoderJob(true) && GetMediaDecoderJob(false));
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
+  EXPECT_EQ(0, demuxer_->num_config_requests());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
+      true, 0));  // Audio |kConfigChanged| as first unit.
+
+  while (GetMediaDecoderJob(true)->is_decoding() ||
+         GetMediaDecoderJob(false)->is_decoding()) {
+    message_loop_.RunUntilIdle();
+  }
+
+  // TODO(wolenetz/qinmin): Prevent redundant demuxer config request and change
+  // expectation to 1 here. See http://crbug.com/325528.
+  EXPECT_EQ(2, demuxer_->num_config_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerConfigsAvailable(CreateAudioVideoDemuxerConfigs());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+
+  // At no time after completing video EOS decode, above, should the
+  // video decoder job resume decoding.
+  EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+  player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
+  EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+
+  // Decode the audio EOS. Spot-check that video decode doesn't resume.
+  EXPECT_FALSE(manager_.playback_completed());
+  do {
+    message_loop_.RunUntilIdle();
+    EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+  } while (GetMediaDecoderJob(true)->is_decoding());
+
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+
+  // Playback should resume with further data requests following seek and start.
+  SeekPlayer(true /* ignored */, base::TimeDelta(), false, 0);
+  Start(CreateAudioVideoDemuxerConfigs());
+  EXPECT_EQ(5, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, AV_NoPrefetchForFinishedVideoOnAudioStarvation) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if one stream (video) has completed decode of EOS, prefetch
+  // resulting from player starvation occurs only for the other stream (audio),
+  // and responding to that prefetch with EOS completes A/V playback, even if
+  // another starvation occurs during the latter EOS's decode.
+  Start(CreateAudioVideoDemuxerConfigs());
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(GetMediaDecoderJob(true) && GetMediaDecoderJob(false));
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
+
+  // Wait until video EOS is processed and more data (assumed to be audio) is
+  // requested.
+  while (demuxer_->num_data_requests() < 3 ||
+         GetMediaDecoderJob(false)->is_decoding()) {
+    message_loop_.RunUntilIdle();
+  }
+
+  // Simulate decoder underrun to trigger prefetch while still decoding audio.
+  EXPECT_EQ(3, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(1));
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding() &&
+              !GetMediaDecoderJob(false)->is_decoding());
+  TriggerPlayerStarvation();
+
+  // Complete the audio decode that was in progress when simulated player
+  // starvation was triggered. At no time after completing video EOS decode,
+  // above, should the video decoder job resume decoding.
+  while (GetMediaDecoderJob(true)->is_decoding()) {
+    EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+    message_loop_.RunUntilIdle();
+  }
+  EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+  EXPECT_EQ(4, demuxer_->num_data_requests());
+
+  player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
+  EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
+
+  // Simulate another decoder underrun to trigger prefetch while decoding EOS.
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
+  TriggerPlayerStarvation();
+
+  EXPECT_FALSE(manager_.playback_completed());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(4, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, StarvationDuringVideoEOSDecode) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that video-only playback completes without further data requested when
+  // starvation occurs during EOS decode.
+  CreateNextTextureAndSetVideoSurface();
+  StartVideoDecoderJob();
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+  message_loop_.Run();
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // Simulate decoder underrun to trigger prefetch while decoding EOS.
+  player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
+  EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
+  TriggerPlayerStarvation();
+  EXPECT_FALSE(manager_.playback_completed());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, StarvationDuringAudioEOSDecode) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that audio-only playback completes without further data requested when
+  // starvation occurs during EOS decode.
+  StartAudioDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  message_loop_.Run();
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // Simulate decoder underrun to trigger prefetch while decoding EOS.
+  player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
+  TriggerPlayerStarvation();
+  EXPECT_FALSE(manager_.playback_completed());
+  message_loop_.Run();
+  EXPECT_TRUE(manager_.playback_completed());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterAbort) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the decoder will not request new data after receiving an aborted
   // access unit.
   StartAudioDecoderJob();
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
@@ skipping 104 matching lines @@
 }
 
 TEST_F(MediaSourcePlayerTest, PrerollAudioAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will preroll the media to the seek position.
   StartAudioDecoderJob();
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
-  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
+  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100), true, 1);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Send some data before the seek position.
   for (int i = 1; i < 4; ++i) {
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
     message_loop_.Run();
   }
   EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
@@ skipping 10 matching lines @@
 
 TEST_F(MediaSourcePlayerTest, PrerollVideoAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will preroll the media to the seek position.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
-  SeekPlayer(false, base::TimeDelta::FromMilliseconds(100));
+  SeekPlayer(false, base::TimeDelta::FromMilliseconds(100), true, 1);
   EXPECT_TRUE(IsPrerolling(false));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Send some data before the seek position.
   DemuxerData data;
   for (int i = 1; i < 4; ++i) {
     data = CreateReadFromDemuxerAckForVideo();
     data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(i * 30);
     player_.OnDemuxerDataAvailable(data);
     EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
@@ skipping 28 matching lines @@
 
   // Complete the initial preroll by feeding data to the decoder.
   for (int i = 0; i < 4; ++i) {
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
     message_loop_.Run();
   }
   EXPECT_LT(0.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_FALSE(IsPrerolling(true));
 
-  SeekPlayer(true, base::TimeDelta::FromMilliseconds(500));
+  SeekPlayer(true, base::TimeDelta::FromMilliseconds(500), true, 1);
 
   // Prerolling should have begun again.
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(500.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Send data at and after the seek position. Prerolling should complete.
   for (int i = 0; i < 4; ++i) {
     DemuxerData data = CreateReadFromDemuxerAckForAudio(i);
     data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(
         500 + 30 * (i - 1));
@@ skipping 12 matching lines @@
 
 TEST_F(MediaSourcePlayerTest, PrerollContinuesAcrossReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will resume media prerolling if interrupted by Release()
   // and Start().
   StartAudioDecoderJob();
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
-  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
+  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100), true, 1);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Send some data before the seek position.
   // Test uses 'large' number of iterations because decoder job may not get
   // MEDIA_CODEC_OK output status until after a few dequeue output attempts.
   // This allows decoder status to stabilize prior to AU timestamp reaching
   // the preroll target.
   DemuxerData data;
   for (int i = 0; i < 10; ++i) {
@@ skipping 36 matching lines @@
 
 TEST_F(MediaSourcePlayerTest, PrerollContinuesAcrossConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will resume media prerolling if interrupted by
   // |kConfigChanged| and OnDemuxerConfigsAvailable().
   StartAudioDecoderJob();
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
-  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100));
+  SeekPlayer(true, base::TimeDelta::FromMilliseconds(100), true, 1);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // In response to data request, simulate that demuxer signals config change by
   // sending an AU with |kConfigChanged|. Player should prepare to reconfigure
   // the audio decoder job, and should request new demuxer configs.
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
   EXPECT_EQ(0, demuxer_->num_config_requests());
   player_.OnDemuxerDataAvailable(data);
   EXPECT_EQ(1, demuxer_->num_config_requests());
@@ skipping 581 matching lines @@
 
   std::vector<std::string> codec_avc(1, "avc1");
   EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L3", kVideoMp4, codec_avc));
   EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L1", kVideoMp4, codec_avc));
 }
 
 // TODO(xhwang): Are these IsTypeSupported tests device specific?
 // TODO(xhwang): Add more IsTypeSupported tests.
 
 }  // namespace media