Add RTCRtpSender.getParameters() and mock setParameters()

Add the getParameters() function forwarding all the values
that are implemented in WebRTC to the Javascript layer.
Other properties that exist will be loaded for future use,
but not passed to the Javascript layer.
Currently behind RuntimeEnabled=RTCRtpSenderParameters.

Bug: 803494
Change-Id: Icd1c1ea58fd1ad3d50a46e97db3026837381c7b6
Reviewed-on: https://chromium-review.googlesource.com/919082Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Henrik Boström <hbos@chromium.org>
Reviewed-by: Guido Urdaneta <guidou@chromium.org>
Commit-Queue: Florent Castelli <orphis@chromium.org>
Cr-Commit-Position: refs/heads/master@{#542086}

content/renderer/BUILD.gn

@@ -764,6 +764,8 @@ target(link_target_type, "renderer") {
       "media/webrtc/rtc_peer_connection_handler.h",
       "media/webrtc/rtc_rtp_contributing_source.cc",
       "media/webrtc/rtc_rtp_contributing_source.h",
+      "media/webrtc/rtc_rtp_parameters.cc",
+      "media/webrtc/rtc_rtp_parameters.h",
       "media/webrtc/rtc_rtp_receiver.cc",
       "media/webrtc/rtc_rtp_receiver.h",
       "media/webrtc/rtc_rtp_sender.cc",

content/renderer/media/webrtc/rtc_rtp_parameters.cc

+// Copyright (c) 2018 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/webrtc/rtc_rtp_parameters.h"
+
+#include <utility>
+
+namespace {
+
+// Relative weights for each priority as defined in RTCWEB-DATA
+// https://tools.ietf.org/html/draft-ietf-rtcweb-data-channel
+const double kPriorityWeightVeryLow = 0.5;
+const double kPriorityWeightLow = 1;
+const double kPriorityWeightMedium = 2;
+const double kPriorityWeightHigh = 4;
+
+template <typename T, typename F>
+base::Optional<T> ToBaseOptional(const rtc::Optional<F>& from) {
+  if (from)
+    return from.value();
+  return base::nullopt;
+}
+
+blink::WebRTCPriorityType PriorityFromDouble(double priority) {
+  // Find the middle point between 2 priority weights to match them to a
+  // WebRTC priority
+  const double very_low_upper_bound =
+      (kPriorityWeightVeryLow + kPriorityWeightLow) / 2;
+  const double low_upper_bound =
+      (kPriorityWeightLow + kPriorityWeightMedium) / 2;
+  const double medium_upper_bound =
+      (kPriorityWeightMedium + kPriorityWeightHigh) / 2;
+
+  if (priority < webrtc::kDefaultBitratePriority * very_low_upper_bound) {
+    return blink::WebRTCPriorityType::VeryLow;
+  }
+  if (priority < webrtc::kDefaultBitratePriority * low_upper_bound) {
+    return blink::WebRTCPriorityType::Low;
+  }
+  if (priority < webrtc::kDefaultBitratePriority * medium_upper_bound) {
+    return blink::WebRTCPriorityType::Medium;
+  }
+  return blink::WebRTCPriorityType::High;
+}
+
+base::Optional<blink::WebRTCDtxStatus> FromRTCDtxStatus(
+    rtc::Optional<webrtc::DtxStatus> status) {
+  if (!status)
+    return base::nullopt;
+
+  blink::WebRTCDtxStatus result;
+  switch (status.value()) {
+    case webrtc::DtxStatus::DISABLED:
+      result = blink::WebRTCDtxStatus::Disabled;
+      break;
+    case webrtc::DtxStatus::ENABLED:
+      result = blink::WebRTCDtxStatus::Enabled;
+      break;
+    default:
+      NOTREACHED();
+  }
+  return result;
+}
+
+base::Optional<blink::WebRTCDegradationPreference> FromRTCDegradationPreference(
+    rtc::Optional<webrtc::DegradationPreference> degradation_preference) {
+  if (!degradation_preference)
+    return base::nullopt;
+
+  blink::WebRTCDegradationPreference result;
+  switch (degradation_preference.value()) {
+    case webrtc::DegradationPreference::MAINTAIN_FRAMERATE:
+      result = blink::WebRTCDegradationPreference::MaintainFramerate;
+      break;
+    case webrtc::DegradationPreference::MAINTAIN_RESOLUTION:
+      result = blink::WebRTCDegradationPreference::MaintainResolution;
+      break;
+    case webrtc::DegradationPreference::BALANCED:
+      result = blink::WebRTCDegradationPreference::Balanced;
+      break;
+    default:
+      NOTREACHED();
+  }
+  return result;
+}
+
+}  // namespace
+
+namespace content {
+
+blink::WebRTCRtpParameters GetWebRTCRtpParameters(
+    const webrtc::RtpParameters& parameters) {
+  blink::WebVector<blink::WebRTCRtpEncodingParameters> encodings;
+  encodings.reserve(parameters.encodings.size());
+  for (const auto& encoding_parameter : parameters.encodings) {
+    encodings.emplace_back(GetWebRTCRtpEncodingParameters(encoding_parameter));
+  }
+
+  blink::WebVector<blink::WebRTCRtpHeaderExtensionParameters> header_extensions;
+  header_extensions.reserve(parameters.header_extensions.size());
+  for (const auto& extension_parameter : parameters.header_extensions) {
+    header_extensions.emplace_back(
+        GetWebRTCRtpHeaderExtensionParameters(extension_parameter));
+  }
+
+  blink::WebVector<blink::WebRTCRtpCodecParameters> codec_parameters;
+  codec_parameters.reserve(parameters.codecs.size());
+  for (const auto& codec_parameter : parameters.codecs) {
+    codec_parameters.emplace_back(GetWebRTCRtpCodecParameters(codec_parameter));
+  }
+
+  return blink::WebRTCRtpParameters(
+      blink::WebString::FromASCII(parameters.transaction_id),
+      blink::WebRTCRtcpParameters(), std::move(encodings), header_extensions,
+      codec_parameters,
+      FromRTCDegradationPreference(parameters.degradation_preference));
+}
+
+blink::WebRTCRtpEncodingParameters GetWebRTCRtpEncodingParameters(
+    const webrtc::RtpEncodingParameters& encoding_parameters) {
+  return blink::WebRTCRtpEncodingParameters(
+      ToBaseOptional<uint8_t>(encoding_parameters.codec_payload_type),
+      FromRTCDtxStatus(encoding_parameters.dtx), encoding_parameters.active,
+      PriorityFromDouble(encoding_parameters.bitrate_priority),
+      ToBaseOptional<uint32_t>(encoding_parameters.ptime),
+      ToBaseOptional<uint32_t>(encoding_parameters.max_bitrate_bps),
+      ToBaseOptional<uint32_t>(encoding_parameters.max_framerate),
+      encoding_parameters.scale_framerate_down_by,
+      blink::WebString::FromASCII(encoding_parameters.rid));
+}
+
+blink::WebRTCRtpHeaderExtensionParameters GetWebRTCRtpHeaderExtensionParameters(
+    const webrtc::RtpHeaderExtensionParameters& extension_parameters) {
+  return blink::WebRTCRtpHeaderExtensionParameters(
+      blink::WebString::FromASCII(extension_parameters.uri),
+      extension_parameters.id, extension_parameters.encrypt);
+}
+
+// TODO(orphis): Copy the RTCP information
+// https://crbug.com/webrtc/7580
+blink::WebRTCRtcpParameters GetWebRTCRtcpParameters() {
+  return blink::WebRTCRtcpParameters();
+}
+
+blink::WebRTCRtpCodecParameters GetWebRTCRtpCodecParameters(
+    const webrtc::RtpCodecParameters& codec_parameters) {
+  return blink::WebRTCRtpCodecParameters(
+      codec_parameters.payload_type,
+      blink::WebString::FromASCII(codec_parameters.mime_type()),
+      ToBaseOptional<uint32_t>(codec_parameters.clock_rate),
+      ToBaseOptional<uint16_t>(codec_parameters.num_channels),
+      // TODO(orphis): Convert the parameters field to sdpFmtpLine
+      // https://crbug.com/webrtc/7580
+      blink::WebString());
+}
+
+}  // namespace content

content/renderer/media/webrtc/rtc_rtp_parameters.h

+// Copyright (c) 2018 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_PARAMETERS_H_
+#define CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_PARAMETERS_H_
+
+#include "base/memory/ref_counted.h"
+#include "content/common/content_export.h"
+#include "third_party/WebKit/public/platform/WebRTCRtpParameters.h"
+#include "third_party/webrtc/api/rtpparameters.h"
+
+namespace content {
+
+CONTENT_EXPORT blink::WebRTCRtpEncodingParameters
+GetWebRTCRtpEncodingParameters(
+    const webrtc::RtpEncodingParameters& encoding_parameters);
+
+CONTENT_EXPORT blink::WebRTCRtpHeaderExtensionParameters
+GetWebRTCRtpHeaderExtensionParameters(
+    const webrtc::RtpHeaderExtensionParameters& extension_parameters);
+
+CONTENT_EXPORT blink::WebRTCRtcpParameters GetWebRTCRtcpParameters();
+
+CONTENT_EXPORT blink::WebRTCRtpCodecParameters GetWebRTCRtpCodecParameters(
+    const webrtc::RtpCodecParameters& codec_parameters);
+
+CONTENT_EXPORT blink::WebRTCRtpParameters GetWebRTCRtpParameters(
+    const webrtc::RtpParameters& parameters);
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_WEBRTC_RTC_RTP_PARAMETERS_H_

content/renderer/media/webrtc/rtc_rtp_parameters_unittest.cc

+// Copyright (c) 2012 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/webrtc/rtc_rtp_parameters.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+TEST(RTCRtpParametersTest, Read) {
+  webrtc::RtpParameters webrtc_parameters;
+  webrtc_parameters.transaction_id = "transaction_id";
+  webrtc_parameters.degradation_preference =
+      webrtc::DegradationPreference::BALANCED;
+
+  webrtc_parameters.encodings.emplace_back();
+  webrtc::RtpEncodingParameters& webrtc_encoding =
+      webrtc_parameters.encodings.front();
+  webrtc_encoding.codec_payload_type = 42;
+  webrtc_encoding.dtx = webrtc::DtxStatus::ENABLED;
+  webrtc_encoding.active = true;
+  webrtc_encoding.bitrate_priority = webrtc::kDefaultBitratePriority;
+  webrtc_encoding.ptime = 1337;
+  webrtc_encoding.max_bitrate_bps = 1337000;
+  webrtc_encoding.max_framerate = 60;
+  webrtc_encoding.scale_resolution_down_by = 1.;
+  webrtc_encoding.rid = "rid";
+
+  webrtc_parameters.header_extensions.emplace_back();
+  webrtc::RtpHeaderExtensionParameters& webrtc_header_extension =
+      webrtc_parameters.header_extensions.front();
+  webrtc_header_extension.uri = "uri";
+  webrtc_header_extension.id = 33;
+  webrtc_header_extension.encrypt = true;
+
+  webrtc_parameters.codecs.emplace_back();
+  webrtc::RtpCodecParameters& webrtc_codec_parameter =
+      webrtc_parameters.codecs.front();
+  webrtc_codec_parameter.payload_type = 42;
+  webrtc_codec_parameter.clock_rate = 1234;
+  webrtc_codec_parameter.num_channels = 2;
+
+  blink::WebRTCRtpParameters parameters =
+      GetWebRTCRtpParameters(webrtc_parameters);
+  EXPECT_EQ(parameters.TransactionId(), "transaction_id");
+  EXPECT_EQ(parameters.DegradationPreference(),
+            blink::WebRTCDegradationPreference::Balanced);
+
+  ASSERT_EQ(parameters.Encodings().size(), 1u);
+  for (const auto& encoding : parameters.Encodings()) {
+    EXPECT_EQ(encoding.CodecPayloadType(), 42);
+    EXPECT_EQ(encoding.Dtx(), blink::WebRTCDtxStatus::Enabled);
+    EXPECT_EQ(encoding.Active(), true);
+    EXPECT_EQ(encoding.Priority(), blink::WebRTCPriorityType::Low);
+    EXPECT_EQ(encoding.Ptime(), 1337u);
+    EXPECT_EQ(encoding.MaxBitrate(), 1337000u);
+    EXPECT_EQ(encoding.MaxFramerate(), 60u);
+    EXPECT_EQ(encoding.ScaleResolutionDownBy(), 1.);
+    EXPECT_EQ(encoding.Rid(), "rid");
+  }
+
+  ASSERT_EQ(parameters.HeaderExtensions().size(), 1u);
+  for (const auto& header_extension : parameters.HeaderExtensions()) {
+    EXPECT_EQ(header_extension.URI(), "uri");
+    EXPECT_EQ(header_extension.Id(), 33);
+    EXPECT_EQ(header_extension.Encrypted(), true);
+  }
+
+  ASSERT_EQ(parameters.Codecs().size(), 1u);
+  for (const auto& codec : parameters.Codecs()) {
+    EXPECT_EQ(codec.PayloadType(), 42);
+    EXPECT_EQ(codec.ClockRate(), 1234u);
+    EXPECT_EQ(codec.Channels(), 2u);
+  }
+}
+
+TEST(RTCRtpParametersTest, CheckDtxStatusEnum) {
+  webrtc::RtpEncodingParameters webrtc_encoding_parameters;
+
+  {
+    webrtc_encoding_parameters.dtx = webrtc::DtxStatus::DISABLED;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Dtx(), blink::WebRTCDtxStatus::Disabled);
+  }
+
+  {
+    webrtc_encoding_parameters.dtx = webrtc::DtxStatus::ENABLED;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Dtx(), blink::WebRTCDtxStatus::Enabled);
+  }
+}
+
+TEST(RTCRtpParametersTest, CheckDegradationPreferenceEnum) {
+  webrtc::RtpParameters webrtc_parameters;
+
+  {
+    webrtc_parameters.degradation_preference =
+        webrtc::DegradationPreference::MAINTAIN_FRAMERATE;
+    blink::WebRTCRtpParameters parameters =
+        GetWebRTCRtpParameters(webrtc_parameters);
+    EXPECT_EQ(parameters.DegradationPreference(),
+              blink::WebRTCDegradationPreference::MaintainFramerate);
+  }
+
+  {
+    webrtc_parameters.degradation_preference =
+        webrtc::DegradationPreference::MAINTAIN_RESOLUTION;
+    blink::WebRTCRtpParameters parameters =
+        GetWebRTCRtpParameters(webrtc_parameters);
+    EXPECT_EQ(parameters.DegradationPreference(),
+              blink::WebRTCDegradationPreference::MaintainResolution);
+  }
+
+  {
+    webrtc_parameters.degradation_preference =
+        webrtc::DegradationPreference::BALANCED;
+    blink::WebRTCRtpParameters parameters =
+        GetWebRTCRtpParameters(webrtc_parameters);
+    EXPECT_EQ(parameters.DegradationPreference(),
+              blink::WebRTCDegradationPreference::Balanced);
+  }
+}
+
+TEST(RTCRtpParametersTest, CheckPriorityEnum) {
+  webrtc::RtpEncodingParameters webrtc_encoding_parameters;
+
+  {
+    webrtc_encoding_parameters.bitrate_priority =
+        webrtc::kDefaultBitratePriority / 2;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Priority(),
+              blink::WebRTCPriorityType::VeryLow);
+  }
+
+  {
+    webrtc_encoding_parameters.bitrate_priority =
+        webrtc::kDefaultBitratePriority;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Priority(), blink::WebRTCPriorityType::Low);
+  }
+
+  {
+    webrtc_encoding_parameters.bitrate_priority =
+        webrtc::kDefaultBitratePriority * 2;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Priority(),
+              blink::WebRTCPriorityType::Medium);
+  }
+
+  {
+    webrtc_encoding_parameters.bitrate_priority =
+        webrtc::kDefaultBitratePriority * 4;
+    blink::WebRTCRtpEncodingParameters encoding_parameters =
+        GetWebRTCRtpEncodingParameters(webrtc_encoding_parameters);
+    EXPECT_EQ(encoding_parameters.Priority(), blink::WebRTCPriorityType::High);
+  }
+}
+
+}  // namespace content

