Change the default rtcp mux policy from negotiate to require.

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

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 211 matching lines @@
   if (policy == "none")
     return WebRTCIceTransportPolicy::kNone;
   if (policy == "relay")
     return WebRTCIceTransportPolicy::kRelay;
   DCHECK_EQ(policy, "all");
   return WebRTCIceTransportPolicy::kAll;
 }
 
 WebRTCConfiguration parseConfiguration(ExecutionContext* context,
                                        const RTCConfiguration& configuration,
-                                       ExceptionState& exceptionState,
-                                       RtcpMuxPolicy* selectedRtcpMuxPolicy) {
+                                       ExceptionState& exceptionState) {
   DCHECK(context);
-  DCHECK(selectedRtcpMuxPolicy);
 
   WebRTCIceTransportPolicy iceTransportPolicy = WebRTCIceTransportPolicy::kAll;
   if (configuration.hasIceTransportPolicy()) {
     UseCounter::count(context, UseCounter::RTCConfigurationIceTransportPolicy);
     iceTransportPolicy =
         iceTransportPolicyFromString(configuration.iceTransportPolicy());
     if (iceTransportPolicy == WebRTCIceTransportPolicy::kNone) {
       UseCounter::count(context,
                         UseCounter::RTCConfigurationIceTransportPolicyNone);
     }
   } else if (configuration.hasIceTransports()) {
     UseCounter::count(context, UseCounter::RTCConfigurationIceTransports);
     iceTransportPolicy =
         iceTransportPolicyFromString(configuration.iceTransports());
     if (iceTransportPolicy == WebRTCIceTransportPolicy::kNone)
       UseCounter::count(context, UseCounter::RTCConfigurationIceTransportsNone);
   }
 
   WebRTCBundlePolicy bundlePolicy = WebRTCBundlePolicy::kBalanced;
   String bundlePolicyString = configuration.bundlePolicy();
   if (bundlePolicyString == "max-compat") {
     bundlePolicy = WebRTCBundlePolicy::kMaxCompat;
   } else if (bundlePolicyString == "max-bundle") {
     bundlePolicy = WebRTCBundlePolicy::kMaxBundle;
   } else {
     DCHECK_EQ(bundlePolicyString, "balanced");
   }
 
-  // For the histogram value of "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
-  *selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  WebRTCRtcpMuxPolicy rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kNegotiate;
-  if (configuration.hasRtcpMuxPolicy()) {
-    String rtcpMuxPolicyString = configuration.rtcpMuxPolicy();
-    if (rtcpMuxPolicyString == "require") {
-      *selectedRtcpMuxPolicy = RtcpMuxPolicyRequire;
-      rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kRequire;
-    } else {
-      DCHECK_EQ(rtcpMuxPolicyString, "negotiate");
-      *selectedRtcpMuxPolicy = RtcpMuxPolicyNegotiate;
-    }
+  WebRTCRtcpMuxPolicy rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kRequire;
+  String rtcpMuxPolicyString = configuration.rtcpMuxPolicy();
+  if (rtcpMuxPolicyString == "negotiate") {

[hbos_chromium, 2016/12/15 15:12:06]

This CL gives rtcpMuxPolicy a default value, but it's still not required, so I
believe it can be explicitly set to undefined, is this the case? If so we could
hit the DCHECK_EQ and crash in debug builds.

[foolip, 2016/12/15 15:26:03]

If dictionary members have a default value, they can't be missing from the point
of view of the generated RTCConfiguration. Even if one uses { rtcpMuxPolicy:
undefined } explicitly, it's treated as missing and then gets the default value.

For required dictionary members, it can also never be missing, but for another
reason.

[hbos_chromium, 2016/12/15 15:31:55]

Oh cool!

+    rtcpMuxPolicy = WebRTCRtcpMuxPolicy::kNegotiate;
+  } else {
+    DCHECK_EQ(rtcpMuxPolicyString, "require");
   }
-
   WebRTCConfiguration webConfiguration;
   webConfiguration.iceTransportPolicy = iceTransportPolicy;
   webConfiguration.bundlePolicy = bundlePolicy;
   webConfiguration.rtcpMuxPolicy = rtcpMuxPolicy;
 
   if (configuration.hasIceServers()) {
     Vector<WebRTCIceServer> iceServers;
     for (const RTCIceServer& iceServer : configuration.iceServers()) {
       Vector<String> urlStrings;
       if (iceServer.hasURLs()) {
@@ skipping 146 matching lines @@
     const RTCConfiguration& rtcConfiguration,
     const Dictionary& mediaConstraints,
     ExceptionState& exceptionState) {
   if (mediaConstraints.isObject())
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorConstraints);
   else
     UseCounter::count(context,
                       UseCounter::RTCPeerConnectionConstructorCompliant);
 
-  // Record the RtcpMuxPolicy for histogram
-  // "WebRTC.PeerConnection.SelectedRtcpMuxPolicy".
-  RtcpMuxPolicy selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  WebRTCConfiguration configuration = parseConfiguration(
-      context, rtcConfiguration, exceptionState, &selectedRtcpMuxPolicy);
+  WebRTCConfiguration configuration =
+      parseConfiguration(context, rtcConfiguration, exceptionState);
   if (exceptionState.hadException())
     return 0;
 
   // Make sure no certificates have expired.
   if (configuration.certificates.size() > 0) {
     DOMTimeStamp now = convertSecondsToDOMTimeStamp(currentTime());
     for (const std::unique_ptr<WebRTCCertificate>& certificate :
          configuration.certificates) {
       DOMTimeStamp expires = certificate->expires();
       if (expires <= now) {
@@ skipping 11 matching lines @@
     mediaErrorState.raiseException(exceptionState);
     return 0;
   }
 
   RTCPeerConnection* peerConnection = new RTCPeerConnection(
       context, configuration, constraints, exceptionState);
   peerConnection->suspendIfNeeded();
   if (exceptionState.hadException())
     return 0;
 
-  peerConnection->m_peerHandler->logSelectedRtcpMuxPolicy(
-      selectedRtcpMuxPolicy);
-
   return peerConnection;
 }
 
 RTCPeerConnection::RTCPeerConnection(ExecutionContext* context,
                                      const WebRTCConfiguration& configuration,
                                      WebMediaConstraints constraints,
                                      ExceptionState& exceptionState)
     : ActiveScriptWrappable(this),
       SuspendableObject(context),
       m_signalingState(SignalingStateStable),
@@ skipping 312 matching lines @@
   return RTCSessionDescription::create(webSessionDescription);
 }
 
 void RTCPeerConnection::updateIce(ExecutionContext* context,
                                   const RTCConfiguration& rtcConfiguration,
                                   const Dictionary&,
                                   ExceptionState& exceptionState) {
   if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
     return;
 
-  RtcpMuxPolicy selectedRtcpMuxPolicy = RtcpMuxPolicyDefault;
-  WebRTCConfiguration configuration = parseConfiguration(
-      context, rtcConfiguration, exceptionState, &selectedRtcpMuxPolicy);
+  WebRTCConfiguration configuration =
+      parseConfiguration(context, rtcConfiguration, exceptionState);
 
   if (exceptionState.hadException())
     return;
 
   MediaErrorState mediaErrorState;
   if (mediaErrorState.hadException()) {
     mediaErrorState.raiseException(exceptionState);
     return;
   }
 
@@ skipping 661 matching lines @@
 DEFINE_TRACE(RTCPeerConnection) {
   visitor->trace(m_localStreams);
   visitor->trace(m_remoteStreams);
   visitor->trace(m_dispatchScheduledEventRunner);
   visitor->trace(m_scheduledEvents);
   EventTargetWithInlineData::trace(visitor);
   SuspendableObject::trace(visitor);
 }
 
 }  // namespace blink