Add support for RTCConfiguration.iceCandidatePoolSize.

content/renderer/media/peer_connection_tracker.cc

 // Copyright (c) 2013 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/peer_connection_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 155 matching lines @@
     break;
   case webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire:
     policy_str = "require";
     break;
   default:
     NOTREACHED();
   };
   return policy_str;
 }
 
+static std::string SerializeConfiguration(
+    const webrtc::PeerConnectionInterface::RTCConfiguration& config) {
+  std::ostringstream oss;
+  oss << "{ iceServers: " << SerializeServers(config.servers) << ", "
+      << "iceTransportPolicy: " << SerializeIceTransportType(config.type)
+      << ", "
+      << "bundlePolicy: " << SerializeBundlePolicy(config.bundle_policy) << ", "
+      << "rtcpMuxPolicy: " << SerializeRtcpMuxPolicy(config.rtcp_mux_policy)

[hbos_chromium, 2017/03/03 11:56:06]

I noticed there's no "certificates", even though certificates is one of the
members supported (and translated between) both blink and webrtc.

And the tracker is used to tell the UI process about the PC, which in practice
for this means displaying this string in chrome://webrtc-internals? This can be
addressed separately. Can you add a TODO and assign it to me (unless you want to
do that)?

[Taylor_Brandstetter, 2017/03/03 18:44:46]

TODO added.

+      << "iceCandidatePoolSize: " << config.ice_candidate_pool_size << " }";
+  return oss.str();
+}
+
 #define GET_STRING_OF_STATE(state)                \
   case WebRTCPeerConnectionHandlerClient::state:  \
     result = #state;                              \
     break;
 
 static const char* GetSignalingStateString(
     WebRTCPeerConnectionHandlerClient::SignalingState state) {
   const char* result = "";
   switch (state) {
     GET_STRING_OF_STATE(SignalingStateStable)
@@ skipping 235 matching lines @@
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const blink::WebMediaConstraints& constraints,
     const blink::WebFrame* frame) {
   DCHECK(main_thread_.CalledOnValidThread());
   DCHECK_EQ(GetLocalIDForHandler(pc_handler), -1);
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
-  info.rtc_configuration =
-      "{ iceServers: " +  SerializeServers(config.servers) + ", " +
-      "iceTransportPolicy: " + SerializeIceTransportType(config.type) + ", " +
-      "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy) + ", " +
-      "rtcpMuxPolicy: " + SerializeRtcpMuxPolicy(config.rtcp_mux_policy) + " }";
+  info.rtc_configuration = SerializeConfiguration(config);
 
   info.constraints = SerializeMediaConstraints(constraints);
   if (frame)
     info.url = frame->document().url().string().utf8();
   else
     info.url = "test:testing";
   SendTarget()->Send(new PeerConnectionTrackerHost_AddPeerConnection(info));
 
   peer_connection_id_map_.insert(std::make_pair(pc_handler, info.lid));
 }
@@ skipping 79 matching lines @@
 }
 
 void PeerConnectionTracker::TrackSetConfiguration(
     RTCPeerConnectionHandler* pc_handler,
     const webrtc::PeerConnectionInterface::RTCConfiguration& config) {
   DCHECK(main_thread_.CalledOnValidThread());
   int id = GetLocalIDForHandler(pc_handler);
   if (id == -1)
     return;
 
-  std::ostringstream result;
-  result << "servers: " << SerializeServers(config.servers)
-         << "iceTransportType: " << SerializeIceTransportType(config.type)
-         << "bundlePolicy: " << SerializeBundlePolicy(config.bundle_policy)
-         << "rtcpMuxPolicy: " << SerializeRtcpMuxPolicy(config.rtcp_mux_policy)
-         << "}";
-
-  SendPeerConnectionUpdate(id, "setConfiguration", result.str());
+  SendPeerConnectionUpdate(id, "setConfiguration",
+                           SerializeConfiguration(config));
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source,
       bool succeeded) {
   DCHECK(main_thread_.CalledOnValidThread());
   int id = GetLocalIDForHandler(pc_handler);
   if (id == -1)
@@ skipping 185 matching lines @@
   DCHECK(main_thread_.CalledOnValidThread());
   SendTarget()->Send(new PeerConnectionTrackerHost_UpdatePeerConnection(
       local_id, std::string(callback_type), value));
 }
 
 void PeerConnectionTracker::OverrideSendTargetForTesting(RenderThread* target) {
   send_target_for_test_ = target;
 }
 
 }  // namespace content