Abort MSP::OnPrefetchDone() if just after MSP::Release(). Let seek and config change survive.

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/callback_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/android/media_drm_bridge.h"
 #include "media/base/android/media_player_manager.h"
 #include "media/base/android/media_source_player.h"
+#include "media/base/bind_to_loop.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/test_data_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "ui/gl/android/surface_texture.h"
 
 namespace media {
 
 // Helper macro to skip the test if MediaCodecBridge isn't available.
 #define SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE() \
   do { \
@@ skipping 49 matching lines @@
   virtual void OnKeyAdded(int key_id,
                           const std::string& session_id) OVERRIDE {}
   virtual void OnKeyError(int key_id,
                           const std::string& session_id,
                           MediaKeys::KeyError error_code,
                           int system_code) OVERRIDE {}
   virtual void OnKeyMessage(int key_id,
                             const std::string& session_id,
                             const std::vector<uint8>& message,
                             const std::string& destination_url) OVERRIDE {}
+  virtual void OnMediaDecoderCallbackForTesting() OVERRIDE {

[acolwell GONE FROM CHROMIUM, 2013/10/30 23:29:53]

This should be in MSP not here.

[wolenetz, 2013/10/31 01:39:11]

Done.

+    if (media_decoder_test_cb_.is_null())
+      return;
+    base::ResetAndReturn(&media_decoder_test_cb_).Run();
+  }
+
+  // Hook the next OnMediaDecoderCallbackForTesting() to run |decode_cb|.
+  void HookNextMediaDecoderCallback(const base::Closure& decode_cb) {
+    media_decoder_test_cb_ = decode_cb;
+  }
 
  private:
   base::MessageLoop* message_loop_;
+  base::Closure media_decoder_test_cb_;
 
   DISALLOW_COPY_AND_ASSIGN(MockMediaPlayerManager);
 };
 
 class MockDemuxerAndroid : public DemuxerAndroid {
  public:
   explicit MockDemuxerAndroid(base::MessageLoop* message_loop)
       : message_loop_(message_loop),
         num_data_requests_(0),
         num_seek_requests_(0),
@@ skipping 39 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
 };
 
 class MediaSourcePlayerTest : public testing::Test {
  public:
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_, scoped_ptr<DemuxerAndroid>(demuxer_)),
+        decoder_callback_hook_executed_(false),
         surface_texture_a_is_next_(true) {}
   virtual ~MediaSourcePlayerTest() {}
 
  protected:
   // Get the decoder job from the MediaSourcePlayer.
   MediaDecoderJob* GetMediaDecoderJob(bool is_audio) {
     if (is_audio) {
       return reinterpret_cast<MediaDecoderJob*>(
           player_.audio_decoder_job_.get());
     }
     return reinterpret_cast<MediaDecoderJob*>(
         player_.video_decoder_job_.get());
   }
 
   // Get the per-job prerolling status from the MediaSourcePlayer's job matching
   // |is_audio|. Caller must guard against NPE if the player's job is NULL.
   bool IsPrerolling(bool is_audio) {
     return GetMediaDecoderJob(is_audio)->prerolling();
   }
 
   // Get the preroll timestamp from the MediaSourcePlayer.
   base::TimeDelta GetPrerollTimestamp() {
     return player_.preroll_timestamp_;
   }
 
+  // Check if the player is pending a prefetch done event.
+  bool IsPendingPrefetchDone() {
+    return player_.IsEventPending(player_.PREFETCH_DONE_EVENT_PENDING);
+  }
+
+  // Check if the player is pending a config change event.
+  bool IsPendingConfigChange() {
+    return player_.IsEventPending(player_.CONFIG_CHANGE_EVENT_PENDING);
+  }
+
+  // Check if the player is pending a seek event.
+  bool IsPendingSeek() {
+    return player_.IsEventPending(player_.SEEK_EVENT_PENDING);
+  }
+
+  // Check if the player is pending a surface change event.
+  bool IsPendingSurfaceChange() {
+    return player_.IsEventPending(player_.SURFACE_CHANGE_EVENT_PENDING);
+  }
+
+  // Check if the player is pending a prefetch request event.
+  bool IsPendingPrefetchRequest() {
+    return player_.IsEventPending(player_.PREFETCH_REQUEST_EVENT_PENDING);
+  }
+
+  // Simulate player has reached starvation timeout.
+  void TriggerPlayerStarvation() {
+    player_.decoder_starvation_callback_.Cancel();
+    player_.OnDecoderStarved();
+  }
+
+  // Asynch test callback posted upon decode completion to verify that a pending
+  // prefetch done event is cleared across |player_|'s Release(). This helps
+  // ensure the ReleaseWithOnPrefetchDoneAlreadyPosted test scenario is met.
+  void ReleaseWithPendingPrefetchDoneVerification() {
+    EXPECT_TRUE(player_.IsPlaying());
+    EXPECT_FALSE(IsPendingPrefetchRequest());
+    EXPECT_TRUE(IsPendingPrefetchDone());
+    player_.Release();
+    EXPECT_FALSE(IsPendingPrefetchDone());
+    EXPECT_FALSE(player_.IsPlaying());
+    EXPECT_FALSE(decoder_callback_hook_executed_);
+    decoder_callback_hook_executed_ = true;
+  }
+
   DemuxerConfigs CreateAudioDemuxerConfigs() {
     DemuxerConfigs configs;
     configs.audio_codec = kCodecVorbis;
     configs.audio_channels = 2;
     configs.audio_sampling_rate = 44100;
     configs.is_audio_encrypted = false;
     configs.duration_ms = kDefaultDurationInMs;
     scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
     configs.audio_extra_data = std::vector<uint8>(
         buffer->data(),
@@ skipping 281 matching lines @@
   }
 
   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);
   }
 
