Reducing the IPC latency for MSE video decoding

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/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 390 matching lines @@
   void StartAudioDecoderJobAndSeekToWhileDecoding(
       const base::TimeDelta& seek_time) {
     EXPECT_FALSE(GetMediaDecoderJob(true));
     EXPECT_FALSE(player_.IsPlaying());
     EXPECT_EQ(0, demuxer_->num_data_requests());
     EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
     EXPECT_EQ(player_.GetCurrentTime(), GetPrerollTimestamp());
     StartAudioDecoderJob(true);
     EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+    EXPECT_EQ(2, demuxer_->num_data_requests());
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
     player_.SeekTo(seek_time);
     EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
     EXPECT_EQ(0, demuxer_->num_seek_requests());
+    player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   }
 
   // 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. Exactly one request for more data is expected
   // following the seek, so use this helper for players with only audio or only
   // video.
   void SeekPlayerWithAbort(bool is_audio, const base::TimeDelta& seek_time) {
     int original_num_seeks = demuxer_->num_seek_requests();
     int original_num_data_requests = demuxer_->num_data_requests();
@@ skipping 42 matching lines @@
     // This simulates the common condition that AUs received after browser
     // seek begin with timestamps before the seek target, and don't
     // immediately complete preroll.
     while (IsPrerolling(is_audio)) {
       data.access_units[0].timestamp =
           base::TimeDelta::FromMilliseconds(current_timestamp);
       player_.OnDemuxerDataAvailable(data);
       EXPECT_TRUE(GetMediaDecoderJob(is_audio)->is_decoding());
       EXPECT_EQ(target_timestamp, player_.GetCurrentTime());
       current_timestamp += 30;
-      message_loop_.Run();
+      WaitForDecodeDone(is_audio, !is_audio);
     }
     EXPECT_LE(target_timestamp, player_.GetCurrentTime());
   }
 
   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);
 
     for (int i = 0; i < config_unit_index; ++i)
       data.access_units[i] = CreateAccessUnitWithData(is_audio, i);
 
     data.access_units[config_unit_index].status = DemuxerStream::kConfigChanged;
     return data;
   }
 
   // Valid only for video-only player tests. If |trigger_with_release_start| is
   // true, triggers the browser seek with a Release() + video data received +
   // Start() with a new surface. If false, triggers the browser seek by
   // setting a new video surface after beginning decode of received video data.
   // Such data receipt causes possibility that an I-frame is not next, and
   // browser seek results once decode completes and surface change processing
   // begins.
   void BrowserSeekPlayer(bool trigger_with_release_start) {
-    int expected_num_data_requests = demuxer_->num_data_requests() + 1;
+    int expected_num_data_requests = demuxer_->num_data_requests() +
+        trigger_with_release_start ? 1 : 2;
     int expected_num_seek_requests = demuxer_->num_seek_requests();
     int expected_num_browser_seek_requests =
         demuxer_->num_browser_seek_requests();
 
     EXPECT_FALSE(GetMediaDecoderJob(false));
     CreateNextTextureAndSetVideoSurface();
     StartVideoDecoderJob(true);
 
     if (trigger_with_release_start) {
       ReleasePlayer();
 
-      // Simulate demuxer's response to the video data request.
+      // Simulate demuxer's response to the video data request. The data will be
+      // discarded.
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
       EXPECT_FALSE(GetMediaDecoderJob(false));
       EXPECT_FALSE(player_.IsPlaying());
       EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
 
       CreateNextTextureAndSetVideoSurface();
       StartVideoDecoderJob(false);
+      EXPECT_FALSE(GetMediaDecoderJob(false));
     } else {
       // Simulate demuxer's response to the video data request.
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
       // While the decoder is decoding, trigger a browser seek by changing
       // surface. Demuxer does not know of browser seek in advance, so no
       // |kAborted| data is required (though |kAborted| can certainly occur for
       // any pending read in reality due to renderer preparing for a regular
       // seek).
       CreateNextTextureAndSetVideoSurface();
 
       // Browser seek should not begin until decoding has completed.
       EXPECT_TRUE(GetMediaDecoderJob(false));
       EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
 
       // Wait for the decoder job to finish decoding and be reset pending the
       // browser seek.
-      while (GetMediaDecoderJob(false))
-        message_loop_.RunUntilIdle();
+      WaitForVideoDecodeDone();
+      player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
     }
 
     // Only one browser seek should have been initiated, and no further data
     // should have been requested.
     expected_num_seek_requests++;
     expected_num_browser_seek_requests++;
     EXPECT_EQ(expected_num_seek_requests, demuxer_->num_seek_requests());
     EXPECT_EQ(expected_num_browser_seek_requests,
               demuxer_->num_browser_seek_requests());
     EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
@@ skipping 20 matching lines @@
 
     int expected_num_data_requests = demuxer_->num_data_requests();
 
     // Feed and decode a standalone access unit so the player exits prefetch.
     if (!config_unit_in_prefetch) {
       if (is_audio)
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
       else
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
-      message_loop_.Run();
+      WaitForDecodeDone(is_audio, !is_audio);
 
       // We should have completed the prefetch phase at this point.
       expected_num_data_requests++;
       EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
     }
 
     EXPECT_EQ(expected_num_config_requests, demuxer_->num_config_requests());
 
     // Feed and decode access units with data for any units prior to
     // |config_unit_index|, and a |kConfigChanged| unit at that index.
@@ skipping 20 matching lines @@
 
     surface_texture_a_is_next_ = !surface_texture_a_is_next_;
     gfx::ScopedJavaSurface surface = gfx::ScopedJavaSurface(surface_texture);
     player_.SetVideoSurface(surface.Pass());
   }
 
   // Wait for one or both of the jobs to complete decoding. Decoder jobs are
   // assumed to exist for any stream whose decode completion is awaited.
   void WaitForDecodeDone(bool wait_for_audio, bool wait_for_video) {
     DCHECK(wait_for_audio || wait_for_video);
-
     while ((wait_for_audio && GetMediaDecoderJob(true) &&
+               GetMediaDecoderJob(true)->HasData() &&
                GetMediaDecoderJob(true)->is_decoding()) ||
            (wait_for_video && GetMediaDecoderJob(false) &&
+               GetMediaDecoderJob(false)->HasData() &&
                GetMediaDecoderJob(false)->is_decoding())) {
       message_loop_.RunUntilIdle();
     }
   }
 
   void WaitForAudioDecodeDone() {
     WaitForDecodeDone(true, false);
   }
 
   void WaitForVideoDecodeDone() {
@@ skipping 50 matching lines @@
     if (have_audio)
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
 
     if (have_video)
       player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
     // Run until more data is requested a number of times equal to the number of
     // media types configured. Since prefetching may be in progress, we cannot
     // reliably expect Run() to complete until we have sent demuxer data for all
     // configured media types, above.
-    for (int i = 0; i < (have_audio ? 1 : 0) + (have_video ? 1 : 0); i++)
-      message_loop_.Run();
+    WaitForDecodeDone(have_audio, have_video);
 
     // Simulate seek while decoding EOS or non-EOS for the appropriate
     // stream(s).
     if (have_audio) {
       if (eos_audio)
         player_.OnDemuxerDataAvailable(CreateEOSAck(true));
       else
         player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(1));
     }
 
