Implement and ship RTCRtpSendParameters.degradationPreference

Intent: https://groups.google.com/a/chromium.org/g/blink-dev/c/WPvxi5nUK2E/m/Xd0ZzPwxAwAJ

Bug: 857041
Change-Id: I3f11c310624d5c2153eefbf9c1e08383d9aad4f8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2074777
Commit-Queue: Florent Castelli <orphis@chromium.org>
Reviewed-by: Henrik Boström <hbos@chromium.org>
Auto-Submit: Florent Castelli <orphis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#755512}

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

@@ -100,9 +100,10 @@ std::unique_ptr<webrtc::RtpParameters> FakeRTCRtpSenderImpl::GetParameters()
   return nullptr;
 }
 
-void FakeRTCRtpSenderImpl::SetParameters(Vector<webrtc::RtpEncodingParameters>,
-                                         webrtc::DegradationPreference,
-                                         blink::RTCVoidRequest*) {
+void FakeRTCRtpSenderImpl::SetParameters(
+    Vector<webrtc::RtpEncodingParameters>,
+    absl::optional<webrtc::DegradationPreference>,
+    blink::RTCVoidRequest*) {
   NOTIMPLEMENTED();
 }
 

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

@@ -47,7 +47,7 @@ class FakeRTCRtpSenderImpl : public blink::RTCRtpSenderPlatform {
   std::unique_ptr<blink::RtcDtmfSenderHandler> GetDtmfSender() const override;
   std::unique_ptr<webrtc::RtpParameters> GetParameters() const override;
   void SetParameters(Vector<webrtc::RtpEncodingParameters>,
-                     webrtc::DegradationPreference,
+                     absl::optional<webrtc::DegradationPreference>,
                      blink::RTCVoidRequest*) override;
   void GetStats(RTCStatsReportCallback,
                 const Vector<webrtc::NonStandardGroupId>&) override;

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

@@ -81,7 +81,7 @@ class DummyRTCRtpSenderPlatform : public RTCRtpSenderPlatform {
     return std::unique_ptr<webrtc::RtpParameters>();
   }
   void SetParameters(Vector<webrtc::RtpEncodingParameters>,
-                     webrtc::DegradationPreference,
+                     absl::optional<webrtc::DegradationPreference>,
                      RTCVoidRequest*) override {}
   void GetStats(RTCStatsReportCallback,
                 const Vector<webrtc::NonStandardGroupId>&) override {}

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

@@ -2,9 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// https://w3c.github.io/mst-content-hint/#dom-rtcdegradationpreference
+enum RTCDegradationPreference {
+    "maintain-framerate",
+    "maintain-resolution",
+    "balanced"
+};
+
 // https://w3c.github.io/webrtc-pc/#rtcsendrtpparameters
 dictionary RTCRtpSendParameters : RTCRtpParameters {
     required DOMString                          transactionId;
     required sequence<RTCRtpEncodingParameters> encodings;
-    //TODO(orphis): Missing degradationPrerence. https://crbug.com/857041
-};
\ No newline at end of file
+             RTCDegradationPreference           degradationPreference;
+};

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

@@ -281,7 +281,8 @@ webrtc::Priority PriorityToEnum(const WTF::String& priority) {
   return result;
 }
 
-std::tuple<Vector<webrtc::RtpEncodingParameters>, webrtc::DegradationPreference>
+std::tuple<Vector<webrtc::RtpEncodingParameters>,
+           absl::optional<webrtc::DegradationPreference>>
 ToRtpParameters(const RTCRtpSendParameters* parameters) {
   Vector<webrtc::RtpEncodingParameters> encodings;
   if (parameters->hasEncodings()) {
@@ -292,8 +293,22 @@ ToRtpParameters(const RTCRtpSendParameters* parameters) {
     }
   }
 
-  webrtc::DegradationPreference degradation_preference =
-      webrtc::DegradationPreference::BALANCED;
+  absl::optional<webrtc::DegradationPreference> degradation_preference;
+
+  if (parameters->hasDegradationPreference()) {
+    if (parameters->degradationPreference() == "balanced") {
+      degradation_preference = webrtc::DegradationPreference::BALANCED;
+    } else if (parameters->degradationPreference() == "maintain-framerate") {
+      degradation_preference =
+          webrtc::DegradationPreference::MAINTAIN_FRAMERATE;
+    } else if (parameters->degradationPreference() == "maintain-resolution") {
+      degradation_preference =
+          webrtc::DegradationPreference::MAINTAIN_RESOLUTION;
+    } else {
+      NOTREACHED();
+    }
+  }
+
   return std::make_tuple(encodings, degradation_preference);
 }
 
@@ -417,12 +432,28 @@ ScriptPromise RTCRtpSender::replaceTrack(ScriptState* script_state,
 
 RTCRtpSendParameters* RTCRtpSender::getParameters() {
   RTCRtpSendParameters* parameters = RTCRtpSendParameters::Create();
-  // TODO(orphis): Forward missing field: degradationPreference
   std::unique_ptr<webrtc::RtpParameters> webrtc_parameters =
       sender_->GetParameters();
 
   parameters->setTransactionId(webrtc_parameters->transaction_id.c_str());
 
+  if (webrtc_parameters->degradation_preference.has_value()) {
+    WTF::String degradation_preference_str;
+    switch (webrtc_parameters->degradation_preference.value()) {
+      case webrtc::DegradationPreference::MAINTAIN_FRAMERATE:
+        degradation_preference_str = "maintain-framerate";
+        break;
+      case webrtc::DegradationPreference::MAINTAIN_RESOLUTION:
+        degradation_preference_str = "maintain-resolution";
+        break;
+      case webrtc::DegradationPreference::BALANCED:
+        degradation_preference_str = "balanced";
+        break;
+      default:
+        NOTREACHED();
+    }
+    parameters->setDegradationPreference(degradation_preference_str);
+  }
   RTCRtcpParameters* rtcp = RTCRtcpParameters::Create();
   rtcp->setCname(webrtc_parameters->rtcp.cname.c_str());
   rtcp->setReducedSize(webrtc_parameters->rtcp.reduced_size);
@@ -515,7 +546,7 @@ ScriptPromise RTCRtpSender::setParameters(
   // native layer without having to transform all the other read-only
   // parameters.
   Vector<webrtc::RtpEncodingParameters> encodings;
-  webrtc::DegradationPreference degradation_preference;
+  absl::optional<webrtc::DegradationPreference> degradation_preference;
   std::tie(encodings, degradation_preference) = ToRtpParameters(parameters);
 
   auto* request = MakeGarbageCollected<SetParametersRequest>(resolver, this);

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

@@ -251,9 +251,10 @@ class RTCRtpSenderImpl::RTCRtpSenderInternal
     return std::make_unique<webrtc::RtpParameters>(parameters_);
   }
 
-  void SetParameters(Vector<webrtc::RtpEncodingParameters> encodings,
-                     webrtc::DegradationPreference degradation_preference,
-                     base::OnceCallback<void(webrtc::RTCError)> callback) {
+  void SetParameters(
+      Vector<webrtc::RtpEncodingParameters> encodings,
+      absl::optional<webrtc::DegradationPreference> degradation_preference,
+      base::OnceCallback<void(webrtc::RTCError)> callback) {
     DCHECK(main_task_runner_->BelongsToCurrentThread());
 
     webrtc::RtpParameters new_parameters = parameters_;
@@ -510,7 +511,7 @@ std::unique_ptr<webrtc::RtpParameters> RTCRtpSenderImpl::GetParameters() const {
 
 void RTCRtpSenderImpl::SetParameters(
     Vector<webrtc::RtpEncodingParameters> encodings,
-    webrtc::DegradationPreference degradation_preference,
+    absl::optional<webrtc::DegradationPreference> degradation_preference,
     blink::RTCVoidRequest* request) {
   internal_->SetParameters(
       std::move(encodings), degradation_preference,

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

@@ -143,7 +143,7 @@ class MODULES_EXPORT RTCRtpSenderImpl : public blink::RTCRtpSenderPlatform {
   std::unique_ptr<blink::RtcDtmfSenderHandler> GetDtmfSender() const override;
   std::unique_ptr<webrtc::RtpParameters> GetParameters() const override;
   void SetParameters(Vector<webrtc::RtpEncodingParameters>,
-                     webrtc::DegradationPreference,
+                     absl::optional<webrtc::DegradationPreference>,
                      blink::RTCVoidRequest*) override;
   void GetStats(RTCStatsReportCallback,
                 const Vector<webrtc::NonStandardGroupId>&) override;

third_party/blink/renderer/platform/peerconnection/rtc_rtp_sender_platform.h

@@ -49,7 +49,7 @@ class PLATFORM_EXPORT RTCRtpSenderPlatform {
   virtual std::unique_ptr<RtcDtmfSenderHandler> GetDtmfSender() const = 0;
   virtual std::unique_ptr<webrtc::RtpParameters> GetParameters() const = 0;
   virtual void SetParameters(Vector<webrtc::RtpEncodingParameters>,
-                             webrtc::DegradationPreference,
+                             absl::optional<webrtc::DegradationPreference>,
                              RTCVoidRequest*) = 0;
   virtual void GetStats(RTCStatsReportCallback,
                         const Vector<webrtc::NonStandardGroupId>&) = 0;

third_party/blink/web_tests/external/wpt/mst-content-hint/RTCRtpSendParameters-degradationPreference.html

+<!doctype html>
+<meta charset=utf-8>
+<title>RTCRtpSendParameters degradationPreference</title>
+<script src="/resources/testharness.js"></script>
+<script src="/resources/testharnessreport.js"></script>
+<script>
+  'use strict';
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('video');
+
+  let param = sender.getParameters();
+
+  assert_equals(param.degradationPreference, undefined,
+    'Expect initial param.degradationPreference to be undefined');
+
+  param.degradationPreference = 'maintain-framerate';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'maintain-framerate');
+
+  param.degradationPreference = 'maintain-resolution';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'maintain-resolution');
+
+  param.degradationPreference = 'balanced';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'balanced');
+
+  param.degradationPreference = undefined;
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, undefined);
+}, 'setParameters with degradationPreference set should succeed on video transceiver');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('video');
+
+  let param = sender.getParameters();
+
+  assert_equals(param.degradationPreference, undefined,
+    'Expect initial param.degradationPreference to be undefined');
+
+  param.degradationPreference = undefined;
+
+  await sender.setParameters(param);
+
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, undefined);
+}, 'setParameters with degradationPreference unset should succeed on video transceiver');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('video');
+
+  let param = sender.getParameters();
+  param.degradationPreference = 'invalid';
+
+  return promise_rejects_js(t, TypeError, sender.setParameters(param));
+}, 'setParameters with invalid degradationPreference should throw TypeError on video transceiver');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('audio');
+
+  let param = sender.getParameters();
+
+  assert_equals(param.degradationPreference, undefined,
+    'Expect initial param.degradationPreference to be undefined');
+
+  param.degradationPreference = 'maintain-framerate';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'maintain-framerate');
+
+  param.degradationPreference = 'maintain-resolution';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'maintain-resolution');
+
+  param.degradationPreference = 'balanced';
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, 'balanced');
+
+  param.degradationPreference = undefined;
+  await sender.setParameters(param);
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, undefined);
+}, 'setParameters with degradationPreference set should succeed on audio transceiver');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('audio');
+
+  let param = sender.getParameters();
+
+  assert_equals(param.degradationPreference, undefined,
+    'Expect initial param.degradationPreference to be undefined');
+
+  param.degradationPreference = undefined;
+
+  await sender.setParameters(param);
+
+  param = sender.getParameters();
+  assert_equals(param.degradationPreference, undefined);
+}, 'setParameters with degradationPreference unset should succeed on audio transceiver');
+
+promise_test(async t => {
+  const pc = new RTCPeerConnection();
+  t.add_cleanup(() => pc.close());
+  const { sender } = pc.addTransceiver('audio');
+
+  let param = sender.getParameters();
+  param.degradationPreference = 'invalid';
+
+  return promise_rejects_js(t, TypeError, sender.setParameters(param));
+}, 'setParameters with invalid degradationPreference should throw TypeError on audio transceiver');
+
+</script>

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-codecs.html

