Extracted media mime type checks from net/base/ into media/base/

mojo/services/html_viewer/webmimeregistry_impl.cc

 // Copyright 2014 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 "mojo/services/html_viewer/webmimeregistry_impl.h"
 
 #include "base/files/file_path.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
+#include "content/common/mime_util.h"
 #include "media/base/key_systems.h"
+#include "media/base/mime_util.h"
 #include "media/filters/stream_parser_factory.h"
-#include "net/base/mime_util.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace html_viewer {
 namespace {
 
 std::string ToASCIIOrEmpty(const blink::WebString& string) {
   return base::IsStringASCII(string) ? base::UTF16ToASCII(string)
                                      : std::string();
 }
 
 }  // namespace
 
 blink::WebMimeRegistry::SupportsType WebMimeRegistryImpl::supportsMIMEType(
     const blink::WebString& mime_type) {
-  return net::IsSupportedMimeType(ToASCIIOrEmpty(mime_type)) ?
+  return content::IsSupportedMimeType(ToASCIIOrEmpty(mime_type)) ?
       blink::WebMimeRegistry::IsSupported :
       blink::WebMimeRegistry::IsNotSupported;
 }
 
 blink::WebMimeRegistry::SupportsType WebMimeRegistryImpl::supportsImageMIMEType(
     const blink::WebString& mime_type) {
   return net::IsSupportedImageMimeType(ToASCIIOrEmpty(mime_type)) ?
       blink::WebMimeRegistry::IsSupported :
       blink::WebMimeRegistry::IsNotSupported;
 }
@@ skipping 16 matching lines @@
       blink::WebMimeRegistry::IsSupported :
       blink::WebMimeRegistry::IsNotSupported;
 }
 
 blink::WebMimeRegistry::SupportsType WebMimeRegistryImpl::supportsMediaMIMEType(
     const blink::WebString& mime_type,
     const blink::WebString& codecs,
     const blink::WebString& key_system) {
   const std::string mime_type_ascii = ToASCIIOrEmpty(mime_type);
   // Not supporting the container is a flat-out no.
-  if (!net::IsSupportedMediaMimeType(mime_type_ascii))
+  if (!media::IsSupportedMediaMimeType(mime_type_ascii))
     return IsNotSupported;
 
   // Mojo does not currently support any key systems.
   if (!key_system.isEmpty())
     return IsNotSupported;
 
   // Check list of strict codecs to see if it is supported.
-  if (net::IsStrictMediaMimeType(mime_type_ascii)) {
+  if (media::IsStrictMediaMimeType(mime_type_ascii)) {
     // Check if the codecs are a perfect match.
     std::vector<std::string> strict_codecs;
-    net::ParseCodecString(ToASCIIOrEmpty(codecs), &strict_codecs, false);
+    media::ParseCodecString(ToASCIIOrEmpty(codecs), &strict_codecs, false);
     return static_cast<WebMimeRegistry::SupportsType>(
-        net::IsSupportedStrictMediaMimeType(mime_type_ascii, strict_codecs));
+        media::IsSupportedStrictMediaMimeType(mime_type_ascii, strict_codecs));
   }
 
   // If we don't recognize the codec, it's possible we support it.
   std::vector<std::string> parsed_codecs;
-  net::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codecs, true);
-  if (!net::AreSupportedMediaCodecs(parsed_codecs))
+  media::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codecs, true);
+  if (!media::AreSupportedMediaCodecs(parsed_codecs))
     return MayBeSupported;
 
   // Otherwise we have a perfect match.
   return IsSupported;
 }
 
 bool WebMimeRegistryImpl::supportsMediaSourceMIMEType(
     const blink::WebString& mime_type,
     const blink::WebString& codecs) {
   const std::string mime_type_ascii = ToASCIIOrEmpty(mime_type);
   if (mime_type_ascii.empty())
     return false;
 
   std::vector<std::string> parsed_codec_ids;
-  net::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codec_ids, false);
+  media::ParseCodecString(ToASCIIOrEmpty(codecs), &parsed_codec_ids, false);
   return media::StreamParserFactory::IsTypeSupported(mime_type_ascii,
                                                      parsed_codec_ids);
 }
 
 bool WebMimeRegistryImpl::supportsEncryptedMediaMIMEType(
     const blink::WebString& key_system,
     const blink::WebString& mime_type,
     const blink::WebString& codecs) {
   // Only supports ASCII parameters.
   if (!base::IsStringASCII(key_system) || !base::IsStringASCII(mime_type) ||
       !base::IsStringASCII(codecs)) {
     return false;
   }
 
   if (key_system.isEmpty())
     return false;
 
   const std::string mime_type_ascii = base::UTF16ToASCII(mime_type);
 
   std::vector<std::string> codec_vector;
-  bool strip_suffix = !net::IsStrictMediaMimeType(mime_type_ascii);
-  net::ParseCodecString(base::UTF16ToASCII(codecs), &codec_vector,
-                        strip_suffix);
+  bool strip_suffix = !media::IsStrictMediaMimeType(mime_type_ascii);
+  media::ParseCodecString(base::UTF16ToASCII(codecs), &codec_vector,
+                          strip_suffix);
 
   return media::IsSupportedKeySystemWithMediaMimeType(
       mime_type_ascii, codec_vector, base::UTF16ToASCII(key_system));
 }
 
 blink::WebMimeRegistry::SupportsType
     WebMimeRegistryImpl::supportsNonImageMIMEType(
     const blink::WebString& mime_type) {
   return net::IsSupportedNonImageMimeType(ToASCIIOrEmpty(mime_type)) ?
       blink::WebMimeRegistry::IsSupported :
@@ skipping 12 matching lines @@
   return blink::WebString();
 }
 
 blink::WebString WebMimeRegistryImpl::mimeTypeFromFile(
     const blink::WebString& file_path) {
   NOTIMPLEMENTED();
   return blink::WebString();
 }
 
 }  // namespace html_viewer