@@ skipping 162 matching lines @@
 
   // While the decoder is decoding, change multiple surfaces. Pass an empty
   // surface first.
   gfx::ScopedJavaSurface empty_surface;
   player_.SetVideoSurface(empty_surface.Pass());
   // Next, pass a new non-empty surface.
   CreateNextTextureAndSetVideoSurface();
 
   // Wait for the decoder job to finish decoding and be reset pending a browser
   // seek.
-  while (GetMediaDecoderJob(false))
-    message_loop_.RunUntilIdle();
+  WaitForVideoDecodeDone();
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // Only one browser seek should have been initiated. No further data request
   // should have been processed on |message_loop_| before surface change event
   // became pending, above.
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Simulate browser seek is done and confirm player requests more data for new
   // video decoder job.
   player_.OnDemuxerSeekDone(player_.GetCurrentTime());
   EXPECT_TRUE(GetMediaDecoderJob(false));
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SetEmptySurfaceAndStarveWhileDecoding) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test player pauses if an empty surface is passed.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // While the decoder is decoding, pass an empty surface.
   gfx::ScopedJavaSurface empty_surface;
   player_.SetVideoSurface(empty_surface.Pass());
-
   // Let the player starve. However, it should not issue any new data request in
   // this case.
   TriggerPlayerStarvation();
   // Wait for the decoder job to finish decoding and be reset.
   while (GetMediaDecoderJob(false))
     message_loop_.RunUntilIdle();
 
   // No further seek or data requests should have been received since the
   // surface is empty.
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // Playback resumes once a non-empty surface is passed.
   CreateNextTextureAndSetVideoSurface();
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ReleaseVideoDecoderResourcesWhileDecoding) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if video decoder is released while decoding, the resources will
   // not be immediately released.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
   EXPECT_EQ(1, manager_.num_resources_requested());
   ReleasePlayer();
   // The resources will be immediately released since the decoder is idle.
   EXPECT_EQ(1, manager_.num_resources_released());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // Recreate the video decoder.
   CreateNextTextureAndSetVideoSurface();
   player_.Start();
