Introduce base::TestSuite::DisableTests().

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/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/android/media_codec_bridge.h"
@@ skipping 224 matching lines @@
     return;
   }
 
   // Test audio decoder job will be created when codec is successfully started.
   StartAudioDecoderJob();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartAudioDecoderWithInvalidConfig) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test audio decoder job will not be created when failed to start the codec.
   DemuxerConfigs configs;
   configs.audio_codec = kCodecVorbis;
   configs.audio_channels = 2;
   configs.audio_sampling_rate = 44100;
   configs.is_audio_encrypted = false;
   configs.duration_ms = kDefaultDurationInMs;
   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);
   EXPECT_EQ(NULL, GetMediaDecoderJob(true));
   EXPECT_EQ(0, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithValidSurface) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test video decoder job will be created when surface is valid.
   StartVideoDecoderJob();
   // Video decoder job will not be created until surface is available.
   EXPECT_EQ(NULL, GetMediaDecoderJob(false));
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   CreateAndSetVideoSurface();
 
   // Player should not seek the demuxer on setting initial surface.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   // The decoder job should be ready now.
   EXPECT_TRUE(NULL != GetMediaDecoderJob(false));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartVideoCodecWithInvalidSurface) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test video decoder job will be created when surface is valid.
   scoped_refptr<gfx::SurfaceTexture> surface_texture(
       new gfx::SurfaceTexture(0));
   gfx::ScopedJavaSurface surface(surface_texture.get());
   StartVideoDecoderJob();
   // Video decoder job will not be created until surface is available.
   EXPECT_EQ(NULL, GetMediaDecoderJob(false));
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   // 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_EQ(NULL, GetMediaDecoderJob(false));
   EXPECT_EQ(0, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ReadFromDemuxerAfterSeek) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test decoder job will resend a ReadFromDemuxer request after seek.
   StartAudioDecoderJob();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Initiate a seek. Skip the round-trip of requesting seek from renderer.
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
 
   // Verify that the seek does not occur until the initial prefetch
@@ skipping 15 matching lines @@
   // Sending back the seek done notification. This should trigger the player to
   // call OnReadFromDemuxer() again.
   player_.OnDemuxerSeekDone();
   EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, SetSurfaceWhileSeeking) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test SetVideoSurface() will not cause an extra seek while the player is
   // waiting for demuxer to indicate seek is done.
   StartVideoDecoderJob();
   // Player is still waiting for SetVideoSurface(), so no request is sent.
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   // Initiate a seek. Skip the round-trip of requesting seek from 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());
 
   CreateAndSetVideoSurface();
   EXPECT_TRUE(NULL == GetMediaDecoderJob(false));
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 
   // Reconfirm player has not yet requested data.
   EXPECT_EQ(0, demuxer_->num_data_requests());
 
   // Send the seek done notification. The player should start requesting data.
   player_.OnDemuxerSeekDone();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(false));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ChangeMultipleSurfaceWhileDecoding) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test MediaSourcePlayer can switch multiple surfaces during decoding.
   CreateAndSetVideoSurface();
   StartVideoDecoderJob();
   EXPECT_EQ(1, demuxer_->num_data_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());
   // Pass a new non-empty surface.
   CreateAndSetVideoSurface();
 
   // Wait for the decoder job to finish decoding.
   while(GetMediaDecoderJob(false)->is_decoding())
     message_loop_.RunUntilIdle();
   // A seek should be initiated to request Iframe.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartAfterSeekFinish) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test decoder job will not start until all pending seek event is handled.
   DemuxerConfigs configs;
   configs.audio_codec = kCodecVorbis;
   configs.audio_channels = 2;
   configs.audio_sampling_rate = 44100;
   configs.is_audio_encrypted = false;
   configs.duration_ms = kDefaultDurationInMs;
   player_.OnDemuxerConfigsAvailable(configs);
   EXPECT_EQ(NULL, GetMediaDecoderJob(true));
   EXPECT_EQ(0, demuxer_->num_data_requests());
