Disable flaky media unit tests.

media/base/android/media_codec_player_unittest.cc

 // Copyright 2015 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 "media/base/android/media_codec_player.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 920 matching lines @@
   // Configuration should propagate through the player and to the manager.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsMetadataChanged,
                                   base::Unretained(&manager_))));
 
   EXPECT_EQ(duration, manager_.media_metadata_.duration);
   EXPECT_EQ(320, manager_.media_metadata_.width);
   EXPECT_EQ(240, manager_.media_metadata_.height);
 }
 
-TEST_F(MediaCodecPlayerTest, AudioPlayTillCompletion) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AudioPlayTillCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(2000);
 
   demuxer_->SetAudioFactory(
       scoped_ptr<AudioFactory>(new AudioFactory(duration)));
 
   CreatePlayer();
 
@@ skipping 94 matching lines @@
   player_->Start();
 
   // Playback should not start.
   EXPECT_FALSE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        start_timeout));
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, AudioSeekAfterStop) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekAfterStop) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then Pause, then Seek to beginning. The playback should
   // start from the beginning.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
   demuxer_->SetAudioFactory(
       scoped_ptr<AudioFactory>(new AudioFactory(duration)));
 
@@ skipping 38 matching lines @@
                                   base::Unretained(&manager_))));
 
   // Make sure we started from the beginninig
   EXPECT_GT(base::TimeDelta::FromMilliseconds(40), manager_.pts_stat_.min());
 
   // The player should have reported the seek completion to the manager.
   EXPECT_TRUE(WaitForCondition(base::Bind(
       &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
-TEST_F(MediaCodecPlayerTest, AudioSeekThenPlay) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekThenPlay) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start. The playback should
   // start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
 
   demuxer_->SetAudioFactory(
       scoped_ptr<AudioFactory>(new AudioFactory(duration)));
@@ skipping 13 matching lines @@
                                   base::Unretained(&manager_))));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 
   // The player should have reported the seek completion to the manager.
   EXPECT_TRUE(WaitForCondition(base::Bind(
       &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
-TEST_F(MediaCodecPlayerTest, AudioSeekThenPlayThenConfig) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekThenPlayThenConfig) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Issue Seek command immediately followed by Start but without prior demuxer
   // configuration. Start should wait for configuration. After it has been
   // posted the playback should start at the seek position.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(500);
 
   demuxer_->SetAudioFactory(
@@ skipping 19 matching lines @@
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 
   // The player should have reported the seek completion to the manager.
   EXPECT_TRUE(WaitForCondition(base::Bind(
       &MockMediaPlayerManager::IsSeekCompleted, base::Unretained(&manager_))));
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, AudioSeekWhilePlaying) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AudioSeekWhilePlaying) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Play for 300 ms, then issue several Seek commands in the row.
   // The playback should continue at the last seek position.
 
   // To test this condition without analyzing the reported time details
   // and without introducing dependency on implementation I make a long (10s)
   // duration and test that the playback resumes after big time jump (5s) in a
   // short period of time (200 ms).
   base::TimeDelta duration = base::TimeDelta::FromSeconds(10);
@@ skipping 58 matching lines @@
                  base::Unretained(demuxer_))));
 
   // Playback should continue with a new surface. Wait till completion.
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_)),
                        timeout));
   EXPECT_LE(duration, manager_.pts_stat_.max());
 }
 
-TEST_F(MediaCodecPlayerTest, VideoRemoveAndSetSurface) {
+TEST_F(MediaCodecPlayerTest, DISABLED_VideoRemoveAndSetSurface) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
 
   ASSERT_TRUE(StartVideoPlayback(duration, "VideoRemoveAndSetSurface"));
 
   // Wait for some time and check statistics.
   WaitForDelay(base::TimeDelta::FromMilliseconds(200));
 
   // Make sure we played at least 100 ms.
@@ skipping 29 matching lines @@
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        reconfigure_timeout));
 
   // Timestamps should not go back.
   EXPECT_LE(max_pts_before_removal, manager_.pts_stat_.max());
 }
 
 // http://crbug.com/518900
