Remove the IPC to request DemuxerConfigs when config changes

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 117 matching lines @@
 
   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),
-        num_browser_seek_requests_(0),
-        num_config_requests_(0) {}
+        num_browser_seek_requests_(0) {}
   virtual ~MockDemuxerAndroid() {}
 
   virtual void Initialize(DemuxerAndroidClient* client) OVERRIDE {}
-  virtual void RequestDemuxerConfigs() OVERRIDE {
-    num_config_requests_++;
-  }
   virtual void RequestDemuxerData(DemuxerStream::Type type) OVERRIDE {
     num_data_requests_++;
     if (message_loop_->is_running())
       message_loop_->Quit();
   }
   virtual void RequestDemuxerSeek(const base::TimeDelta& time_to_seek,
                                   bool is_browser_seek) OVERRIDE {
     num_seek_requests_++;
     if (is_browser_seek)
       num_browser_seek_requests_++;
   }
 
   int num_data_requests() const { return num_data_requests_; }
   int num_seek_requests() const { return num_seek_requests_; }
   int num_browser_seek_requests() const { return num_browser_seek_requests_; }
-  int num_config_requests() const { return num_config_requests_; }
 
  private:
   base::MessageLoop* message_loop_;
 
   // The number of encoded data requests this object has seen.
   int num_data_requests_;
 
   // The number of regular and browser seek requests this object has seen.
   int num_seek_requests_;
 
   // The number of browser seek requests this object has seen.
   int num_browser_seek_requests_;
 
