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

content/renderer/media/rtc_peer_connection_handler.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/rtc_peer_connection_handler.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 151 matching lines @@
         description_callback,
     std::string* sdp, std::string* type) {
   const webrtc::SessionDescriptionInterface* description =
       description_callback.Run();
   if (description) {
     description->ToString(sdp);
     *type = description->type();
   }
 }
 
-// Converter functions from WebKit types to libjingle types.
+// Converter functions from WebKit types to WebRTC types.
 
 void GetNativeRtcConfiguration(
-    const blink::WebRTCConfiguration& server_configuration,
-    webrtc::PeerConnectionInterface::RTCConfiguration* config) {
-  if (server_configuration.isNull() || !config)
+    const blink::WebRTCConfiguration& blink_config,
+    webrtc::PeerConnectionInterface::RTCConfiguration* webrtc_config) {
+  if (blink_config.isNull() || !webrtc_config)
     return;
-  for (size_t i = 0; i < server_configuration.numberOfServers(); ++i) {
+  for (size_t i = 0; i < blink_config.numberOfServers(); ++i) {
     webrtc::PeerConnectionInterface::IceServer server;
     const blink::WebRTCICEServer& webkit_server =
-        server_configuration.server(i);
+        blink_config.server(i);
     server.username = base::UTF16ToUTF8(webkit_server.username());
     server.password = base::UTF16ToUTF8(webkit_server.credential());
     server.uri = webkit_server.uri().spec();
-    config->servers.push_back(server);
+    webrtc_config->servers.push_back(server);
   }
 
-  switch (server_configuration.iceTransports()) {
+  switch (blink_config.iceTransports()) {
   case blink::WebRTCIceTransportsNone:
-    config->type = webrtc::PeerConnectionInterface::kNone;
+    webrtc_config->type = webrtc::PeerConnectionInterface::kNone;
     break;
   case blink::WebRTCIceTransportsRelay:
-    config->type = webrtc::PeerConnectionInterface::kRelay;
+    webrtc_config->type = webrtc::PeerConnectionInterface::kRelay;
     break;
   case blink::WebRTCIceTransportsAll:
-    config->type = webrtc::PeerConnectionInterface::kAll;
+    webrtc_config->type = webrtc::PeerConnectionInterface::kAll;
     break;
   default:
     NOTREACHED();
+  }
+
+  switch (blink_config.bundlePolicy()) {
+  case blink::WebRTCBundlePolicyBalanced:
+    webrtc_config->bundle_policy =
+        webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
+    break;
+  case blink::WebRTCBundlePolicyMaxBundle:
+    webrtc_config->bundle_policy =
+        webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
+    break;
+  case blink::WebRTCBundlePolicyMaxCompat:
+    webrtc_config->bundle_policy =
+        webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
+    break;
+  default:
+    NOTREACHED();
   }
 }
 
 class SessionDescriptionRequestTracker {
  public:
   SessionDescriptionRequestTracker(
       const base::WeakPtr<RTCPeerConnectionHandler>& handler,
       const base::WeakPtr<PeerConnectionTracker>& tracker,
       PeerConnectionTracker::Action action)
       : handler_(handler), tracker_(tracker), action_(action) {}
@@ skipping 1248 matching lines @@
     base::WaitableEvent event(false, false);
     thread->PostTask(FROM_HERE,
         base::Bind(&RunSynchronousClosure, closure,
                    base::Unretained(trace_event_name),
                    base::Unretained(&event)));
     event.Wait();
   }
 }
 
 }  // namespace content