-TEST_F(MediaCodecPlayerTest, VideoReleaseAndStart) {
+TEST_F(MediaCodecPlayerTest, DISABLED_VideoReleaseAndStart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1000);
 
   ASSERT_TRUE(StartVideoPlayback(duration, "VideoReleaseAndStart"));
 
   // Wait for some time and check statistics.
   WaitForDelay(base::TimeDelta::FromMilliseconds(200));
 
   // Make sure we played at least 100 ms.
@@ skipping 27 matching lines @@
   base::TimeDelta reconfigure_timeout = base::TimeDelta::FromMilliseconds(800);
   EXPECT_TRUE(
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackStarted,
                                   base::Unretained(&manager_)),
                        reconfigure_timeout));
 
   // Timestamps should not go back.
   EXPECT_LE(max_pts_before_backgrounding, manager_.pts_stat_.max());
 }
 
-TEST_F(MediaCodecPlayerTest, VideoSeekAndRelease) {
+TEST_F(MediaCodecPlayerTest, DISABLED_VideoSeekAndRelease) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
 
   ASSERT_TRUE(StartVideoPlayback(duration, "VideoSeekAndRelease"));
 
   // Wait for some time and check statistics.
   WaitForDelay(base::TimeDelta::FromMilliseconds(200));
 
@@ skipping 142 matching lines @@
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_))));
 
   // The first pts should be equal than seek position even if video frames
   // started 100 ms eralier than the seek request.
   EXPECT_EQ(seek_position, manager_.pts_stat_.min());
 
   EXPECT_EQ(6, manager_.pts_stat_.num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollAudioWaitsForVideo) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollAudioWaitsForVideo) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that during prerolling neither audio nor video plays and that both
   // resume simultaneously after preroll is finished. In other words, test
   // that preroll works.
   // We put the video into the long preroll and intercept the time when first
   // rendering happens in each stream. The moment of rendering is approximated
   // with a decoder PTS that is delivered by a test-only callback.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
@@ skipping 30 matching lines @@
   EXPECT_TRUE(AlmostEqual(manager_.FirstFramePTS(DemuxerStream::AUDIO),
                           manager_.FirstFramePTS(DemuxerStream::VIDEO), 25));
 
   EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
                           manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollReleaseAndRestart) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollReleaseAndRestart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that player will resume prerolling if prerolling is interrupted by
   // Release() and Start().
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(2000);
 
   // Set significant preroll interval. 500 ms means 25 frames, at 10 ms
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
@@ skipping 53 matching lines @@
                           manager_.FirstFramePTS(DemuxerStream::VIDEO), 50));
 
   EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
                           manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|, but Release() might discard
   // the first audio frame.
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 50));
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollStopAndRestart) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollStopAndRestart) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that if Pause() happens during the preroll phase,
   // we continue to do preroll after restart.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
 
   // Set significant preroll interval. 500 ms means 25 frames, at 10 ms
   // per frame it would take 250 ms to preroll.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
@@ skipping 71 matching lines @@
   EXPECT_TRUE(AlmostEqual(manager_.FirstFramePTS(DemuxerStream::AUDIO),
                           manager_.FirstFramePTS(DemuxerStream::VIDEO), 25));
 
   EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
                           manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollVideoEndsWhilePrerolling) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollVideoEndsWhilePrerolling) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that when one stream ends in the preroll phase and another is not
   // the preroll finishes and playback continues after it.
 
   // http://crbug.com/526755
   // TODO(timav): remove these logs after verifying that the bug is fixed.
   DVLOG(0) << "AVPrerollVideoEndsWhilePrerolling: begin";
 
   base::TimeDelta audio_duration = base::TimeDelta::FromMilliseconds(1100);
@@ skipping 64 matching lines @@
       WaitForCondition(base::Bind(&MockMediaPlayerManager::IsPlaybackCompleted,
                                   base::Unretained(&manager_))));
 
   // There should not be any video frames.
   EXPECT_FALSE(manager_.HasFirstFrame(DemuxerStream::VIDEO));
 
   // http://crbug.com/526755
   DVLOG(0) << "AVPrerollVideoEndsWhilePrerolling: end";
 }
 
-TEST_F(MediaCodecPlayerTest, VideoConfigChangeWhilePlaying) {
+TEST_F(MediaCodecPlayerTest, DISABLED_VideoConfigChangeWhilePlaying) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that video only playback continues after video config change.
 
   // Initialize video playback
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta start_timeout = base::TimeDelta::FromMilliseconds(2000);
@@ skipping 96 matching lines @@
 
   // Check that we did not miss audio frames. We expect one postponed frames
   // that are not reported.
   // For Nexus 4 KitKat the AAC decoder seems to swallow the first frame
   // but reports the last pts twice, maybe it just shifts the reported PTS.
   int expected_audio_frames = GetFrameCount(duration, kAudioFramePeriod, 0) - 1;
   EXPECT_EQ(expected_audio_frames,
             manager_.render_stat_[DemuxerStream::AUDIO].num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVAudioConfigChangeWhilePlaying) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVAudioConfigChangeWhilePlaying) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that A/V playback continues after audio config change.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
