Add jitterBufferDelayHint property to RTCRtpReceiver interface in Blink.

This change is required to allow modification of Jitter Buffer delay
in javascript via Origin Trial Experiment.
Link to experiment description:
https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/Tgm4qiNepJc

Bug: webrtc:10287
Change-Id: I5abb6eb8f02f0868253aba00693fdcbce451c7b1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1552824
Commit-Queue: Ruslan Burakov <kuddai@google.com>
Reviewed-by: Philip Jägenstedt <foolip@chromium.org>
Reviewed-by: Jason Chase <chasej@chromium.org>
Reviewed-by: Henrik Boström <hbos@chromium.org>
Cr-Commit-Position: refs/heads/master@{#649092}

content/renderer/media/webrtc/fake_rtc_rtp_transceiver.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "content/renderer/media/webrtc/fake_rtc_rtp_transceiver.h"
+#include "content/renderer/media/webrtc/webrtc_util.h"
 
 #include <vector>
 
@@ -175,6 +176,11 @@ std::unique_ptr<webrtc::RtpParameters> FakeRTCRtpReceiver::GetParameters()
   return nullptr;
 }
 
+void FakeRTCRtpReceiver::SetJitterBufferMinimumDelay(
+    base::Optional<double> delay_seconds) {
+  NOTIMPLEMENTED();
+}
+
 FakeRTCRtpTransceiver::FakeRTCRtpTransceiver(
     base::Optional<std::string> mid,
     FakeRTCRtpSender sender,

content/renderer/media/webrtc/fake_rtc_rtp_transceiver.h

@@ -77,6 +77,8 @@ class FakeRTCRtpReceiver : public blink::WebRTCRtpReceiver {
   void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>,
                 const std::vector<webrtc::NonStandardGroupId>&) override;
   std::unique_ptr<webrtc::RtpParameters> GetParameters() const override;
+  void SetJitterBufferMinimumDelay(
+      base::Optional<double> delay_seconds) override;
 
  private:
   blink::WebMediaStreamTrack track_;

content/renderer/media/webrtc/mock_peer_connection_impl.cc

@@ -225,6 +225,11 @@ void FakeRtpReceiver::SetObserver(
   NOTIMPLEMENTED();
 }
 
+void FakeRtpReceiver::SetJitterBufferMinimumDelay(
+    absl::optional<double> delay_seconds) {
+  NOTIMPLEMENTED();
+}
+
 std::vector<webrtc::RtpSource> FakeRtpReceiver::GetSources() const {
   NOTIMPLEMENTED();
   return std::vector<webrtc::RtpSource>();

content/renderer/media/webrtc/mock_peer_connection_impl.h

@@ -73,6 +73,8 @@ class FakeRtpReceiver : public webrtc::RtpReceiverInterface {
   webrtc::RtpParameters GetParameters() const override;
   bool SetParameters(const webrtc::RtpParameters& parameters) override;
   void SetObserver(webrtc::RtpReceiverObserverInterface* observer) override;
+  void SetJitterBufferMinimumDelay(
+      absl::optional<double> delay_seconds) override;
   std::vector<webrtc::RtpSource> GetSources() const override;
   void SetTransport(
       rtc::scoped_refptr<webrtc::DtlsTransportInterface> transport) {

content/renderer/media/webrtc/rtc_rtp_receiver.cc

@@ -8,6 +8,7 @@
 #include "base/logging.h"
 #include "content/renderer/media/webrtc/rtc_rtp_source.h"
 #include "content/renderer/media/webrtc/rtc_stats.h"
+#include "content/renderer/media/webrtc/webrtc_util.h"
 #include "third_party/webrtc/api/scoped_refptr.h"
 
 namespace content {
@@ -181,6 +182,11 @@ class RTCRtpReceiver::RTCRtpReceiverInternal
         webrtc_receiver_->GetParameters());
   }
 
+  void SetJitterBufferMinimumDelay(base::Optional<double> delay_seconds) {
+    webrtc_receiver_->SetJitterBufferMinimumDelay(
+        ToAbslOptional(delay_seconds));
+  }
+
  private:
   friend struct RTCRtpReceiver::RTCRtpReceiverInternalTraits;
 
@@ -300,6 +306,11 @@ std::unique_ptr<webrtc::RtpParameters> RTCRtpReceiver::GetParameters() const {
   return internal_->GetParameters();
 }
 
+void RTCRtpReceiver::SetJitterBufferMinimumDelay(
+    base::Optional<double> delay_seconds) {
+  internal_->SetJitterBufferMinimumDelay(delay_seconds);
+}
+
 RTCRtpReceiverOnlyTransceiver::RTCRtpReceiverOnlyTransceiver(
     std::unique_ptr<blink::WebRTCRtpReceiver> receiver)
     : receiver_(std::move(receiver)) {

content/renderer/media/webrtc/rtc_rtp_receiver.h

@@ -132,6 +132,8 @@ class CONTENT_EXPORT RTCRtpReceiver : public blink::WebRTCRtpReceiver {
   void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>,
                 const std::vector<webrtc::NonStandardGroupId>&) override;
   std::unique_ptr<webrtc::RtpParameters> GetParameters() const override;
+  void SetJitterBufferMinimumDelay(
+      base::Optional<double> delay_seconds) override;
 
  private:
   class RTCRtpReceiverInternal;

third_party/blink/public/platform/web_rtc_rtp_receiver.h

@@ -7,6 +7,8 @@
 
 #include <memory>
 #include <vector>
+
+#include "base/optional.h"
 #include "third_party/blink/public/platform/web_common.h"
 #include "third_party/blink/public/platform/web_rtc_stats.h"
 #include "third_party/blink/public/platform/web_string.h"
@@ -43,6 +45,8 @@ class BLINK_PLATFORM_EXPORT WebRTCRtpReceiver {
   virtual void GetStats(std::unique_ptr<blink::WebRTCStatsReportCallback>,
                         const std::vector<webrtc::NonStandardGroupId>&) = 0;
   virtual std::unique_ptr<webrtc::RtpParameters> GetParameters() const = 0;
+  virtual void SetJitterBufferMinimumDelay(
+      base::Optional<double> delay_seconds) = 0;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver.cc

@@ -45,6 +45,27 @@ RTCDtlsTransport* RTCRtpReceiver::rtcp_transport() {
   return nullptr;
 }
 
+double RTCRtpReceiver::jitterBufferDelayHint(bool& is_null, ExceptionState&) {
+  is_null = !jitter_buffer_delay_hint_.has_value();
+  return jitter_buffer_delay_hint_.value_or(0.0);
+}
+
+void RTCRtpReceiver::setJitterBufferDelayHint(double value,
+                                              bool is_null,
+                                              ExceptionState& exception_state) {
+  base::Optional<double> hint =
+      is_null ? base::nullopt : base::Optional<double>(value);
+  if (hint && *hint < 0.0) {
+    exception_state.ThrowDOMException(
+        DOMExceptionCode::kInvalidAccessError,
+        "jitterBufferDelayHint can't be negative");
+    return;
+  }
+
+  jitter_buffer_delay_hint_ = hint;
+  receiver_->SetJitterBufferMinimumDelay(jitter_buffer_delay_hint_);
+}
+
 HeapVector<Member<RTCRtpSynchronizationSource>>
 RTCRtpReceiver::getSynchronizationSources() {
   UpdateSourcesIfNeeded();

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver.h

@@ -7,6 +7,7 @@
 
 #include <map>
 
+#include "base/optional.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_receiver.h"
 #include "third_party/blink/public/platform/web_rtc_rtp_source.h"
@@ -16,6 +17,7 @@
 #include "third_party/blink/renderer/modules/peerconnection/rtc_rtp_contributing_source.h"
 #include "third_party/blink/renderer/modules/peerconnection/rtc_rtp_receive_parameters.h"
 #include "third_party/blink/renderer/modules/peerconnection/rtc_rtp_synchronization_source.h"
+#include "third_party/blink/renderer/platform/bindings/exception_state.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
 #include "third_party/blink/renderer/platform/heap/member.h"
@@ -43,6 +45,8 @@ class RTCRtpReceiver final : public ScriptWrappable {
   MediaStreamTrack* track() const;
   RTCDtlsTransport* transport();
   RTCDtlsTransport* rtcp_transport();
+  double jitterBufferDelayHint(bool&, ExceptionState&);
+  void setJitterBufferDelayHint(double, bool, ExceptionState&);
   RTCRtpReceiveParameters* getParameters();
   HeapVector<Member<RTCRtpSynchronizationSource>> getSynchronizationSources();
   HeapVector<Member<RTCRtpContributingSource>> getContributingSources();
@@ -71,6 +75,11 @@ class RTCRtpReceiver final : public ScriptWrappable {
   WebVector<std::unique_ptr<WebRTCRtpSource>> web_sources_;
   bool web_sources_needs_updating_ = true;
   Member<RTCRtpTransceiver> transceiver_;
+
+  // Hint to the WebRTC Jitter Buffer about desired playout delay. Actual
+  // observed delay may differ depending on the congestion control. |nullopt|
+  // means default value must be used.
+  base::Optional<double> jitter_buffer_delay_hint_;
 };
 
 }  // namespace blink

third_party/blink/renderer/modules/peerconnection/rtc_rtp_receiver.idl

@@ -8,6 +8,7 @@ interface RTCRtpReceiver {
     readonly attribute MediaStreamTrack track;
     [RuntimeEnabled=RTCDtlsTransport] readonly attribute RTCDtlsTransport? transport;
     [RuntimeEnabled=RTCDtlsTransport] readonly attribute RTCDtlsTransport? rtcp_transport;
+    [RaisesException, OriginTrialEnabled=RtcJitterBufferDelayHint] attribute double? jitterBufferDelayHint;
     static RTCRtpCapabilities?            getCapabilities(DOMString kind);
     RTCRtpReceiveParameters               getParameters();
     sequence<RTCRtpSynchronizationSource> getSynchronizationSources();

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -1205,6 +1205,11 @@
       origin_trial_feature_name: "RTCQuicTransport",
       status: "experimental",
     },
+    {
+      name: "RtcJitterBufferDelayHint",
+      origin_trial_feature_name: "RtcJitterBufferDelayHint",
+      status: "experimental",
+    },
     // Enables the use of the RTCQuicTransport object.
     {
       name: "RTCQuicTransport",

third_party/blink/renderer/platform/testing/testing_platform_support_with_web_rtc.cc

@@ -139,6 +139,9 @@ class DummyWebRTCRtpReceiver : public WebRTCRtpReceiver {
     return nullptr;
   }
 
+  void SetJitterBufferMinimumDelay(
+      base::Optional<double> delay_seconds) override {}
+
  private:
   const uintptr_t id_;
   WebMediaStreamTrack track_;

third_party/blink/web_tests/http/tests/origin_trials/webexposed/rtc-jitter-buffer-delay-hint.html

+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>JitterBufferDelayHint - property exposed on RTCRtpReceiver by origin trial</title>
+<script src="../../resources/testharness.js"></script>
+<script src="../../resources/testharnessreport.js"></script>
+<script src="../../resources/origin-trials-helper.js"></script>
+
+<script>
+
+if (!self.internals.runtimeFlags.rtcJitterBufferDelayHintEnabled) {
+  test(t => {
+    OriginTrialsHelper.check_properties_missing(
+        this, {'RTCRtpReceiver': ['jitterBufferDelayHint']});
+  }, 'RTCRtpReceiver jitterBufferDelayHint is not available without token');
+}
+
+// Generated with command:
+// tools/origin_trials/generate_token.py http://127.0.0.1:8000 RtcJitterBufferDelayHint --expire-timestamp=2000000000
+const token = 'AooRFiyDVrZyXNbm9GQp3TYVKdLvpH99sd/OKrMUHQ8FSxG4ok5MAff2Wqu9j6rXMfuaIITeQvifdQLIvR5bTwkAAAB1eyJvcmlnaW4iOiAiaHR0cDovLzEyNy4wLjAuMTo4MDAwIiwgImlzU3ViZG9tYWluIjogdHJ1ZSwgImZlYXR1cmUiOiAiUnRjSml0dGVyQnVmZmVyRGVsYXlIaW50IiwgImV4cGlyeSI6IDIwMDAwMDAwMDB9';
+OriginTrialsHelper.add_token(token);
+
+test(t => {
+  OriginTrialsHelper.check_properties(
+      this, {'RTCRtpReceiver': ['jitterBufferDelayHint']});
+}, 'RTCRtpReceiver jitterBufferDelayHint is in Origin-Trial enabled document');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+
+  pc.addTransceiver('audio', {direction:'recvonly'});
+  pc.addTransceiver('video', {direction:'recvonly'});
+
+  for (let receiver of pc.getReceivers()) {
+    assert_equals(receiver.jitterBufferDelayHint, null,
+       'jitterBufferDelayHint null by default');
+
+    receiver.jitterBufferDelayHint = 0.5;
+    assert_equals(receiver.jitterBufferDelayHint, 0.5,
+       'jitterBufferDelayHint saves correct value');
+
+    receiver.jitterBufferDelayHint = 20.5;
+    assert_equals(receiver.jitterBufferDelayHint, 20.5,
+       'jitterBufferDelayHint saves large value');
+
+    assert_throws('InvalidAccessError', () => {
+      receiver.jitterBufferDelayHint = -0.5;
+    }, 'jitterBufferDelayHint accepts only positive values and 0.0');
+    assert_equals(receiver.jitterBufferDelayHint, 20.5,
+       'jitterBufferDelayHint returns last valid value');
+
+    receiver.jitterBufferDelayHint = null;
+    assert_equals(receiver.jitterBufferDelayHint, null,
+       'jitterBufferDelayHint resets value to null');
+  }
+}, 'RTCRtpReceiver jitterBufferDelayHint validation');
+
+</script>

third_party/blink/web_tests/webexposed/global-interface-listing-expected.txt

@@ -5815,6 +5815,7 @@ interface RTCQuicTransport : EventTarget
 interface RTCRtpReceiver
     static method getCapabilities
     attribute @@toStringTag
+    getter jitterBufferDelayHint
     getter rtcp_transport
     getter track
     getter transport
@@ -5823,6 +5824,7 @@ interface RTCRtpReceiver
     method getParameters
     method getStats
     method getSynchronizationSources
+    setter jitterBufferDelayHint
 interface RTCRtpSender
     static method getCapabilities
     attribute @@toStringTag