-  // The number of demuxer config requests this object has seen.
-  int num_config_requests_;
-
   DISALLOW_COPY_AND_ASSIGN(MockDemuxerAndroid);
 };
 
 class MediaSourcePlayerTest : public testing::Test {
  public:
   MediaSourcePlayerTest()
       : manager_(&message_loop_),
         demuxer_(new MockDemuxerAndroid(&message_loop_)),
         player_(0, &manager_,
                 base::Bind(&MockMediaPlayerManager::OnMediaResourcesRequested,
@@ skipping 122 matching lines @@
 
     if (have_audio && !have_video)
       return CreateAudioDemuxerConfigs(kCodecVorbis);
 
     if (have_video && !have_audio)
       return CreateVideoDemuxerConfigs();
 
     return CreateAudioVideoDemuxerConfigs();
   }
 
-  // Starts an audio decoder job. Verifies player behavior relative to
-  // |expect_player_requests_data|.
-  void StartAudioDecoderJob(bool expect_player_requests_data) {
-    Start(CreateAudioDemuxerConfigs(kCodecVorbis), expect_player_requests_data);
+  // Starts an audio decoder job.
+  void StartAudioDecoderJob() {
+    Start(CreateAudioDemuxerConfigs(kCodecVorbis));
   }
 
-  // Starts a video decoder job. Verifies player behavior relative to
-  // |expect_player_requests_data|.
-  void StartVideoDecoderJob(bool expect_player_requests_data) {
-    Start(CreateVideoDemuxerConfigs(), expect_player_requests_data);
+  // Starts a video decoder job.
+  void StartVideoDecoderJob() {
+    Start(CreateVideoDemuxerConfigs());
   }
 
-  // Starts decoding the data. Verifies player behavior relative to
-  // |expect_player_requests_data|.
-  void Start(const DemuxerConfigs& configs, bool expect_player_requests_data) {
-    bool has_audio = configs.audio_codec != kUnknownAudioCodec;
-    bool has_video = configs.video_codec != kUnknownVideoCodec;
+  // Starts decoding the data.
+  void Start(const DemuxerConfigs& configs) {
+    EXPECT_EQ(demuxer_->num_data_requests(), 0);
+    player_.OnDemuxerConfigsAvailable(configs);
+    player_.Start();
+
+    EXPECT_TRUE(player_.IsPlaying());
+    int expected_num_requests = (GetMediaDecoderJob(true) ? 1 : 0) +
+        (GetMediaDecoderJob(false) ? 1 : 0);
+    EXPECT_EQ(expected_num_requests, demuxer_->num_data_requests());
+  }
+
+  // Resumes decoding the data. Verifies player behavior relative to
+  // |expect_player_requests_audio_data| and
+  // |expect_player_requests_video_data|.
+  void Resume(bool expect_player_requests_audio_data,
+              bool expect_player_requests_video_data) {
+    EXPECT_FALSE(player_.IsPlaying());
+    EXPECT_TRUE(player_.HasVideo() || player_.HasAudio());
     int original_num_data_requests = demuxer_->num_data_requests();
-    int expected_request_delta = expect_player_requests_data ?
-        ((has_audio ? 1 : 0) + (has_video ? 1 : 0)) : 0;
+    int expected_request_delta =
+        (expect_player_requests_audio_data ? 1 : 0) +
+        (expect_player_requests_video_data ? 1 : 0);
 
-    player_.OnDemuxerConfigsAvailable(configs);
     player_.Start();
 
     EXPECT_TRUE(player_.IsPlaying());
     EXPECT_EQ(original_num_data_requests + expected_request_delta,
               demuxer_->num_data_requests());
-
-    // Verify player has decoder job iff the config included the media type for
-    // the job and the player is expected to request data due to Start(), above.
-    EXPECT_EQ(expect_player_requests_data && has_audio,
-              GetMediaDecoderJob(true) != NULL);
-    EXPECT_EQ(expect_player_requests_data && has_video,
-              GetMediaDecoderJob(false) != NULL);
+    EXPECT_EQ(expect_player_requests_audio_data,
+              expect_player_requests_audio_data && GetMediaDecoderJob(true));
+    EXPECT_EQ(expect_player_requests_video_data,
+              expect_player_requests_video_data && GetMediaDecoderJob(false));
   }
 
   // Keeps decoding audio data until the decoder starts to output samples.
   // Gives up if no audio output after decoding 10 frames.
   void DecodeAudioDataUntilOutputBecomesAvailable() {
     EXPECT_TRUE(player_.IsPlaying());
     base::TimeDelta current_time = player_.GetCurrentTime();
     base::TimeDelta start_timestamp = current_time;
     for (int i = 0; i < 10; ++i) {
       manager_.ResetTimestampUpdated();
@@ skipping 72 matching lines @@
   // the player should not yet have sent the DemuxerSeek IPC request, though
   // seek event should be pending. The audio decoder job will also still be
   // decoding.
   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);
+    StartAudioDecoderJob();
     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));
   }
 
@@ skipping 65 matching lines @@
   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;
+    data.demuxer_configs.resize(1);
+    data.demuxer_configs[0] = CreateDemuxerConfigs(is_audio, !is_audio);
     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() +
         (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);
-
+    StartVideoDecoderJob();
     if (trigger_with_release_start) {
       ReleasePlayer();
-
       // 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);
+      Resume(false, 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).
@@ skipping 21 matching lines @@
 
   // Creates a new decoder job and feeds it data ending with a |kConfigChanged|
   // access unit. If |config_unit_in_prefetch| is true, sends feeds the config
   // change AU in response to the job's first read request (prefetch). If
   // false, regular data is fed and decoded prior to feeding the config change
   // AU in response to the second data request (after prefetch completed).
   // |config_unit_index| controls which access unit is |kConfigChanged|.
   void StartConfigChange(bool is_audio,
                          bool config_unit_in_prefetch,
                          int config_unit_index) {
-    int expected_num_config_requests = demuxer_->num_config_requests();
-
     EXPECT_FALSE(GetMediaDecoderJob(is_audio));
     if (is_audio) {
-      StartAudioDecoderJob(true);
+      StartAudioDecoderJob();
     } else {
       CreateNextTextureAndSetVideoSurface();
-      StartVideoDecoderJob(true);
+      StartVideoDecoderJob();
     }
 
     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());
 
       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.
     // Player should prepare to reconfigure the decoder job, and should request
     // new demuxer configs.
     player_.OnDemuxerDataAvailable(
         CreateReadFromDemuxerAckWithConfigChanged(is_audio, config_unit_index));
-    WaitForDecodeDone(is_audio, !is_audio);
-
-    expected_num_config_requests++;
-    EXPECT_EQ(expected_num_data_requests, demuxer_->num_data_requests());
-    EXPECT_EQ(expected_num_config_requests, demuxer_->num_config_requests());
+    // Run until decoder starts to request new data.
+    while (demuxer_->num_data_requests() == expected_num_data_requests)
+      message_loop_.RunUntilIdle();
   }
 
   void CreateNextTextureAndSetVideoSurface() {
     gfx::SurfaceTexture* surface_texture;
     if (surface_texture_a_is_next_) {
       surface_texture_a_ = gfx::SurfaceTexture::Create(next_texture_id_++);
       surface_texture = surface_texture_a_.get();
     } else {
       surface_texture_b_ = gfx::SurfaceTexture::Create(next_texture_id_++);
       surface_texture = surface_texture_b_.get();
@@ skipping 47 matching lines @@
   }
 
   void VerifyCompletedPlaybackResumesOnSeekPlusStart(bool have_audio,
                                                      bool have_video) {
     DCHECK(have_audio || have_video);
 
     EXPECT_TRUE(manager_.playback_completed());
 
     player_.SeekTo(base::TimeDelta());
     player_.OnDemuxerSeekDone(kNoTimestamp());
-    Start(CreateDemuxerConfigs(have_audio, have_video), true);
+    Resume(have_audio, have_video);
   }
 
   // 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. |eos_{audio,video}| is ignored if the
   // corresponding |have_{audio,video}| is false.
   void VerifySeekDuringEOSDecodePreventsPlaybackCompletion(bool have_audio,
                                                            bool have_video,
                                                            bool eos_audio,
                                                            bool eos_video) {
     DCHECK(have_audio || have_video);
 
     if (have_video)
       CreateNextTextureAndSetVideoSurface();
 
-    Start(CreateDemuxerConfigs(have_audio, have_video), true);
+    Start(CreateDemuxerConfigs(have_audio, have_video));
 
     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
@@ skipping 49 matching lines @@
   bool surface_texture_a_is_next_;
   int next_texture_id_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSourcePlayerTest);
 };
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithValidConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio decoder job will be created when codec is successfully started.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithInvalidConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test audio decoder job will not be created when failed to start the codec.
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis);
   // Replace with invalid |audio_extra_data|
   configs.audio_extra_data.clear();
   uint8 invalid_codec_data[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
   configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
-  Start(configs, false);
+  Start(configs);
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video decoder job will be created when surface is valid.
   // Video decoder job will not be created until surface is available.
-  StartVideoDecoderJob(false);
+  StartVideoDecoderJob();
 
   // Set both an initial and a later video surface without receiving any
   // demuxed data yet.
   CreateNextTextureAndSetVideoSurface();
   MediaDecoderJob* first_job = GetMediaDecoderJob(false);
   EXPECT_TRUE(first_job);
   CreateNextTextureAndSetVideoSurface();
 
   // Setting another surface will not create a new job until any pending
   // read is satisfied (and job is no longer decoding).
   EXPECT_EQ(first_job, GetMediaDecoderJob(false));
 
   // No seeks, even on setting surface, should have occurred. (Browser seeks can
   // occur on setting surface, but only after previously receiving video data.)
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   // Note, the decoder job for the second surface set, above, will be created
   // only after the pending read is satisfied and decoded, and the resulting
   // browser seek is done. See BrowserSeek_* tests for this coverage.
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithInvalidSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video decoder job will not be created when surface is invalid.
   scoped_refptr<gfx::SurfaceTexture> surface_texture(
       gfx::SurfaceTexture::Create(0));
   gfx::ScopedJavaSurface surface(surface_texture.get());
-  StartVideoDecoderJob(false);
+  StartVideoDecoderJob();
 
   // Release the surface texture.
   surface_texture = NULL;
   player_.SetVideoSurface(surface.Pass());
 
   // Player should not seek the demuxer on setting initial surface.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   EXPECT_FALSE(GetMediaDecoderJob(false));
   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(true);
+  StartAudioDecoderJob();
   SeekPlayerWithAbort(true, base::TimeDelta());
 }
 
 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.
   // Player is still waiting for SetVideoSurface(), so no request is sent.
-  StartVideoDecoderJob(false);  // Verifies no data requested.
+  StartVideoDecoderJob();  // Verifies no data requested.
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaDecoderJob(false));
   EXPECT_EQ(1, demuxer_->num_seek_requests());
@@ skipping 10 matching lines @@
   // was not a browser seek request.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ChangeMultipleSurfaceWhileDecoding) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test MediaSourcePlayer can switch multiple surfaces during decoding.
   CreateNextTextureAndSetVideoSurface();
-  StartVideoDecoderJob(true);
+  StartVideoDecoderJob();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
 
   // 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.
@@ skipping 16 matching lines @@
   EXPECT_TRUE(GetMediaDecoderJob(false));
   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);