+  EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
+  player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_EQ(2, manager_.num_resources_requested());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   ReleasePlayer();
   // The resource is still held by the video decoder until it finishes decoding.
   EXPECT_EQ(1, manager_.num_resources_released());
   // Wait for the decoder job to finish decoding and be reset.
   while (manager_.num_resources_released() != 2)
     message_loop_.RunUntilIdle();
 }
 
@@ skipping 56 matching lines @@
   // Test that if the decoding job is not fully stopped after Pause(),
   // calling Start() will be a noop.
   StartAudioDecoderJob(true);
 
   MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
   EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
 
   // Sending data to player.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Decoder job will not immediately stop after Pause() since it is
   // running on another thread.
   player_.Pause(true);
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
 
   // Nothing happens when calling Start() again.
   player_.Start();
   // Verify that Start() will not destroy and recreate the decoder job.
   EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
-  EXPECT_EQ(1, demuxer_->num_data_requests());
-  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-  message_loop_.Run();
-  // The decoder job should finish and a new request will be sent.
+
+  while(GetMediaDecoderJob(true)->is_decoding())
+    message_loop_.RunUntilIdle();
+  // The decoder job should finish and waiting for data.
   EXPECT_EQ(2, demuxer_->num_data_requests());
-  EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_requesting_demuxer_data());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that when Start() is called, video decoder jobs will wait for audio
   // decoder job before start decoding the data.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs(), true);
   MediaDecoderJob* audio_decoder_job = GetMediaDecoderJob(true);
@@ skipping 19 matching lines @@
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test start time ticks will reset after decoder job underruns.
   StartAudioDecoderJob(true);
 
   // For the first couple chunks, the decoder job may return
   // DECODE_FORMAT_CHANGED status instead of DECODE_SUCCEEDED status. Decode
   // more frames to guarantee that DECODE_SUCCEEDED will be returned.
   for (int i = 0; i < 4; ++i) {
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
-    EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-    message_loop_.Run();
+    // Decode data until decoder started requesting new data again.
+   WaitForAudioDecodeDone();
   }
 
   // The decoder job should finish and a new request will be sent.
   EXPECT_EQ(5, demuxer_->num_data_requests());
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   base::TimeTicks previous = StartTimeTicks();
 
-  // Let the decoder timeout and execute the OnDecoderStarved() callback.
-  base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
-
-  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-  EXPECT_TRUE(StartTimeTicks() != base::TimeTicks());
-  message_loop_.RunUntilIdle();
-
-  // Send new data to the decoder so it can finish the currently
-  // pending decode.
+  // Let the decoder starve.
+  TriggerPlayerStarvation();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   WaitForAudioDecodeDone();
 
   // Verify the start time ticks is cleared at this point because the
   // player is prefetching.
   EXPECT_TRUE(StartTimeTicks() == base::TimeTicks());
 
   // 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());
+  EXPECT_LE(0, (current - previous).InMillisecondsF());
 }
 
 TEST_F(MediaSourcePlayerTest, V_SecondAccessUnitIsEOSAndResumePlayAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test MediaSourcePlayer can replay video after input EOS is reached.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
-  message_loop_.Run();
+  WaitForVideoDecodeDone();
 
   VerifyPlaybackCompletesOnEOSDecode(true, false);
   VerifyCompletedPlaybackResumesOnSeekPlusStart(false, true);
 }
 
 TEST_F(MediaSourcePlayerTest, A_FirstAccessUnitIsEOSAndResumePlayAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decode of audio EOS buffer without any prior decode. See also
   // http://b/11696552.
@@ skipping 93 matching lines @@
   // and responding to that prefetch with EOS completes A/V playback, even if
   // another starvation occurs during the latter EOS's decode.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs(), true);
 
   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)