@@ skipping 10 matching lines @@
   // Sending back the seek done notification.
   player_.OnDemuxerSeekDone();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Reconfirm exactly 1 seek request has been made of demuxer.
   EXPECT_EQ(1, demuxer_->num_seek_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, StartImmediatelyAfterPause) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test that if the decoding job is not fully stopped after Pause(),
   // calling Start() will be a noop.
   StartAudioDecoderJob();
 
   MediaDecoderJob* decoder_job = GetMediaDecoderJob(true);
   EXPECT_TRUE(NULL != decoder_job);
   EXPECT_EQ(1, demuxer_->num_data_requests());
   EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
 
   // Sending data to player.
@@ skipping 11 matching lines @@
   EXPECT_EQ(decoder_job, GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   message_loop_.Run();
   // The decoder job should finish and a new request will be sent.
   EXPECT_EQ(2, demuxer_->num_data_requests());
   EXPECT_FALSE(GetMediaDecoderJob(true)->is_decoding());
 }
 
 TEST_F(MediaSourcePlayerTest, DecoderJobsCannotStartWithoutAudio) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test that when Start() is called, video decoder jobs will wait for audio
   // decoder job before start decoding the data.
   DemuxerConfigs configs;
   configs.audio_codec = kCodecVorbis;
   configs.audio_channels = 2;
   configs.audio_sampling_rate = 44100;
   configs.is_audio_encrypted = false;
   scoped_refptr<DecoderBuffer> buffer = ReadTestDataFile("vorbis-extradata");
   configs.audio_extra_data = std::vector<uint8>(
       buffer->data(),
@@ skipping 20 matching lines @@
   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());
 }
 
 TEST_F(MediaSourcePlayerTest, StartTimeTicksResetAfterDecoderUnderruns) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test start time ticks will reset after decoder job underruns.
   StartAudioDecoderJob();
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
   EXPECT_EQ(1, demuxer_->num_data_requests());
   // For the first couple chunks, the decoder job may return
   // DECODE_FORMAT_CHANGED status instead of DECODE_SUCCEEDED status. Decode
   // more frames to guarantee that DECODE_SUCCEEDED will be returned.
   for (int i = 0; i < 4; ++i) {
     player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(i));
     EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
@@ skipping 25 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() != base::TimeTicks());
 
   base::TimeTicks current = StartTimeTicks();
   EXPECT_LE(100.0, (current - previous).InMillisecondsF());
 }
 
 TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterInputEOS) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test MediaSourcePlayer will not request for new data after input EOS is
   // reached.
   CreateAndSetVideoSurface();
   StartVideoDecoderJob();
   // Player should not seek the demuxer on setting initial surface.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   EXPECT_EQ(1, demuxer_->num_data_requests());
   // Send the first input chunk.
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForVideo());
   message_loop_.Run();
   EXPECT_EQ(2, demuxer_->num_data_requests());
 
   // Send EOS.
   player_.OnDemuxerDataAvailable(CreateEOSAck(false));
   message_loop_.Run();
   // No more request for data should be made.
   EXPECT_EQ(2, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, ReplayAfterInputEOS) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test MediaSourcePlayer can replay after input EOS is
   // reached.
   CreateAndSetVideoSurface();
   StartVideoDecoderJob();
 
   // Player should not seek the demuxer on setting initial surface.
   EXPECT_EQ(0, demuxer_->num_seek_requests());
 
   EXPECT_EQ(1, demuxer_->num_data_requests());
   // Send the first input chunk.
