Revert r12998 - it broke some media/mime-related layout tests.

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 <map>
 #include <string>
 
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
@@ skipping 37 matching lines @@
   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;
 
  private:
   friend struct base::DefaultLazyInstanceTraits<MimeUtil>;
-
-  typedef base::hash_set<std::string> MimeMappings;
-  typedef std::map<std::string, MimeMappings> StrictMappings;
-
-  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);
+  MimeUtil() {
+    InitializeMimeTypeMaps();
+  }
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
-  bool GetMimeTypeFromExtensionHelper(const FilePath::StringType& ext,
-                                      bool include_platform_types,
-                                      std::string* mime_type) const;
+  bool GetMimeTypeFromExtensionHelper(
+      const FilePath::StringType& ext, bool include_platform_types,
+      std::string* mime_type) const;
 
+  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
 
 static base::LazyInstance<MimeUtil> g_mime_util = LAZY_INSTANCE_INITIALIZER;
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
 
@@ skipping 63 matching lines @@
   }
   return NULL;
 }
 
 bool MimeUtil::GetMimeTypeFromExtension(const FilePath::StringType& ext,
                                         string* result) const {
   return GetMimeTypeFromExtensionHelper(ext, true, result);
 }
 
 bool MimeUtil::GetWellKnownMimeTypeFromExtension(
-    const FilePath::StringType& ext,
-    string* result) const {
+    const FilePath::StringType& ext, string* result) const {
   return GetMimeTypeFromExtensionHelper(ext, false, result);
 }
 
 bool MimeUtil::GetMimeTypeFromFile(const FilePath& file_path,
                                    string* result) const {
   FilePath::StringType file_name_str = file_path.Extension();
   if (file_name_str.empty())
     return false;
   return GetMimeTypeFromExtension(file_name_str.substr(1), result);
 }
 
-bool MimeUtil::GetMimeTypeFromExtensionHelper(const FilePath::StringType& ext,
-                                              bool include_platform_types,
-                                              string* result) const {
+bool MimeUtil::GetMimeTypeFromExtensionHelper(
+    const FilePath::StringType& ext, bool include_platform_types,
+    string* result) const {
   // Avoids crash when unable to handle a long file path. See crbug.com/48733.
   const unsigned kMaxFilePathSize = 65536;
   if (ext.length() > kMaxFilePathSize)
     return false;
 
   // We implement the same algorithm as Mozilla for mapping a file extension to
   // a mime type.  That is, we first check a hard-coded list (that cannot be
   // overridden), and then if not found there, we defer to the system registry.
   // Finally, we scan a secondary hard-coded list to catch types that we can
   // deduce but that we also want to allow the OS to override.
@@ skipping 153 matching lines @@
   const char* mime_type;
   const char* codecs_list;
 };
 
 static const MediaFormatStrict format_codec_mappings[] = {
   { "video/webm", "vorbis,vp8,vp8.0" },
   { "audio/webm", "vorbis" },
   { "audio/wav", "1" }
 };
 
-MimeUtil::MimeUtil() {
-  InitializeMimeTypeMaps();
-}
-
-// static
-bool MimeUtil::AreSupportedCodecs(const MimeMappings& supported_codecs,
-                                  const std::vector<std::string>& codecs) {
-  for (size_t i = 0; i < codecs.size(); ++i) {
-    if (supported_codecs.find(codecs[i]) == supported_codecs.end())
-      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_javascript_types); ++i)
     non_image_map_.insert(supported_javascript_types[i]);
   for (size_t i = 0; i < arraysize(supported_media_types); ++i)
@@ skipping 46 matching lines @@
   return view_source_map_.find(mime_type) != view_source_map_.end();
 }
 
 // Mirrors WebViewImpl::CanShowMIMEType()
 bool MimeUtil::IsSupportedMimeType(const std::string& mime_type) const {
   return (mime_type.compare(0, 6, "image/") == 0 &&
           IsSupportedImageMimeType(mime_type.c_str())) ||
          IsSupportedNonImageMimeType(mime_type.c_str());
 }
 
-bool MimeUtil::MatchesMimeType(const std::string& mime_type_pattern,
-                               const std::string& mime_type) const {
+bool MimeUtil::MatchesMimeType(const std::string &mime_type_pattern,
+                               const std::string &mime_type) const {
   // verify caller is passing lowercase
   DCHECK_EQ(StringToLowerASCII(mime_type_pattern), mime_type_pattern);
   DCHECK_EQ(StringToLowerASCII(mime_type), mime_type);
 
   // This comparison handles absolute maching and also basic
   // wildcards.  The plugin mime types could be:
   //      application/x-foo
   //      application/*
   //      application/*+xml
   //      *
@@ skipping 17 matching lines @@
 
   if (!right.empty() &&
       mime_type.rfind(right) != mime_type.length() - right.length())
     return false;
 
   return true;
 }
 
 bool MimeUtil::AreSupportedMediaCodecs(
     const std::vector<std::string>& codecs) const {
-  return AreSupportedCodecs(codecs_map_, codecs);
+  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,
                                 bool strip) {
   std::string no_quote_codecs;
   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())
     return false;
   return true;
 }
 
-bool MimeUtil::IsSupportedStrictMediaMimeType(
-    const std::string& mime_type,
+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);
+
+  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
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
@@ skipping 230 matching lines @@
 
   GetExtensionsFromHardCodedMappings(secondary_mappings,
                                      arraysize(secondary_mappings),
                                      mime_type,
                                      &unique_extensions);
 
   HashSetToVector(&unique_extensions, extensions);
 }
 
 }  // namespace net