Shuffle media-related WebMimeRegistry code from webkit/ to content/.

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 59 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;
 
+  void RemoveProprietaryMediaTypesAndCodecsForTests();
+
  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|.
@@ skipping 578 matching lines @@
 }
 
 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);
 }
 
+void MimeUtil::RemoveProprietaryMediaTypesAndCodecsForTests() {
+  // Unless/until WebM files are added to the media layout tests, we need to
+  // avoid removing MP4 and H.264 when Theora is not supported (and
+  // proprietary codecs are) so that the media tests can still run.
+#if defined(ENABLE_MEDIA_CODEC_THEORA)
+#if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)

[mmenke, 2013/06/21 18:11:27]

Why the change here?

[mmenke, 2013/06/21 18:12:19]

I mean why are the ifdef's different than the old ones.

[scherkus (not reviewing), 2013/06/21 19:23:38]

actually ... we don't need these because if the types+codecs were never inserted
then this method is a no-op

the one exception is that if ENABLE_MEDIA_CODEC_THEORA is not defined we don't
want to call this method, in which case the caller should be checking for that
condition instead of net code

and you know what? this whole ENABLE_MEDIA_CODEC_THEORA define is misleading.
it's equivalent to !defined(OS_ANDROID) -- I'd much rather have that then have
to hunt down where/when its defined

+  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]);
+#endif
+#endif
+}
+
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
 bool GetMimeTypeFromExtension(const base::FilePath::StringType& ext,
                               std::string* mime_type) {
   return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
 
 bool GetMimeTypeFromFile(const base::FilePath& file_path,
@@ skipping 239 matching lines @@
 
     GetExtensionsFromHardCodedMappings(secondary_mappings,
                                        arraysize(secondary_mappings),
                                        mime_type,
                                        &unique_extensions);
   }
 
   HashSetToVector(&unique_extensions, extensions);
 }
 
-void GetMediaTypesBlacklistedForTests(std::vector<std::string>* types) {
-  types->clear();
-
-// Unless/until WebM files are added to the media layout tests, we need to avoid
-// blacklisting mp4 and H.264 when Theora is not supported (and proprietary
-// codecs are) so that the media tests can still run.
-#if defined(ENABLE_MEDIA_CODEC_THEORA) || !defined(USE_PROPRIETARY_CODECS)
-  for (size_t i = 0; i < arraysize(proprietary_media_types); ++i)
-    types->push_back(proprietary_media_types[i]);
-#endif
-}
-
-void GetMediaCodecsBlacklistedForTests(std::vector<std::string>* codecs) {
-  codecs->clear();
-
-// Unless/until WebM files are added to the media layout tests, we need to avoid
-// blacklisting mp4 and H.264 when Theora is not supported (and proprietary
-// codecs are) so that the media tests can still run.
-#if defined(ENABLE_MEDIA_CODEC_THEORA) || !defined(USE_PROPRIETARY_CODECS)
-  for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
-    codecs->push_back(proprietary_media_codecs[i]);
-#endif
+void RemoveProprietaryMediaTypesAndCodecsForTests() {
+  g_mime_util.Get().RemoveProprietaryMediaTypesAndCodecsForTests();
 }
 
 const std::string GetIANAMediaType(const std::string& mime_type) {
   for (size_t i = 0; i < arraysize(kIanaMediaTypes); ++i) {
     if (StartsWithASCII(mime_type, kIanaMediaTypes[i].matcher, true)) {
       return kIanaMediaTypes[i].name;
     }
   }
   return std::string();
 }
@@ skipping 34 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