@@ -28,7 +28,6 @@
         sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
         RTCRtcpParameters                         rtcp;
         sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
       };
 
       dictionary RTCRtpCodecParameters {

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-degradationPreference-expected.txt

-This is a testharness.js-based test.
-FAIL setParameters with degradationPreference set should succeed assert_equals: Expect initial param.degradationPreference to be balanced expected (string) "balanced" but got (undefined) undefined
-FAIL setParameters with degradationPreference unset should succeed assert_equals: Expect initial param.degradationPreference to be balanced expected (string) "balanced" but got (undefined) undefined
-Harness: the test ran to completion.
-

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-degradationPreference.html

-<!doctype html>
-<meta charset=utf-8>
-<title>RTCRtpParameters degradationPreference</title>
-<script src="/resources/testharness.js"></script>
-<script src="/resources/testharnessreport.js"></script>
-<script src="dictionary-helper.js"></script>
-<script src="RTCRtpParameters-helper.js"></script>
-<script>
-  'use strict';
-
-  // Test is based on the following editor draft:
-  // https://w3c.github.io/webrtc-pc/archives/20170605/webrtc.html
-
-  // The following helper functions are called from RTCRtpParameters-helper.js:
-  //   validateSenderRtpParameters
-
-  /*
-    5.2.  RTCRtpSender Interface
-      interface RTCRtpSender {
-        Promise<void>           setParameters(optional RTCRtpParameters parameters);
-        RTCRtpParameters        getParameters();
-      };
-
-      dictionary RTCRtpParameters {
-        DOMString                                 transactionId;
-        sequence<RTCRtpEncodingParameters>        encodings;
-        sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
-        RTCRtcpParameters                         rtcp;
-        sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
-      };
-
-      enum RTCDegradationPreference {
-        "maintain-framerate",
-        "maintain-resolution",
-        "balanced"
-      };
-
-      - degradationPreference is set to the last value passed into setParameters,
-        or the default value of "balanced" if setParameters hasn't been called.
-   */
-
-  promise_test(t => {
-    const pc = new RTCPeerConnection();
-    t.add_cleanup(() => pc.close());
-    const { sender } = pc.addTransceiver('audio');
-
-    const param = sender.getParameters();
-    validateSenderRtpParameters(param);
-
-    assert_equals(param.degradationPreference, 'balanced',
-      'Expect initial param.degradationPreference to be balanced');
-
-    param.degradationPreference = 'maintain-framerate';
-
-    return pc.setParameters(param)
-    .then(() => {
-      const param = sender.getParameters();
-      validateSenderRtpParameters(param);
-
-      assert_equals(param.degradationPreference, 'maintain-framerate');
-    });
-  }, 'setParameters with degradationPreference set should succeed');
-
-  promise_test(t => {
-    const pc = new RTCPeerConnection();
-    t.add_cleanup(() => pc.close());
-    const { sender } = pc.addTransceiver('audio');
-
-    const param = sender.getParameters();
-    validateSenderRtpParameters(param);
-
-    assert_equals(param.degradationPreference, 'balanced',
-      'Expect initial param.degradationPreference to be balanced');
-
-    param.degradationPreference = undefined;
-
-    return pc.setParameters(param)
-    .then(() => {
-      const param = sender.getParameters();
-      validateSenderRtpParameters(param);
-
-      assert_equals(param.degradationPreference, undefined);
-    });
-  }, 'setParameters with degradationPreference unset should succeed');
-
-</script>

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-encodings.html

@@ -41,7 +41,6 @@
         sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
         RTCRtcpParameters                         rtcp;
         sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
       };
 
       dictionary RTCRtpEncodingParameters {

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-headerExtensions.html

@@ -27,7 +27,6 @@
         sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
         RTCRtcpParameters                         rtcp;
         sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
       };
 
       dictionary RTCRtpHeaderExtensionParameters {

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-helper.js

@@ -46,9 +46,6 @@ async function doOfferAnswerExchange(t, caller) {
 
       - rtcp.cname is set to the CNAME of the associated RTCPeerConnection. rtcp.reducedSize
         is set to true if reduced-size RTCP has been negotiated for sending, and false otherwise.
-
-      - degradationPreference is set to the last value passed into setParameters, or the
-        default value of "balanced" if setParameters hasn't been called.
  */
 function validateSenderRtpParameters(param) {
   validateRtpParameters(param);
@@ -80,7 +77,7 @@ function validateSenderRtpParameters(param) {
       - rtcp.reducedSize is set to true if the receiver is currently prepared to receive
         reduced-size RTCP packets, and false otherwise. rtcp.cname is left undefined.
 
-      - transactionId and degradationPreference are left undefined.
+      - transactionId is left undefined.
  */
 function validateReceiverRtpParameters(param) {
   validateRtpParameters(param);
@@ -93,9 +90,6 @@ function validateReceiverRtpParameters(param) {
 
   assert_equals(param.rtcp.cname, undefined,
     'Expect receiver param.rtcp.cname to be unset');
-
-  assert_equals(param.degradationPreference, undefined,
-    'Expect receiver param.degradationPreference to be unset');
 }
 
 /*
@@ -105,7 +99,6 @@ function validateReceiverRtpParameters(param) {
     sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
     RTCRtcpParameters                         rtcp;
     sequence<RTCRtpCodecParameters>           codecs;
-    RTCDegradationPreference                  degradationPreference;
   };
 
   enum RTCDegradationPreference {
@@ -134,9 +127,6 @@ function validateRtpParameters(param) {
   for(const codec of param.codecs) {
     validateCodecParameters(codec);
   }
-
-  assert_optional_enum_field(param, 'degradationPreference',
-    ['maintain-framerate', 'maintain-resolution', 'balanced']);
 }
 
 /*
@@ -307,4 +297,4 @@ function test_modified_encoding(kind, field, value1, value2, desc) {
     const encoding2 = getFirstEncoding(param2);
     assert_equals(encoding2[field], value2);
   }, desc + ' without RTCRtpTransceiverInit');
-}
\ No newline at end of file
+}

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-rtcp.html

@@ -27,7 +27,6 @@
         sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
         RTCRtcpParameters                         rtcp;
         sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
       };
 
       dictionary RTCRtcpParameters {

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpParameters-transactionId.html

@@ -48,7 +48,6 @@
         sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
         RTCRtcpParameters                         rtcp;
         sequence<RTCRtpCodecParameters>           codecs;
-        RTCDegradationPreference                  degradationPreference;
       };
 
       getParameters

third_party/blink/web_tests/external/wpt/webrtc/RTCRtpReceiver-getParameters.html

@@ -30,9 +30,7 @@
 
         - rtcp.reducedSize is set to true if the receiver is currently prepared to receive
           reduced-size RTCP packets, and false otherwise. rtcp.cname is left undefined.
-
-        - transactionId and degradationPreference are left undefined.
-   */
+  */
   promise_test(async t => {
     const pc = new RTCPeerConnection();
     t.add_cleanup(() => pc.close());