Disable various MediaSourcePlayerTests on unsupported devices

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 "media/base/android/media_source_player.h"
 
 #include <stdint.h>
 
 #include <string>
 #include <utility>
@@ skipping 872 matching lines @@
   configs.audio_extra_data.insert(configs.audio_extra_data.begin(),
                                  invalid_codec_data, invalid_codec_data + 4);
   Start(configs);
 
   // Decoder is not created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_FALSE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test video codec will not be created until data is received.
   StartVideoDecoderJob();
 
   // Set both an initial and a later video surface without receiving any
   // demuxed data yet.
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaCodecBridge(false));
   CreateNextTextureAndSetVideoSurface();
   EXPECT_FALSE(GetMediaCodecBridge(false));
@@ skipping 31 matching lines @@
 
 TEST_F(MediaSourcePlayerTest, ReadFromDemuxerAfterSeek) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test decoder job will resend a ReadFromDemuxer request after seek.
   StartAudioDecoderJob();
   SeekPlayerWithAbort(true, base::TimeDelta());
 }
 
 TEST_F(MediaSourcePlayerTest, SetSurfaceWhileSeeking) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test SetVideoSurface() will not cause an extra seek while the player is
   // waiting for demuxer to indicate seek is done.
   player_.OnDemuxerConfigsAvailable(
       CreateVideoDemuxerConfigs(false));
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
@@ skipping 10 matching lines @@
   EXPECT_TRUE(GetMediaCodecBridge(false));
 
   // Reconfirm exactly 1 seek request has been made of demuxer, and that it
   // was not a browser seek request.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, ChangeMultipleSurfaceWhileDecoding) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test MediaSourcePlayer can switch multiple surfaces during decoding.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
 
   // While the decoder is decoding, change multiple surfaces. Pass an empty
@@ skipping 20 matching lines @@
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(false));
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, SetEmptySurfaceAndStarveWhileDecoding) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test player pauses if an empty surface is passed.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
 
   // While the decoder is decoding, pass an empty surface.
@@ skipping 14 matching lines @@
 
   // Playback resumes once a non-empty surface is passed.
   CreateNextTextureAndSetVideoSurface();
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
   while(demuxer_->num_browser_seek_requests() != 1)
     message_loop_.RunUntilIdle();
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, ReleaseVideoDecoderResourcesWhileDecoding) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that if video decoder is released while decoding, the resources will
   // not be immediately released.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   ReleasePlayer();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
 
   // Recreate the video decoder.
   CreateNextTextureAndSetVideoSurface();
@@ skipping 29 matching lines @@
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   // Decoder is created after data is received.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   EXPECT_TRUE(GetMediaCodecBridge(true));
 }
 
 TEST_F(MediaSourcePlayerTest, VideoOnlyStartAfterSeekFinish) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test video decoder job will not start until pending seek event is handled.
   CreateNextTextureAndSetVideoSurface();
   DemuxerConfigs configs = CreateVideoDemuxerConfigs(false);
   player_.OnDemuxerConfigsAvailable(configs);
 
   // Initiate a seek. Skip requesting element seek of renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
@@ skipping 41 matching lines @@
   EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
 
   while (GetMediaDecoderJob(true)->is_decoding())
     message_loop_.RunUntilIdle();
   // The decoder job should finish and wait for data.
   EXPECT_EQ(2, demuxer_->num_data_requests());
   EXPECT_TRUE(IsRequestingDemuxerData(true));
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that when Start() is called, video decoder job will wait for audio
   // decoder job before start decoding the data.
   CreateNextTextureAndSetVideoSurface();
   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());
