Support port range for IPC P2P UDP sockets.

content/renderer/p2p/socket_client_impl.cc

 // Copyright 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/p2p/socket_client_impl.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 26 matching lines @@
       state_(STATE_UNINITIALIZED),
       random_socket_id_(0),
       next_packet_id_(0) {
   crypto::RandBytes(&random_socket_id_, sizeof(random_socket_id_));
 }
 
 P2PSocketClientImpl::~P2PSocketClientImpl() {
   CHECK(state_ == STATE_CLOSED || state_ == STATE_UNINITIALIZED);
 }
 
-void P2PSocketClientImpl::Init(
-    P2PSocketType type,
-    const net::IPEndPoint& local_address,
-    const P2PHostAndIPEndPoint& remote_address,
-    P2PSocketClientDelegate* delegate) {
+void P2PSocketClientImpl::Init(P2PSocketType type,
+                               const net::IPEndPoint& local_address,
+                               uint16_t min_port,
+                               uint16_t max_port,
+                               const P2PHostAndIPEndPoint& remote_address,
+                               P2PSocketClientDelegate* delegate) {
   DCHECK(delegate_task_runner_->BelongsToCurrentThread());
   DCHECK(delegate);
   // |delegate_| is only accessesed on |delegate_message_loop_|.
   delegate_ = delegate;
 
   ipc_task_runner_->PostTask(
       FROM_HERE, base::Bind(&P2PSocketClientImpl::DoInit, this, type,
-                            local_address, remote_address));
+                            local_address, min_port, max_port, remote_address));
 }
 
 void P2PSocketClientImpl::DoInit(P2PSocketType type,
                                  const net::IPEndPoint& local_address,
+                                 uint16_t min_port,
+                                 uint16_t max_port,
                                  const P2PHostAndIPEndPoint& remote_address) {
+  DCHECK(local_address.port() == 0 || (min_port == 0 && max_port == 0));
   DCHECK_EQ(state_, STATE_UNINITIALIZED);
   state_ = STATE_OPENING;
   socket_id_ = dispatcher_->RegisterClient(this);
   dispatcher_->SendP2PMessage(new P2PHostMsg_CreateSocket(
-      type, socket_id_, local_address, remote_address));
+      type, socket_id_, local_address, P2PPortRange(min_port, max_port),
+      remote_address));
 }
 
 uint64_t P2PSocketClientImpl::Send(const net::IPEndPoint& address,
                                    const std::vector<char>& data,
                                    const rtc::PacketOptions& options) {
   uint64_t unique_id = GetUniqueId(random_socket_id_, ++next_packet_id_);
   if (!ipc_task_runner_->BelongsToCurrentThread()) {
     ipc_task_runner_->PostTask(
         FROM_HERE, base::Bind(&P2PSocketClientImpl::SendWithPacketId, this,
                               address, data, options, unique_id));
@@ skipping 165 matching lines @@
     delegate_->OnDataReceived(address, data, timestamp);
 }
 
 void P2PSocketClientImpl::Detach() {
   DCHECK(ipc_task_runner_->BelongsToCurrentThread());
   dispatcher_ = NULL;
   OnError();
 }
 
 }  // namespace content