- protected:
   base::MessageLoop message_loop_;
   MockMediaPlayerManager manager_;
   MockDemuxerAndroid* demuxer_;  // Owned by |player_|.
   MediaSourcePlayer player_;
 
+  // Track whether a possibly asynch decoder callback test hook has run.
+  bool decoder_callback_hook_executed_;
+
   // We need to keep the surface texture while the decoder is actively decoding.
   // Otherwise, it may trigger unexpected crashes on some devices. To switch
   // surfaces, tests need to create a new surface texture without releasing
   // their previous one. In CreateNextTextureAndSetVideoSurface(), we toggle
   // between two surface textures, only replacing the N-2 texture. Assumption is
   // that no more than N-1 texture is in use by decoder when
   // CreateNextTextureAndSetVideoSurface() is called.
   scoped_refptr<gfx::SurfaceTexture> surface_texture_a_;
   scoped_refptr<gfx::SurfaceTexture> surface_texture_b_;
   bool surface_texture_a_is_next_;
@@ skipping 885 matching lines @@
   player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
   MediaDecoderJob* second_job = GetMediaDecoderJob(false);
   EXPECT_NE(first_job, second_job);
   EXPECT_TRUE(second_job);
 
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(1, demuxer_->num_config_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
+TEST_F(MediaSourcePlayerTest, ReleaseClearsSurfaceChangeAndPrefetchDone) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that Release() clears both a pending surface change event as well
+  // as a pending prefetch done event.
+  StartVideoDecoderJob();
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_TRUE(GetMediaDecoderJob(false));
+
+  EXPECT_FALSE(IsPendingSurfaceChange());
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(IsPendingSurfaceChange());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+
+  player_.Release();
+  EXPECT_FALSE(IsPendingSurfaceChange());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+
+  // Player should have no decoder job until after Start() and setting non-empty
+  // surface.
+  EXPECT_FALSE(GetMediaDecoderJob(false));
+  EXPECT_FALSE(player_.IsPlaying());
+  StartVideoDecoderJob();
+  EXPECT_FALSE(GetMediaDecoderJob(false));
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(GetMediaDecoderJob(false));
+}
+
+TEST_F(MediaSourcePlayerTest, ReleaseWithOnPrefetchDoneAlreadyPosted) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if OnPrefetchDone() had already been posted before and is
+  // executed after Release(), player does not DCHECK.
+  StartAudioDecoderJob();
+
+  // Escape the original prefetch by decoding a single access unit.
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  message_loop_.Run();
+
+  // 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) &&
+      GetMediaDecoderJob(true)->is_decoding());
+  EXPECT_FALSE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+
+  // Simulate decoder underrun, so trivial prefetch starts while still decoding.
+  // The prefetch and posting of OnPrefetchDone() will not occur until next
+  // MediaDecoderCallBack() occurs.
+  TriggerPlayerStarvation();
+  EXPECT_TRUE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+
+  // Upon the next successful decode callback, post a task to Release()
+  // |player_|, such that the trivial OnPrefetchDone() task posting also occurs
+  // and should execute after the Release().
+  manager_.HookNextMediaDecoderCallback(media::BindToLoop(
+      message_loop_.message_loop_proxy(),
+      base::Bind(
+          &MediaSourcePlayerTest_ReleaseWithOnPrefetchDoneAlreadyPosted_Test::
+              ReleaseWithPendingPrefetchDoneVerification,
+              base::Unretained(this))));
+
+  while (GetMediaDecoderJob(true))
+    message_loop_.RunUntilIdle();
+  EXPECT_TRUE(decoder_callback_hook_executed_);
+  EXPECT_FALSE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+  EXPECT_FALSE(player_.IsPlaying());
+
+  // Player should have no decoder job until after Start().
+  StartAudioDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+}
+
+TEST_F(MediaSourcePlayerTest, SeekToThenReleaseThenDemuxerSeekAndDone) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if Release() occurs after SeekTo(), but the DemuxerSeek IPC
+  // request has not yet been sent, that the seek request will be sent after
+  // Release(). Also, if OnDemuxerSeekDone() occurs prior to next Start(), then
+  // the player will resume correct post-seek preroll upon Start().
+  StartAudioDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
+
+  // SeekTo() while the job is decoding, so DemuxerSeek IPC transmission pends
+  // decoder completion (or player Release()).
+  player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
+  EXPECT_TRUE(IsPendingSeek());
+  EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
+  EXPECT_EQ(0, demuxer_->num_seek_requests());
+
+  // TODO(qinmin/wolenetz): Don't drop previously received data. See
+  // http://crbug.com/306314 and http://crbug.com/304234.
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingSeek());
+  EXPECT_EQ(1, demuxer_->num_seek_requests());
+
+  player_.OnDemuxerSeekDone(kNoTimestamp());
+  EXPECT_FALSE(IsPendingSeek());
+  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());
+  StartAudioDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(IsPendingSeek());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_TRUE(IsPrerolling(true));
+  EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // 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 that if Release() occurs after SeekTo(), but the DemuxerSeek IPC
+  // request has not yet been sent, that the seek request will be sent after
+  // Release(). Also, if OnDemuxerSeekDone() does not occur until after the next
+  // Start(), then the player remains pending seek done and, after
+  // OnDemuxerSeekDone(), resumes correct post-seek preroll.
+  StartAudioDecoderJob();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
+  player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
+  EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
+
+  // SeekTo() while the job is decoding, so DemuxerSeek IPC transmission pends
+  // decoder completion (or player Release()).
+  player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
+  EXPECT_TRUE(IsPendingSeek());
+  EXPECT_EQ(0.0, GetPrerollTimestamp().InMillisecondsF());
+  EXPECT_EQ(0, demuxer_->num_seek_requests());
+
+  // TODO(qinmin/wolenetz): Don't drop previously received data. See
+  // http://crbug.com/306314 and http://crbug.com/304234.
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingSeek());
+  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());
+  StartAudioDecoderJob();
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingSeek());
+  EXPECT_FALSE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+
+  player_.OnDemuxerSeekDone(kNoTimestamp());
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(IsPendingSeek());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_TRUE(IsPrerolling(true));
+  EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // No further seek should have been requested since Release(), above.
+  EXPECT_EQ(1, demuxer_->num_seek_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenConfigsAvailable) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if Release() occurs after |kConfigChanged| detected and new
+  // configs requested of demuxer, and the requested configs arrive before
+  // the next Start(), then the player completes the pending config change
+  // processing on their receipt.
+  StartConfigChange(true, true, 0);
+
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingConfigChange());
+
+  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs());
+  EXPECT_FALSE(IsPendingConfigChange());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+
+  // Player should resume upon Start(), even without further configs supplied.
+  player_.Start();
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(IsPendingConfigChange());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_TRUE(player_.IsPlaying());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // No further config request should have occurred since StartConfigChange().
+  EXPECT_EQ(1, demuxer_->num_config_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, ConfigChangedThenReleaseThenStart) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if Release() occurs after |kConfigChanged| detected and new
+  // configs requested of demuxer, and the requested configs arrive after the
+  // next Start(), then the player pends job creation until the new configs
+  // arrive.
+  StartConfigChange(true, true, 0);
+
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingConfigChange());
+
+  player_.Start();
+  EXPECT_TRUE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(IsPendingConfigChange());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+
+  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs());
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(IsPendingConfigChange());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // No further config request should have occurred since StartConfigChange().
+  EXPECT_EQ(1, demuxer_->num_config_requests());
+}
+
+TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenDemuxerSeekDone) {
+  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+
+  // Test that if Release() occurs after a browser seek's DemuxerSeek IPC
+  // request has been sent, that the seek survives the Release(). Also, if
+  // OnDemuxerSeekDone() occurs prior to the next Start(), then the player will
+  // resume correct post-seek preroll upon Start().
+  // Note, the SeekToThenReleaseThenDemuxerSeek* tests, above, cover the
+  // case where seek request has not yet been sent at time of Release(). Browser
+  // seeks use similar logic, so no extra test coverage is deemed necessary. On
+  // removal of browser seeks, consider retaining a regular seek version of this
+  // test.
+
+  BrowserSeekPlayer(false);
+  EXPECT_FALSE(GetMediaDecoderJob(false));  // It is reset pending the seek.
+  EXPECT_TRUE(IsPendingSeek());
+  base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
+
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(false));
+  EXPECT_TRUE(IsPendingSeek());
+
+  player_.OnDemuxerSeekDone(expected_preroll_timestamp);
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(false));
+  EXPECT_FALSE(IsPendingSeek());
+  EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
+
+  // Player should begin prefetch and resume preroll upon Start().
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+  EXPECT_FALSE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+  StartVideoDecoderJob();
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_TRUE(GetMediaDecoderJob(false));
+  EXPECT_FALSE(IsPendingSeek());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_TRUE(IsPrerolling(false));
+  EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
+  EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // 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 if Release() occurs after a browser seek's DemuxerSeek IPC
+  // request has been sent, that the seek survives the Release(). Also, if
+  // OnDemuxerSeekDone() does not occur until after the next Start(), then the
+  // player remains pending seek done and, after OnDemuxerSeekDone(), resumes
+  // correct post-seek preroll.
+  // Note, the SeekToThenReleaseThenDemuxerSeek* tests, above, cover the
+  // case where seek request has not yet been sent at time of Release(). Browser
+  // seeks use similar logic, so no extra test coverage is deemed necessary. On
+  // removal of browser seeks, consider retaining a regular seek version of this
+  // test.
+
+  // BIG TODO
+  BrowserSeekPlayer(false);
+  EXPECT_FALSE(GetMediaDecoderJob(false));  // It is reset pending the seek.
+  EXPECT_TRUE(IsPendingSeek());
+  base::TimeDelta expected_preroll_timestamp = player_.GetCurrentTime();
+
+  player_.Release();
+  EXPECT_FALSE(player_.IsPlaying());
+  EXPECT_FALSE(GetMediaDecoderJob(false));