@@ skipping 32 matching lines @@
   // Send new data to the decoder so it can finish prefetching. This should
   // reset the start time ticks.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(3));
   EXPECT_TRUE(StartTimeTicks() != previous);
 
   base::TimeTicks current = StartTimeTicks();
   EXPECT_LE(0, (current - previous).InMillisecondsF());
 }
 
 TEST_F(MediaSourcePlayerTest, V_SecondAccessUnitIsEOSAndResumePlayAfterSeek) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test MediaSourcePlayer can replay video after input EOS is reached.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
 
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   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, false));
   VerifyPlaybackCompletesOnEOSDecode(true, true);
   VerifyCompletedPlaybackResumesOnSeekPlusStart(true, false);
 }
 
 TEST_F(MediaSourcePlayerTest, V_FirstAccessUnitAfterSeekIsEOS) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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();
   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, false));
   SeekPlayerWithAbort(true, base::TimeDelta());
   VerifyPlaybackCompletesOnEOSDecode(true, true);
 }
 
 TEST_F(MediaSourcePlayerTest, AV_PlaybackCompletionAcrossConfigChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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());
 
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
   DemuxerConfigs configs = CreateVideoDemuxerConfigs(true);
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
       false, 0, configs));  // Video |kConfigChanged| as first unit.
 
   WaitForAudioVideoDecodeDone();
 
   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();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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());
 
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
   // Audio |kConfigChanged| as first unit.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, CreateAudioDemuxerConfigs(kCodecVorbis, false)));
 
   WaitForAudioVideoDecodeDone();
 
   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();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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());
 
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
@@ skipping 16 matching lines @@
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
   EXPECT_FALSE(GetMediaDecoderJob(false)->is_decoding());
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
 
   // Simulate another decoder underrun to trigger prefetch while decoding EOS.
   TriggerPlayerStarvation();
   VerifyPlaybackCompletesOnEOSDecode(false, true /* ignored */);
 }
 
 TEST_F(MediaSourcePlayerTest, V_StarvationDuringEOSDecode) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that video-only playback completes without further data requested when
   // starvation occurs during EOS decode.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   WaitForVideoDecodeDone();
 
   // Simulate decoder underrun to trigger prefetch while decoding EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));  // Video EOS
@@ skipping 12 matching lines @@
   WaitForAudioDecodeDone();
 
   // Simulate decoder underrun to trigger prefetch while decoding EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(true));  // Audio EOS
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   TriggerPlayerStarvation();
   VerifyPlaybackCompletesOnEOSDecode(false, true /* ignored */);
 }
 
 TEST_F(MediaSourcePlayerTest, AV_SeekDuringEOSDecodePreventsCompletion) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that seek supercedes audio+video playback completion on simultaneous
   // audio and video EOS decode, if SeekTo() occurs during these EOS decodes.
   VerifySeekDuringEOSDecodePreventsPlaybackCompletion(true, true, true, true);
 }
 
 TEST_F(MediaSourcePlayerTest, AV_SeekDuringAudioEOSDecodePreventsCompletion) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that seek supercedes audio+video playback completion on simultaneous
   // audio EOS and video non-EOS decode, if SeekTo() occurs during these
   // decodes.
   VerifySeekDuringEOSDecodePreventsPlaybackCompletion(true, true, true, false);
 }
 
 TEST_F(MediaSourcePlayerTest, AV_SeekDuringVideoEOSDecodePreventsCompletion) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that seek supercedes audio+video playback completion on simultaneous
   // audio non-EOS and video EOS decode, if SeekTo() occurs during these
   // decodes.
   VerifySeekDuringEOSDecodePreventsPlaybackCompletion(true, true, false, true);
 }
 
 TEST_F(MediaSourcePlayerTest, V_SeekDuringEOSDecodePreventsCompletion) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that seek supercedes video-only playback completion on EOS decode, if
   // SeekTo() occurs during EOS decode.
   VerifySeekDuringEOSDecodePreventsPlaybackCompletion(false, true, false, true);
 }
 
 TEST_F(MediaSourcePlayerTest, A_SeekDuringEOSDecodePreventsCompletion) {
   SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
 
   // Test that seek supercedes audio-only playback completion on EOS decode, if
@@ skipping 34 matching lines @@
   EXPECT_FALSE(player_.IsPlaying());
 
   // No further data should have been requested.
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // No seek requests should have occurred.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_RegularSeekPendsBrowserSeekDone) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that a browser seek, once started, delays a newly arrived regular
   // SeekTo() request's demuxer seek until the browser seek is done.
   BrowserSeekPlayer(false);
 
   // Simulate renderer requesting a regular seek while browser seek in progress.
   player_.SeekTo(base::TimeDelta());
 
   // Simulate browser seek is done. Confirm player requests the regular seek,
   // still has no video codec configured, and has not requested any
   // further data since the surface change event became pending in
   // BrowserSeekPlayer().
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
   EXPECT_EQ(1, demuxer_->num_browser_seek_requests());
 
   // Simulate regular seek is done and confirm player requests more data for
   // new video codec.
   player_.OnDemuxerSeekDone(kNoTimestamp());
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(2, demuxer_->num_seek_requests());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(false));
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_InitialReleaseAndStart) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that no browser seek is requested if player Release() + Start() occurs
   // prior to receiving any data.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   ReleasePlayer();
 
   // Pass a new non-empty surface.
   CreateNextTextureAndSetVideoSurface();
 
   player_.Start();
 
   // No data request is issued since there is still one pending.
   EXPECT_EQ(1, demuxer_->num_data_requests());
   EXPECT_FALSE(GetMediaCodecBridge(false));
 
   // No browser seek is needed.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_EQ(0, demuxer_->num_browser_seek_requests());
   EXPECT_EQ(2, demuxer_->num_data_requests());
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_MidStreamReleaseAndStart) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that one browser seek is requested if player Release() + Start(), with
   // video data received between Release() and Start().
   BrowserSeekPlayer(true);
 
   // Simulate browser seek is done and confirm player requests more data.
   player_.OnDemuxerSeekDone(base::TimeDelta());
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, NoBrowserSeekWithKeyFrameInCache) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that browser seek is not needed if a key frame is found in data
   // cache.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   DemuxerData data = CreateReadFromDemuxerAckForVideo(false);
   data.access_units[0].is_key_frame = true;
 
   // Simulate demuxer's response to the video data request.
   player_.OnDemuxerDataAvailable(data);
