Add UMA logging to track bad MIME types passed to HTMLMediaElement

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 66 matching lines @@
 #include "core/page/ChromeClient.h"
 #include "platform/Histogram.h"
 #include "platform/LayoutTestSupport.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/network/NetworkStateNotifier.h"
+#include "platform/network/ParsedContentType.h"
 #include "platform/network/mime/ContentType.h"
 #include "platform/network/mime/MIMETypeFromURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebAudioSourceProvider.h"
 #include "public/platform/WebContentDecryptionModule.h"
 #include "public/platform/WebInbandTextTrack.h"
 #include "public/platform/WebMediaPlayerSource.h"
 #include "public/platform/WebMediaStream.h"
 #include "public/platform/modules/remoteplayback/WebRemotePlaybackAvailability.h"
@@ skipping 38 matching lines @@
 // This enum is used to record histograms. Do not reorder.
 enum MediaControlsShow {
   MediaControlsShowAttribute = 0,
   MediaControlsShowFullscreen,
   MediaControlsShowNoScript,
   MediaControlsShowNotShown,
   MediaControlsShowDisabledSettings,
   MediaControlsShowMax
 };
 
+// These values are used for the Media.MediaElement.ContentTypeResult histogram.
+// Do not reorder.
+enum ContentTypeParseableResult {
+  IsSupportedParseable = 0,
+  MayBeSupportedParseable,
+  IsNotSupportedParseable,
+  IsSupportedNotParseable,
+  MayBeSupportedNotParseable,
+  IsNotSupportedNotParseable,
+  ContentTypeParseableMax
+};
+
+void ReportContentTypeResultToUMA(String contentType,
+                                  MIMETypeRegistry::SupportsType result) {
+  DEFINE_THREAD_SAFE_STATIC_LOCAL(
+      EnumerationHistogram, contentTypeParseableHistogram,
+      new EnumerationHistogram("Media.MediaElement.ContentTypeParseable",
+                               ContentTypeParseableMax));
+  ParsedContentType parsedContentType(contentType);
+  ContentTypeParseableResult umaResult = IsNotSupportedNotParseable;
+  switch (result) {
+    case MIMETypeRegistry::IsSupported:
+      umaResult = parsedContentType.isValid() ? IsSupportedParseable
+                                              : IsSupportedNotParseable;
+      break;
+    case MIMETypeRegistry::MayBeSupported:
+      umaResult = parsedContentType.isValid() ? MayBeSupportedParseable
+                                              : MayBeSupportedNotParseable;
+      break;
+    case MIMETypeRegistry::IsNotSupported:
+      umaResult = parsedContentType.isValid() ? IsNotSupportedParseable
+                                              : IsNotSupportedNotParseable;
+      break;
+  }
+  contentTypeParseableHistogram.count(umaResult);
+}
+
 String urlForLoggingMedia(const KURL& url) {
   static const unsigned maximumURLLengthForLogging = 128;
 
   if (url.getString().length() < maximumURLLengthForLogging)
     return url.getString();
   return url.getString().substring(0, maximumURLLengthForLogging) + "...";
 }
 
 const char* boolString(bool val) {
   return val ? "true" : "false";
@@ skipping 85 matching lines @@
     case WebMediaPlayerClient::VideoTrackKindSubtitles:
       return VideoTrack::subtitlesKeyword();
     case WebMediaPlayerClient::VideoTrackKindCommentary:
       return VideoTrack::commentaryKeyword();
   }
 
   NOTREACHED();
   return emptyAtom;
 }
 
