Support port range for IPC P2P UDP sockets.

content/browser/renderer_host/p2p/socket_host_udp_unittest.cc

Index: content/browser/renderer_host/p2p/socket_host_udp_unittest.cc
diff --git a/content/browser/renderer_host/p2p/socket_host_udp_unittest.cc b/content/browser/renderer_host/p2p/socket_host_udp_unittest.cc
index c9a7b92dbf12e864e74411b384518641fa02c9cb..344380d10157c17509bbeccf2eec82e9f12901c9 100644
--- a/content/browser/renderer_host/p2p/socket_host_udp_unittest.cc
+++ b/content/browser/renderer_host/p2p/socket_host_udp_unittest.cc
@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
 #include "content/browser/renderer_host/p2p/socket_host_throttler.h"
@@ -61,6 +62,14 @@ class FakeDatagramServerSocket : public net::DatagramServerSocket {
   }
 
   int Listen(const net::IPEndPoint& address) override {
+    if (address.port() != kTestPort1) {
+      for (auto used_port : *used_ports) {
+        if (used_port == address.port())
+          return -1;
+      }
+      used_ports->push_back(address.port());
+    }
+
     address_ = address;
     return 0;
   }
@@ -163,8 +172,17 @@ class FakeDatagramServerSocket : public net::DatagramServerSocket {
   net::IPEndPoint* recv_address_;
   int recv_size_;
   net::CompletionCallback recv_callback_;
+  static std::vector<uint16_t>* used_ports;
 };
 
+std::vector<uint16_t>* FakeDatagramServerSocket::used_ports =
+    new std::vector<uint16_t>;

[tommi (sloooow) - chröme, 2016/07/11 17:54:59]

would be good to avoid global vars like this considering parallel or repeated
runs.
Can we instead, have a factory object that owns the vector and instances get a
pointer back to the vector that's owned by the factory? (and the factory goes
out of scope when the test ends)

[Guido Urdaneta, 2016/07/12 10:15:00]

Done.

+
+std::unique_ptr<net::DatagramServerSocket> FakeDatagramServerSocketFactory(
+    std::deque<FakeDatagramServerSocket::UDPPacket>* sent_packets) {
+  return base::WrapUnique(new FakeDatagramServerSocket(sent_packets));
+}
+
 }  // namespace
 
 namespace content {
@@ -177,12 +195,13 @@ class P2PSocketHostUdpTest : public testing::Test {
         Send(MatchMessage(static_cast<uint32_t>(P2PMsg_OnSocketCreated::ID))))
         .WillOnce(DoAll(DeleteArg<0>(), Return(true)));
 
-    socket_host_.reset(new P2PSocketHostUdp(&sender_, 0, &throttler_));
-    socket_ = new FakeDatagramServerSocket(&sent_packets_);
-    socket_host_->socket_.reset(socket_);
+    socket_host_.reset(new P2PSocketHostUdp(
+        &sender_, 0, &throttler_,
+        base::Bind(&FakeDatagramServerSocketFactory, &sent_packets_)));
 
     local_address_ = ParseAddress(kTestLocalIpAddress, kTestPort1);
-    socket_host_->Init(local_address_, P2PHostAndIPEndPoint());
+    socket_host_->Init(local_address_, 0, 0, P2PHostAndIPEndPoint());
+    socket_ = GetSocketFromHost(socket_host_.get());
 
     dest1_ = ParseAddress(kTestIpAddress1, kTestPort1);
     dest2_ = ParseAddress(kTestIpAddress2, kTestPort2);
@@ -191,9 +210,14 @@ class P2PSocketHostUdpTest : public testing::Test {
     throttler_.SetTiming(std::move(timing));
   }
 
+  static FakeDatagramServerSocket* GetSocketFromHost(
+      P2PSocketHostUdp* socket_host) {
+    return static_cast<FakeDatagramServerSocket*>(socket_host->socket_.get());
+  }
+
   P2PMessageThrottler throttler_;
   std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets_;
-  FakeDatagramServerSocket* socket_; // Owned by |socket_host_|.
+  FakeDatagramServerSocket* socket_;  // Owned by |socket_host_|.
   std::unique_ptr<P2PSocketHostUdp> socket_host_;
   MockIPCSender sender_;
 
@@ -381,4 +405,43 @@ TEST_F(P2PSocketHostUdpTest, ThrottleAfterLimitAfterReceive) {
   ASSERT_EQ(sent_packets_.size(), 4U);
 }
 
+// Verify that we can open UDP sockets listening in a given port range,
+// and fail if all ports in the range are already in use.
+TEST_F(P2PSocketHostUdpTest, PortRange) {
+  const uint16_t min_port = 10000;
+  const uint16_t max_port = 10001;
+  std::deque<FakeDatagramServerSocket::UDPPacket> sent_packets;
+  P2PSocketHostUdp::DatagramServerSocketFactory fake_socket_factory =
+      base::Bind(&FakeDatagramServerSocketFactory, &sent_packets);
+  P2PMessageThrottler throttler;
+  MockIPCSender sender;
+  EXPECT_CALL(
+      sender,
+      Send(MatchMessage(static_cast<uint32_t>(P2PMsg_OnSocketCreated::ID))))
+      .Times(max_port - min_port + 1);
+
+  for (unsigned port = min_port; port <= max_port; ++port) {
+    std::unique_ptr<P2PSocketHostUdp> socket_host(
+        new P2PSocketHostUdp(&sender, 0, &throttler, fake_socket_factory));
+    net::IPEndPoint local_address = ParseAddress(kTestLocalIpAddress, 0);
+    bool rv = socket_host->Init(local_address, min_port, max_port,
+                                P2PHostAndIPEndPoint());
+    EXPECT_TRUE(rv);
+
+    FakeDatagramServerSocket* socket = GetSocketFromHost(socket_host.get());
+    net::IPEndPoint bound_address;
+    socket->GetLocalAddress(&bound_address);
+    EXPECT_EQ(port, bound_address.port());
+  }
+
+  EXPECT_CALL(sender,
+              Send(MatchMessage(static_cast<uint32_t>(P2PMsg_OnError::ID))));
+  std::unique_ptr<P2PSocketHostUdp> socket_host(
+      new P2PSocketHostUdp(&sender, 0, &throttler, fake_socket_factory));
+  net::IPEndPoint local_address = ParseAddress(kTestLocalIpAddress, 0);
+  bool rv = socket_host->Init(local_address, min_port, max_port,
+                              P2PHostAndIPEndPoint());
+  EXPECT_FALSE(rv);
+}
+
 }  // namespace content