Connect the BundlePolicy code in WebRTC to the BundlePolicy in Blink.

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 "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/media/peer_connection_tracker_messages.h"
 #include "content/renderer/media/rtc_media_constraints.h"
@@ skipping 127 matching lines @@
     break;
   case webrtc::PeerConnectionInterface::kNoHost:
     transport_type = "noHost";
     break;
   default:
     NOTREACHED();
   };
   return transport_type;
 }
 
+static std::string SerializeBundlePolicy(
+    webrtc::PeerConnectionInterface::BundlePolicy policy) {
+  string policy_str;
+  switch (policy) {
+  case webrtc::PeerConnectionInterface::kBundlePolicyBalanced:
+    policy_str = "balanced";
+    break;
+  case webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle:
+    policy_str = "max-bundle";
+    break;
+  case webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat:
+    policy_str = "max-compat";
+    break;
+  default:
+    NOTREACHED();
+  };
+  return policy_str;
+}
+
 #define GET_STRING_OF_STATE(state)                \
   case WebRTCPeerConnectionHandlerClient::state:  \
     result = #state;                              \
     break;
 
 static string GetSignalingStateString(
     WebRTCPeerConnectionHandlerClient::SignalingState state) {
   string result;
   switch (state) {
     GET_STRING_OF_STATE(SignalingStateStable)
@@ skipping 174 matching lines @@
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     const RTCMediaConstraints& constraints,
     const blink::WebFrame* frame) {
   DCHECK(main_thread_.CalledOnValidThread());
   DVLOG(1) << "PeerConnectionTracker::RegisterPeerConnection()";
   PeerConnectionInfo info;
 
   info.lid = GetNextLocalID();
   info.rtc_configuration =
       "{ servers: " +  SerializeServers(config.servers) + ", " +
-      "iceTransportType: " + SerializeIceTransportType(config.type) + " }";
+      "iceTransportType: " + SerializeIceTransportType(config.type) + ", " +
+      "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy) + " }";
 
   info.constraints = SerializeMediaConstraints(constraints);
   info.url = frame->document().url().spec();
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_AddPeerConnection(info));
 
   DCHECK(peer_connection_id_map_.find(pc_handler) ==
          peer_connection_id_map_.end());
   peer_connection_id_map_[pc_handler] = info.lid;
 }
@@ skipping 50 matching lines @@
 void PeerConnectionTracker::TrackUpdateIce(
       RTCPeerConnectionHandler* pc_handler,
       const webrtc::PeerConnectionInterface::RTCConfiguration& config,
       const RTCMediaConstraints& options) {
   DCHECK(main_thread_.CalledOnValidThread());
   string servers_string = "servers: " + SerializeServers(config.servers);
 
   string transport_type =
       "iceTransportType: " + SerializeIceTransportType(config.type);
 
+  string bundle_policy =
+      "bundlePolicy: " + SerializeBundlePolicy(config.bundle_policy);
+
   string constraints =
       "constraints: {" + SerializeMediaConstraints(options) + "}";
 
   SendPeerConnectionUpdate(
       pc_handler,
       "updateIce",
-      servers_string + ", " + transport_type + ", " + constraints);
+      servers_string + ", " + transport_type + ", " +
+      bundle_policy + ", " + constraints);
 }
 
 void PeerConnectionTracker::TrackAddIceCandidate(
       RTCPeerConnectionHandler* pc_handler,
       const blink::WebRTCICECandidate& candidate,
       Source source,
       bool succeeded) {
   DCHECK(main_thread_.CalledOnValidThread());
   string value =
       "sdpMid: " + base::UTF16ToUTF8(candidate.sdpMid()) + ", " +
@@ skipping 144 matching lines @@
   DCHECK(main_thread_.CalledOnValidThread());
   if (peer_connection_id_map_.find(pc_handler) == peer_connection_id_map_.end())
     return;
 
   RenderThreadImpl::current()->Send(
       new PeerConnectionTrackerHost_UpdatePeerConnection(
           peer_connection_id_map_[pc_handler], type, value));
 }
 
 }  // namespace content