Document some quirks of media MIME type code and reference related bugs

net/base/mime_util.cc

 // Copyright (c) 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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 505 matching lines @@
 //                 compatibility)
 //   mp4a.40.29  - MPEG-4 HE-AAC v2 (AAC LC + SBR + PS)
 //
 //   avc1.42E0xx - H.264 Baseline
 //   avc1.4D40xx - H.264 Main
 //   avc1.6400xx - H.264 High
 static const char kMP4AudioCodecsExpression[] =
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
     "mp4a.40.05,mp4a.40.29";
 static const char kMP4VideoCodecsExpression[] =
+    // This is not a complete list of supported avc1 codecs. It is simply used
+    // to register support for the corresponding Codec enum. Instead of using
+    // strings in these three arrays, we should use the Codec enum values.
+    // This will avoid confusion and unnecessary parsing at runtime.
+    // kUnambiguousCodecStringMap/kAmbiguousCodecStringMap should be the only
+    // mapping from strings to codecs. See crbug.com/461009.
     "avc1.42E00A,avc1.4D400A,avc1.64000A,"
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.02,mp4a.40.5,"
     "mp4a.40.05,mp4a.40.29";
 
+// These containers are also included in
+// common_media_types/proprietary_media_types. See crbug.com/461012.
 static const MediaFormatStrict format_codec_mappings[] = {
     {"video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0"},
     {"audio/webm", "opus,vorbis"},
     {"audio/wav", "1"},
     {"audio/x-wav", "1"},
 // Android does not support Opus in Ogg container.
 #if defined(OS_ANDROID)
     {"video/ogg", "theora,vorbis"},
     {"audio/ogg", "vorbis"},
     {"application/ogg", "theora,vorbis"},
@@ skipping 14 matching lines @@
 
 struct CodecIDMappings {
   const char* const codec_id;
   MimeUtil::Codec codec;
 };
 
 // List of codec IDs that provide enough information to determine the
 // codec and profile being requested.
 //
 // The "mp4a" strings come from RFC 6381.
-static const CodecIDMappings kUnambiguousCodecIDs[] = {
+static const CodecIDMappings kUnambiguousCodecStringMap[] = {
     {"1", MimeUtil::PCM},  // We only allow this for WAV so it isn't ambiguous.
+    // avc1/avc3.XXXXXX may be unambiguous; handled by ParseH264CodecID().
     {"mp3", MimeUtil::MP3},
     {"mp4a.66", MimeUtil::MPEG2_AAC_MAIN},
     {"mp4a.67", MimeUtil::MPEG2_AAC_LC},
     {"mp4a.68", MimeUtil::MPEG2_AAC_SSR},
     {"mp4a.69", MimeUtil::MP3},
     {"mp4a.6B", MimeUtil::MP3},
     {"mp4a.40.2", MimeUtil::MPEG4_AAC_LC},
     {"mp4a.40.02", MimeUtil::MPEG4_AAC_LC},
     {"mp4a.40.5", MimeUtil::MPEG4_AAC_SBR_v1},
     {"mp4a.40.05", MimeUtil::MPEG4_AAC_SBR_v1},
     {"mp4a.40.29", MimeUtil::MPEG4_AAC_SBR_PS_v2},
     {"vorbis", MimeUtil::VORBIS},
     {"opus", MimeUtil::OPUS},
     {"vp8", MimeUtil::VP8},
     {"vp8.0", MimeUtil::VP8},
     {"vp9", MimeUtil::VP9},
     {"vp9.0", MimeUtil::VP9},
     {"theora", MimeUtil::THEORA}};
 
 // List of codec IDs that are ambiguous and don't provide
 // enough information to determine the codec and profile.
 // The codec in these entries indicate the codec and profile
 // we assume the user is trying to indicate.
-static const CodecIDMappings kAmbiguousCodecIDs[] = {
-  { "mp4a.40", MimeUtil::MPEG4_AAC_LC },
-  { "avc1", MimeUtil::H264_BASELINE },
-  { "avc3", MimeUtil::H264_BASELINE },
+static const CodecIDMappings kAmbiguousCodecStringMap[] = {
+    {"mp4a.40", MimeUtil::MPEG4_AAC_LC},
+    {"avc1", MimeUtil::H264_BASELINE},
+    {"avc3", MimeUtil::H264_BASELINE},
+    // avc1/avc3.XXXXXX may be ambiguous; handled by ParseH264CodecID().
 };
 
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
   InitializeMimeTypeMaps();
 }
 
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs) const {
   DCHECK(!supported_codecs.empty());
@@ skipping 54 matching lines @@
     media_map_.insert(common_media_types[i]);
   }
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i)
     media_map_.insert(proprietary_media_types[i]);
 #endif
 
   for (size_t i = 0; i < arraysize(supported_javascript_types); ++i)
     javascript_map_.insert(supported_javascript_types[i]);
 
-  for (size_t i = 0; i < arraysize(kUnambiguousCodecIDs); ++i) {
-    string_to_codec_map_[kUnambiguousCodecIDs[i].codec_id] =
-        CodecEntry(kUnambiguousCodecIDs[i].codec, false);
+  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(kAmbiguousCodecIDs); ++i) {
-    string_to_codec_map_[kAmbiguousCodecIDs[i].codec_id] =
-        CodecEntry(kAmbiguousCodecIDs[i].codec, true);
+  for (size_t i = 0; i < arraysize(kAmbiguousCodecStringMap); ++i) {
+    string_to_codec_map_[kAmbiguousCodecStringMap[i].codec_id] =
+        CodecEntry(kAmbiguousCodecStringMap[i].codec, true);
   }
 
   // Initialize the strict supported media types.
   for (size_t i = 0; i < arraysize(format_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
     ParseCodecString(format_codec_mappings[i].codecs_list,
                      &mime_type_codecs,
                      false);
 
     CodecSet codecs;
@@ skipping 733 matching lines @@
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net