@@ skipping 23 matching lines @@
   EXPECT_EQ(expected_video_frames,
             manager_.render_stat_[DemuxerStream::VIDEO].num_values());
 
   // Check that we did not miss audio frames. We expect two postponed frames
   // that are not reported.
   int expected_audio_frames = GetFrameCount(duration, kAudioFramePeriod, 1) - 2;
   EXPECT_EQ(expected_audio_frames,
             manager_.render_stat_[DemuxerStream::AUDIO].num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVSimultaneousConfigChange_1) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVSimultaneousConfigChange_1) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the playback continues if audio and video config changes happen
   // at the same time.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
@@ skipping 26 matching lines @@
   EXPECT_EQ(expected_video_frames,
             manager_.render_stat_[DemuxerStream::VIDEO].num_values());
 
   // Check that we did not miss audio frames. We expect two postponed frames
   // that are not reported.
   int expected_audio_frames = GetFrameCount(duration, kAudioFramePeriod, 1) - 2;
   EXPECT_EQ(expected_audio_frames,
             manager_.render_stat_[DemuxerStream::AUDIO].num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVSimultaneousConfigChange_2) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVSimultaneousConfigChange_2) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that the playback continues if audio and video config changes happen
   // at the same time. Move audio change moment slightly to make it drained
   // after video.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_audio = base::TimeDelta::FromMilliseconds(1020);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(expected_video_frames,
             manager_.render_stat_[DemuxerStream::VIDEO].num_values());
 
   // Check that we did not miss audio frames. We expect two postponed frames
   // that are not reported.
   int expected_audio_frames = GetFrameCount(duration, kAudioFramePeriod, 1) - 2;
   EXPECT_EQ(expected_audio_frames,
             manager_.render_stat_[DemuxerStream::AUDIO].num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVAudioEndsAcrossVideoConfigChange) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVAudioEndsAcrossVideoConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that audio can end while video config change processing.
 
   base::TimeDelta audio_duration = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta video_duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta config_change_video = base::TimeDelta::FromMilliseconds(1000);
 
   base::TimeDelta completion_timeout = base::TimeDelta::FromMilliseconds(3000);
 
@@ skipping 68 matching lines @@
   EXPECT_EQ(1, manager_.num_video_codecs_created());
 
   // Check that we did not miss audio frames. We expect two postponed frames
   // that are not reported.
   int expected_audio_frames =
       GetFrameCount(audio_duration, kAudioFramePeriod, 1) - 2;
   EXPECT_EQ(expected_audio_frames,
             manager_.render_stat_[DemuxerStream::AUDIO].num_values());
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollAcrossVideoConfigChange) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollAcrossVideoConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that preroll continues if interrupted by video config change.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta video_preroll_intvl = base::TimeDelta::FromMilliseconds(500);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
@@ skipping 28 matching lines @@
   EXPECT_TRUE(AlmostEqual(manager_.FirstFramePTS(DemuxerStream::AUDIO),
                           manager_.FirstFramePTS(DemuxerStream::VIDEO), 25));
 
   EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
                           manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
-TEST_F(MediaCodecPlayerTest, AVPrerollAcrossAudioConfigChange) {
+TEST_F(MediaCodecPlayerTest, DISABLED_AVPrerollAcrossAudioConfigChange) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that preroll continues if interrupted by video config change.
 
   base::TimeDelta duration = base::TimeDelta::FromMilliseconds(1200);
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta config_change_position =
       base::TimeDelta::FromMilliseconds(800);
   base::TimeDelta audio_preroll_intvl = base::TimeDelta::FromMilliseconds(400);
   base::TimeDelta preroll_timeout = base::TimeDelta::FromMilliseconds(3000);
@@ skipping 37 matching lines @@
   // TODO(timav): maybe we should not call the testing callback for
   // kRenderAfterPreroll for video (for audio we already do not call).
   // EXPECT_TRUE(AlmostEqual(manager_.FirstFrameTime(DemuxerStream::AUDIO),
   //                        manager_.FirstFrameTime(DemuxerStream::VIDEO), 50));
 
   // The playback should start at |seek_position|
   EXPECT_TRUE(AlmostEqual(seek_position, manager_.pts_stat_.min(), 25));
 }
 
 }  // namespace media