+  StartVideoDecoderJob();
   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.
@@ skipping 12 matching lines @@
   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);
+  StartVideoDecoderJob();
   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());
@@ skipping 59 matching lines @@
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartImmediatelyAfterPause) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if the decoding job is not fully stopped after Pause(),
   // calling Start() will be a noop.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
 
   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
@@ skipping 12 matching lines @@
   EXPECT_EQ(2, demuxer_->num_data_requests());
   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);
+  Start(CreateAudioVideoDemuxerConfigs());
   MediaDecoderJob* audio_decoder_job = GetMediaDecoderJob(true);
   MediaDecoderJob* video_decoder_job = GetMediaDecoderJob(false);
 
   EXPECT_FALSE(audio_decoder_job->is_decoding());
   EXPECT_FALSE(video_decoder_job->is_decoding());
 
   // Sending video data to player, video decoder should not start.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   EXPECT_FALSE(video_decoder_job->is_decoding());
 
   // Sending audio data to player, both decoders should start now.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_TRUE(audio_decoder_job->is_decoding());
   EXPECT_TRUE(video_decoder_job->is_decoding());
 
   // No seeks should have occurred.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartTimeTicksResetAfterDecoderUnderruns) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test start time ticks will reset after decoder job underruns.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
 
   DecodeAudioDataUntilOutputBecomesAvailable();
 
   // The decoder job should finish and a new request will be sent.
   base::TimeTicks previous = StartTimeTicks();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
 
   // Let the decoder starve.
   TriggerPlayerStarvation();
   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(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);
