Revert of Convert USE_PROPRIETARY_CODECS to a buildflag header.

media/filters/audio_decoder_unittest.cc

 // Copyright 2014 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 <stddef.h>
 #include <stdint.h>
 
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 11 matching lines @@
 #include "media/base/audio_hash.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_util.h"
 #include "media/base/test_data_util.h"
 #include "media/base/test_helpers.h"
 #include "media/base/timestamp_constants.h"
 #include "media/ffmpeg/ffmpeg_common.h"
 #include "media/filters/audio_file_reader.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/in_memory_url_protocol.h"
-#include "media/media_features.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/filters/android/media_codec_audio_decoder.h"
 
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(USE_PROPRIETARY_CODECS)
 #include "media/formats/mpeg/adts_stream_parser.h"
 #endif
 
 // Helper macro to skip the test if MediaCodec is not available.
 #define SKIP_TEST_IF_NO_MEDIA_CODEC()                                \
   do {                                                               \
     if (GetParam().decoder_type == MEDIA_CODEC) {                    \
       if (!MediaCodecUtil::IsMediaCodecAvailable()) {                \
         VLOG(0) << "Could not run test - no MediaCodec on device.";  \
         return;                                                      \
@@ skipping 130 matching lines @@
     start_timestamp_ = ConvertFromTimeBase(
         reader_->GetAVStreamForTesting()->time_base, packet.pts);
 
     // Seek back to the beginning.
     ASSERT_TRUE(reader_->SeekForTesting(start_timestamp_));
 
     AudioDecoderConfig config;
     ASSERT_TRUE(AVCodecContextToAudioDecoderConfig(
         reader_->codec_context_for_testing(), Unencrypted(), &config));
 
-#if defined(OS_ANDROID) && BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(OS_ANDROID) && defined(USE_PROPRIETARY_CODECS)
     // MEDIA_CODEC type requires config->extra_data() for AAC codec. For ADTS
     // streams we need to extract it with a separate procedure.
     if (GetParam().decoder_type == MEDIA_CODEC &&
         GetParam().codec == kCodecAAC && config.extra_data().empty()) {
       int sample_rate;
       ChannelLayout channel_layout;
       std::vector<uint8_t> extra_data;
       ASSERT_GT(ADTSStreamParser().ParseFrameHeader(
                     packet.data, packet.size, nullptr, &sample_rate,
                     &channel_layout, nullptr, nullptr, &extra_data),
@@ skipping 250 matching lines @@
   EXPECT_EQ(DecodeStatus::DECODE_ERROR, last_decode_status());
 }
 
 const DecodedBufferExpectations kBearOpusExpectations[] = {
     {500, 3500, "-0.26,0.87,1.36,0.84,-0.30,-1.22,"},
     {4000, 10000, "0.09,0.23,0.21,0.03,-0.17,-0.24,"},
     {14000, 10000, "0.10,0.24,0.23,0.04,-0.14,-0.23,"},
 };
 
 #if defined(OS_ANDROID)
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(USE_PROPRIETARY_CODECS)
 const DecodedBufferExpectations kSfxAdtsMcExpectations[] = {
     {0, 23219, "-1.80,-1.49,-0.23,1.11,1.54,-0.11,"},
     {23219, 23219, "-1.90,-1.53,-0.15,1.28,1.23,-0.33,"},
     {46439, 23219, "0.54,0.88,2.19,3.54,3.24,1.63,"},
 };
 
 const DecodedBufferExpectations kHeAacMcExpectations[] = {
     {0, 42666, "-1.76,-0.12,1.72,1.45,0.10,-1.32,"},
     {42666, 42666, "-1.78,-0.13,1.70,1.44,0.09,-1.32,"},
     {85333, 42666, "-1.78,-0.13,1.70,1.44,0.08,-1.33,"},
 };
 #endif
 
 const DecoderTestData kMediaCodecTests[] = {
     {MEDIA_CODEC, kCodecOpus, "bear-opus.ogg", kBearOpusExpectations, 24, 48000,
      CHANNEL_LAYOUT_STEREO},
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(USE_PROPRIETARY_CODECS)
     {MEDIA_CODEC, kCodecAAC, "sfx.adts", kSfxAdtsMcExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {MEDIA_CODEC, kCodecAAC, "bear-audio-implicit-he-aac-v2.aac",
      kHeAacMcExpectations, 0, 24000, CHANNEL_LAYOUT_MONO},
 #endif
 };
 
 INSTANTIATE_TEST_CASE_P(MediaCodecAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kMediaCodecTests));
 #endif  // defined(OS_ANDROID)
 
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(USE_PROPRIETARY_CODECS)
 const DecodedBufferExpectations kSfxMp3Expectations[] = {
     {0, 1065, "2.81,3.99,4.53,4.10,3.08,2.46,"},
     {1065, 26122, "-3.81,-4.14,-3.90,-3.36,-3.03,-3.23,"},
     {27188, 26122, "4.24,3.95,4.22,4.78,5.13,4.93,"},
 };
 
 const DecodedBufferExpectations kSfxAdtsExpectations[] = {
     {0, 23219, "-1.90,-1.53,-0.15,1.28,1.23,-0.33,"},
     {23219, 23219, "0.54,0.88,2.19,3.54,3.24,1.63,"},
     {46439, 23219, "1.42,1.69,2.95,4.23,4.02,2.36,"},
@@ skipping 38 matching lines @@
 };
 #else
 const DecodedBufferExpectations kSfxOpusExpectations[] = {
     {0, 13500, "-2.70,-1.41,-0.78,-1.27,-2.56,-3.73,"},
     {13500, 20000, "5.48,5.93,6.04,5.83,5.54,5.45,"},
     {33500, 20000, "-3.45,-3.35,-3.57,-4.12,-4.74,-5.14,"},
 };
 #endif
 
 const DecoderTestData kFFmpegTests[] = {
-#if BUILDFLAG(USE_PROPRIETARY_CODECS)
+#if defined(USE_PROPRIETARY_CODECS)
     {FFMPEG, kCodecMP3, "sfx.mp3", kSfxMp3Expectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {FFMPEG, kCodecAAC, "sfx.adts", kSfxAdtsExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
 #endif
     {FFMPEG, kCodecFLAC, "sfx.flac", kSfxFlacExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {FFMPEG, kCodecPCM, "sfx_f32le.wav", kSfxWaveExpectations, 0, 44100,
      CHANNEL_LAYOUT_MONO},
     {FFMPEG, kCodecPCM, "4ch.wav", kFourChannelWaveExpectations, 0, 44100,
@@ skipping 16 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderTest,
                         AudioDecoderTest,
                         testing::ValuesIn(kFFmpegTests));
 INSTANTIATE_TEST_CASE_P(FFmpegAudioDecoderBehavioralTest,
                         FFmpegAudioDecoderBehavioralTest,
                         testing::ValuesIn(kFFmpegBehavioralTest));
 
 }  // namespace media