content/renderer/media/webrtc/rtc_rtp_sender.cc

@@ -4,8 +4,11 @@
 
 #include "content/renderer/media/webrtc/rtc_rtp_sender.h"
 
+#include <utility>
+
 #include "base/logging.h"
 #include "content/renderer/media/webrtc/rtc_dtmf_sender_handler.h"
+#include "content/renderer/media/webrtc/rtc_rtp_parameters.h"
 
 namespace content {
 
@@ -119,6 +122,12 @@ class RTCRtpSender::RTCRtpSenderInternal
     return std::make_unique<RtcDtmfSenderHandler>(dtmf_sender);
   }
 
+  std::unique_ptr<blink::WebRTCRtpParameters> GetParameters() const {
+    webrtc::RtpParameters parameters = webrtc_sender_->GetParameters();
+    return std::make_unique<blink::WebRTCRtpParameters>(
+        GetWebRTCRtpParameters(parameters));
+  }
+
   bool RemoveFromPeerConnection(webrtc::PeerConnectionInterface* pc) {
     if (!pc->RemoveTrack(webrtc_sender_))
       return false;
@@ -256,6 +265,11 @@ std::unique_ptr<blink::WebRTCDTMFSenderHandler> RTCRtpSender::GetDtmfSender()
   return internal_->GetDtmfSender();
 }
 