+  StartVideoDecoderJob();
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   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.
   // Also tests that seeking+Start() after completing audio playback resumes
   // playback.
-  Start(CreateAudioDemuxerConfigs(kCodecAAC), true);
+  Start(CreateAudioDemuxerConfigs(kCodecAAC));
   VerifyPlaybackCompletesOnEOSDecode(true, true);
   VerifyCompletedPlaybackResumesOnSeekPlusStart(true, false);
 }
 
 TEST_F(MediaSourcePlayerTest, V_FirstAccessUnitAfterSeekIsEOS) {
   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(true);
+  StartVideoDecoderJob();
   SeekPlayerWithAbort(false, base::TimeDelta());
   VerifyPlaybackCompletesOnEOSDecode(true, false);
 }
 
 TEST_F(MediaSourcePlayerTest, A_FirstAccessUnitAfterSeekIsEOS) {
   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), true);
+  Start(CreateAudioDemuxerConfigs(kCodecAAC));
   SeekPlayerWithAbort(true, base::TimeDelta());
   VerifyPlaybackCompletesOnEOSDecode(true, true);
 }
 
 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.
   CreateNextTextureAndSetVideoSurface();
-  Start(CreateAudioVideoDemuxerConfigs(), true);
+  Start(CreateAudioVideoDemuxerConfigs());
 
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
-  EXPECT_EQ(0, demuxer_->num_config_requests());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
       false, 0));  // Video |kConfigChanged| as first unit.
 
   WaitForAudioVideoDecodeDone();
 