-    message_loop_.RunUntilIdle();
-  WaitForVideoDecodeDone();
+  WaitForAudioVideoDecodeDone();
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // Simulate decoder underrun to trigger prefetch while still decoding audio.
   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.
   WaitForAudioDecodeDone();
   EXPECT_EQ(4, demuxer_->num_data_requests());
-
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
   EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
 
   // Simulate another decoder underrun to trigger prefetch while decoding EOS.
   TriggerPlayerStarvation();
   VerifyPlaybackCompletesOnEOSDecode(false, true /* ignored */);
 }
 
 TEST_F(MediaSourcePlayerTest, V_StarvationDuringEOSDecode) {
   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(true);
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
-  message_loop_.Run();
+  WaitForVideoDecodeDone();
 
   // Simulate decoder underrun to trigger prefetch while decoding EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
   EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
   TriggerPlayerStarvation();
   VerifyPlaybackCompletesOnEOSDecode(false, false /* ignored */);
 }
 
 TEST_F(MediaSourcePlayerTest, A_StarvationDuringEOSDecode) {
   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(true);
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
-  message_loop_.Run();
+  WaitForAudioDecodeDone();
 
   // Simulate decoder underrun to trigger prefetch while decoding EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   TriggerPlayerStarvation();
   VerifyPlaybackCompletesOnEOSDecode(false, true /* ignored */);
 }
 
 TEST_F(MediaSourcePlayerTest, AV_SeekDuringEOSDecodePreventsCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
@@ skipping 89 matching lines @@
 
   // Simulate browser seek is done. Confirm player requests the regular seek,
   // still has no video decoder job configured, and has not requested any
   // further data since the surface change event became pending in
   // BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_FALSE(GetMediaDecoderJob(false));
   EXPECT_EQ(2, demuxer_->num_seek_requests());
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
-  EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Simulate regular seek is done and confirm player requests more data for
   // new video decoder job.
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_TRUE(GetMediaDecoderJob(false));
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
 }
 
-TEST_F(MediaSourcePlayerTest, NoSeekForInitialReleaseAndStart) {
+TEST_F(MediaSourcePlayerTest, BrowserSeek_InitialReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  // Test that no seek is requested if player Release() + Start() occurs prior
-  // to receiving any data.
+  // Test that browser seek is requested if player Release() + Start() occurs
+  // prior to receiving any data.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
   ReleasePlayer();
 
   // Pass a new non-empty surface.
   CreateNextTextureAndSetVideoSurface();
 
   player_.Start();
 
-  // TODO(wolenetz/qinmin): Multiple in-flight data requests for same stream
-  // should be prevented. See http://crbug.com/306314.
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-  EXPECT_TRUE(GetMediaDecoderJob(false));
+  // The new player won't be created until the pending data request is
+  // processed.
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_FALSE(GetMediaDecoderJob(false));
 
-  EXPECT_EQ(0, demuxer_->num_seek_requests());
+  // A browser seek should be requested.
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
+  EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
+  EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_MidStreamReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that one browser seek is requested if player Release() + Start(), with
   // video data received between Release() and Start().
   BrowserSeekPlayer(true);
-  EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Simulate browser seek is done and confirm player requests more data.
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(2, demuxer_->num_data_requests());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, PrerollAudioAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
@@ skipping 26 matching lines @@
   // Test decoder job will begin prerolling upon seek, when it was not
   // prerolling prior to the seek.
   StartAudioDecoderJob(true);
   MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(true));
 
   // 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();
+    WaitForAudioDecodeDone();
   }
   EXPECT_LT(0.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_FALSE(IsPrerolling(true));
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(500));
 
   // 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));
     player_.OnDemuxerDataAvailable(data);
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-    message_loop_.Run();
+    WaitForAudioDecodeDone();
   }
   EXPECT_LT(500.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_FALSE(IsPrerolling(true));
 
   // Throughout this test, we should have not re-created the decoder job, so
   // IsPrerolling() transition from false to true was not due to constructor
   // initialization. It was due to BeginPrerolling().
   EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
 }
 
