Convert enable_mpeg2ts into a new-style buildflag

media/filters/stream_parser_factory.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 "media/filters/stream_parser_factory.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/pattern.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_switches.h"
 #include "media/formats/mpeg/adts_stream_parser.h"
 #include "media/formats/mpeg/mpeg1_audio_stream_parser.h"
 #include "media/formats/webm/webm_stream_parser.h"
+#include "media/media_features.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 #if defined(USE_PROPRIETARY_CODECS)
-#if defined(ENABLE_MPEG2TS_STREAM_PARSER)
+#if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 #include "media/formats/mp2t/mp2t_stream_parser.h"
 #endif
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/mp4_stream_parser.h"
 #endif
 
 namespace media {
 
 typedef bool (*CodecIDValidatorFunction)(
     const std::string& codecs_id,
@@ skipping 190 matching lines @@
 static const CodecInfo* kAudioADTSCodecs[] = {
   &kADTSCodecInfo,
   NULL
 };
 
 static StreamParser* BuildADTSParser(const std::vector<std::string>& codecs,
                                      const scoped_refptr<MediaLog>& media_log) {
   return new ADTSStreamParser();
 }
 
-#if defined(ENABLE_MPEG2TS_STREAM_PARSER)
+#if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 static const CodecInfo* kVideoMP2TCodecs[] = {
   &kH264AVC1CodecInfo,
   &kH264AVC3CodecInfo,
   &kMPEG4AACCodecInfo,
   &kMPEG2AACLCCodecInfo,
   NULL
 };
 
 static StreamParser* BuildMP2TParser(const std::vector<std::string>& codecs,
                                      const scoped_refptr<MediaLog>& media_log) {
   bool has_sbr = false;
   for (size_t i = 0; i < codecs.size(); ++i) {
     std::string codec_id = codecs[i];
     if (base::MatchPattern(codec_id, kMPEG4AACCodecInfo.pattern)) {
       int audio_object_type = GetMP4AudioObjectType(codec_id, media_log);
       if (audio_object_type == kAACSBRObjectType ||
           audio_object_type == kAACPSObjectType) {
         has_sbr = true;
       }
     }
   }
 
   return new media::mp2t::Mp2tStreamParser(has_sbr);
 }
 #endif
 #endif
 
-
 static const SupportedTypeInfo kSupportedTypeInfo[] = {
-  { "video/webm", &BuildWebMParser, kVideoWebMCodecs },
-  { "audio/webm", &BuildWebMParser, kAudioWebMCodecs },
+    {"video/webm", &BuildWebMParser, kVideoWebMCodecs},
+    {"audio/webm", &BuildWebMParser, kAudioWebMCodecs},
 #if defined(USE_PROPRIETARY_CODECS)
-  { "audio/aac", &BuildADTSParser, kAudioADTSCodecs },
-  { "audio/mpeg", &BuildMP3Parser, kAudioMP3Codecs },
-  { "video/mp4", &BuildMP4Parser, kVideoMP4Codecs },
-  { "audio/mp4", &BuildMP4Parser, kAudioMP4Codecs },
-#if defined(ENABLE_MPEG2TS_STREAM_PARSER)
-  { "video/mp2t", &BuildMP2TParser, kVideoMP2TCodecs },
+    {"audio/aac", &BuildADTSParser, kAudioADTSCodecs},
+    {"audio/mpeg", &BuildMP3Parser, kAudioMP3Codecs},
+    {"video/mp4", &BuildMP4Parser, kVideoMP4Codecs},
+    {"audio/mp4", &BuildMP4Parser, kAudioMP4Codecs},
+#if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
+    {"video/mp2t", &BuildMP2TParser, kVideoMP2TCodecs},
 #endif
 #endif
 };
 
 // Verify that |codec_info| is supported on this platform.
 //
 // Returns true if |codec_info| is a valid audio/video codec and is allowed.
 // |audio_codecs| has |codec_info|.tag added to its list if |codec_info| is an
 // audio codec. |audio_codecs| may be NULL, in which case it is not updated.
 // |video_codecs| has |codec_info|.tag added to its list if |codec_info| is a
@@ skipping 145 matching lines @@
                                 CodecInfo::HISTOGRAM_MAX + 1);
     }
 
     stream_parser.reset(factory_function(codecs, media_log));
   }
 
   return stream_parser;
 }
 
 }  // namespace media