Convert USE_PROPRIETARY_CODECS to a buildflag header.

media/base/mime_util_internal.cc

 // Copyright 2012 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/mime_util_internal.h"
 
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/media.h"
 #include "media/base/media_client.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_codecs.h"
+#include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #include "media/base/android/media_codec_util.h"
 #endif
 
 namespace media {
 namespace internal {
 
 struct CodecIDMappings {
@@ skipping 213 matching lines @@
     }
 
     if (is_ambiguous)
       result = MayBeSupported;
   }
 
   return result;
 }
 
 void MimeUtil::InitializeMimeTypeMaps() {
-#if defined(USE_PROPRIETARY_CODECS)
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
   allow_proprietary_codecs_ = true;
 #endif
 
   for (size_t i = 0; i < arraysize(kUnambiguousCodecStringMap); ++i) {
     string_to_codec_map_[kUnambiguousCodecStringMap[i].codec_id] =
         CodecEntry(kUnambiguousCodecStringMap[i].codec, false);
   }
 
   for (size_t i = 0; i < arraysize(kAmbiguousCodecStringMap); ++i) {
     string_to_codec_map_[kAmbiguousCodecStringMap[i].codec_id] =
@@ skipping 24 matching lines @@
 
   CodecSet webm_audio_codecs;
   webm_audio_codecs.insert(OPUS);
   webm_audio_codecs.insert(VORBIS);
   CodecSet webm_video_codecs;
   webm_video_codecs.insert(VP8);
   webm_video_codecs.insert(VP9);
   CodecSet webm_codecs(webm_audio_codecs);
   webm_codecs.insert(webm_video_codecs.begin(), webm_video_codecs.end());
 
-#if defined(USE_PROPRIETARY_CODECS)
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
   CodecSet mp3_codecs;
   mp3_codecs.insert(MP3);
 
   CodecSet aac;
   aac.insert(MPEG2_AAC);
   aac.insert(MPEG4_AAC);
 
   CodecSet avc_and_aac(aac);
   avc_and_aac.insert(H264);
 
   CodecSet mp4_audio_codecs(aac);
   mp4_audio_codecs.insert(MP3);
 #if BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
   mp4_audio_codecs.insert(AC3);
   mp4_audio_codecs.insert(EAC3);
 #endif  // BUILDFLAG(ENABLE_AC3_EAC3_AUDIO_DEMUXING)
 
   CodecSet mp4_video_codecs;
   mp4_video_codecs.insert(H264);
 #if BUILDFLAG(ENABLE_HEVC_DEMUXING)
   mp4_video_codecs.insert(HEVC);
 #endif  // BUILDFLAG(ENABLE_HEVC_DEMUXING)
   // Only VP9 with valid codec string vp09.xx.xx.xx.xx.xx.xx.xx is supported.
   // See ParseVp9CodecID for details.
   mp4_video_codecs.insert(VP9);
   CodecSet mp4_codecs(mp4_audio_codecs);
   mp4_codecs.insert(mp4_video_codecs.begin(), mp4_video_codecs.end());
-#endif  // defined(USE_PROPRIETARY_CODECS)
+#endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 
   AddContainerWithCodecs("audio/wav", wav_codecs, false);
   AddContainerWithCodecs("audio/x-wav", wav_codecs, false);
   AddContainerWithCodecs("audio/webm", webm_audio_codecs, false);
   DCHECK(!webm_video_codecs.empty());
   AddContainerWithCodecs("video/webm", webm_codecs, false);
   AddContainerWithCodecs("audio/ogg", ogg_audio_codecs, false);
   // video/ogg is only supported if an appropriate video codec is supported.
   // Note: This assumes such codecs cannot be later excluded.
   if (!ogg_video_codecs.empty())
     AddContainerWithCodecs("video/ogg", ogg_codecs, false);
   // TODO(ddorwin): Should the application type support Opus?
   AddContainerWithCodecs("application/ogg", ogg_codecs, false);
   AddContainerWithCodecs("audio/flac", implicit_codec, false);
 
-#if defined(USE_PROPRIETARY_CODECS)
+#if BUILDFLAG(USE_PROPRIETARY_CODECS)
   AddContainerWithCodecs("audio/mpeg", mp3_codecs, true);  // Allow "mp3".
   AddContainerWithCodecs("audio/mp3", implicit_codec, true);
   AddContainerWithCodecs("audio/x-mp3", implicit_codec, true);
   AddContainerWithCodecs("audio/aac", implicit_codec, true);  // AAC / ADTS.
   AddContainerWithCodecs("audio/mp4", mp4_audio_codecs, true);
   DCHECK(!mp4_video_codecs.empty());
   AddContainerWithCodecs("video/mp4", mp4_codecs, true);
   // These strings are supported for backwards compatibility only and thus only
   // support the codecs needed for compatibility.
   AddContainerWithCodecs("audio/x-m4a", aac, true);
   AddContainerWithCodecs("video/x-m4v", avc_and_aac, true);
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
   // TODO(ddorwin): Exactly which codecs should be supported?
   DCHECK(!mp4_video_codecs.empty());
   AddContainerWithCodecs("video/mp2t", mp4_codecs, true);
 #endif  // BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 #if defined(OS_ANDROID)
   // HTTP Live Streaming (HLS).
   // TODO(ddorwin): Is any MP3 codec string variant included in real queries?
   CodecSet hls_codecs(avc_and_aac);
   hls_codecs.insert(MP3);
   AddContainerWithCodecs("application/x-mpegurl", hls_codecs, true);
   AddContainerWithCodecs("application/vnd.apple.mpegurl", hls_codecs, true);
 #endif  // defined(OS_ANDROID)
-#endif  // defined(USE_PROPRIETARY_CODECS)
+#endif  // BUILDFLAG(USE_PROPRIETARY_CODECS)
 }
 
 void MimeUtil::AddContainerWithCodecs(const std::string& mime_type,
                                       const CodecSet& codecs,
                                       bool is_proprietary_mime_type) {
-#if !defined(USE_PROPRIETARY_CODECS)
+#if !BUILDFLAG(USE_PROPRIETARY_CODECS)
   DCHECK(!is_proprietary_mime_type);
 #endif
 
   media_format_map_[mime_type] = codecs;
 
   if (is_proprietary_mime_type)
     proprietary_media_containers_.push_back(mime_type);
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
@@ skipping 352 matching lines @@
     const std::string& mime_type_lower_case,
     bool is_encrypted) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodecLowerCase(mime_type_lower_case, &default_codec))
     return false;
   return IsCodecSupported(default_codec, mime_type_lower_case, is_encrypted);
 }
 
 }  // namespace internal
 }  // namespace media