@@ skipping 23 matching lines @@
       // TODO(qinmin): Simulation of multiple in-flight data requests (one from
       // before Release(), one from after Start()) is not included here, and
       // neither is any data enqueued for later decode if it arrives after
       // Release() and before Start(). See http://crbug.com/306314. Assumption
       // for this test, to prevent flakiness until the bug is fixed, is the
       // first request's data arrives before Start(). Though that data is not
       // seen by decoder, this assumption allows preroll continuation
       // verification and prevents multiple in-flight data requests.
       ReleasePlayer();
       player_.OnDemuxerDataAvailable(data);
-      message_loop_.RunUntilIdle();
+      WaitForAudioDecodeDone();
       EXPECT_FALSE(GetMediaDecoderJob(true));
       StartAudioDecoderJob(true);
     } else {
       player_.OnDemuxerDataAvailable(data);
       EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
-      message_loop_.Run();
+      WaitForAudioDecodeDone();
     }
     EXPECT_TRUE(IsPrerolling(true));
   }
   EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_TRUE(IsPrerolling(true));
 
   // Send data after the seek position.
   PrerollDecoderToTime(true, target_timestamp, target_timestamp);
 }
 
@@ skipping 107 matching lines @@
   // Test decoder job will preroll the media to the actual seek position
   // resulting from a browser seek.
   BrowserSeekPlayer(false);
 
   // Simulate browser seek is done, but to a later time than was requested.
   EXPECT_LT(player_.GetCurrentTime().InMillisecondsF(), 100);
   player_.OnDemuxerSeekDone(base::TimeDelta::FromMilliseconds(100));
   EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
 
   PrerollDecoderToTime(
       false, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100));
 }
 
 TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that video config change notification results in request for demuxer
   // configuration, and that a video decoder job results without any browser
@@ skipping 90 matching lines @@
   // should not cause any crashes.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
   DemuxerData data = CreateReadFromDemuxerAckForVideo();
   player_.OnDemuxerDataAvailable(data);
 
   // Trigger a surface change and decoder starvation.
   CreateNextTextureAndSetVideoSurface();
   TriggerPlayerStarvation();
   WaitForVideoDecodeDone();
+  EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
 
   // Surface change should trigger a seek.
+  player_.OnDemuxerDataAvailable(data);
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_TRUE(GetMediaDecoderJob(false));
 
   // A new data request should be sent.
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ReleaseWithOnPrefetchDoneAlreadyPosted) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if OnPrefetchDone() had already been posted before and is executed
   // after Release(), then player does not DCHECK. This test is fragile to
   // change to MediaDecoderJob::Prefetch() implementation; it assumes task
   // is posted to run |prefetch_cb| if the job already HasData().
   // TODO(wolenetz): Remove MSP::set_decode_callback_for_testing() if this test
   // becomes obsolete. See http://crbug.com/304234.
   StartAudioDecoderJob(true);
 
   // Escape the original prefetch by decoding a single access unit.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
-  message_loop_.Run();
+  WaitForAudioDecodeDone();
 
   // Prime the job with a few more access units, so that a later prefetch,
   // triggered by starvation to simulate decoder underrun, can trivially
   // post task to run OnPrefetchDone().
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(true, 4));
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
 
   // Simulate decoder underrun, so trivial prefetch starts while still decoding.
   // The prefetch and posting of OnPrefetchDone() will not occur until next
   // MediaDecoderCallBack() occurs.
   TriggerPlayerStarvation();
 
   // Upon the next successful decode callback, post a task to call Release() on
   // the |player_|, such that the trivial OnPrefetchDone() task posting also
   // occurs and should execute after the Release().
   OnNextTestDecodeCallbackPostTaskToReleasePlayer();
 