-bool canLoadURL(const KURL& url, const ContentType& contentType) {
+bool canLoadURL(const KURL& url, const String& contentTypeStr) {
   DEFINE_STATIC_LOCAL(const String, codecs, ("codecs"));
 
+  ContentType contentType(contentTypeStr);
   String contentMIMEType = contentType.type().lower();
   String contentTypeCodecs = contentType.parameter(codecs);
 
   // If the MIME type is missing or is not meaningful, try to figure it out from
   // the URL.
   if (contentMIMEType.isEmpty() ||
       contentMIMEType == "application/octet-stream" ||
       contentMIMEType == "text/plain") {
     if (url.protocolIsData())
       contentMIMEType = mimeTypeFromDataURL(url.getString());
   }
 
   // If no MIME type is specified, always attempt to load.
   if (contentMIMEType.isEmpty())
     return true;
 
   // 4.8.12.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()) {
     return MIMETypeRegistry::supportsMediaMIMEType(contentMIMEType,
-                                                   contentTypeCodecs);
+                                                   contentTypeCodecs) !=
+           MIMETypeRegistry::IsNotSupported;
   }
 
   return false;
 }
 
 String preloadTypeToString(WebMediaPlayer::Preload preloadType) {
   switch (preloadType) {
     case WebMediaPlayer::PreloadNone:
       return "none";
     case WebMediaPlayer::PreloadMetaData:
@@ skipping 59 matching lines @@
 
   if (type.isEmpty())
     return MIMETypeRegistry::IsNotSupported;
 
   // 4.8.12.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 MIMETypeRegistry::IsNotSupported;
 
-  return MIMETypeRegistry::supportsMediaMIMEType(type, typeCodecs);
+  // Check if stricter parsing of |contentType| will cause problems.
+  // TODO(jrummell): Either switch to ParsedContentType or remove this UMA,
+  // depending on the results reported.
+  MIMETypeRegistry::SupportsType result =
+      MIMETypeRegistry::supportsMediaMIMEType(type, typeCodecs);
+  ReportContentTypeResultToUMA(contentType.raw(), result);
+  return result;
 }
 
 URLRegistry* HTMLMediaElement::s_mediaStreamRegistry = 0;
 
 void HTMLMediaElement::setMediaStreamRegistry(URLRegistry* registry) {
   DCHECK(!s_mediaStreamRegistry);
   s_mediaStreamRegistry = registry;
 }
 
 bool HTMLMediaElement::isMediaStreamURL(const String& url) {
@@ skipping 680 matching lines @@
       NOTREACHED();
   }
 }
 
 void HTMLMediaElement::loadSourceFromObject() {
   DCHECK(m_srcObject);
   m_loadState = LoadingFromSrcObject;
 
   // No type is available when the resource comes from the 'srcObject'
   // attribute.
-  loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)),
-               ContentType((String())));
+  loadResource(WebMediaPlayerSource(WebMediaStream(m_srcObject)), String());
 }
 
 void HTMLMediaElement::loadSourceFromAttribute() {
   m_loadState = LoadingFromSrcAttr;
   const AtomicString& srcValue = fastGetAttribute(srcAttr);
 
   // If the src attribute's value is the empty string ... jump down to the
   // failed step below
   if (srcValue.isEmpty()) {
     mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     BLINK_MEDIA_LOG << "loadSourceFromAttribute(" << (void*)this
                     << "), empty 'src'";
     return;
   }
 
   KURL mediaURL = document().completeURL(srcValue);
   if (!isSafeToLoadURL(mediaURL, Complain)) {
     mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     return;
   }
 
   // No type is available when the url comes from the 'src' attribute so
   // MediaPlayer will have to pick a media engine based on the file extension.
-  loadResource(WebMediaPlayerSource(WebURL(mediaURL)), ContentType((String())));
+  loadResource(WebMediaPlayerSource(WebURL(mediaURL)), String());
 }
 
 void HTMLMediaElement::loadNextSourceChild() {
-  ContentType contentType((String()));
+  String contentType;
   KURL mediaURL = selectNextSourceChild(&contentType, Complain);
   if (!mediaURL.isValid()) {
     waitForSourceChange();
     return;
   }
 
   // Reset the MediaPlayer and MediaSource if any
   resetMediaPlayerAndMediaSource();
 
   m_loadState = LoadingFromSourceElement;
   loadResource(WebMediaPlayerSource(WebURL(mediaURL)), contentType);
 }
 
 void HTMLMediaElement::loadResource(const WebMediaPlayerSource& source,
-                                    const ContentType& contentType) {
+                                    const String& contentType) {
   DCHECK(isMainThread());
   KURL url;
   if (source.isURL()) {
     url = source.getAsURL();
     DCHECK(isSafeToLoadURL(url, Complain));
     BLINK_MEDIA_LOG << "loadResource(" << (void*)this << ", "
-                    << urlForLoggingMedia(url) << ", " << contentType.raw()
-                    << ")";
+                    << urlForLoggingMedia(url) << ", " << contentType << ")";
   }
 
   LocalFrame* frame = document().frame();
   if (!frame) {
     mediaLoadingFailed(WebMediaPlayer::NetworkStateFormatError);
     return;
   }
 
   // The resource fetch algorithm
   setNetworkState(kNetworkLoading);
@@ skipping 1774 matching lines @@
   AutomaticTrackSelection trackSelection(configuration);
   trackSelection.perform(*m_textTracks);
 }
 
 bool HTMLMediaElement::havePotentialSourceChild() {
   // Stash the current <source> node and next nodes so we can restore them after
   // checking to see there is another potential.
   HTMLSourceElement* currentSourceNode = m_currentSourceNode;
   Node* nextNode = m_nextChildNodeToConsider;
 
-  KURL nextURL = selectNextSourceChild(0, DoNothing);
+  KURL nextURL = selectNextSourceChild(nullptr, DoNothing);
 
   m_currentSourceNode = currentSourceNode;
   m_nextChildNodeToConsider = nextNode;
 
   return nextURL.isValid();
 }
 
-KURL HTMLMediaElement::selectNextSourceChild(ContentType* contentType,
+KURL HTMLMediaElement::selectNextSourceChild(String* contentType,
                                              InvalidURLAction actionIfInvalid) {
   // Don't log if this was just called to find out if there are any valid
   // <source> elements.
   bool shouldLog = actionIfInvalid != DoNothing;
   if (shouldLog)
     BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ")";
 
   if (!m_nextChildNodeToConsider) {
     if (shouldLog)
       BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this
@@ skipping 63 matching lines @@
     // Making it this far means the <source> looks reasonable.
     canUseSourceElement = true;
 
   checkAgain:
     if (!canUseSourceElement && actionIfInvalid == Complain && source)
       source->scheduleErrorEvent();
   }
 
   if (canUseSourceElement) {
     if (contentType)
-      *contentType = ContentType(type);
+      *contentType = type;
     m_currentSourceNode = source;
     m_nextChildNodeToConsider = source->nextSibling();
   } else {
     m_currentSourceNode = nullptr;
     m_nextChildNodeToConsider = nullptr;
   }
 
   if (shouldLog)
     BLINK_MEDIA_LOG << "selectNextSourceChild(" << (void*)this << ") -> "
                     << m_currentSourceNode.get() << ", "
@@ skipping 1199 matching lines @@
       kMostlyFillViewportBecomeStableSeconds, BLINK_FROM_HERE);
 }
 
 void HTMLMediaElement::viewportFillDebouncerTimerFired(TimerBase*) {
   m_mostlyFillingViewport = true;
   if (m_webMediaPlayer)
     m_webMediaPlayer->becameDominantVisibleContent(m_mostlyFillingViewport);
 }
 
 }  // namespace blink