@@ skipping 19 matching lines @@
   // Test decoder job will preroll the media to the seek position.
   StartAudioDecoderJob();
 
   SeekPlayerWithAbort(true, base::TimeDelta::FromMilliseconds(100));
   EXPECT_TRUE(IsPrerolling(true));
   PrerollDecoderToTime(
       true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), true);
 }
 
 TEST_F(MediaSourcePlayerTest, PrerollVideoAfterSeek) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test decoder job will preroll the media to the seek position.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
 
   SeekPlayerWithAbort(false, base::TimeDelta::FromMilliseconds(100));
   EXPECT_TRUE(IsPrerolling(false));
   PrerollDecoderToTime(
       false, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), true);
 }
@@ skipping 123 matching lines @@
   // In response to data request, simulate that demuxer signals config change by
   // sending an AU with |kConfigChanged|.
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   PrerollDecoderToTime(
       true, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), true);
 }
 
 TEST_F(MediaSourcePlayerTest, AudioPrerollFinishesBeforeVideo) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that after audio finishes prerolling, it will wait for video to finish
   // prerolling before advancing together.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs());
 
   // Initiate a seek.
   base::TimeDelta seek_position = base::TimeDelta::FromMilliseconds(100);
   player_.SeekTo(seek_position);
   player_.OnDemuxerDataAvailable(CreateAbortedAck(true));
@@ skipping 31 matching lines @@
   EXPECT_FALSE(IsPrerolling(false));
 
   // Both audio and video decoders should start decoding again.
   player_.OnDemuxerDataAvailable(audio_data);
   player_.OnDemuxerDataAvailable(video_data);
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   EXPECT_TRUE(GetMediaDecoderJob(false)->is_decoding());
 }
 
 TEST_F(MediaSourcePlayerTest, SimultaneousAudioVideoConfigChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_TRUE(GetMediaCodecBridge(true));
   EXPECT_TRUE(GetMediaCodecBridge(false));
@@ skipping 20 matching lines @@
   EXPECT_TRUE(IsDrainingDecoder(true));
   EXPECT_TRUE(IsDrainingDecoder(false));
 
   // Waiting for decoder to finish draining.
   while (IsDrainingDecoder(true) || IsDrainingDecoder(false))
     message_loop_.RunUntilIdle();
 }
 
 TEST_F(MediaSourcePlayerTest,
        SimultaneousAudioVideoConfigChangeWithAdaptivePlayback) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that the player allows simultaneous audio and video config change with
   // adaptive video playback enabled.
   CreateNextTextureAndSetVideoSurface();
   Start(CreateAudioVideoDemuxerConfigs());
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo(false));
   EXPECT_EQ(4, demuxer_->num_data_requests());
   EXPECT_TRUE(GetMediaCodecBridge(true));
   EXPECT_TRUE(GetMediaCodecBridge(false));