-  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. Send and decode video EOS.
   VerifyPlaybackCompletesOnEOSDecode(true, false);
   VerifyCompletedPlaybackResumesOnSeekPlusStart(true, true);
 }
 
 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.
   CreateNextTextureAndSetVideoSurface();
-  Start(CreateAudioVideoDemuxerConfigs(), true);
+  Start(CreateAudioVideoDemuxerConfigs());
 
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
-  EXPECT_EQ(0, demuxer_->num_config_requests());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
       true, 0));  // Audio |kConfigChanged| as first unit.
 
   WaitForAudioVideoDecodeDone();
 
-  // 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. Send and decode audio EOS.
   VerifyPlaybackCompletesOnEOSDecode(true, true);
   VerifyCompletedPlaybackResumesOnSeekPlusStart(true, true);
 }
 
 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.
   CreateNextTextureAndSetVideoSurface();
-  Start(CreateAudioVideoDemuxerConfigs(), true);
+  Start(CreateAudioVideoDemuxerConfigs());
 
   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.
   WaitForAudioVideoDecodeDone();
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // Simulate decoder underrun to trigger prefetch while still decoding audio.
@@ skipping 14 matching lines @@
   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);
+  StartVideoDecoderJob();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   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);
+  StartAudioDecoderJob();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   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 */);
 }
 
@@ skipping 37 matching lines @@
   // Test that seek supercedes audio-only playback completion on EOS decode, if
   // SeekTo() occurs during EOS decode.
   VerifySeekDuringEOSDecodePreventsPlaybackCompletion(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(true);
+  StartAudioDecoderJob();
 
   // Send an aborted access unit.
   player_.OnDemuxerDataAvailable(CreateAbortedAck(true));
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   WaitForAudioDecodeDone();
 
   // No request will be sent for new data.
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // No seek requests should have occurred.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerDataArrivesAfterRelease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the decoder should not crash if demuxer data arrives after
   // Release().
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
 
   ReleasePlayer();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
 
   // The decoder job should have been released.
   EXPECT_FALSE(player_.IsPlaying());
 
   // No further data should have been requested.
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
@@ skipping 29 matching lines @@
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_InitialReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that browser seek is requested if player Release() + Start() occurs
   // prior to receiving any data.
   CreateNextTextureAndSetVideoSurface();
-  StartVideoDecoderJob(true);
+  StartVideoDecoderJob();
   ReleasePlayer();
 
   // Pass a new non-empty surface.
   CreateNextTextureAndSetVideoSurface();
 
   player_.Start();
 
   // The new player won't be created until the pending data request is
   // processed.
   EXPECT_EQ(1, demuxer_->num_data_requests());
@@ skipping 16 matching lines @@
   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();
 
   // Test decoder job will preroll the media to the seek position.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
   EXPECT_TRUE(IsPrerolling(true));
   PrerollDecoderToTime(
       true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100));
 }
 
 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(true);
+  StartVideoDecoderJob();
 
   SeekPlayerWithAbort(false, base::TimeDelta::FromMilliseconds(100));
   EXPECT_TRUE(IsPrerolling(false));
   PrerollDecoderToTime(
       false, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100));
 }
 
 TEST_F(MediaSourcePlayerTest, SeekingAfterCompletingPrerollRestartsPreroll) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will begin prerolling upon seek, when it was not
   // prerolling prior to the seek.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
   MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
   EXPECT_TRUE(IsPrerolling(true));
 
   // Complete the initial preroll by feeding data to the decoder.
   DecodeAudioDataUntilOutputBecomesAvailable();
   EXPECT_FALSE(IsPrerolling(true));
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(500));
 
   // Prerolling should have begun again.
@@ skipping 16 matching lines @@
   // IsPrerolling() transition from false to true was not due to constructor
   // initialization. It was due to BeginPrerolling().
   EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
 }
 
 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(true);
