Media Capabilities encoding: Blink pass-thru and skeleton renderer/ impl

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"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
+#include "content/child/scoped_web_callbacks.h"
 #include "content/renderer/media/media_stream_audio_track.h"
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/media_recorder/audio_track_recorder.h"
 #include "media/base/audio_bus.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/mime_util.h"
 #include "media/base/video_frame.h"
 #include "media/muxers/webm_muxer.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/modules/media_capabilities/WebMediaConfiguration.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using base::ToLowerASCII;
 
 namespace content {
 
+using blink::WebMediaCapabilitiesQueryCallbacks;
+
 namespace {
 
 media::VideoCodec CodecIdToMediaVideoCodec(VideoTrackRecorder::CodecId id) {
   switch (id) {
     case VideoTrackRecorder::CodecId::VP8:
       return media::kCodecVP8;
     case VideoTrackRecorder::CodecId::VP9:
       return media::kCodecVP9;
 #if BUILDFLAG(RTC_USE_H264)
     case VideoTrackRecorder::CodecId::H264:
       return media::kCodecH264;
 #endif
     case VideoTrackRecorder::CodecId::LAST:
       return media::kUnknownVideoCodec;
   }
   NOTREACHED() << "Unsupported codec";
   return media::kUnknownVideoCodec;
 }
 
+void OnEncodingInfoError(
+    std::unique_ptr<WebMediaCapabilitiesQueryCallbacks> callbacks) {
+  callbacks->OnError();
+}
+
 }  // anonymous namespace
 
 MediaRecorderHandler::MediaRecorderHandler()
     : video_bits_per_second_(0),
       audio_bits_per_second_(0),
       codec_id_(VideoTrackRecorder::CodecId::VP8),
       recording_(false),
       client_(nullptr),
       weak_factory_(this) {}
 
@@ skipping 196 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   recording_ = true;
   for (const auto& video_recorder : video_recorders_)
     video_recorder->Resume();
   for (const auto& audio_recorder : audio_recorders_)
     audio_recorder->Resume();
   webm_muxer_->Resume();
 }
 
+void MediaRecorderHandler::EncodingInfo(
+    const blink::WebMediaConfiguration& configuration,
+    std::unique_ptr<blink::WebMediaCapabilitiesQueryCallbacks> callbacks) {
+  DCHECK(main_render_thread_checker_.CalledOnValidThread());
+
+  ScopedWebCallbacks<WebMediaCapabilitiesQueryCallbacks> scoped_callbacks =
+      make_scoped_web_callbacks(callbacks.release(),
+                                base::Bind(&OnEncodingInfoError));
+
+  if (!configuration.video_configuration && !configuration.audio_configuration)
+    return;

[mlamouri (slow - plz ping), 2017/04/18 12:24:35]

That should not happen.

[mcasas, 2017/04/18 21:41:51]

The current code allows for this to happen. What
do you mean "should" ?

Note that :

const configuration = { type : 'record'};

navigator.mediaCapabilities.encodingInfo(configuration)
    .then((result) => {
       console.log('yay!');
    })    
    .catch(() => {
       console.error('boo'); 
    });

is perfectly legal idl-wise. In this case, we want to
reject the promise; what we might want to do is to
reject it in MediaCapabilities.cpp.  

I'm going to assume that you meant the latter, and
I'll DCHECK here and reject in MediaCapabilities.cpp.

+
+  std::unique_ptr<blink::WebMediaCapabilitiesInfo> info(
+      new blink::WebMediaCapabilitiesInfo());
+
+  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();

[mlamouri (slow - plz ping), 2017/04/18 12:24:35]

what if there is audio and video?

[mcasas, 2017/04/18 21:41:51]

TODO :-)

+
+  // |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());
+    }
+  }

[mlamouri (slow - plz ping), 2017/04/18 12:24:35]

I think most of this is going to be moved to Blink.

[mcasas, 2017/04/18 21:41:51]

That'd be great but for that we'd need to split 
Web{Video,Audio}Configuration.type [1] into two
strings: |type| and |parameter| that could be fed
from a ContentType [2] like we do, e.g. in [3].
but those were too many changes for this CL and
the existing code, so decided to split the mime
type here.

[1]
https://cs.chromium.org/chromium/src/third_party/WebKit/public/platform/modul...
[2]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/platform/netwo...
[3]
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/modules/mediar...

[mlamouri (slow - plz ping), 2017/04/20 13:37:13]

chcunningham@ has a CL for that. Worse case I guess we can refactor anyway.

+
+  info->supported = CanSupportMimeType(web_type, web_codecs);
+  DVLOG(1) << "type: " << web_type.Ascii() << ", params:" << web_codecs.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,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
 
   if (UpdateTracksAndCheckIfChanged()) {
     client_->OnError("Amount of tracks in MediaStream has changed.");
@@ skipping 95 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