Convert MediaLog from being ref counted to owned by WebMediaPlayer.

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"
@@ skipping 17 matching lines @@
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 #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,
-    const scoped_refptr<MediaLog>& media_log);
+typedef bool (*CodecIDValidatorFunction)(const std::string& codecs_id,
+                                         MediaLog* media_log);
 
 struct CodecInfo {
   enum Type {
     UNKNOWN,
     AUDIO,
     VIDEO
   };
 
   // Update tools/metrics/histograms/histograms.xml if new values are added.
   enum HistogramTag {
@@ skipping 15 matching lines @@
   };
 
   const char* pattern;
   Type type;
   CodecIDValidatorFunction validator;
   HistogramTag tag;
 };
 
 typedef StreamParser* (*ParserFactoryFunction)(
     const std::vector<std::string>& codecs,
-    const scoped_refptr<MediaLog>& media_log);
+    MediaLog* media_log);
 
 struct SupportedTypeInfo {
   const char* type;
   const ParserFactoryFunction factory_function;
   const CodecInfo** codecs;
 };
 
 static const CodecInfo kVP8CodecInfo = { "vp8", CodecInfo::VIDEO, NULL,
                                          CodecInfo::HISTOGRAM_VP8 };
 static const CodecInfo kLegacyVP9CodecInfo = {"vp9", CodecInfo::VIDEO, NULL,
                                               CodecInfo::HISTOGRAM_VP9};
 static const CodecInfo kVP9CodecInfo = {"vp09.*", CodecInfo::VIDEO, NULL,
                                         CodecInfo::HISTOGRAM_VP9};
 static const CodecInfo kVorbisCodecInfo = { "vorbis", CodecInfo::AUDIO, NULL,
                                             CodecInfo::HISTOGRAM_VORBIS };
 static const CodecInfo kOpusCodecInfo = { "opus", CodecInfo::AUDIO, NULL,
                                           CodecInfo::HISTOGRAM_OPUS };
 
 static const CodecInfo* kVideoWebMCodecs[] = {
     &kVP8CodecInfo,    &kLegacyVP9CodecInfo, &kVP9CodecInfo,
     &kVorbisCodecInfo, &kOpusCodecInfo,      NULL};
 
 static const CodecInfo* kAudioWebMCodecs[] = {
   &kVorbisCodecInfo,
   &kOpusCodecInfo,
   NULL
 };
 
 static StreamParser* BuildWebMParser(const std::vector<std::string>& codecs,
-                                     const scoped_refptr<MediaLog>& media_log) {
+                                     MediaLog* media_log) {
   return new WebMStreamParser();
 }
 
 #if BUILDFLAG(USE_PROPRIETARY_CODECS)
 bool CheckIfMp4Vp9DemuxingEnabled(const std::string& codec_id,
-                                  const scoped_refptr<MediaLog>& media_log) {
+                                  MediaLog* media_log) {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableVp9InMp4);
 }
 
 // AAC Object Type IDs that Chrome supports.
 static const int kAACLCObjectType = 2;
 static const int kAACSBRObjectType = 5;
 static const int kAACPSObjectType = 29;
 
 static int GetMP4AudioObjectType(const std::string& codec_id,
-                                 const scoped_refptr<MediaLog>& media_log) {
+                                 MediaLog* media_log) {
   // From RFC 6381 section 3.3 (ISO Base Media File Format Name Space):
   // When the first element of a ['codecs' parameter value] is 'mp4a' ...,
   // the second element is a hexadecimal representation of the MP4 Registration
   // Authority ObjectTypeIndication (OTI). Note that MP4RA uses a leading "0x"
   // with these values, which is omitted here and hence implied.
   std::vector<base::StringPiece> tokens = base::SplitStringPiece(
       codec_id, ".", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (tokens.size() == 3 && tokens[0] == "mp4a" && tokens[1] == "40") {
     // From RFC 6381 section 3.3:
     // One of the OTI values for 'mp4a' is 40 (identifying MPEG-4 audio). For
     // this value, the third element identifies the audio ObjectTypeIndication
     // (OTI) ... expressed as a decimal number.
     int audio_object_type;
     if (base::StringToInt(tokens[2], &audio_object_type))
       return audio_object_type;
   }
 
   MEDIA_LOG(DEBUG, media_log) << "Malformed mimetype codec '" << codec_id
                               << "'";
   return -1;
 }
 
-bool ValidateMP4ACodecID(const std::string& codec_id,
-                         const scoped_refptr<MediaLog>& media_log) {
+bool ValidateMP4ACodecID(const std::string& codec_id, MediaLog* media_log) {
   int audio_object_type = GetMP4AudioObjectType(codec_id, media_log);
   if (audio_object_type == kAACLCObjectType ||
       audio_object_type == kAACSBRObjectType ||
       audio_object_type == kAACPSObjectType) {
     return true;
   }
 
   MEDIA_LOG(DEBUG, media_log) << "Unsupported audio object type "
                               << audio_object_type << " in codec '" << codec_id
                               << "'";
@@ skipping 72 matching lines @@
                                              &kAC3CodecInfo1,
                                              &kAC3CodecInfo2,
                                              &kAC3CodecInfo3,
                                              &kEAC3CodecInfo1,
                                              &kEAC3CodecInfo2,
                                              &kEAC3CodecInfo3,
 #endif
                                              NULL};
 
 static StreamParser* BuildMP4Parser(const std::vector<std::string>& codecs,
-                                    const scoped_refptr<MediaLog>& media_log) {
+                                    MediaLog* media_log) {
   std::set<int> audio_object_types;
 
   bool has_sbr = false;
   for (size_t i = 0; i < codecs.size(); ++i) {
     std::string codec_id = codecs[i];
     if (base::MatchPattern(codec_id, kMPEG2AACLCCodecInfo.pattern)) {
       audio_object_types.insert(mp4::kISO_13818_7_AAC_LC);
     } else if (base::MatchPattern(codec_id, kMPEG4AACCodecInfo.pattern)) {
       int audio_object_type = GetMP4AudioObjectType(codec_id, media_log);
       DCHECK_GT(audio_object_type, 0);
@@ skipping 23 matching lines @@
 
 static const CodecInfo kMP3CodecInfo = { NULL, CodecInfo::AUDIO, NULL,
                                          CodecInfo::HISTOGRAM_MP3 };
 
 static const CodecInfo* kAudioMP3Codecs[] = {
   &kMP3CodecInfo,
   NULL
 };
 
 static StreamParser* BuildMP3Parser(const std::vector<std::string>& codecs,
-                                    const scoped_refptr<MediaLog>& media_log) {
+                                    MediaLog* media_log) {
   return new MPEG1AudioStreamParser();
 }
 
 static const CodecInfo kADTSCodecInfo = { NULL, CodecInfo::AUDIO, NULL,
                                           CodecInfo::HISTOGRAM_MPEG4AAC };
 static const CodecInfo* kAudioADTSCodecs[] = {
   &kADTSCodecInfo,
   NULL
 };
 
 static StreamParser* BuildADTSParser(const std::vector<std::string>& codecs,
-                                     const scoped_refptr<MediaLog>& media_log) {
+                                     MediaLog* media_log) {
   return new ADTSStreamParser();
 }
 
 #if BUILDFLAG(ENABLE_MSE_MPEG2TS_STREAM_PARSER)
 // These codec ids correspond to object types registered with MP4RA and are the
 // same as MP3 audio codec ids in media/base/mime_util_internal.cc.
 // From http://www.mp4ra.org/object.html:
 // 69   Audio ISO/IEC 13818-3
 // 6B   Audio ISO/IEC 11172-3
 static const CodecInfo kMPEG2TS_MP3CodecInfo1 = {
     "mp4a.69", CodecInfo::AUDIO, NULL, CodecInfo::HISTOGRAM_MP3};
 static const CodecInfo kMPEG2TS_MP3CodecInfo2 = {
     "mp4a.6B", CodecInfo::AUDIO, NULL, CodecInfo::HISTOGRAM_MP3};
 
 static const CodecInfo* kVideoMP2TCodecs[] = {&kH264AVC1CodecInfo,
                                               &kH264AVC3CodecInfo,
                                               &kMPEG2TS_MP3CodecInfo1,
                                               &kMPEG2TS_MP3CodecInfo2,
                                               &kMPEG4AACCodecInfo,
                                               &kMPEG2AACLCCodecInfo,
                                               NULL};
 
 static StreamParser* BuildMP2TParser(const std::vector<std::string>& codecs,
-                                     const scoped_refptr<MediaLog>& media_log) {
+                                     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;
       }
     }
@@ skipping 66 matching lines @@
 // not touched.
 // |video_codecs| is updated with the appropriate HistogramTags for matching
 // video codecs specified in |codecs|. Value may be NULL, in which case it is
 // not touched.
 //
 // Returns false otherwise. The values of |factory_function|, |audio_codecs|,
 // and |video_codecs| are undefined.
 static bool CheckTypeAndCodecs(
     const std::string& type,
     const std::vector<std::string>& codecs,
-    const scoped_refptr<MediaLog>& media_log,
+    MediaLog* media_log,
     ParserFactoryFunction* factory_function,
     std::vector<CodecInfo::HistogramTag>* audio_codecs,
     std::vector<CodecInfo::HistogramTag>* video_codecs) {
   // Search for the SupportedTypeInfo for |type|.
   for (size_t i = 0; i < arraysize(kSupportedTypeInfo); ++i) {
     const SupportedTypeInfo& type_info = kSupportedTypeInfo[i];
     if (type == type_info.type) {
       if (codecs.empty()) {
         const CodecInfo* codec_info = type_info.codecs[0];
         if (codec_info && !codec_info->pattern &&
@@ skipping 39 matching lines @@
       // All codecs were supported by this |type|.
       return true;
     }
   }
 
   // |type| didn't match any of the supported types.
   return false;
 }
 
 bool StreamParserFactory::IsTypeSupported(
-    const std::string& type, const std::vector<std::string>& codecs) {
-  return CheckTypeAndCodecs(type, codecs, new MediaLog(), NULL, NULL, NULL);
+    const std::string& type,
+    const std::vector<std::string>& codecs) {
+  // TODO(wolenetz): Questionable MediaLog usage, http://crbug.com/712310
+  MediaLog media_log;
+  return CheckTypeAndCodecs(type, codecs, &media_log, NULL, NULL, NULL);
 }
 
 std::unique_ptr<StreamParser> StreamParserFactory::Create(
     const std::string& type,
     const std::vector<std::string>& codecs,
-    const scoped_refptr<MediaLog>& media_log) {
+    MediaLog* media_log) {
   std::unique_ptr<StreamParser> stream_parser;
   ParserFactoryFunction factory_function;
   std::vector<CodecInfo::HistogramTag> audio_codecs;
   std::vector<CodecInfo::HistogramTag> video_codecs;
 
   if (CheckTypeAndCodecs(type, codecs, media_log, &factory_function,
                          &audio_codecs, &video_codecs)) {
     // Log the number of codecs specified, as well as the details on each one.
     UMA_HISTOGRAM_COUNTS_100("Media.MSE.NumberOfTracks", codecs.size());
     for (size_t i = 0; i < audio_codecs.size(); ++i) {
       UMA_HISTOGRAM_ENUMERATION("Media.MSE.AudioCodec",
                                 audio_codecs[i],
                                 CodecInfo::HISTOGRAM_MAX + 1);
     }
     for (size_t i = 0; i < video_codecs.size(); ++i) {
       UMA_HISTOGRAM_ENUMERATION("Media.MSE.VideoCodec",
                                 video_codecs[i],
                                 CodecInfo::HISTOGRAM_MAX + 1);
     }
 
     stream_parser.reset(factory_function(codecs, media_log));
   }
 
   return stream_parser;
 }
 
 }  // namespace media