+  StartAudioDecoderJob();
 
   base::TimeDelta target_timestamp = base::TimeDelta::FromMilliseconds(100);
   SeekPlayerWithAbort(true, target_timestamp);
   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) {
     data = CreateReadFromDemuxerAckForAudio(3);
     data.access_units[0].timestamp = base::TimeDelta::FromMilliseconds(i * 10);
     if (i == 1) {
       // While still prerolling, Release() and Start() the player.
       // 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);
       WaitForAudioDecodeDone();
       EXPECT_FALSE(GetMediaDecoderJob(true));
-      StartAudioDecoderJob(true);
+      Resume(true, false);
     } else {
       player_.OnDemuxerDataAvailable(data);
       EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
       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);
 }
 
 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(true);
+  StartAudioDecoderJob();
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
   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.
+  // sending an AU with |kConfigChanged|. Player should reconfigure the
+  // audio decoder job with the supplied configs.
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
-  EXPECT_EQ(0, demuxer_->num_config_requests());
   player_.OnDemuxerDataAvailable(data);
-  EXPECT_EQ(1, demuxer_->num_config_requests());
-
-  // Simulate arrival of new configs.
-  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
-
   PrerollDecoderToTime(
       true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100));
 }
 
 TEST_F(MediaSourcePlayerTest, SimultaneousAudioVideoConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player allows simultaneous audio and video config change,
   // such as might occur during OnPrefetchDone() if next access unit for both
   // audio and video jobs is |kConfigChanged|.
   CreateNextTextureAndSetVideoSurface();
-  Start(CreateAudioVideoDemuxerConfigs(), true);
+  Start(CreateAudioVideoDemuxerConfigs());
   MediaDecoderJob* first_audio_job = GetMediaDecoderJob(true);
   MediaDecoderJob* first_video_job = GetMediaDecoderJob(false);
 
   // Simulate audio |kConfigChanged| prefetched as standalone access unit.
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(true, 0));
-  EXPECT_EQ(0, demuxer_->num_config_requests());  // No OnPrefetchDone() yet.
 
   // Simulate video |kConfigChanged| prefetched as standalone access unit.
   player_.OnDemuxerDataAvailable(
       CreateReadFromDemuxerAckWithConfigChanged(false, 0));
-  EXPECT_EQ(1, demuxer_->num_config_requests());  // OnPrefetchDone() occurred.
-  EXPECT_EQ(2, demuxer_->num_data_requests());  // No more data requested yet.
+  EXPECT_EQ(4, demuxer_->num_data_requests());
 
-  // No job re-creation should occur until the requested configs arrive.
-  EXPECT_EQ(first_audio_job, GetMediaDecoderJob(true));
-  EXPECT_EQ(first_video_job, GetMediaDecoderJob(false));
-
-  player_.OnDemuxerConfigsAvailable(CreateAudioVideoDemuxerConfigs());
-  EXPECT_EQ(4, demuxer_->num_data_requests());
-  MediaDecoderJob* second_audio_job = GetMediaDecoderJob(true);
-  MediaDecoderJob* second_video_job = GetMediaDecoderJob(false);
-  EXPECT_NE(first_audio_job, second_audio_job);
-  EXPECT_NE(first_video_job, second_video_job);
-  EXPECT_TRUE(second_audio_job && second_video_job);
-
-  // Confirm no further demuxer configs requested.
-  EXPECT_EQ(1, demuxer_->num_config_requests());
+  // Both jobs should have been reconfigured by now.
+  // TODO(qinmin): Fix flaky pointer-based MDJ inequality testing.
+  // See http://crbug.com/327839.
+  EXPECT_NE(first_audio_job, GetMediaDecoderJob(true));
+  EXPECT_NE(first_video_job, GetMediaDecoderJob(false));
+  EXPECT_TRUE(GetMediaDecoderJob(true) && GetMediaDecoderJob(false));
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerConfigRequestedIfInPrefetchUnit0) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is the very first unit in the set of units
   // received in OnDemuxerDataAvailable() ostensibly while
   // |PREFETCH_DONE_EVENT_PENDING|.
   StartConfigChange(true, true, 0);
