Introduce base::TestSuite::DisableTests().

media/base/android/media_codec_bridge_unittest.cc

 // Copyright (c) 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 "media/base/android/media_codec_bridge.h"
@@ skipping 114 matching lines @@
     if (status == MEDIA_CODEC_OK && output_buf_index > 0)
       media_codec->ReleaseOutputBuffer(output_buf_index, false);
     // Output time stamp should not be smaller than old timestamp.
     ASSERT_TRUE(new_timestamp >= timestamp);
     input_pts += base::TimeDelta::FromMicroseconds(33000);
     timestamp = new_timestamp;
   }
 }
 
 TEST(MediaCodecBridgeTest, Initialize) {
-  if (!MediaCodecBridge::IsAvailable())
-    return;
-
   scoped_ptr<media::MediaCodecBridge> media_codec;
   media_codec.reset(VideoCodecBridge::Create(kCodecH264, false));
 }
 
 TEST(MediaCodecBridgeTest, DoNormal) {
-  if (!MediaCodecBridge::IsAvailable())
-    return;
-
   scoped_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecMP3));
 
   media_codec->Start(kCodecMP3, 44100, 2, NULL, 0, false, NULL);
 
   int input_buf_index = -1;
   MediaCodecStatus status =
       media_codec->DequeueInputBuffer(InfiniteTimeOut(), &input_buf_index);
   ASSERT_EQ(MEDIA_CODEC_OK, status);
   ASSERT_GE(input_buf_index, 0);
@@ skipping 38 matching lines @@
     ASSERT_GE(output_buf_index, 0);
     EXPECT_LE(1u, size);
     if (!eos)
       EXPECT_EQ(++input_pts, timestamp.InMicroseconds());
     ASSERT_LE(input_pts, kPresentationTimeBase + 2);
   }
   ASSERT_EQ(input_pts, kPresentationTimeBase + 2);
 }
 
 TEST(MediaCodecBridgeTest, InvalidVorbisHeader) {
-  if (!MediaCodecBridge::IsAvailable())
-    return;
-
   scoped_ptr<media::AudioCodecBridge> media_codec;
   media_codec.reset(AudioCodecBridge::Create(kCodecVorbis));
 
   // The first byte of the header is not 0x02.
   uint8 invalid_first_byte[] = { 0x00, 0xff, 0xff, 0xff, 0xff };
   EXPECT_FALSE(media_codec->Start(
       kCodecVorbis, 44100, 2, invalid_first_byte, sizeof(invalid_first_byte),
       false, NULL));
 
   // Size of the header does not match with the data we passed in.
   uint8 invalid_size[] = { 0x02, 0x01, 0xff, 0x01, 0xff };
   EXPECT_FALSE(media_codec->Start(
       kCodecVorbis, 44100, 2, invalid_size, sizeof(invalid_size), false, NULL));
 
   // Size of the header is too large.
   size_t large_size = 8 * 1024 * 1024 + 2;
   uint8* very_large_header = new uint8[large_size];
   very_large_header[0] = 0x02;
   for (size_t i = 1; i < large_size - 1; ++i)
     very_large_header[i] = 0xff;
   very_large_header[large_size - 1] = 0xfe;
   EXPECT_FALSE(media_codec->Start(
       kCodecVorbis, 44100, 2, very_large_header, 0x80000000, false, NULL));
   delete[] very_large_header;
 }
 
 TEST(MediaCodecBridgeTest, PresentationTimestampsDoNotDecrease) {
-  if (!MediaCodecBridge::IsAvailable())
-    return;
-
   scoped_ptr<VideoCodecBridge> media_codec;
   media_codec.reset(VideoCodecBridge::Create(kCodecVP8, false));
   EXPECT_TRUE(media_codec->Start(
       kCodecVP8, gfx::Size(320, 240), NULL, NULL));
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("vp8-I-frame-320x240");
   DecodeMediaFrame(
       media_codec.get(), buffer->data(), buffer->data_size(),
       base::TimeDelta(), base::TimeDelta());
 
@@ skipping 13 matching lines @@
                    base::TimeDelta::FromMicroseconds(5000000),
                    base::TimeDelta::FromMicroseconds(4900000));
 }
 
 TEST(MediaCodecBridgeTest, CreateUnsupportedCodec) {
   EXPECT_EQ(NULL, AudioCodecBridge::Create(kUnknownAudioCodec));
   EXPECT_EQ(NULL, VideoCodecBridge::Create(kUnknownVideoCodec, false));
 }
 
 }  // namespace media