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,
+  static bool AreSupportedCodecs(const MimeExpressionMappings& 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(
-      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_;
+  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) {
+// 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::AreSupportedCodecs(
+    const MimeExpressionMappings& 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();
-}
-
-// 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;
       }
       // If suffix exists, check whether it is hexadecimal.
       for (size_t wildcard_pos = supported_codecs[j].find('?');
            wildcard_pos != std::string::npos &&
            wildcard_pos < supported_codecs[j].length();
            wildcard_pos = supported_codecs[j].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;
     }
     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);
+        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 161 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() &&
-      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)) {
     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()) {
+    MimeExpressionMappings all_supported_codecs = it_expression_map->second;

[amogh.bihani, 2014/07/11 09:03:53]

Now the coping part has moved here :(. I am sorry if I have misunderstood the
comment, from what I could get I can say that at some point we will have to
merge two vectors as AreSupportedCodecs() accepts vectors. If we change that
method to accept string instead of vector then we will also have to make changes
at other places (like line 822-825, line 859 etc) and call it in a loop.

Frankly putting it I am not pretty happy with what I have done here as I have
introduced another vector which stores the same things again. Earlier we had to
store conclusive and (conclusive + inconclusive), now we store conclusive,
inconclusive and (conclusive + inconclusive).However, if the compiler optimizes
the heap memory allocation, then this might be better (but I am not sure on that
part).

[Ryan Sleevi, 2014/07/11 18:51:17]

I'm sorry, I'm still not clear why you need to store (conclusive + inconclusive)

My request was that you have (conclusive) and (inconclusive). If you need to
check for the set of those two, you do so within the function, not by making a
copy.

Why can you not make a version of AreSupportedCodecs take two factors -
conclusive and inconclusive? It's an internal function.

+    if (it_strict_map != strict_format_map_.end()) {
+      all_supported_codecs.insert(all_supported_codecs.end(),
+          it_strict_map->second.begin(), it_strict_map->second.end());
+    }
+    if (AreSupportedCodecs(all_supported_codecs, codecs))
+      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