[qinmin, 2013/10/30 23:07:48]

lots of the testing code are testing the same initial sequence, can we remove
them?

[wolenetz, 2013/10/31 01:39:11]

Yes, indeed. I've coalesced many of the duplicate verifications and setups. I
also removed my "// BIG TODO" comment ! :)

+  EXPECT_TRUE(IsPendingSeek());
+
+  StartVideoDecoderJob();
+  CreateNextTextureAndSetVideoSurface();
+  EXPECT_FALSE(GetMediaDecoderJob(false));
+  EXPECT_TRUE(IsPendingSeek());
+  EXPECT_FALSE(IsPendingPrefetchRequest());
+  EXPECT_FALSE(IsPendingPrefetchDone());
+  EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
+  EXPECT_EQ(1, demuxer_->num_data_requests());
+
+  player_.OnDemuxerSeekDone(expected_preroll_timestamp);
+  EXPECT_TRUE(GetMediaDecoderJob(false));
+  EXPECT_FALSE(IsPendingSeek());
+  EXPECT_TRUE(IsPendingPrefetchDone());
+  EXPECT_TRUE(IsPrerolling(false));
+  EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
+  EXPECT_EQ(expected_preroll_timestamp, player_.GetCurrentTime());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
+
+  // No further seek should have been requested since BrowserSeekPlayer().
+  EXPECT_EQ(1, demuxer_->num_seek_requests());
+}
+
 // TODO(xhwang): Enable this test when the test devices are updated.
 TEST_F(MediaSourcePlayerTest, DISABLED_IsTypeSupported_Widevine) {
   if (!MediaCodecBridge::IsAvailable() || !MediaDrmBridge::IsAvailable()) {
     LOG(INFO) << "Could not run test - not supported on device.";
     return;
   }
 
   uint8 kWidevineUUID[] = { 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
                             0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
 
@@ skipping 54 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