Wire up MediaCapabilities is_supported to MimeUtil

content/renderer/media_recorder/media_recorder_handler.cc

 // Copyright 2015 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 "content/renderer/media_recorder/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 274 matching lines @@
 
   ScopedWebCallbacks<WebMediaCapabilitiesQueryCallbacks> scoped_callbacks =
       make_scoped_web_callbacks(callbacks.release(),
                                 base::Bind(&OnEncodingInfoError));
 
   std::unique_ptr<blink::WebMediaCapabilitiesInfo> info(
       new blink::WebMediaCapabilitiesInfo());
 
   // TODO(mcasas): Support the case when both video and audio configurations are
   // specified: https://crbug.com/709181.
-  std::string content_type;
-  if (configuration.video_configuration)
-    content_type = configuration.video_configuration->content_type.Ascii();
-  else
-    content_type = configuration.audio_configuration->content_type.Ascii();
-
-  // |content_type| should be of the form "bla;codecs=foo", where "bla" is the
-  // type and "codecs=foo" is the parameter ("foo" is the parameter value), see
-  // RFC 2231 [1]. CanSupportMimeType() operates on type and parameter value.
-  // [1] https://tools.ietf.org/html/rfc2231
-  base::StringTokenizer mime_tokenizer(content_type, ";");
-  blink::WebString web_type;
-  blink::WebString web_codecs;
-  if (mime_tokenizer.GetNext())
-    web_type = blink::WebString::FromASCII(mime_tokenizer.token());
-  if (mime_tokenizer.GetNext()) {
-    const std::string parameters = mime_tokenizer.token();
-    base::StringTokenizer parameter_tokenizer(parameters, "=");
-    if (parameter_tokenizer.GetNext() &&
-        base::ToLowerASCII(parameter_tokenizer.token()) == "codecs" &&
-        parameter_tokenizer.GetNext()) {
-      web_codecs = blink::WebString::FromASCII(parameter_tokenizer.token());
-    }
+  blink::WebString mime_type;
+  blink::WebString codec;
+  if (configuration.video_configuration) {
+    mime_type = configuration.video_configuration->mime_type;
+    codec = configuration.video_configuration->codec;
+  } else {
+    mime_type = configuration.audio_configuration->mime_type;
+    codec = configuration.audio_configuration->codec;
   }
 
-  info->supported = CanSupportMimeType(web_type, web_codecs);
-  DVLOG(1) << "type: " << web_type.Ascii() << ", params:" << web_codecs.Ascii()
+  // See RFC 2231. https://tools.ietf.org/html/rfc2231
+  info->supported = CanSupportMimeType(mime_type, codec);
+  DVLOG(1) << "type: " << mime_type.Ascii() << ", codec:" << codec.Ascii()
            << " is" << (info->supported ? " supported" : " NOT supported");
 
   scoped_callbacks.PassCallbacks()->OnSuccess(std::move(info));
 }
 
 void MediaRecorderHandler::OnEncodedVideo(
     const media::WebmMuxer::VideoParameters& params,
     std::unique_ptr<std::string> encoded_data,
     std::unique_ptr<std::string> encoded_alpha,
     TimeTicks timestamp,
@@ skipping 100 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (const auto& recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content