Support port range for IPC P2P UDP sockets.

content/browser/renderer_host/p2p/socket_host_udp_unittest.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/browser/renderer_host/p2p/socket_host_udp.h"
 
 #include <stdint.h>
 #include <deque>
 #include <utility>
 #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"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/udp/datagram_server_socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/base/timing.h"
@@ skipping 31 matching lines @@
     NOTREACHED();
     return net::ERR_SOCKET_NOT_CONNECTED;
   }
 
   int GetLocalAddress(net::IPEndPoint* address) const override {
     *address = address_;
     return 0;
   }
 
   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;
   }
 
   int RecvFrom(net::IOBuffer* buf,
                int buf_len,
                net::IPEndPoint* address,
                const net::CompletionCallback& callback) override {
     CHECK(recv_callback_.is_null());
     if (incoming_packets_.size() > 0) {
@@ skipping 82 matching lines @@
  private:
   net::IPEndPoint address_;
   std::deque<UDPPacket>* sent_packets_;
   std::deque<UDPPacket> incoming_packets_;
   net::BoundNetLog net_log_;
 
   scoped_refptr<net::IOBuffer> recv_buffer_;
   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 {
 
 class P2PSocketHostUdpTest : public testing::Test {
  protected:
   void SetUp() override {
     EXPECT_CALL(
         sender_,
         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);
 
     std::unique_ptr<rtc::Timing> timing(new FakeTiming());
     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_;
 
   net::IPEndPoint local_address_;
 
   net::IPEndPoint dest1_;
   net::IPEndPoint dest2_;
 };
 
 // Verify that we can send STUN messages before we receive anything
@@ skipping 167 matching lines @@
   // This packet will be dropped, as limit only for a single packet.
   socket_host_->Send(dest3, packet1, options, 0);
   net::IPEndPoint dest4 = ParseAddress(kTestIpAddress1, 2224);
   // This packet should also be dropped.
   socket_host_->Send(dest4, packet1, options, 0);
   // |dest1| is known, we can send as many packets to it.
   socket_host_->Send(dest1_, packet1, options, 0);
   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