@@ skipping 11 matching lines @@
   // Instead behave as if the renderer has asked us to seek.
   player_.SeekTo(base::TimeDelta());
   StartVideoDecoderJob();
   EXPECT_EQ(1, demuxer_->num_seek_requests());
   player_.OnDemuxerSeekDone();
   // Seek/Play after EOS should request more data.
   EXPECT_EQ(3, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, NoRequestForDataAfterAbort) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test that the decoder will request new data after receiving an aborted
   // access unit.
   StartAudioDecoderJob();
   EXPECT_EQ(1, demuxer_->num_data_requests());
 
   // Send an aborted access unit.
   DemuxerData data;
   data.type = DemuxerStream::AUDIO;
   data.access_units.resize(1);
   data.access_units[0].status = DemuxerStream::kAborted;
   player_.OnDemuxerDataAvailable(data);
   EXPECT_TRUE(GetMediaDecoderJob(true)->is_decoding());
   // Wait for the decoder job to finish decoding.
   while(GetMediaDecoderJob(true)->is_decoding())
     message_loop_.RunUntilIdle();
 
   // No request will be sent for new data.
   EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 TEST_F(MediaSourcePlayerTest, DemuxerDataArrivesAfterRelease) {
-  if (!MediaCodecBridge::IsAvailable()) {
-    LOG(INFO) << "Could not run test - not supported on device.";
-    return;
-  }
-
   // Test that the decoder should not crash if demuxer data arrives after
   // Release().
   StartAudioDecoderJob();
   EXPECT_TRUE(player_.IsPlaying());
   EXPECT_EQ(1, demuxer_->num_data_requests());
   EXPECT_TRUE(NULL != GetMediaDecoderJob(true));
 
   player_.Release();
   player_.OnDemuxerDataAvailable(CreateReadFromDemuxerAckForAudio(0));
 
   // The decoder job should have been released.
   EXPECT_FALSE(player_.IsPlaying());
   EXPECT_EQ(1, demuxer_->num_data_requests());
 }
 
 // TODO(xhwang): Enable this test when the test devices are updated.
 TEST_F(MediaSourcePlayerTest, DISABLED_IsTypeSupported_Widevine) {
-  if (!MediaCodecBridge::IsAvailable() || !MediaDrmBridge::IsAvailable()) {
+  if (!MediaDrmBridge::IsAvailable()) {
     LOG(INFO) << "Could not run test - not supported on device.";
     return;
   }
 
   uint8 kWidevineUUID[] = { 0xED, 0xEF, 0x8B, 0xA9, 0x79, 0xD6, 0x4A, 0xCE,
                             0xA3, 0xC8, 0x27, 0xDC, 0xD5, 0x1D, 0x21, 0xED };
 
   std::vector<uint8> widevine_uuid(kWidevineUUID,
                                    kWidevineUUID + arraysize(kWidevineUUID));
 
@@ skipping 31 matching lines @@
   // Clean this up after we have a solution to specifying decoding mode.
   EXPECT_TRUE(IsTypeSupported(widevine_uuid, "L3", kAudioWebM, codec_vorbis));
   IsTypeSupported(widevine_uuid, "L1", kAudioWebM, codec_vorbis);
 
   EXPECT_TRUE(
       IsTypeSupported(widevine_uuid, "L3", kVideoWebM, codec_vp8_vorbis));
   IsTypeSupported(widevine_uuid, "L1", kVideoWebM, codec_vp8_vorbis);
 }
 
 TEST_F(MediaSourcePlayerTest, IsTypeSupported_InvalidUUID) {
-  if (!MediaCodecBridge::IsAvailable() || !MediaDrmBridge::IsAvailable()) {
+  if (!MediaDrmBridge::IsAvailable()) {
     LOG(INFO) << "Could not run test - not supported on device.";
     return;
   }
 
   uint8 kInvalidUUID[] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                            0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
 
   std::vector<uint8> invalid_uuid(kInvalidUUID,
                                   kInvalidUUID + arraysize(kInvalidUUID));
 
   std::vector<std::string> codec_avc(1, "avc1");
   EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L3", kVideoMp4, codec_avc));
   EXPECT_FALSE(IsTypeSupported(invalid_uuid, "L1", kVideoMp4, codec_avc));
 }
 
 // TODO(xhwang): Are these IsTypeSupported tests device specific?
 // TODO(xhwang): Add more IsTypeSupported tests.
 // TODO(wolenetz): Add tests around second SetVideoSurface, once fix to reach
 // next I-frame is correct.
 
 }  // namespace media