+std::unique_ptr<blink::WebRTCRtpParameters> RTCRtpSender::GetParameters()
+    const {
+  return internal_->GetParameters();
+}
+
 webrtc::RtpSenderInterface* RTCRtpSender::webrtc_sender() const {
   return internal_->webrtc_sender();
 }

content/renderer/media/webrtc/rtc_rtp_sender.h

@@ -67,6 +67,7 @@ class CONTENT_EXPORT RTCRtpSender : public blink::WebRTCRtpSender {
                     blink::WebRTCVoidRequest request) override;
   std::unique_ptr<blink::WebRTCDTMFSenderHandler> GetDtmfSender()
       const override;
+  std::unique_ptr<blink::WebRTCRtpParameters> GetParameters() const override;
 
   webrtc::RtpSenderInterface* webrtc_sender() const;
   const webrtc::MediaStreamTrackInterface* webrtc_track() const;

content/test/BUILD.gn

@@ -1845,6 +1845,7 @@ test("content_unittests") {
       "../renderer/media/webrtc/peer_connection_tracker_unittest.cc",
       "../renderer/media/webrtc/rtc_data_channel_handler_unittest.cc",
       "../renderer/media/webrtc/rtc_peer_connection_handler_unittest.cc",
+      "../renderer/media/webrtc/rtc_rtp_parameters_unittest.cc",
       "../renderer/media/webrtc/rtc_rtp_sender_unittest.cc",
       "../renderer/media/webrtc/rtc_stats_unittest.cc",
       "../renderer/media/webrtc/rtc_video_decoder_unittest.cc",

third_party/WebKit/LayoutTests/external/wpt/webrtc/interfaces.https-expected.txt

@@ -334,9 +334,9 @@ FAIL RTCRtpSender interface: attribute rtcpTransport assert_true: The prototype
 PASS Unscopable handled correctly for rtcpTransport property on RTCRtpSender
 FAIL RTCRtpSender interface: operation getCapabilities(DOMString) assert_own_property: interface object missing static operation expected property "getCapabilities" missing
 PASS Unscopable handled correctly for getCapabilities(DOMString) on RTCRtpSender
-FAIL RTCRtpSender interface: operation setParameters(RTCRtpParameters) assert_own_property: interface prototype object missing non-static operation expected property "setParameters" missing
+PASS RTCRtpSender interface: operation setParameters(RTCRtpParameters)
 PASS Unscopable handled correctly for setParameters(RTCRtpParameters) on RTCRtpSender
-FAIL RTCRtpSender interface: operation getParameters() assert_own_property: interface prototype object missing non-static operation expected property "getParameters" missing
+PASS RTCRtpSender interface: operation getParameters()
 PASS Unscopable handled correctly for getParameters() on RTCRtpSender
 PASS RTCRtpSender interface: operation replaceTrack(MediaStreamTrack)
 PASS Unscopable handled correctly for replaceTrack(MediaStreamTrack) on RTCRtpSender

third_party/WebKit/LayoutTests/fast/peerconnection/RTCPeerConnection-getParameters.html

+<!DOCTYPE html>
+<html>
+<head>
+<title>RTCPeerConnection.getParameters</title>
+<script src="../../resources/testharness.js"></script>
+<script src="../../resources/testharnessreport.js"></script>
+</head>
+<body>
+<script>
+promise_test(function() {
+  let pc1 = new RTCPeerConnection();
+  let pc2 = new RTCPeerConnection();
+  let video_sender, audio_sender;
+
+  return createStreams({audio:true, video:true}, 1)
+    .then(function(streams) {
+      video_sender = pc1.addTrack(streams[0].getVideoTracks()[0], streams[0]);
+      audio_sender = pc1.addTrack(streams[0].getAudioTracks()[0], streams[0]);
+    }).then(() => connect_pcs(pc1, pc2))
+    .then(() => {
+      video_parameters = video_sender.getParameters();
+      verifySenderParameters(video_parameters, 'video');
+
+      audio_parameters = audio_sender.getParameters();
+      verifySenderParameters(audio_parameters, 'audio');
+    });
+}, 'getParameters()');
+
+/**
+ * Helper functions to tests.
+ */
+
+function createStreams(constraints, numStreams, streamsSoFar = []) {
+  if (numStreams == 0) {
+    return Promise.resolve(streamsSoFar);
+  }
+  return navigator.mediaDevices.getUserMedia(constraints)
+    .then(function(stream) {
+      return createStreams(constraints,
+                           numStreams - 1,
+                           streamsSoFar.concat([stream]));
+    });
+}
+
+function connect_pcs(localPc, remotePc) {
+  return localPc.createOffer()
+  .then(offer => Promise.all([
+    localPc.setLocalDescription(offer),
+    remotePc.setRemoteDescription(offer)]))
+  .then(() => remotePc.createAnswer())
+  .then(answer => Promise.all([
+    remotePc.setLocalDescription(answer),
+    localPc.setRemoteDescription(answer)]))
+}
+
+function verifySenderParameters(parameters, kind) {
+  assert_not_exists(parameters, "transactionId", "unimplemented transactionId");
+  assert_not_exists(parameters, "rtcp", "unimplemented rtcp");
+
+  assert_greater_than(parameters.codecs.length, 0);
+  for(let codec of parameters.codecs) {
+    if(kind === 'video') {
+      assert_not_exists(codec, "channels", "no channels on video tracks");
+      assert_equals(codec.clockRate, 90000);
+    } else {
+      assert_exists(codec, "channels", "channel count");
+      assert_greater_than(codec.clockRate, 0);
+    }
+
+    assert_exists(codec, "mimeType", "mime type");
+    assert_true(codec.mimeType.startsWith(kind + "/"));
+
+    assert_exists(codec, "payloadType", "payload type");
+    assert_not_exists(codec, "sdpFmtpLine", "unimplemented sdp_fmtp_line");
+  }
+
+  assert_not_exists(parameters, "headerExtensions", "unimplemented headerExtension");
+
+  assert_greater_than(parameters.encodings.length, 0);
+  for(let encoding of parameters.encodings) {
+    assert_not_exists(encoding, "codecPayloadType", "unset codecPayloadType");
+    assert_not_exists(encoding, "dtx", "unset dtx");
+    assert_true(encoding.active);
+    assert_equals(encoding.priority, "low");
+    assert_not_exists(encoding, "ptime", "unset ptime");
+    assert_not_exists(encoding, "maxBitrate", "unset maxBitrate");
+    assert_not_exists(encoding, "maxFramerate", "unset maxFramerate");
+    assert_not_exists(encoding, "scaleResolutionDownBy", "unset scaleResolutionDownBy");
+    assert_not_exists(encoding, "rid", "unset rid");
+  }
+
+  assert_not_exists(parameters, "degradationPreference", "unimplemented degradationPreference");
+}
+</script>
+</body>
+</html>

third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt

@@ -5389,7 +5389,9 @@ interface RTCRtpSender
     getter dtmf
     getter track
     method constructor
+    method getParameters
     method replaceTrack
+    method setParameters
 interface RTCSessionDescription
     attribute @@toStringTag
     getter sdp

third_party/WebKit/Source/modules/modules_idl_files.gni

@@ -568,6 +568,11 @@ modules_dictionary_idl_files =
           "peerconnection/RTCOfferAnswerOptions.idl",
           "peerconnection/RTCOfferOptions.idl",
           "peerconnection/RTCPeerConnectionIceEventInit.idl",
+          "peerconnection/RTCRtcpParameters.idl",
+          "peerconnection/RTCRtpCodecParameters.idl",
+          "peerconnection/RTCRtpEncodingParameters.idl",
+          "peerconnection/RTCRtpHeaderExtensionParameters.idl",
+          "peerconnection/RTCRtpParameters.idl",
           "peerconnection/RTCSessionDescriptionInit.idl",
           "peerconnection/RTCTrackEventInit.idl",
           "permissions/ClipboardPermissionDescriptor.idl",

third_party/WebKit/Source/modules/peerconnection/RTCRtcpParameters.idl

+// Copyright 2018 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.
+
+// https://w3c.github.io/webrtc-pc/#rtcrtcpparameters*
+dictionary RTCRtcpParameters {
+    DOMString cname;
+    boolean   reducedSize;
+};
\ No newline at end of file

third_party/WebKit/Source/modules/peerconnection/RTCRtpCodecParameters.idl

+// Copyright 2018 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.
+
+// https://w3c.github.io/webrtc-pc/#rtcrtpcodecparameters*
+dictionary RTCRtpCodecParameters {
+    octet          payloadType;
+    DOMString      mimeType;
+    unsigned long  clockRate;
+    unsigned short channels;
+    DOMString      sdpFmtpLine;
+};
\ No newline at end of file

third_party/WebKit/Source/modules/peerconnection/RTCRtpEncodingParameters.idl

+// Copyright 2018 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.
+
+// https://w3c.github.io/webrtc-pc/#rtcprioritytype-enum
+enum RTCPriorityType {
+    "very-low",
+    "low",
+    "medium",
+    "high"
+};
+
+// https://w3c.github.io/webrtc-pc/#rtcdtxstatus*
+enum RTCDtxStatus {
+    "disabled",
+    "enabled"
+};
+
+// https://w3c.github.io/webrtc-pc/#rtcrtpencodingparameters*
+dictionary RTCRtpEncodingParameters {
+    octet           codecPayloadType;
+    RTCDtxStatus    dtx;
+    boolean         active = true;
+    RTCPriorityType priority = "low";
+    unsigned long   ptime;
+    unsigned long   maxBitrate;
+    double          maxFramerate;
+    DOMString       rid;
+    double          scaleResolutionDownBy;
+};
\ No newline at end of file

third_party/WebKit/Source/modules/peerconnection/RTCRtpHeaderExtensionParameters.idl

+// Copyright 2018 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.
+
+// https://w3c.github.io/webrtc-pc/#rtcrtpheaderextensionparameters*
+dictionary RTCRtpHeaderExtensionParameters {
+    DOMString      uri;
+    unsigned short id;
+    boolean        encrypted;
+};
\ No newline at end of file

third_party/WebKit/Source/modules/peerconnection/RTCRtpParameters.idl

+// Copyright 2018 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.
+
+// https://w3c.github.io/webrtc-pc/#rtcdegradationpreference*
+enum RTCDegradationPreference {
+    "maintain-framerate",
+    "maintain-resolution",
+    "balanced"
+};
+
+// https://w3c.github.io/webrtc-pc/#rtcrtpparameters*
+dictionary RTCRtpParameters {
+    DOMString                                 transactionId;
+    sequence<RTCRtpEncodingParameters>        encodings;
+    sequence<RTCRtpHeaderExtensionParameters> headerExtensions;
+    RTCRtcpParameters                         rtcp;
+    sequence<RTCRtpCodecParameters>           codecs;
+    RTCDegradationPreference                  degradationPreference;
+};
\ No newline at end of file

third_party/WebKit/Source/modules/peerconnection/RTCRtpSender.cpp

@@ -9,6 +9,7 @@
 #include "modules/mediastream/MediaStreamTrack.h"
 #include "modules/peerconnection/RTCDTMFSender.h"
 #include "modules/peerconnection/RTCPeerConnection.h"
+#include "modules/peerconnection/RTCRtpParameters.h"
 #include "platform/peerconnection/RTCVoidRequest.h"
 #include "public/platform/WebRTCDTMFSenderHandler.h"
 
@@ -87,6 +88,69 @@ ScriptPromise RTCRtpSender::replaceTrack(ScriptState* script_state,
   return promise;
 }
 
+void RTCRtpSender::getParameters(RTCRtpParameters& parameters) {
+  // TODO(orphis): Forward missing fields from the WebRTC library:
+  // transactionId, rtcp, headerExtensions, degradationPreference
+  std::unique_ptr<WebRTCRtpParameters> web_parameters =
+      sender_->GetParameters();
+
+  HeapVector<RTCRtpEncodingParameters> encodings;
+  encodings.ReserveCapacity(web_parameters->Encodings().size());
+  for (const auto& web_encoding : web_parameters->Encodings()) {
+    // TODO(orphis): Forward missing fields from the WebRTC library:
+    // codecPayloadType, dtx, ptime, maxFramerate, scaleResolutionDownBy, rid
+    encodings.emplace_back();
+    RTCRtpEncodingParameters& encoding = encodings.back();
+    encoding.setActive(web_encoding.Active());
+    if (web_encoding.MaxBitrate())
+      encoding.setMaxBitrate(web_encoding.MaxBitrate().value());
+
+    const char* priority = "";
+    switch (web_encoding.Priority()) {
+      case WebRTCPriorityType::VeryLow:
+        priority = "very-low";
+        break;
+      case WebRTCPriorityType::Low:
+        priority = "low";
+        break;
+      case WebRTCPriorityType::Medium:
+        priority = "medium";
+        break;
+      case WebRTCPriorityType::High:
+        priority = "high";
+        break;
+      default:
+        NOTREACHED();
+    }
+    encoding.setPriority(priority);
+  }
+  parameters.setEncodings(encodings);
+
+  HeapVector<RTCRtpCodecParameters> codecs;
+  codecs.ReserveCapacity(web_parameters->Codecs().size());
+  for (const auto& web_codec : web_parameters->Codecs()) {
+    // TODO(orphis): Forward missing field from the WebRTC library: sdpFmtpLine
+    codecs.emplace_back();
+    RTCRtpCodecParameters& codec = codecs.back();
+    if (web_codec.PayloadType())
+      codec.setPayloadType(web_codec.PayloadType().value());
+    if (web_codec.MimeType())
+      codec.setMimeType(web_codec.MimeType().value());
+    if (web_codec.ClockRate())
+      codec.setClockRate(web_codec.ClockRate().value());
+    if (web_codec.Channels())
+      codec.setChannels(web_codec.Channels().value());
+  }
+  parameters.setCodecs(codecs);
+}
+
+ScriptPromise RTCRtpSender::setParameters(ScriptState* script_state,
+                                          const RTCRtpParameters&) {
+  return ScriptPromise::RejectWithDOMException(
+      script_state,
+      DOMException::Create(kNotSupportedError, "Method not implemented"));
+}
+
 WebRTCRtpSender* RTCRtpSender::web_sender() {
   return sender_.get();
 }

third_party/WebKit/Source/modules/peerconnection/RTCRtpSender.h

@@ -19,6 +19,7 @@ namespace blink {
 class MediaStreamTrack;
 class RTCDTMFSender;
 class RTCPeerConnection;
+class RTCRtpParameters;
 
 // https://w3c.github.io/webrtc-pc/#rtcrtpsender-interface
 class RTCRtpSender final : public ScriptWrappable {
@@ -35,6 +36,8 @@ class RTCRtpSender final : public ScriptWrappable {
   MediaStreamTrack* track();
   ScriptPromise replaceTrack(ScriptState*, MediaStreamTrack*);
   RTCDTMFSender* dtmf();
+  void getParameters(RTCRtpParameters&);
+  ScriptPromise setParameters(ScriptState*, const RTCRtpParameters&);
 
   WebRTCRtpSender* web_sender();
   // Sets the track. This must be called when the |WebRTCRtpSender| has its

third_party/WebKit/Source/modules/peerconnection/RTCRtpSender.idl

@@ -6,6 +6,8 @@
 [Exposed=Window]
 interface RTCRtpSender {
     readonly attribute MediaStreamTrack? track;
+    [RuntimeEnabled=RTCRtpSenderParameters, CallWith=ScriptState] Promise<void> setParameters(optional RTCRtpParameters parameters);
+    [RuntimeEnabled=RTCRtpSenderParameters] RTCRtpParameters getParameters();
     [Measure, CallWith=ScriptState] Promise<void> replaceTrack(MediaStreamTrack? withTrack);
     [Measure] readonly attribute RTCDTMFSender? dtmf;
     // TODO(hbos): Implement the rest of RTCRtpSender, https://crbug.com/700916.

third_party/WebKit/Source/platform/runtime_enabled_features.json5

@@ -943,6 +943,10 @@
       origin_trial_feature_name: "RtcPeerConnectionId",
       status: "experimental",
     },
+    {
+      name: "RTCRtpSenderParameters",
+      status: "experimental",
+    },
     {
       name: "RTCUnifiedPlan",
       status: "experimental",

third_party/WebKit/Source/platform/testing/TestingPlatformSupportWithWebRTC.cpp

@@ -31,6 +31,9 @@ class DummyWebRTCRtpSender : public WebRTCRtpSender {
   std::unique_ptr<WebRTCDTMFSenderHandler> GetDtmfSender() const override {
     return nullptr;
   }
+  std::unique_ptr<WebRTCRtpParameters> GetParameters() const override {
+    return std::unique_ptr<WebRTCRtpParameters>();
+  }
 
  private:
   const uintptr_t id_;

third_party/WebKit/public/platform/WebRTCRtpParameters.h

+// Copyright 2016 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.
+
+#ifndef WebRTCRtpParameters_h
+#define WebRTCRtpParameters_h
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "WebCommon.h"
+#include "WebString.h"
+#include "WebVector.h"
+#include "base/optional.h"
+
+namespace blink {
+
+enum class WebRTCPriorityType {
+  VeryLow,
+  Low,
+  Medium,
+  High,
+};
+
+enum class WebRTCDegradationPreference {
+  MaintainFramerate,
+  MaintainResolution,
+  Balanced,
+};
+
+enum class WebRTCDtxStatus {
+  Disabled,
+  Enabled,
+};
+
+class BLINK_PLATFORM_EXPORT WebRTCRtpEncodingParameters {
+ public:
+  WebRTCRtpEncodingParameters();
+  WebRTCRtpEncodingParameters(
+      const base::Optional<uint8_t>& codec_payload_type,
+      const base::Optional<WebRTCDtxStatus>& dtx,
+      bool active,
+      WebRTCPriorityType priority,
+      const base::Optional<uint32_t>& ptime,
+      const base::Optional<uint32_t>& max_bitrate,
+      const base::Optional<uint32_t>& max_framerate,
+      const base::Optional<double>& scale_resolution_down_by,
+      const base::Optional<WebString>& rid)
+      : codec_payload_type_(codec_payload_type),
+        dtx_(dtx),
+        active_(active),
+        priority_(priority),
+        ptime_(ptime),
+        max_bitrate_(max_bitrate),
+        max_framerate_(max_framerate),
+        scale_resolution_down_by_(scale_resolution_down_by),
+        rid_(rid) {}
+
+  const base::Optional<uint8_t>& CodecPayloadType() const {
+    return codec_payload_type_;
+  }
+  const base::Optional<WebRTCDtxStatus>& Dtx() const { return dtx_; }
+  bool Active() const { return active_; }
+  WebRTCPriorityType Priority() const { return priority_; }
+  const base::Optional<uint32_t>& Ptime() const { return ptime_; }
+  const base::Optional<uint32_t>& MaxBitrate() const { return max_bitrate_; }
+  const base::Optional<uint32_t>& MaxFramerate() const {
+    return max_framerate_;
+  }
+  const base::Optional<double>& ScaleResolutionDownBy() const {
+    return scale_resolution_down_by_;
+  }
+  const base::Optional<WebString> Rid() const { return rid_; }
+
+ private:
+  base::Optional<uint8_t> codec_payload_type_;
+  base::Optional<WebRTCDtxStatus> dtx_;
+  bool active_;
+  WebRTCPriorityType priority_;
+  base::Optional<uint32_t> ptime_;
+  base::Optional<uint32_t> max_bitrate_;
+  base::Optional<uint32_t> max_framerate_;
+  base::Optional<double> scale_resolution_down_by_;
+  base::Optional<WebString> rid_;
+};
+
+class BLINK_PLATFORM_EXPORT WebRTCRtpHeaderExtensionParameters {
+ public:
+  WebRTCRtpHeaderExtensionParameters();
+  WebRTCRtpHeaderExtensionParameters(const base::Optional<WebString>& uri,
+                                     const base::Optional<uint16_t>& id,
+                                     const base::Optional<bool>& encrypted)
+      : uri_(uri), id_(id), encrypted_(encrypted) {}
+
+  const base::Optional<WebString>& URI() const { return uri_; }
+  const base::Optional<uint16_t>& Id() const { return id_; }
+  const base::Optional<bool>& Encrypted() const { return encrypted_; }
+
+ private:
+  base::Optional<WebString> uri_;
+  base::Optional<uint16_t> id_;
+  base::Optional<bool> encrypted_;
+};
+
+class BLINK_PLATFORM_EXPORT WebRTCRtcpParameters {
+ public:
+  const base::Optional<WebString>& Cname() const;
+  const base::Optional<bool>& ReducedSize() const;
+
+ private:
+  base::Optional<WebString> cname_;
+  base::Optional<bool> reduced_size_;
+};
+
+class BLINK_PLATFORM_EXPORT WebRTCRtpCodecParameters {
+ public:
+  WebRTCRtpCodecParameters() = default;
+  WebRTCRtpCodecParameters(const base::Optional<uint8_t>& payload_type,
+                           const base::Optional<WebString>& mime_type,
+                           const base::Optional<uint32_t>& clock_rate,
+                           const base::Optional<uint16_t>& channels,
+                           const base::Optional<WebString>& sdp_fmtp_line)
+      : payload_type_(payload_type),
+        mime_type_(mime_type),
+        clock_rate_(clock_rate),
+        channels_(channels),
+        sdp_fmtp_line_(sdp_fmtp_line) {}
+
+  const base::Optional<uint8_t>& PayloadType() const { return payload_type_; }
+  const base::Optional<WebString>& MimeType() const { return mime_type_; }
+  const base::Optional<uint32_t>& ClockRate() const { return clock_rate_; }
+  const base::Optional<uint16_t>& Channels() const { return channels_; }
+  const base::Optional<WebString>& SdpFmtpLine() const {
+    return sdp_fmtp_line_;
+  }
+
+ private:
+  base::Optional<uint8_t> payload_type_;
+  base::Optional<WebString> mime_type_;
+  base::Optional<uint32_t> clock_rate_;
+  base::Optional<uint16_t> channels_;
+  base::Optional<WebString> sdp_fmtp_line_;
+};
+
+class BLINK_PLATFORM_EXPORT WebRTCRtpParameters {
+ public:
+  WebRTCRtpParameters(
+      const base::Optional<WebString>& transaction_id,
+      const WebRTCRtcpParameters& rtcp,
+      const WebVector<WebRTCRtpEncodingParameters>& encodings,
+      const WebVector<WebRTCRtpHeaderExtensionParameters>& header_extensions,
+      const WebVector<WebRTCRtpCodecParameters>& codecs,
+      const base::Optional<WebRTCDegradationPreference>& degradation_preference)
+      : transaction_id_(transaction_id),
+        rtcp_(rtcp),
+        encodings_(encodings),
+        header_extensions_(header_extensions),
+        codecs_(codecs),
+        degradation_preference_(degradation_preference) {}
+
+  const base::Optional<WebString>& TransactionId() const {
+    return transaction_id_;
+  }
+  const WebVector<WebRTCRtpEncodingParameters>& Encodings() const {
+    return encodings_;
+  }
+  const WebVector<WebRTCRtpHeaderExtensionParameters>& HeaderExtensions()
+      const {
+    return header_extensions_;
+  }
+  const WebRTCRtcpParameters& Rtcp() const { return rtcp_; }
+  const WebVector<WebRTCRtpCodecParameters>& Codecs() const { return codecs_; }
+  const base::Optional<WebRTCDegradationPreference>& DegradationPreference()
+      const {
+    return degradation_preference_;
+  }
+
+ private:
+  base::Optional<WebString> transaction_id_;
+  WebRTCRtcpParameters rtcp_;
+  WebVector<WebRTCRtpEncodingParameters> encodings_;
+  WebVector<WebRTCRtpHeaderExtensionParameters> header_extensions_;
+  WebVector<WebRTCRtpCodecParameters> codecs_;
+  base::Optional<WebRTCDegradationPreference> degradation_preference_;
+};
+
+}  // namespace blink
+
+#endif  // WebRTCRtpParameters_h

third_party/WebKit/public/platform/WebRTCRtpSender.h

@@ -6,6 +6,7 @@
 #define WebRTCRtpSender_h
 
 #include "WebCommon.h"
+#include "WebRTCRtpParameters.h"
 #include "WebRTCVoidRequest.h"
 #include "WebString.h"
 
@@ -32,6 +33,7 @@ class BLINK_PLATFORM_EXPORT WebRTCRtpSender {
   // https://crbug.com/790007
   virtual void ReplaceTrack(WebMediaStreamTrack, WebRTCVoidRequest) = 0;
   virtual std::unique_ptr<WebRTCDTMFSenderHandler> GetDtmfSender() const = 0;
+  virtual std::unique_ptr<WebRTCRtpParameters> GetParameters() const = 0;
 };
 
 }  // namespace blink