@@ skipping 63 matching lines @@
 
   // Test that the player detects need for and requests demuxer configs if
   // the |kConfigChanged| unit is not the first unit in the set of units
   // received in OnDemuxerDataAvailable() from data requested ostensibly while
   // not prefetching.
   StartConfigChange(true, false, 1, false);
   WaitForAudioDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_PrerollAfterBrowserSeek) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test decoder job will preroll the media to the actual seek position
   // resulting from a browser seek.
   BrowserSeekPlayer(false);
 
   // Simulate browser seek is done, but to a later time than was requested.
   EXPECT_LT(player_.GetCurrentTime().InMillisecondsF(), 100);
   player_.OnDemuxerSeekDone(base::TimeDelta::FromMilliseconds(100));
   // Because next AU is not I-frame, MediaCodecBridge will not be recreated.
   EXPECT_FALSE(GetMediaCodecBridge(false));
   EXPECT_EQ(100.0, player_.GetCurrentTime().InMillisecondsF());
   EXPECT_EQ(100.0, GetPrerollTimestamp().InMillisecondsF());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 
   PrerollDecoderToTime(
       false, base::TimeDelta(), base::TimeDelta::FromMilliseconds(100), true);
 }
 
 TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that video config change notification results in creating a new
   // video codec without any browser seek.
   StartConfigChange(false, true, 1, false);
 
   // New video codec should have been created and configured, without any
   // browser seek.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
   WaitForVideoDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, VideoDemuxerConfigChangeWithAdaptivePlayback) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that if codec supports adaptive playback, no new codec should be
   // created beyond the one used to decode the prefetch media data prior to
   // the kConfigChanged.
   StartConfigChange(false, true, 1, true);
 
   // No browser seek should be needed.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
@@ skipping 32 matching lines @@
 
   EXPECT_FALSE(GetMediaCodecBridge(true));
   EXPECT_FALSE(player_.IsPlaying());
 
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
   EXPECT_EQ(3, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderDrainInterruptedBySurfaceChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test if a video decoder is being drained while surface changes, draining
   // is canceled.
   SendConfigChangeToDecoder(false, false, 0, false);
   EXPECT_TRUE(IsDrainingDecoder(false));
 
   CreateNextTextureAndSetVideoSurface();
   WaitForVideoDecodeDone();
 
   EXPECT_FALSE(IsDrainingDecoder(false));
   EXPECT_TRUE(player_.IsPlaying());
 
   // The frame after the config change should always be an iframe, so no browser
   // seek is needed when recreating the video decoder due to surface change.
   EXPECT_TRUE(GetMediaCodecBridge(false));
   EXPECT_EQ(4, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest,
        BrowserSeek_DecoderStarvationWhilePendingSurfaceChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test video decoder starvation while handling a pending surface change
   // should not cause any crashes.
   CreateNextTextureAndSetVideoSurface();
   StartVideoDecoderJob();
   DemuxerData data = CreateReadFromDemuxerAckForVideo(false);
   player_.OnDemuxerDataAvailable(data);
 
   // Trigger a surface change and decoder starvation.
   CreateNextTextureAndSetVideoSurface();
@@ skipping 188 matching lines @@
 
   // Player should resume upon Start(), even without further configs supplied.
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
   EXPECT_EQ(3, demuxer_->num_data_requests());
   EXPECT_EQ(0, demuxer_->num_seek_requests());
   WaitForAudioDecodeDone();
 }
 
 TEST_F(MediaSourcePlayerTest, BrowserSeek_ThenReleaseThenDemuxerSeekDone) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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(GetMediaCodecBridge(false));
   EXPECT_EQ(expected_preroll_timestamp, GetPrerollTimestamp());
 
   // Player should begin prefetch and resume preroll upon Start().
   EXPECT_EQ(2, demuxer_->num_data_requests());
   CreateNextTextureAndSetVideoSurface();
   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();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // 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();
 
@@ skipping 65 matching lines @@
 
   DemuxerConfigs configs = CreateAudioDemuxerConfigs(kCodecVorbis, true);
   DemuxerData data = CreateReadFromDemuxerAckWithConfigChanged(
       true, 0, configs);
   player_.OnDemuxerDataAvailable(data);
   WaitForAudioDecodeDone();
   DecodeAudioDataUntilOutputBecomesAvailable();
 }
 
 TEST_F(MediaSourcePlayerTest, VideoMetadataChangeAfterConfigChange) {
-  SKIP_TEST_IF_MEDIA_CODEC_BRIDGE_IS_NOT_AVAILABLE();
+  // crbug.com/604602 and crbug.com/597836
+  SKIP_TEST_IF_VP8_DECODER_IS_NOT_SUPPORTED();
 
   // Test that after a config change, metadata change will be happen
   // after decoder is drained.
   StartConfigChange(false, true, 2, false);
   EXPECT_EQ(1, manager_.num_metadata_changes());
   EXPECT_FALSE(IsDrainingDecoder(false));
 
   // Create video data with new resolutions.
   DemuxerData data = CreateReadFromDemuxerAckForVideo(true);
 
@@ skipping 44 matching lines @@
 
   EXPECT_EQ(demuxer_->num_data_requests(), 0);
   player_.OnDemuxerConfigsAvailable(CreateDemuxerConfigs(true, true));
 
   manager_.set_allow_play(true);
   player_.Start();
   EXPECT_TRUE(player_.IsPlaying());
 }
 
 }  // namespace media