Add policy to control valid UDP port range in WebRTC

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

 // Copyright 2014 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/peer_connection_dependency_factory.h"
 
 #include <stddef.h>
 
 #include <utility>
 #include <vector>
@@ skipping 73 matching lines @@
     const std::string& preference) {
   if (preference == kWebRTCIPHandlingDefaultPublicAndPrivateInterfaces)
     return DEFAULT_PUBLIC_AND_PRIVATE_INTERFACES;
   if (preference == kWebRTCIPHandlingDefaultPublicInterfaceOnly)
     return DEFAULT_PUBLIC_INTERFACE_ONLY;
   if (preference == kWebRTCIPHandlingDisableNonProxiedUdp)
     return DISABLE_NON_PROXIED_UDP;
   return DEFAULT;
 }
 
+bool IsValidPortRange(uint16_t min_port, uint16_t max_port) {
+  DCHECK(min_port <= max_port);
+  return min_port != 0 && max_port != 0;
+}
+
 }  // namespace
 
 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_signaling_thread_("Chrome_libJingle_Signaling"),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
@@ skipping 186 matching lines @@
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     blink::WebFrame* web_frame,
     webrtc::PeerConnectionObserver* observer) {
   CHECK(web_frame);
   CHECK(observer);
   if (!GetPcFactory().get())
     return NULL;
 
   // Copy the flag from Preference associated with this WebFrame.
   P2PPortAllocator::Config port_config;
+  uint16_t min_port = 0;
+  uint16_t max_port = 0;
 
   // |media_permission| will be called to check mic/camera permission. If at
   // least one of them is granted, P2PPortAllocator is allowed to gather local
   // host IP addresses as ICE candidates. |media_permission| could be nullptr,
   // which means the permission will be granted automatically. This could be the
   // case when either the experiment is not enabled or the preference is not
   // enforced.
   //
   // Note on |media_permission| lifetime: |media_permission| is owned by a frame
   // (RenderFrameImpl). It is also stored as an indirect member of
@@ skipping 36 matching lines @@
           case DISABLE_NON_PROXIED_UDP:
             port_config.enable_multiple_routes = false;
             port_config.enable_nonproxied_udp = false;
             break;
           case DEFAULT:
             port_config.enable_multiple_routes = true;
             port_config.enable_nonproxied_udp = true;
             break;
         }
 
+        min_port =
+            renderer_view_impl->renderer_preferences().webrtc_udp_min_port;
+        max_port =
+            renderer_view_impl->renderer_preferences().webrtc_udp_max_port;
+
         VLOG(3) << "WebRTC routing preferences: "
                 << "policy: " << policy
                 << ", multiple_routes: " << port_config.enable_multiple_routes
-                << ", nonproxied_udp: " << port_config.enable_nonproxied_udp;
+                << ", nonproxied_udp: " << port_config.enable_nonproxied_udp
+                << ", min_udp_port: " << min_port
+                << ", max_udp_port: " << max_port;
       }
     }
     if (port_config.enable_multiple_routes) {
       bool create_media_permission =
           base::CommandLine::ForCurrentProcess()->HasSwitch(
               switches::kEnforceWebRtcIPPermissionCheck);
       create_media_permission =
           create_media_permission ||
           !StartsWith(base::FieldTrialList::FindFullName(
                           "WebRTC-LocalIPPermissionCheck"),
@@ skipping 16 matching lines @@
     FilteringNetworkManager* filtering_network_manager =
         new FilteringNetworkManager(network_manager_, requesting_origin,
                                     media_permission);
     network_manager.reset(filtering_network_manager);
   } else {
     network_manager.reset(new EmptyNetworkManager(network_manager_));
   }
   std::unique_ptr<P2PPortAllocator> port_allocator(new P2PPortAllocator(
       p2p_socket_dispatcher_, std::move(network_manager), socket_factory_.get(),
       port_config, requesting_origin));
+  if (IsValidPortRange(min_port, max_port))
+    port_allocator->SetPortRange(min_port, max_port);
 
   return GetPcFactory()
       ->CreatePeerConnection(config, std::move(port_allocator),
                              nullptr, observer)
       .get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
@@ skipping 153 matching lines @@
 
 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   DCHECK(CalledOnValidThread());
   if (audio_device_.get())
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content