Fix: Changing canPlayType behaviour 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 75 matching lines @@
   SupportsType IsSupportedStrictMediaMimeType(
       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);
-  // Returns true is |codecs| is nonempty and all the items in it match with the
-  // codecs expression in |supported_codecs|.
-  static bool AreSupportedCodecsWithProfile(
+  static bool AreCodecsListedInSingleLookupTable(
       const MimeExpressionMappings& supported_codecs,
       const std::vector<std::string>& codecs);
 
+  // Returns true if |codecs| is nonempty and all the items in it are present in
+  // either |confirmed_supported_codecs| or |mightbe_supported_codecs|.
+  static bool AreCodecsListedInMultipleLookupTables(
+      const MimeExpressionMappings& confirmed_supported_codecs,
+      const MimeExpressionMappings& mightbe_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_;
+  MimeExpressionMappings codecs_map_;
 
   // A map of mime_types and hash map of the supported codecs for the mime_type.
-  StrictMappings strict_format_map_;
-  // A map of MP4 mime_types which expect codecs with profile parameter and
-  // vector of supported codecs expressions for the mime_type.
-  StrictExpressionMappings strict_mp4_format_map_;
+  StrictExpressionMappings strict_format_map_;
+  // A map of mime_types, which expect codecs which are RFC compliant but do not
+  // have sufficient informatation whether they are supported or not, and vector
+  // of supported codecs expressions for the mime_type.
+  StrictExpressionMappings inconclusive_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 136 matching lines @@
   "image/bmp",
   "image/vnd.microsoft.icon",    // ico
   "image/x-icon",    // ico
   "image/x-xbitmap",  // xbm
   "image/x-png"
 };
 
 // A list of media types: http://en.wikipedia.org/wiki/Internet_media_type
 // A comprehensive mime type list: http://plugindoc.mozdev.org/winmime.php
 // This set of codecs is supported by all variations of Chromium.
+// (Except for 'video/ogg', which is not supported by Android.)
 static const char* const common_media_types[] = {
   // Ogg.
   "audio/ogg",
   "application/ogg",
-#if !defined(OS_ANDROID)  // Android doesn't support Ogg Theora.
   "video/ogg",
-#endif
 
   // WebM.
   "video/webm",
   "audio/webm",
 
   // Wav.
   "audio/wav",
   "audio/x-wav",
 
 #if defined(OS_ANDROID)
@@ skipping 12 matching lines @@
   "audio/x-m4a",
 
   // MP3.
   "audio/mp3",
   "audio/x-mp3",
   "audio/mpeg",
 };
 
 // List of supported codecs when passed in with <source type="...">.
 // This set of codecs is supported by all variations of Chromium.
+// (Except for 'theora' and 'opus' (http://crbug.com/318436), which are not
+// supported by Android.)
 //
 // Refer to http://wiki.whatwg.org/wiki/Video_type_parameters#Browser_Support
 // for more information.
 //
 // The codecs for WAV are integers as defined in Appendix A of RFC2361:
 // http://tools.ietf.org/html/rfc2361
 static const char* const common_media_codecs[] = {
-#if !defined(OS_ANDROID)  // Android doesn't support Ogg Theora.
   "theora",
-#endif
   "opus",
   "vorbis",
   "vp8",
   "vp9",
   "1"  // WAVE_FORMAT_PCM.
 };
 
 // List of proprietary codecs only supported by Google Chrome.
 static const char* const proprietary_media_codecs[] = {
   "avc1",
@@ skipping 88 matching lines @@
     return false;
 
   // VP9 is supported only in KitKat+ (API Level 19).
   if ((!codec.compare("vp9") || !codec.compare("vp9.0")) &&
       base::android::BuildInfo::GetInstance()->sdk_int() < 19) {
     return false;
   }
 
   // TODO(vigneshv): Change this similar to the VP9 check once Opus is
   // supported on Android (http://crbug.com/318436).
-  if (!codec.compare("opus")) {
+  if (!codec.compare("opus"))
+    return false;
+
+  // MPEG-2 AAC is not supported on Android
+  if (!codec.compare("mp4a.67"))
+    return false;
+
+  // H.264 Main and High profiles are not supported on Android
+  if (!codec.compare("avc1.4d40??") || !codec.compare("avc3.4d40??") ||
+      !codec.compare("avc1.4D40??") || !codec.compare("avc3.4D40??") ||
+      !codec.compare("avc1.6400??") || !codec.compare("avc3.6400??")) {
     return false;
   }
+
   return true;
 }
 
 static bool IsMimeTypeSupportedOnAndroid(const std::string& mimeType) {
+  // Ogg Theora is not supported on Android
+  if (!mimeType.compare("video/ogg"))
+    return false;
+
   // HLS codecs are supported in ICS and above (API level 14)
   if ((!mimeType.compare("application/vnd.apple.mpegurl") ||
       !mimeType.compare("application/x-mpegurl")) &&
       base::android::BuildInfo::GetInstance()->sdk_int() < 14) {
     return false;
   }
+
   return true;
 }
 #endif
 
 struct MediaFormatStrict {
   const char* mime_type;
   const char* codecs_list;
 };
 
-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" },
-  { "video/ogg", "opus,theora,vorbis" },
-  { "audio/ogg", "opus,vorbis" },
-  { "application/ogg", "opus,theora,vorbis" },
-  { "audio/mpeg", "" },
-  { "audio/mp3", "" },
-  { "audio/x-mp3", "" }
-};
-
 // Following is the list of RFC 6381 compliant codecs:
 //   mp4a.6B     - MPEG-1 audio
 //   mp4a.69     - MPEG-2 extension to MPEG-1
 //   mp4a.67     - MPEG-2 AAC
 //   mp4a.40.2   - MPEG-4 AAC
-//   mp4a.40.5   - MPEG-4 HE-AAC
+//   mp4a.40.5   - MPEG-4 HE-AACv1
 //
 //   avc1.42E0xx - H.264 Baseline
 //   avc1.4D40xx - H.264 Main
 //   avc1.6400xx - H.264 High
+static const char kProprietaryAudioCodecsExpression[] =
+    "mp4a.6B,mp4a.69,mp4a.67,mp4a.40.2,mp4a.40.5";
+static const char kProprietaryCodecsExpression[] =
+    "avc1.42E0??,avc1.42e0??,avc1.4D40??,avc1.4d40??,avc1.6400??,"
+    "avc3.42E0??,avc3.42e0??,avc3.4D40??,avc3.4d40??,avc3.6400??,"
+    "mp4a.6B,mp4a.69,mp4a.67,mp4a.40.2,mp4a.40.5";
+
+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"},
+    {"video/ogg", "opus,theora,vorbis"},
+    {"audio/ogg", "opus,vorbis"},
+    {"application/ogg", "opus,theora,vorbis"},
+    {"audio/mpeg", ""},
+    {"audio/mp3", ""},
+    {"audio/x-mp3", ""},
+    {"audio/mp4", kProprietaryAudioCodecsExpression},
+    {"audio/x-m4a", kProprietaryAudioCodecsExpression},
+    {"video/mp4", kProprietaryCodecsExpression},
+    {"video/x-m4v", kProprietaryCodecsExpression},
+    {"application/x-mpegurl", kProprietaryCodecsExpression},
+    {"application/vnd.apple.mpegurl", kProprietaryCodecsExpression}
+};
+
+// Following is the list of codecs that are RFC 6381 compliant, but support for
+// which varies with platform and cannot be determined beforehand.
+//   mp4a.40
+//   avc1
+//   avc3
 //
 // Additionally, several non-RFC compliant codecs are allowed, due to their
 // existing use on web.