-  while (GetMediaDecoderJob(true))
-    message_loop_.RunUntilIdle();
+  WaitForAudioDecodeDone();
   EXPECT_TRUE(decoder_callback_hook_executed_);
   EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Player should have no decoder job until after Start().
   StartAudioDecoderJob(true);
 }
 
 TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenDemuxerSeekAndDone) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after SeekTo(), but the DemuxerSeek IPC request
   // has not yet been sent, then the seek request is sent after Release(). Also,
   // test if OnDemuxerSeekDone() occurs prior to next Start(), then the player
   // will resume correct post-seek preroll upon Start().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   ReleasePlayer();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_FALSE(GetMediaDecoderJob(true));
   EXPECT_FALSE(player_.IsPlaying());
 
   // Player should begin prefetch and resume preroll upon Start().
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   StartAudioDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // No further seek should have been requested since Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenDemuxerSeekThenStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after SeekTo(), but the DemuxerSeek IPC request
   // has not yet been sent, then the seek request is sent after Release(). Also,
   // test if OnDemuxerSeekDone() does not occur until after the next Start(),
   // then the player remains pending seek done until (and resumes correct
   // post-seek preroll after) OnDemuxerSeekDone().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   ReleasePlayer();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   // Player should not prefetch upon Start() nor create the decoder job, due to
   // awaiting DemuxerSeekDone.
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   StartAudioDecoderJob(false);
 
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SeekToThenDemuxerSeekThenReleaseThenSeekDone) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after a SeekTo()'s subsequent DemuxerSeek IPC
   // request and OnDemuxerSeekDone() arrives prior to the next Start(), then the
   // player will resume correct post-seek preroll upon Start().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   ReleasePlayer();
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_FALSE(player_.IsPlaying());
   EXPECT_FALSE(GetMediaDecoderJob(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // Player should begin prefetch and resume preroll upon Start().
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   StartAudioDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
 
   // No further seek should have been requested since before Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after a SeekTo()'s subsequent DemuxerSeeK IPC
   // request and OnDemuxerSeekDone() does not occur until after the next
   // Start(), then the player remains pending seek done until (and resumes
   // correct post-seek preroll after) OnDemuxerSeekDone().
   StartAudioDecoderJobAndSeekToWhileDecoding(
       base::TimeDelta::FromMilliseconds(100));
   WaitForAudioDecodeDone();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   ReleasePlayer();
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   StartAudioDecoderJob(false);
 
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since before Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenConfigsAvailable) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test if Release() occurs after |kConfigChanged| detected, new configs
   // requested of demuxer, and the requested configs arrive before the next
@@ skipping 49 matching lines @@
   BrowserSeekPlayer(false);
   base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
   ReleasePlayer();
 
   player_.OnDemuxerSeekDone(expected_preroll_timestamp);
   EXPECT_FALSE(player_.IsPlaying());
   EXPECT_FALSE(GetMediaDecoderJob(false));
   EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
 
   // Player should begin prefetch and resume preroll upon Start().
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(false));
   EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
   EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
 
   // No further seek should have been requested since BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that Release() after a browser seek's DemuxerSeek IPC request has been
   // sent behaves similar to a regular seek: if OnDemuxerSeekDone() does not
   // occur until after the next Start()+SetVideoSurface(), then the player
   // remains pending seek done until (and resumes correct post-seek preroll
   // after) OnDemuxerSeekDone().
   BrowserSeekPlayer(false);
   base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
   ReleasePlayer();
 
-  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob(false);
 
   player_.OnDemuxerSeekDone(expected_preroll_timestamp);
   EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_TRUE(IsPrerolling(false));
   EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
   EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 // TODO(xhwang): Once we add tests to cover DrmBridge, update this test to
 // also verify that the job is successfully created if SetDrmBridge(), Start()
 // and eventually OnMediaCrypto() occur. This would increase test coverage of
 // http://crbug.com/313470 and allow us to remove inspection of internal player
 // pending event state. See http://crbug.com/313860.
 TEST_F(MediaSourcePlayerTest, SurfaceChangeClearedEvenIfMediaCryptoAbsent) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that |SURFACE_CHANGE_EVENT_PENDING| is not pending after
   // SetVideoSurface() for a player configured for encrypted video, when the
   // player has not yet received media crypto.
   DemuxerConfigs configs = CreateVideoDemuxerConfigs();
   configs.is_video_encrypted = true;
 
   player_.OnDemuxerConfigsAvailable(configs);
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(IsPendingSurfaceChange());
   EXPECT_FALSE(GetMediaDecoderJob(false));
 }
 
 }  // namespace media