MediaRecorder: correct MIME type parsing

content/renderer/media/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/media_recorder_handler.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "content/renderer/media/audio_track_recorder.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/video_track_recorder.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "media/audio/audio_parameters.h"
 #include "media/base/audio_bus.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/mime_util.h"
 #include "media/base/video_frame.h"
 #include "media/capture/webm_muxer.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 
 MediaRecorderHandler::MediaRecorderHandler()
     : use_vp9_(false),
       recording_(false),
       client_(nullptr),
       weak_factory_(this) {}
 
 MediaRecorderHandler::~MediaRecorderHandler() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Send a |last_in_slice| to our |client_|.
   if (client_)
     client_->writeData(nullptr, 0u, true);
 }
 
 bool MediaRecorderHandler::canSupportMimeType(
-    const blink::WebString& mimeType) {
+    const blink::WebString& web_type, const blink::WebString& web_codecs) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-  // Ensure we can support each passed MIME type.
-  const std::string input = mimeType.utf8();  // Must outlive tokenizer!
-  base::StringTokenizer tokenizer(input, ",");
-  while (tokenizer.GetNext()) {
-    // Strip whitespace.
-    const std::string token(base::CollapseWhitespaceASCII(
-        tokenizer.token(), true /* trim sequences with line breaks*/));
-    if (!token.empty() &&
-        !base::EqualsCaseInsensitiveASCII(token, "video/vp8") &&
-        !base::EqualsCaseInsensitiveASCII(token, "video/vp9") &&
-        !base::EqualsCaseInsensitiveASCII(token, "audio/opus") &&
-        !base::EqualsCaseInsensitiveASCII(token, "video/webm") &&
-        !base::EqualsCaseInsensitiveASCII(token, "audio/webm")) {
+  // An empty |web_type| means MediaRecorderHandler can choose its preferred
+  // codecs.
+  if (web_type.isEmpty())
+    return true;
+
+  const std::string type(web_type.utf8());
+  const bool video = base::EqualsCaseInsensitiveASCII(type, "video/webm");
+  const bool audio =
+      video ? false : base::EqualsCaseInsensitiveASCII(type, "audio/webm");
+  if (!video && !audio)
+    return false;
+
+  // Both |video| and |audio| support empty |codecs|; |type| == "video" supports
+  // vp8, vp9 or opus; |type| = "audio", supports only opus.
+  // http://www.webmproject.org/docs/container Sec:"HTML5 Video Type Parameters"
+  static const char* kVideoCodecs[] = { "vp8", "vp9", "opus" };
+  static const char* kAudioCodecs[] = { "opus" };
+  const char** codecs = video ? &kVideoCodecs[0] : &kAudioCodecs[0];
+  int codecs_count =  video ? arraysize(kVideoCodecs) : arraysize(kAudioCodecs);
+
+  std::vector<std::string> codecs_list;
+  media::ParseCodecString(web_codecs.utf8(), &codecs_list, true /* strip */);
+  for (const auto& codec : codecs_list) {
+    const auto found = std::find_if(
+        &codecs[0], &codecs[codecs_count], [&codec](const char* name) {
+          return base::EqualsCaseInsensitiveASCII(codec, name);
+        });
+    if (found == &codecs[codecs_count])
       return false;
-    }
   }
-
   return true;
 }
 
 bool MediaRecorderHandler::initialize(
     blink::WebMediaRecorderHandlerClient* client,
     const blink::WebMediaStream& media_stream,
-    const blink::WebString& mimeType) {
+    const blink::WebString& type,
+    const blink::WebString& codecs) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Save histogram data so we can see how much MediaStream Recorder is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_MEDIA_STREAM_RECORDER);
 
-  if (!canSupportMimeType(mimeType)) {
-    DLOG(ERROR) << "Can't support type " << mimeType.utf8();
+  if (!canSupportMimeType(type, codecs)) {
+    DLOG(ERROR) << "Can't support " << type.utf8()
+                << ";codecs=" << codecs.utf8();
     return false;
   }
-  use_vp9_ = mimeType.utf8().compare("video/vp9") == 0;
+  use_vp9_ = base::ToLowerASCII(codecs.utf8()).find("vp9") != std::string::npos;
   media_stream_ = media_stream;
   DCHECK(client);
   client_ = client;
 
   return true;
 }
 
 bool MediaRecorderHandler::start() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
@@ skipping 150 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (auto* recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content