@@ skipping 44 matching lines @@
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   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
-  // seek necessary once the new demuxer config arrives.
+  // Test that video config change notification results in creating a new
+  // video decoder job results without any browser seek.
   StartConfigChange(false, true, 1);
-  MediaDecoderJob* first_job = GetMediaDecoderJob(false);
-  EXPECT_TRUE(first_job);
-  EXPECT_EQ(1, demuxer_->num_data_requests());
-  EXPECT_EQ(1, demuxer_->num_config_requests());
-
-  // Simulate arrival of new configs.
-  player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
-
-  // New video decoder job should have been created and configured, without any
-  // browser seek.
-  MediaDecoderJob* second_job = GetMediaDecoderJob(false);
-  EXPECT_TRUE(second_job);
-  EXPECT_NE(first_job, second_job);
+  EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(2, demuxer_->num_data_requests());
-  EXPECT_EQ(1, demuxer_->num_config_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
-TEST_F(MediaSourcePlayerTest, VideoConfigChangeContinuesAcrossSeek) {
+TEST_F(MediaSourcePlayerTest, NewSurfaceAfterChangingConfigs) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
-  // Test if a demuxer config request is pending (due to previously receiving
-  // |kConfigChanged|), and a seek request arrives prior to demuxer configs,
-  // then seek is processed first, followed by the decoder config change.
-  // This assumes the demuxer sends |kConfigChanged| read response prior to
-  // canceling any reads pending seek; no |kAborted| is involved in this test.
+  // Test that no seek results from a SetVideoSurface() that occurs after
+  // the player processes new demuxer configs. This test may be good to keep
+  // beyond browser seek hack.
   StartConfigChange(false, false, 1);
-  MediaDecoderJob* first_job = GetMediaDecoderJob(false);
-  EXPECT_TRUE(first_job);
-  EXPECT_EQ(1, demuxer_->num_config_requests());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-  EXPECT_EQ(0, demuxer_->num_seek_requests());
-
-  player_.SeekTo(base::TimeDelta::FromMilliseconds(100));
-
-  // Verify that the seek is requested immediately.
-  EXPECT_EQ(1, demuxer_->num_seek_requests());
-
-  // Simulate unlikely delayed arrival of the demuxer configs, completing the
-  // config change.
-  // TODO(wolenetz): Is it even possible for requested demuxer configs to be
-  // delayed until after a SeekTo request arrives?
-  player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
-
-  MediaDecoderJob* second_job = GetMediaDecoderJob(false);
-  EXPECT_NE(first_job, second_job);
-  EXPECT_TRUE(second_job);
-
-  // Send back the seek done notification. This should finish the seek and
-  // trigger the player to request more data.
-  EXPECT_EQ(2, demuxer_->num_data_requests());
-  player_.OnDemuxerSeekDone(kNoTimestamp());
+  EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
-}
-
-TEST_F(MediaSourcePlayerTest, NewSurfaceWhileChangingConfigs) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
-
-  // Test that no seek or duplicated demuxer config request results from a
-  // SetVideoSurface() that occurs while the player is expecting new demuxer
-  // configs. This test may be good to keep beyond browser seek hack.
-  StartConfigChange(false, false, 1);
-  MediaDecoderJob* first_job = GetMediaDecoderJob(false);
-  EXPECT_TRUE(first_job);
-  EXPECT_EQ(1, demuxer_->num_config_requests());
-  EXPECT_EQ(2, demuxer_->num_data_requests());
 
   CreateNextTextureAndSetVideoSurface();
-
-  // Surface change processing (including decoder job re-creation) should
-  // not occur until the pending video config change is completed.
-  EXPECT_EQ(first_job, GetMediaDecoderJob(false));
-
-  player_.OnDemuxerConfigsAvailable(CreateVideoDemuxerConfigs());
-  MediaDecoderJob* second_job = GetMediaDecoderJob(false);
-  EXPECT_NE(first_job, second_job);
-  EXPECT_TRUE(second_job);
-
+  EXPECT_TRUE(GetMediaDecoderJob(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
-  EXPECT_EQ(1, demuxer_->num_config_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest,
        BrowserSeek_DecoderStarvationWhilePendingSurfaceChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test video decoder starvation while handling a pending surface change
   // should not cause any crashes.
   CreateNextTextureAndSetVideoSurface();
-  StartVideoDecoderJob(true);
+  StartVideoDecoderJob();
   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(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);
+  StartAudioDecoderJob();
 
   // Escape the original prefetch by decoding a single access unit.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   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();
 
   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);
+  Resume(true, false);
 }
 
 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(2, demuxer_->num_data_requests());
-  StartAudioDecoderJob(true);
+  Resume(true, false);
   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(2, demuxer_->num_data_requests());
-  StartAudioDecoderJob(false);
+  Resume(false, false);
 
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since Release(), above.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
@@ skipping 10 matching lines @@
   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(2, demuxer_->num_data_requests());
-  StartAudioDecoderJob(true);
+  Resume(true, false);
   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(2, demuxer_->num_data_requests());
-  StartAudioDecoderJob(false);
+  Resume(false, false);
 
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_TRUE(GetMediaDecoderJob(true));
   EXPECT_TRUE(IsPrerolling(true));
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   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
-  // Start(), then the player completes the pending config change processing on
-  // their receipt.
-  StartConfigChange(true, true, 0);
-  ReleasePlayer();
-
-  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
-  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_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 if Release() occurs after |kConfigChanged| detected, 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.
+  // Test if Release() occurs after |kConfigChanged| detected, and then Start()
+  // is called, then the player does not issue any new data request since it is
+  // still waiting for the previous one.
   StartConfigChange(true, true, 0);
   ReleasePlayer();
 
-  player_.Start();
-  EXPECT_TRUE(player_.IsPlaying());
   EXPECT_FALSE(GetMediaDecoderJob(true));
-  EXPECT_EQ(1, demuxer_->num_data_requests());
-
-  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
-  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_FALSE(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());
+  // Player should resume upon Start().
+  Resume(false, false);
+  EXPECT_TRUE(GetMediaDecoderJob(true));
+  EXPECT_TRUE(player_.IsPlaying());
+  EXPECT_EQ(2, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenDemuxerSeekDone) {
   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() occurs
   // before the next Start()+SetVideoSurface(), then the player will resume
   // correct post-seek preroll upon Start()+SetVideoSurface().
   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(2, demuxer_->num_data_requests());
   CreateNextTextureAndSetVideoSurface();
-  StartVideoDecoderJob(true);
+  Resume(false, 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(2, demuxer_->num_data_requests());
   CreateNextTextureAndSetVideoSurface();
-  StartVideoDecoderJob(false);
+  Resume(false, 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(3, demuxer_->num_data_requests());
 
   // No further seek should have been requested since BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
@@ skipping 16 matching lines @@
   player_.OnDemuxerConfigsAvailable(configs);
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(IsPendingSurfaceChange());
   EXPECT_FALSE(GetMediaDecoderJob(false));
 }
 
 TEST_F(MediaSourcePlayerTest, CurrentTimeUpdatedWhileDecoderStarved) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that current time is updated while decoder is starved.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
   DecodeAudioDataUntilOutputBecomesAvailable();
 
   // Trigger starvation while the decoder is decoding.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   manager_.ResetTimestampUpdated();
   TriggerPlayerStarvation();
   WaitForAudioDecodeDone();
 
   // Current time should be updated.
   EXPECT_TRUE(manager_.timestamp_updated());
 }
 
 TEST_F(MediaSourcePlayerTest, CurrentTimeKeepsIncreasingAfterConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test current time keep on increasing after audio config change.
   // Test that current time is updated while decoder is starved.
-  StartAudioDecoderJob(true);
+  StartAudioDecoderJob();
 
   DecodeAudioDataUntilOutputBecomesAvailable();
 
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(true, 0);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
-
-  // Simulate arrival of new configs.
-  player_.OnDemuxerConfigsAvailable(CreateAudioDemuxerConfigs(kCodecVorbis));
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
 }  // namespace media