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 139 matching lines @@
     } else {
       surface_texture_b_ = new gfx::SurfaceTexture(next_texture_id_++);
       surface_texture = surface_texture_b_.get();
     }
 
     surface_texture_a_is_next_ = !surface_texture_a_is_next_;
     gfx::ScopedJavaSurface surface = gfx::ScopedJavaSurface(surface_texture);
     player_.SetVideoSurface(surface.Pass());
   }
 
+  // Starts the appropriate decoder jobs according to |have_audio| and
+  // |have_video|. Then starts seek during decode of EOS or non-EOS according to
+  // |eos_audio| and |eos_video|. Simulates seek completion and verifies that
+  // playback never completed.
+  void SeekDuringEOSDecode(bool have_audio, bool have_video,
+                           bool eos_audio, bool eos_video) {
+    EXPECT_TRUE(have_audio || have_video);

[acolwell GONE FROM CHROMIUM, 2013/12/06 18:28:30]

These should be DCHECKs since these are verifying preconditions.

[wolenetz, 2013/12/09 22:58:27]

Done.

+    EXPECT_TRUE(have_audio || !eos_audio);
+    EXPECT_TRUE(have_video || !eos_video);
+
+    DemuxerConfigs configs;
+    int data_request_delta = 1;
+    if (have_audio && !have_video) {
+      configs = CreateAudioDemuxerConfigs(kCodecVorbis);
+    } else if (have_video && !have_audio) {
+      configs = CreateVideoDemuxerConfigs();
+    } else {
+      configs = CreateAudioVideoDemuxerConfigs();
+      data_request_delta = 2;
+    }
+
+    if (have_video)
+      CreateNextTextureAndSetVideoSurface();
+    Start(configs);
+    EXPECT_TRUE((GetMediaDecoderJob(true) != NULL) == have_audio &&
+                (GetMediaDecoderJob(false) != NULL) == have_video);
+    EXPECT_EQ(data_request_delta, demuxer_->num_data_requests());
+
+    if (have_audio)
+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+    if (have_video)
+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+    for (int i = data_request_delta + 1; i <= 2 * data_request_delta; i++) {
+      message_loop_.Run();  // Loop Quit() occurs on each data request.
+      EXPECT_EQ(i, demuxer_->num_data_requests());
+    }
+
+    // Simulate seek while decoding EOS or non-EOS for the appropriate
+    // stream(s).
+    if (eos_audio) {
+      player_.OnDemuxerDataAvailable(CreateEOSAck(true));
+    } else if (have_audio) {
+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(1));
+    }
+    if (eos_video) {
+      player_.OnDemuxerDataAvailable(CreateEOSAck(false));
+    } else if (have_video) {
+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+    }
+    EXPECT_TRUE(!have_audio || GetMediaDecoderJob(true)->is_decoding());
+    EXPECT_TRUE(!have_video || GetMediaDecoderJob(false)->is_decoding());
+    player_.SeekTo(base::TimeDelta());
+    EXPECT_EQ(0, demuxer_->num_seek_requests());
+    while ((have_audio && GetMediaDecoderJob(true)->is_decoding()) ||
+           (have_video && GetMediaDecoderJob(false)->is_decoding())) {
+      message_loop_.RunUntilIdle();
+    }
+
+    EXPECT_EQ(1, demuxer_->num_seek_requests());
+    player_.OnDemuxerSeekDone(kNoTimestamp());
+    EXPECT_EQ(3 * data_request_delta, demuxer_->num_data_requests());
+    EXPECT_FALSE(manager_.playback_completed());
+  }
+
   base::TimeTicks StartTimeTicks() {
     return player_.start_time_ticks_;
   }
 
   bool IsTypeSupported(const std::vector<uint8>& scheme_uuid,
                        const std::string& security_level,
                        const std::string& container,
                        const std::vector<std::string>& codecs) {
     return MediaSourcePlayer::IsTypeSupported(
         scheme_uuid, security_level, container, codecs);
@@ skipping 100 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);

[acolwell GONE FROM CHROMIUM, 2013/12/06 18:28:30]

nit: add and overload or default values so this type of change isn't needed here
and below.

[wolenetz, 2013/12/09 22:58:27]

Done.
Note
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml?showone=Defaul...
disallows usage of default argument values for this case, so I used an overload.

   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) {

[qinmin, 2013/12/06 20:34:47]

the test name is hard to understand. What about
SecondVideoAccessUnitIsEOSAndResumePlayAfterSeek

[wolenetz, 2013/12/09 22:58:27]

Done, using {A,V,AV,VA} prefixes across these new/changed tests for consistency
and line length.

   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());

[acolwell GONE FROM CHROMIUM, 2013/12/06 18:28:30]

nit: Do we really care about how many data requests there are? These seem to
just clutter these new tests. It seems like the verification of these counts
should be done in simple focused tests and left out of all other tests.

[wolenetz, 2013/12/09 22:58:27]

I've dropped the checks that are redundant with simpler tests that already cover
things like test condition setup. Some of these new cases have distinct setup,
so I've kept some of the checks or used helpers to abstract the clutter.

+}
+
+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() ||

[acolwell GONE FROM CHROMIUM, 2013/12/06 18:28:30]

nit: It seems like loops like this should just be put in some sort of
WaitForDecodeDone() helper that allows you to control which streams you are
waiting for.

[wolenetz, 2013/12/09 22:58:27]

Good point, I'll add a helper.

+         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, AV_SeekDuringEOSDecodePreventsCompletion) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that seek supercedes audio+video playback completion on simultaneous
+  // audio and video EOS decode, if SeekTo() occurs during these EOS decodes.
+  SeekDuringEOSDecode(true, true, true, true);
+}
+
+TEST_F(MediaSourcePlayerTest, AV_SeekDuringAudioEOSDecodePreventsCompletion) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that seek supercedes audio+video playback completion on simultaneous
+  // audio EOS and video non-EOS decode, if SeekTo() occurs during these
+  // decodes.
+  SeekDuringEOSDecode(true, true, true, false);
+}
+
+TEST_F(MediaSourcePlayerTest, AV_SeekDuringVideoEOSDecodePreventsCompletion) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that seek supercedes audio+video playback completion on simultaneous
+  // audio non-EOS and video EOS decode, if SeekTo() occurs during these
+  // decodes.
+  SeekDuringEOSDecode(true, true, false , false);

[wolenetz, 2013/12/09 22:58:27]

Oops. This configuration mismatched test intent, and had bad style!!
Fixed.

+}
+
+TEST_F(MediaSourcePlayerTest, SeekDuringVideoEOSDecodePreventsCompletion) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that seek supercedes video-only playback completion on EOS decode, if
+  // SeekTo() occurs during EOS decode.
+  SeekDuringEOSDecode(false, true, false, true);
+}
+
+TEST_F(MediaSourcePlayerTest, SeekDuringAudioEOSDecodePreventsCompletion) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that seek supercedes audio-only playback completion on EOS decode, if
+  // SeekTo() occurs during EOS decode.
+  SeekDuringEOSDecode(true, false, true, false);
 }
 
 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