-//   mp4a.40
 //   avc1.xxxxxx
 //   avc3.xxxxxx
-//   mp4a.6x
-static const char kProprietaryAudioCodecsExpression[] =
-    "mp4a.6?,mp4a.40,mp4a.40.?";
-static const char kProprietaryCodecsExpression[] =
-    "avc1,avc3,avc1.??????,avc3.??????,mp4a.6?,mp4a.40,mp4a.40.?";
+static const char kInconclusiveProprietaryAudioCodecsExpression[] =
+    "mp4a.40,mp4a.66,mp4a.68";
+static const char kInconclusiveProprietaryCodecsExpression[] =
+    "avc1,avc1.??????,avc3,avc3.??????,mp4a.40,mp4a.66,mp4a.68";
 
-static const MediaFormatStrict format_mp4_codec_mappings[] = {
-  { "audio/mp4", kProprietaryAudioCodecsExpression },
-  { "audio/x-m4a", kProprietaryAudioCodecsExpression },
-  { "video/mp4", kProprietaryCodecsExpression },
-  { "video/x-m4v", kProprietaryCodecsExpression },
-  { "application/x-mpegurl", kProprietaryCodecsExpression },
-  { "application/vnd.apple.mpegurl", kProprietaryCodecsExpression }
+static const MediaFormatStrict format_inconclusive_codec_mappings[] = {
+    {"audio/mp4", kInconclusiveProprietaryAudioCodecsExpression},
+    {"audio/x-m4a", kInconclusiveProprietaryAudioCodecsExpression},
+    {"video/mp4", kInconclusiveProprietaryCodecsExpression},
+    {"video/x-m4v", kInconclusiveProprietaryCodecsExpression},
+    {"application/x-mpegurl", kInconclusiveProprietaryCodecsExpression},
+    {"application/vnd.apple.mpegurl", kInconclusiveProprietaryCodecsExpression},
 };
 
 MimeUtil::MimeUtil() {
   InitializeMimeTypeMaps();
 }
 
 // static
-bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
-                                  const std::vector<std::string>& codecs) {
-  if (supported_codecs.empty())
+// Checks all the codecs present in the |codecs| against the entries in
+// |supported_codecs|. Returns true only if |codecs| is non-empty and all the
+// codecs match |supported_codecs| expressions.
+bool MimeUtil::AreCodecsListedInSingleLookupTable(
+    const MimeExpressionMappings& supported_codecs,
+    const std::vector<std::string>& codecs) {
+  MimeExpressionMappings empty_vector;
+  return AreCodecsListedInMultipleLookupTables(
+      supported_codecs, empty_vector, codecs);
+}
+
+// static
+// Checks all the codecs present in the |codecs| against the entries in
+// |supported_codecs|. Returns true only if |codecs| is non-empty and all the
+// codecs match expression in either |confirmed_supported_codecs| or
+// |mightbe_supported_codecs|.
+bool MimeUtil::AreCodecsListedInMultipleLookupTables(
+    const MimeExpressionMappings& confirmed_supported_codecs,
+    const MimeExpressionMappings& mightbe_supported_codecs,
+    const std::vector<std::string>& codecs) {
+  if (confirmed_supported_codecs.empty() && mightbe_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();
-}
-
-// Checks all the codecs present in the |codecs| against the entries in
-// |supported_codecs|. Returns true only if |codecs| is non-empty and all the
-// codecs match |supported_codecs| expressions.
-bool MimeUtil::AreSupportedCodecsWithProfile(
-    const MimeExpressionMappings& supported_codecs,
-    const std::vector<std::string>& codecs) {
-  DCHECK(!supported_codecs.empty());
-  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(base::StringPiece(codecs[i]),
-                        base::StringPiece(supported_codecs[j]))) {
-        continue;
+    std::string matched_codec;
+    for (size_t j = 0; j < confirmed_supported_codecs.size(); ++j) {
+      if (MatchPattern(base::StringPiece(codecs[i]),
+                       base::StringPiece(confirmed_supported_codecs[j]))) {
+        matched_codec = confirmed_supported_codecs[j];
+        break;
       }
+    }
+    for (size_t j = 0;
+         j < mightbe_supported_codecs.size() && matched_codec.empty();
+         ++j) {
+      if (MatchPattern(base::StringPiece(codecs[i]),
+                       base::StringPiece(mightbe_supported_codecs[j]))) {
+        matched_codec = mightbe_supported_codecs[j];
+        break;
+      }
+    }
+    if (!matched_codec.empty()) {
       // If suffix exists, check whether it is hexadecimal.
-      for (size_t wildcard_pos = supported_codecs[j].find('?');
+      for (size_t wildcard_pos = matched_codec.find('?');
            wildcard_pos != std::string::npos &&
-           wildcard_pos < supported_codecs[j].length();
-           wildcard_pos = supported_codecs[j].find('?', wildcard_pos + 1)) {
+               wildcard_pos < matched_codec.length();
+           wildcard_pos = matched_codec.find('?', wildcard_pos + 1)) {
         // Don't enforce case sensitivity, even though it's called for, as it
         // would break some websites.
         if (wildcard_pos >= codecs[i].length() ||
             !IsHexDigit(codecs[i].at(wildcard_pos))) {
           return false;
         }
       }
-      codec_matched = true;
-      break;
+    } else {
+      return false;
     }
-    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]);
@@ skipping 29 matching lines @@
 #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(common_media_codecs); ++i) {
 #if defined(OS_ANDROID)
     if (!IsCodecSupportedOnAndroid(common_media_codecs[i]))
       continue;
 #endif
-    codecs_map_.insert(common_media_codecs[i]);
+    codecs_map_.push_back(common_media_codecs[i]);
   }
 #if defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
-    codecs_map_.insert(proprietary_media_codecs[i]);
+    codecs_map_.push_back(proprietary_media_codecs[i]);
 #endif
 
   // 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);
 
-    MimeMappings codecs;
+    MimeExpressionMappings 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]);
+      codecs.push_back(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) {
+  for (size_t i = 0; i < arraysize(format_inconclusive_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
-    ParseCodecString(
-        format_mp4_codec_mappings[i].codecs_list, &mime_type_codecs, false);
+    ParseCodecString(format_inconclusive_codec_mappings[i].codecs_list,
+                     &mime_type_codecs,
+                     false);
 
     MimeExpressionMappings codecs;
-    for (size_t j = 0; j < mime_type_codecs.size(); ++j)
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
+#if defined(OS_ANDROID)
+      if (!IsCodecSupportedOnAndroid(mime_type_codecs[j]))
+        continue;
+#endif
       codecs.push_back(mime_type_codecs[j]);
-    strict_mp4_format_map_[format_mp4_codec_mappings[i].mime_type] = codecs;
+    }
+    inconclusive_format_map_[format_inconclusive_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 137 matching lines @@
   for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
     if (lower_type.compare(legal_top_level_types[i]) == 0)
       return true;
   }
 
   return type_string.size() > 2 && StartsWithASCII(type_string, "x-", false);
 }
 
 bool MimeUtil::AreSupportedMediaCodecs(
     const std::vector<std::string>& codecs) const {
-  return AreSupportedCodecs(codecs_map_, codecs);
+  return AreCodecsListedInSingleLookupTable(codecs_map_, codecs);
 }
 
 void MimeUtil::ParseCodecString(const std::string& codecs,
                                 std::vector<std::string>* codecs_out,
                                 bool strip) {
   std::string no_quote_codecs;
   base::TrimString(codecs, "\"", &no_quote_codecs);
   base::SplitString(no_quote_codecs, ',', codecs_out);
 
   if (!strip)
     return;
 
   // Strip everything past the first '.'
   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() &&
-      strict_mp4_format_map_.find(mime_type) == strict_mp4_format_map_.end())
+  if (strict_format_map_.find(mime_type) == strict_format_map_.end())
     return false;
   return true;
 }
 
 SupportsType MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
