Use uint16 for port numbers more pervasively.

We currently use a mixture of ints and uint16s for port numbers.  This triggers a variety of "value possibly truncated" warnings on MSVC (currently disabled) wherever we implicitly truncate.  Fix this by using uint16 consistently through more functions.  (Using int consistently would be more problematic as the majority of third-party/system APIs that use port numbers use 16-bit types for them.)

By far the majority of these changes are fallout from changing IPEndPoint, which is widely used; it'd be difficult to split this CL up into smaller pieces :(

Note that I didn't use uint16_t to avoid introducing inconsistencies between existing uint16 usage and new uint16_t usage.  Conversion of everything to uint16_t can happen later.

This CL was reviewed and approved in pieces in the following CLs:
https://codereview.chromium.org/716223002/
https://codereview.chromium.org/717263003/
https://codereview.chromium.org/717373002/
https://codereview.chromium.org/718273002/
https://codereview.chromium.org/722503002/
Committing as TBR to the original reviewers.

BUG=81439
TEST=none
TBR=gunsch,cpu,jhawkins,davidben,jyasskin,mmenke

Review URL: https://codereview.chromium.org/655063002

Cr-Commit-Position: refs/heads/master@{#304961}

7 files changed, 29 insertions, 27 deletions

diff --git a/remoting/host/chromoting_messages.h b/remoting/host/chromoting_messages.h
index f9b68e2..e6d8091 100644
--- a/remoting/host/chromoting_messages.h
+++ b/remoting/host/chromoting_messages.h
@@ -86,9 +86,9 @@ IPC_MESSAGE_CONTROL2(ChromotingNetworkDaemonMsg_SetScreenResolution,
 IPC_STRUCT_BEGIN(SerializedTransportRoute)
   IPC_STRUCT_MEMBER(int, type)
   IPC_STRUCT_MEMBER(net::IPAddressNumber, remote_address)
-  IPC_STRUCT_MEMBER(int, remote_port)
+  IPC_STRUCT_MEMBER(uint16, remote_port)
   IPC_STRUCT_MEMBER(net::IPAddressNumber, local_address)
-  IPC_STRUCT_MEMBER(int, local_port)
+  IPC_STRUCT_MEMBER(uint16, local_port)
 IPC_STRUCT_END()
 
 // Hosts status notifications (see HostStatusObserver interface) sent by
diff --git a/remoting/host/remoting_me2me_host.cc b/remoting/host/remoting_me2me_host.cc
index f880803..a01122a 100644
--- a/remoting/host/remoting_me2me_host.cc
+++ b/remoting/host/remoting_me2me_host.cc
@@ -306,8 +306,8 @@ class HostProcess
   bool host_username_match_required_;
   bool allow_nat_traversal_;
   bool allow_relay_;
-  int min_udp_port_;
-  int max_udp_port_;
+  uint16 min_udp_port_;
+  uint16 max_udp_port_;
   std::string talkgadget_prefix_;
   bool allow_pairing_;
 
@@ -1067,8 +1067,8 @@ bool HostProcess::OnUdpPortPolicyUpdate(base::DictionaryValue* policies) {
   }
 
   // Use default values if policy setting is empty or invalid.
-  int min_udp_port = 0;
-  int max_udp_port = 0;
+  uint16 min_udp_port = 0;
+  uint16 max_udp_port = 0;
   if (!udp_port_range.empty() &&
       !NetworkSettings::ParsePortRange(udp_port_range, &min_udp_port,
                                        &max_udp_port)) {
diff --git a/remoting/host/win/rdp_client.cc b/remoting/host/win/rdp_client.cc
index 80868da..fcfce89 100644
--- a/remoting/host/win/rdp_client.cc
+++ b/remoting/host/win/rdp_client.cc
@@ -136,14 +136,16 @@ void RdpClient::Core::Connect(const webrtc::DesktopSize& screen_size,
   DWORD server_port;
   base::win::RegKey key(HKEY_LOCAL_MACHINE, kRdpPortKeyName, KEY_READ);
   if (!key.Valid() ||
-      (key.ReadValueDW(kRdpPortValueName, &server_port) != ERROR_SUCCESS)) {
+      (key.ReadValueDW(kRdpPortValueName, &server_port) != ERROR_SUCCESS) ||
+      server_port > 65535) {
     server_port = kDefaultRdpPort;
   }
 
   net::IPAddressNumber server_address(
       kRdpLoopbackAddress,
       kRdpLoopbackAddress + arraysize(kRdpLoopbackAddress));
-  net::IPEndPoint server_endpoint(server_address, server_port);
+  net::IPEndPoint server_endpoint(server_address,
+                                  static_cast<uint16>(server_port));
 
   // Create the ActiveX control window.
   rdp_client_window_.reset(new RdpClientWindow(server_endpoint, terminal_id,
diff --git a/remoting/protocol/chromium_socket_factory.cc b/remoting/protocol/chromium_socket_factory.cc
index 0cfa1ad..6777937 100644
--- a/remoting/protocol/chromium_socket_factory.cc
+++ b/remoting/protocol/chromium_socket_factory.cc
@@ -122,10 +122,10 @@ bool UdpPacketSocket::Init(const rtc::SocketAddress& local_address,
     return false;
   }
 
-  for (uint16 port = min_port; port <= max_port; ++port) {
+  for (uint32 port = min_port; port <= max_port; ++port) {
     socket_.reset(new net::UDPServerSocket(NULL, net::NetLog::Source()));
     int result = socket_->Listen(
-        net::IPEndPoint(local_endpoint.address(), port));
+        net::IPEndPoint(local_endpoint.address(), static_cast<uint16>(port)));
     if (result == net::OK) {
       break;
     } else {
diff --git a/remoting/protocol/network_settings.cc b/remoting/protocol/network_settings.cc
index 67db267..65068ef 100644
--- a/remoting/protocol/network_settings.cc
+++ b/remoting/protocol/network_settings.cc
@@ -15,8 +15,8 @@ namespace protocol {
 
 // static
   bool NetworkSettings::ParsePortRange(const std::string& port_range,
-                                       int* out_min_port,
-                                       int* out_max_port) {
+                                       uint16* out_min_port,
+                                       uint16* out_max_port) {
   size_t separator_index = port_range.find('-');
   if (separator_index == std::string::npos)
     return false;
@@ -38,8 +38,8 @@ namespace protocol {
   if (min_port == 0 || min_port > max_port || max_port > USHRT_MAX)
     return false;
 
-  *out_min_port = static_cast<int>(min_port);
-  *out_max_port = static_cast<int>(max_port);
+  *out_min_port = static_cast<uint16>(min_port);
+  *out_max_port = static_cast<uint16>(max_port);
   return true;
 }
 
diff --git a/remoting/protocol/network_settings.h b/remoting/protocol/network_settings.h
index 7a9687e..f64958a 100644
--- a/remoting/protocol/network_settings.h
+++ b/remoting/protocol/network_settings.h
@@ -18,8 +18,8 @@ struct NetworkSettings {
   // When hosts are configured with NAT traversal disabled they will
   // typically also limit their P2P ports to this range, so that
   // sessions may be blocked or un-blocked via firewall rules.
-  static const int kDefaultMinPort = 12400;
-  static const int kDefaultMaxPort = 12409;
+  static const uint16 kDefaultMinPort = 12400;
+  static const uint16 kDefaultMaxPort = 12409;
 
   enum Flags {
     // Don't use STUN or relay servers. Accept incoming P2P connection
@@ -59,15 +59,15 @@ struct NetworkSettings {
   // Parse string in the form "<min_port>-<max_port>". E.g. "12400-12409".
   // Returns true if string was parsed successfuly.
   static bool ParsePortRange(const std::string& port_range,
-                             int* out_min_port,
-                             int* out_max_port);
+                             uint16* out_min_port,
+                             uint16* out_max_port);
 
   uint32 flags;
 
   // |min_port| and |max_port| specify range (inclusive) of ports used by
   // P2P sessions. Any port can be used when both values are set to 0.
-  int min_port;
-  int max_port;
+  uint16 min_port;
+  uint16 max_port;
 };
 
 }  // namespace protocol
diff --git a/remoting/protocol/network_settings_unittest.cc b/remoting/protocol/network_settings_unittest.cc
index c62c51b..398d559 100644
--- a/remoting/protocol/network_settings_unittest.cc
+++ b/remoting/protocol/network_settings_unittest.cc
@@ -10,20 +10,20 @@ namespace remoting {
 namespace protocol {
 
 TEST(ParsePortRange, Basic) {
-  int min, max;
+  uint16 min, max;
 
   // Valid range
   EXPECT_TRUE(NetworkSettings::ParsePortRange("1-65535", &min, &max));
-  EXPECT_EQ(1, min);
-  EXPECT_EQ(65535, max);
+  EXPECT_EQ(1u, min);
+  EXPECT_EQ(65535u, max);
 
   EXPECT_TRUE(NetworkSettings::ParsePortRange(" 1 - 65535 ", &min, &max));
-  EXPECT_EQ(1, min);
-  EXPECT_EQ(65535, max);
+  EXPECT_EQ(1u, min);
+  EXPECT_EQ(65535u, max);
 
   EXPECT_TRUE(NetworkSettings::ParsePortRange("12400-12400", &min, &max));
-  EXPECT_EQ(12400, min);
-  EXPECT_EQ(12400, max);
+  EXPECT_EQ(12400u, min);
+  EXPECT_EQ(12400u, max);
 
   // Invalid
   EXPECT_FALSE(NetworkSettings::ParsePortRange("", &min, &max));