Chromium side changes for enabling VP8 and WebM support.

net/base/mime_util.cc

-// Copyright (c) 2006-2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 <map>
 #include <string>
 
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 19 matching lines @@
   bool IsViewSourceMimeType(const char* mime_type) const;
 
   bool IsSupportedMimeType(const std::string& mime_type) const;
 
   bool MatchesMimeType(const std::string &mime_type_pattern,
                        const std::string &mime_type) const;
 
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
-                        std::vector<std::string>* codecs_out);
+                        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;
 
  private:
   friend struct DefaultSingletonTraits<MimeUtil>;
   MimeUtil() {
     InitializeMimeTypeMaps();
   }
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   typedef base::hash_set<std::string> MimeMappings;
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings javascript_map_;
   MimeMappings view_source_map_;
   MimeMappings codecs_map_;
+
+  typedef std::map<std::string, base::hash_set<std::string> > StrictMappings;
+  StrictMappings strict_format_map_;
 };  // class MimeUtil
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
 
 static const MimeInfo primary_mappings[] = {
   { "text/html", "html,htm" },
   { "text/css", "css" },
   { "text/xml", "xml" },
   { "image/gif", "gif" },
   { "image/jpeg", "jpeg,jpg" },
   { "image/png", "png" },
   { "video/mp4", "mp4,m4v" },
   { "audio/x-m4a", "m4a" },
   { "audio/mp3", "mp3" },
   { "video/ogg", "ogv,ogm" },
   { "audio/ogg", "ogg,oga" },
+  { "video/webm", "webm" },
+  { "audio/webm", "webm" },
   { "application/xhtml+xml", "xhtml,xht" },
   { "application/x-chrome-extension", "crx" }
 };
 
 static const MimeInfo secondary_mappings[] = {
   { "application/octet-stream", "exe,com,bin" },
   { "application/gzip", "gz" },
   { "application/pdf", "pdf" },
   { "application/postscript", "ps,eps,ai" },
   { "application/x-javascript", "js" },
@@ skipping 90 matching lines @@
   "image/x-xbitmap"  // xbm
 };
 
 // A list of media types: http://en.wikipedia.org/wiki/Internet_media_type
 // A comprehensive mime type list: http://plugindoc.mozdev.org/winmime.php
 static const char* const supported_media_types[] = {
   // Ogg.
   "video/ogg",
   "audio/ogg",
   "application/ogg",
+  "video/webm",
+  "audio/webm",
 
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)
   // MPEG-4.
   "video/mp4",
   "video/x-m4v",
   "audio/mp4",
   "audio/x-m4a",
 
   // MP3.
   "audio/mp3",
   "audio/x-mp3",
   "audio/mpeg",
 #endif
 };
 
 // List of supported codecs when passed in with <source type="...">.
 //
 // Refer to http://wiki.whatwg.org/wiki/Video_type_parameters#Browser_Support
 // for more information.
 static const char* const supported_media_codecs[] = {
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)
   "avc1",
   "mp4a",
 #endif
   "theora",
   "vorbis",
+  "vp8"
 };
 
 // Note: does not include javascript types list (see supported_javascript_types)
 static const char* const supported_non_image_types[] = {
   "text/cache-manifest",
   "text/html",
   "text/xml",
   "text/xsl",
   "text/plain",
   // Many users complained about css files served for
@@ skipping 43 matching lines @@
 
 static const char* const view_source_types[] = {
   "text/xml",
   "text/xsl",
   "application/xml",
   "application/rss+xml",
   "application/atom+xml",
   "image/svg+xml"
 };
 
+struct MediaFormatStrict {
+  const char* mime_type;
+  const char* codecs_list;
+};
+
+static const MediaFormatStrict format_codec_mappings[] = {
+  { "video/webm", "vorbis,vp8,vp8.0" },
+  { "audio/webm", "vorbis" }
+};
+
 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_javascript_types); ++i)
     non_image_map_.insert(supported_javascript_types[i]);
   for (size_t i = 0; i < arraysize(supported_media_types); ++i)
     non_image_map_.insert(supported_media_types[i]);
 
   // Initialize the supported media types.
   for (size_t i = 0; i < arraysize(supported_media_types); ++i)
     media_map_.insert(supported_media_types[i]);
 
   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(view_source_types); ++i)
     view_source_map_.insert(view_source_types[i]);
 
   for (size_t i = 0; i < arraysize(supported_media_codecs); ++i)
     codecs_map_.insert(supported_media_codecs[i]);
+
+  // 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;
+    for (size_t j = 0; j < mime_type_codecs.size(); ++j)
+      codecs.insert(mime_type_codecs[j]);
+    strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
+  }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const char* mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const char* mime_type) const {
   return media_map_.find(mime_type) != media_map_.end();
 }
 
@@ skipping 57 matching lines @@
     const std::vector<std::string>& codecs) const {
   for (size_t i = 0; i < codecs.size(); ++i) {
     if (codecs_map_.find(codecs[i]) == codecs_map_.end()) {
       return false;
     }
   }
   return true;
 }
 
 void MimeUtil::ParseCodecString(const std::string& codecs,
-                                std::vector<std::string>* codecs_out) {
+                                std::vector<std::string>* codecs_out,
+                                bool strip) {
   std::string no_quote_codecs;
   TrimString(codecs, "\"", &no_quote_codecs);
   SplitString(no_quote_codecs, ',', codecs_out);
 
-  // Truncate each string at the '.'
+  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())
+    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);
+
+  if (it == strict_format_map_.end())
+    return false;
+
+  const MimeMappings strict_codecs_map = it->second;
+  for (size_t i = 0; i < codecs.size(); ++i) {
+    if (strict_codecs_map.find(codecs[i]) == strict_codecs_map.end()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 static MimeUtil* GetMimeUtil() {
   return Singleton<MimeUtil>::get();
 }
 
 bool GetMimeTypeFromExtension(const FilePath::StringType& ext,
                               std::string* mime_type) {
@@ skipping 35 matching lines @@
 
 bool MatchesMimeType(const std::string &mime_type_pattern,
                      const std::string &mime_type) {
   return GetMimeUtil()->MatchesMimeType(mime_type_pattern, mime_type);
 }
 
 bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) {
   return GetMimeUtil()->AreSupportedMediaCodecs(codecs);
 }
 
+bool IsStrictMediaMimeType(const std::string& mime_type) {
+  return GetMimeUtil()->IsStrictMediaMimeType(mime_type);
+}
+
+bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
+                                    const std::vector<std::string>& codecs) {
+  return GetMimeUtil()->IsSupportedStrictMediaMimeType(mime_type, codecs);
+}
+
 void ParseCodecString(const std::string& codecs,
-                      std::vector<std::string>* codecs_out) {
-  GetMimeUtil()->ParseCodecString(codecs, codecs_out);
+                      std::vector<std::string>* codecs_out,
+                      const bool strip) {
+  GetMimeUtil()->ParseCodecString(codecs, codecs_out, strip);
 }
 
 }  // namespace net