-  StrictMappings::const_iterator it_strict_map =
+  StrictExpressionMappings::const_iterator it_strict_map =
       strict_format_map_.find(mime_type);
   if ((it_strict_map != strict_format_map_.end()) &&
-      AreSupportedCodecs(it_strict_map->second, codecs)) {
+      AreCodecsListedInSingleLookupTable(it_strict_map->second, codecs)) {
     return IsSupported;
   }
 
   StrictExpressionMappings::const_iterator it_expression_map =
-      strict_mp4_format_map_.find(mime_type);
-  if ((it_expression_map != strict_mp4_format_map_.end()) &&
-      AreSupportedCodecsWithProfile(it_expression_map->second, codecs)) {
-    return MayBeSupported;
+      inconclusive_format_map_.find(mime_type);
+  if (it_expression_map != inconclusive_format_map_.end()) {
+    bool maybe = false;
+    if (it_strict_map != strict_format_map_.end()) {
+      maybe = AreCodecsListedInMultipleLookupTables(it_strict_map->second,
+                                                    it_expression_map->second,
+                                                    codecs);
+    } else {
+      maybe = AreCodecsListedInSingleLookupTable(it_expression_map->second,
+                                                 codecs);
+    }
+
+    if (maybe)
+      return MayBeSupported;
   }
 
   if (codecs.empty())
     return MayBeSupported;
 
   return IsNotSupported;
 }
 
 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]);
+  for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i) {
+    codecs_map_.erase(std::remove(codecs_map_.begin(),
+                                  codecs_map_.end(),
+                                  proprietary_media_codecs[i]),
+                      codecs_map_.end());
+  }
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
@@ skipping 305 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