Fix: Adding list of supported codecs for MP4 containers

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 63 matching lines @@
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
 
   bool IsStrictMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedStrictMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs) const;
+  bool IsSupportedStrictMP4OrHLSMediaMimeType(
+      const std::string& mime_type,
+      const std::vector<std::string>& codecs) const;
 
   void RemoveProprietaryMediaTypesAndCodecsForTests();
 
  private:
   friend struct base::DefaultLazyInstanceTraits<MimeUtil>;
 
   typedef base::hash_set<std::string> MimeMappings;
   typedef std::map<std::string, MimeMappings> StrictMappings;
 
+  typedef std::vector<std::string> MimeExpressionMappings;
+  typedef std::map<std::string, MimeExpressionMappings>
+      StrictExpressionMappings;
+
   MimeUtil();
 
   // Returns true if |codecs| is nonempty and all the items in it are present in
   // |supported_codecs|.
   static bool AreSupportedCodecs(const MimeMappings& supported_codecs,
                                  const std::vector<std::string>& codecs);
+  static bool AreSupportedCodecsWithProfile(
+      const MimeExpressionMappings& supported_codecs,
+      const std::vector<std::string>& codecs);
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   bool GetMimeTypeFromExtensionHelper(const base::FilePath::StringType& ext,
                                       bool include_platform_types,
                                       std::string* mime_type) const;
 
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings unsupported_text_map_;
   MimeMappings javascript_map_;
   MimeMappings codecs_map_;
 
   StrictMappings strict_format_map_;
+  StrictExpressionMappings strict_mp4_format_map_;
 };  // class MimeUtil
 
 // This variable is Leaky because we need to access it from WorkerPool threads.
 static base::LazyInstance<MimeUtil>::Leaky g_mime_util =
     LAZY_INSTANCE_INITIALIZER;
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
@@ skipping 312 matching lines @@
   { "audio/wav", "1" },
   { "audio/x-wav", "1" },
   { "video/ogg", "opus,theora,vorbis" },
   { "audio/ogg", "opus,vorbis" },
   { "application/ogg", "opus,theora,vorbis" },
   { "audio/mpeg", "" },
   { "audio/mp3", "" },
   { "audio/x-mp3", "" }
 };
 
+static const MediaFormatStrict format_mp4_codec_mappings[] = {
+    {"audio/mp4", "mp4a,mp4a.40,mp4a.40.?"},

[acolwell GONE FROM CHROMIUM, 2014/05/12 14:54:18]

mp4a is not valid. mp4a.67 should be added to this list as well since that is
what is used for MPEG2 AAC in an MP4 container. This applies everywhere below as
well.

[amogh.bihani, 2014/05/15 09:05:53]

Done.

+    {"audio/x-m4a", "mp4a,mp4a.40,mp4a.40.?"},
+    {"video/mp4", "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?"},

[acolwell GONE FROM CHROMIUM, 2014/05/12 14:54:18]

nit: perhaps move this into a static constant so it is a little clearer that
these are all using the exact same value.

[amogh.bihani, 2014/05/15 09:05:53]

Done.

+    {"video/x-m4v", "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?"},
+    {"application/x-mpegurl",
+     "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?"},
+    {"application/vnd.apple.mpegurl",
+     "avc1,avc3,avc1.??????,avc3.??????,mp4a,mp4a.40,mp4a.40.?"}};
+
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
 bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
                                   const std::vector<std::string>& codecs) {
   if (supported_codecs.empty())
     return codecs.empty();
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (supported_codecs.find(codecs[i]) == supported_codecs.end())
       return false;
   }
   return !codecs.empty();
 }
 
