Move WebMIMERegistry impl from //content to blink:platform/network/mime

third_party/WebKit/Source/core/html/HTMLMediaElement.cpp

 /*
  * Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 58 matching lines @@
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/FrameLoaderClient.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/NetworkStateNotifier.h"
 #include "platform/ContentType.h"
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.h"
 #include "platform/MIMETypeFromURL.h"
-#include "platform/MIMETypeRegistry.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/audio/AudioBus.h"
 #include "platform/audio/AudioSourceProviderClient.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/mediastream/MediaStreamDescriptor.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioSourceProvider.h"
 #include "public/platform/WebContentDecryptionModule.h"
@@ skipping 165 matching lines @@
   // If no MIME type is specified, always attempt to load.
   if (contentMIMEType.isEmpty())
     return true;
 
   // 4.8.10.3 MIME types - In the absence of a specification to the contrary,
   // the MIME type "application/octet-stream" when used with parameters, e.g.
   // "application/octet-stream;codecs=theora", is a type that the user agent
   // knows it cannot render.
   if (contentMIMEType != "application/octet-stream" ||
       contentTypeCodecs.isEmpty()) {
-    WebMimeRegistry::SupportsType supported =
-        Platform::current()->mimeRegistry()->supportsMediaMIMEType(
-            contentMIMEType, contentTypeCodecs);
-    return supported > WebMimeRegistry::IsNotSupported;
+    return MIMETypeRegistry::supportsMediaMIMEType(contentMIMEType,
+                                                   contentTypeCodecs);
   }
 
   return false;
 }
 
 String preloadTypeToString(WebMediaPlayer::Preload preloadType) {
   switch (preloadType) {
     case WebMediaPlayer::PreloadNone:
       return "none";
     case WebMediaPlayer::PreloadMetaData:
@@ skipping 71 matching lines @@
 
   Member<HTMLMediaElement> m_element;
 };
 
 void HTMLMediaElement::recordAutoplayMetric(AutoplayMetrics metric) {
   DEFINE_STATIC_LOCAL(EnumerationHistogram, autoplayHistogram,
                       ("Blink.MediaElement.Autoplay", NumberOfAutoplayMetrics));
   autoplayHistogram.count(metric);
 }
 
-WebMimeRegistry::SupportsType HTMLMediaElement::supportsType(
+MIMETypeRegistry::SupportsType HTMLMediaElement::supportsType(
     const ContentType& contentType) {
   DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
   String type = contentType.type().lower();
   // The codecs string is not lower-cased because MP4 values are case sensitive
   // per http://tools.ietf.org/html/rfc4281#page-7.
   String typeCodecs = contentType.parameter(codecs);
 
   if (type.isEmpty())
-    return WebMimeRegistry::IsNotSupported;
+    return MIMETypeRegistry::IsNotSupported;
 
   // 4.8.10.3 MIME types - The canPlayType(type) method must return the empty
   // string if type is a type that the user agent knows it cannot render or is
   // the type "application/octet-stream"
   if (type == "application/octet-stream")
-    return WebMimeRegistry::IsNotSupported;
+    return MIMETypeRegistry::IsNotSupported;
 
-  return Platform::current()->mimeRegistry()->supportsMediaMIMEType(type,
-                                                                    typeCodecs);
+  return MIMETypeRegistry::supportsMediaMIMEType(type, typeCodecs);
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
 void HTMLMediaElement::setMediaStreamRegistry(URLRegistry* registry) {
   DCHECK(!s_mediaStreamRegistry);
   s_mediaStreamRegistry = registry;
 }
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url) {
@@ skipping 322 matching lines @@
   BLINK_MEDIA_LOG << "setSrcObject(" << (void*)this << ")";
   m_srcObject = srcObject;
   invokeLoadAlgorithm();
 }
 
 HTMLMediaElement::NetworkState HTMLMediaElement::getNetworkState() const {
   return m_networkState;
 }
 
 String HTMLMediaElement::canPlayType(const String& mimeType) const {
-  WebMimeRegistry::SupportsType support = supportsType(ContentType(mimeType));
+  MIMETypeRegistry::SupportsType support = supportsType(ContentType(mimeType));
   String canPlay;
 
   // 4.8.10.3
   switch (support) {
-    case WebMimeRegistry::IsNotSupported:
+    case MIMETypeRegistry::IsNotSupported:
       canPlay = emptyString();
       break;
-    case WebMimeRegistry::MayBeSupported:
+    case MIMETypeRegistry::MayBeSupported:
       canPlay = "maybe";
       break;
-    case WebMimeRegistry::IsSupported:
+    case MIMETypeRegistry::IsSupported:
       canPlay = "probably";
       break;
   }
 
   BLINK_MEDIA_LOG << "canPlayType(" << (void*)this << ", " << mimeType
                   << ") -> " << canPlay;
 
   return canPlay;
 }
 
@@ skipping 3343 matching lines @@
 
 IntRect HTMLMediaElement::AutoplayHelperClientImpl::absoluteBoundingBoxRect()
     const {
   IntRect result;
   if (LayoutObject* object = m_element->layoutObject())
     result = object->absoluteBoundingBoxRect();
   return result;
 }
 
 }  // namespace blink