+bool MimeUtil::AreSupportedCodecsWithProfile(
+    const MimeExpressionMappings& supported_codecs,
+    const std::vector<std::string>& codecs) {
+  for (size_t i = 0; i < codecs.size(); ++i) {
+    bool codec_matched = false;
+    for (size_t j = 0; j < supported_codecs.size(); ++j) {
+      if (MatchPattern(static_cast<base::StringPiece>(codecs[i]),

[acolwell GONE FROM CHROMIUM, 2014/05/12 14:54:18]

nit: reverse condition & continue

[amogh.bihani, 2014/05/15 09:05:53]

Done.

+                       static_cast<base::StringPiece>(supported_codecs[j]))) {
+        codec_matched = true;
+        std::vector<std::string> split_string;
+        base::SplitString(codecs[i], '.', &split_string);
+        if (split_string.size() > 1 &&
+            !IsUpperCaseHexNumber(split_string.back())) {

[acolwell GONE FROM CHROMIUM, 2014/05/12 14:54:18]

I don't think we should enforce upper case here. You'll likely break existing
sites for no good reason.

[amogh.bihani, 2014/05/15 09:05:53]

Done.

+          codec_matched = false;

[acolwell GONE FROM CHROMIUM, 2014/05/12 14:54:18]

nit: just return false here and move codec_matched = true  right before the
break below since that is when you know you actually have a match.

[amogh.bihani, 2014/05/15 09:05:53]

Done.

+        }
+        break;
+      }
+    }
+    // Return false if any of the codecs is not matching.
+    if (!codec_matched)
+      return false;
+  }
+  return !codecs.empty();
+}
+
 void MimeUtil::InitializeMimeTypeMaps() {
   for (size_t i = 0; i < arraysize(supported_image_types); ++i)
     image_map_.insert(supported_image_types[i]);
 
   // Initialize the supported non-image types.
   for (size_t i = 0; i < arraysize(supported_non_image_types); ++i)
     non_image_map_.insert(supported_non_image_types[i]);
   for (size_t i = 0; i < arraysize(supported_certificate_types); ++i)
     non_image_map_.insert(supported_certificate_types[i].mime_type);
   for (size_t i = 0; i < arraysize(unsupported_text_types); ++i)
@@ skipping 40 matching lines @@
     MimeMappings codecs;
     for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
 #if defined(OS_ANDROID)
       if (!IsCodecSupportedOnAndroid(mime_type_codecs[j]))
         continue;
 #endif
       codecs.insert(mime_type_codecs[j]);
     }
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
+  for (size_t i = 0; i < arraysize(format_mp4_codec_mappings); ++i) {
+    std::vector<std::string> mime_type_codecs;
+    ParseCodecString(
+        format_mp4_codec_mappings[i].codecs_list, &mime_type_codecs, false);
+
+    MimeExpressionMappings codecs;
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
+      codecs.push_back(mime_type_codecs[j]);
+    }
+    strict_mp4_format_map_[format_mp4_codec_mappings[i].mime_type] = codecs;
+  }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_map_.find(mime_type) != media_map_.end();
 }
 
@@ skipping 162 matching lines @@
   for (std::vector<std::string>::iterator it = codecs_out->begin();
        it != codecs_out->end();
        ++it) {
     size_t found = it->find_first_of('.');
     if (found != std::string::npos)
       it->resize(found);
   }
 }
 
 bool MimeUtil::IsStrictMediaMimeType(const std::string& mime_type) const {
-  if (strict_format_map_.find(mime_type) == strict_format_map_.end())
+  if (strict_format_map_.find(mime_type) == strict_format_map_.end() &&
+      strict_mp4_format_map_.find(mime_type) == strict_mp4_format_map_.end())
     return false;
   return true;
 }
 
 bool MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
   StrictMappings::const_iterator it = strict_format_map_.find(mime_type);
   return (it != strict_format_map_.end()) &&
       AreSupportedCodecs(it->second, codecs);
 }
 
+bool MimeUtil::IsSupportedStrictMP4OrHLSMediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs) const {
+  StrictExpressionMappings::const_iterator it =
+      strict_mp4_format_map_.find(mime_type);
+  return (it != strict_mp4_format_map_.end() &&
+          AreSupportedCodecsWithProfile(it->second, codecs));
+}
+
 void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i) {
     non_image_map_.erase(proprietary_media_types[i]);
     media_map_.erase(proprietary_media_types[i]);
   }
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs_map_.erase(proprietary_media_codecs[i]);
 }
 
 //----------------------------------------------------------------------------
@@ skipping 60 matching lines @@
 
 bool IsStrictMediaMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsStrictMediaMimeType(mime_type);
 }
 
 bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
                                     const std::vector<std::string>& codecs) {
   return g_mime_util.Get().IsSupportedStrictMediaMimeType(mime_type, codecs);
 }
 
+bool IsSupportedStrictMP4OrHLSMediaMimeType(
+    const std::string& mime_type,
+    const std::vector<std::string>& codecs) {
+  return g_mime_util.Get().IsSupportedStrictMP4OrHLSMediaMimeType(mime_type,
+                                                                  codecs);
+}
+
 void ParseCodecString(const std::string& codecs,
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
   g_mime_util.Get().ParseCodecString(codecs, codecs_out, strip);
 }
 
 namespace {
 
 // From http://www.w3schools.com/media/media_mimeref.asp and
 // http://plugindoc.mozdev.org/winmime.php
@@ skipping 225 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