Update from https://crrev.com/305340

net/udp/udp_socket_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 "net/udp/udp_socket.h"
 
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
@@ skipping 101 matching lines @@
     return bytes_sent;
   }
 
  protected:
   static const int kMaxRead = 1024;
   scoped_refptr<IOBufferWithSize> buffer_;
   IPEndPoint recv_from_address_;
 };
 
 // Creates and address from an ip/port and returns it in |address|.
-void CreateUDPAddress(std::string ip_str, int port, IPEndPoint* address) {
+void CreateUDPAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
   IPAddressNumber ip_number;
   bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
   if (!rv)
     return;
   *address = IPEndPoint(ip_number, port);
 }
 
 TEST_F(UDPSocketTest, Connect) {
-  const int kPort = 9999;
+  const uint16 kPort = 9999;
   std::string simple_message("hello world!");
 
   // Setup the server to listen.
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", kPort, &bind_address);
   CapturingNetLog server_log;
   scoped_ptr<UDPServerSocket> server(
       new UDPServerSocket(&server_log, NetLog::Source()));
   server->AllowAddressReuse();
   int rv = server->Listen(bind_address);
@@ skipping 67 matching lines @@
 // root permissions on OSX 10.7+.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
 #elif defined(OS_ANDROID)
 // It is also disabled for Android because it is extremely flaky.
 // The first call to SendToSocket returns -109 (Address not reachable)
 // in some unpredictable cases. crbug.com/139144.
 TEST_F(UDPSocketTest, DISABLED_Broadcast) {
 #else
 TEST_F(UDPSocketTest, Broadcast) {
 #endif
-  const int kPort = 9999;
+  const uint16 kPort = 9999;
   std::string first_message("first message"), second_message("second message");
 
   IPEndPoint broadcast_address;
   CreateUDPAddress("255.255.255.255", kPort, &broadcast_address);
   IPEndPoint listen_address;
   CreateUDPAddress("0.0.0.0", kPort, &listen_address);
 
   CapturingNetLog server1_log, server2_log;
   scoped_ptr<UDPServerSocket> server1(
       new UDPServerSocket(&server1_log, NetLog::Source()));
@@ skipping 132 matching lines @@
 
 // In this test, we verify that connect() on a socket will have the effect
 // of filtering reads on this socket only to data read from the destination
 // we connected to.
 //
 // The purpose of this test is that some documentation indicates that connect
 // binds the client's sends to send to a particular server endpoint, but does
 // not bind the client's reads to only be from that endpoint, and that we need
 // to always use recvfrom() to disambiguate.
 TEST_F(UDPSocketTest, VerifyConnectBindsAddr) {
-  const int kPort1 = 9999;
-  const int kPort2 = 10000;
+  const uint16 kPort1 = 9999;
+  const uint16 kPort2 = 10000;
   std::string simple_message("hello world!");
   std::string foreign_message("BAD MESSAGE TO GET!!");
 
   // Setup the first server to listen.
   IPEndPoint bind_address;
   CreateUDPAddress("127.0.0.1", kPort1, &bind_address);
   UDPServerSocket server1(NULL, NetLog::Source());
   server1.AllowAddressReuse();
   int rv = server1.Listen(bind_address);
   ASSERT_EQ(OK, rv);
@@ skipping 147 matching lines @@
 #if defined(OS_ANDROID)
 // Some Android devices do not support multicast socket.
 // The ones supporting multicast need WifiManager.MulitcastLock to enable it.
 // http://goo.gl/jjAk9
 #define MAYBE_JoinMulticastGroup DISABLED_JoinMulticastGroup
 #else
 #define MAYBE_JoinMulticastGroup JoinMulticastGroup
 #endif  // defined(OS_ANDROID)
 
 TEST_F(UDPSocketTest, MAYBE_JoinMulticastGroup) {
-  const int kPort = 9999;
+  const uint16 kPort = 9999;
   const char* const kGroup = "237.132.100.17";
 
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
   IPAddressNumber group_ip;
   EXPECT_TRUE(ParseIPLiteralToNumber(kGroup, &group_ip));
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   EXPECT_EQ(OK, socket.Bind(bind_address));
   EXPECT_EQ(OK, socket.JoinGroup(group_ip));
   // Joining group multiple times.
   EXPECT_NE(OK, socket.JoinGroup(group_ip));
   EXPECT_EQ(OK, socket.LeaveGroup(group_ip));
   // Leaving group multiple times.
   EXPECT_NE(OK, socket.LeaveGroup(group_ip));
 
   socket.Close();
 }
 
 TEST_F(UDPSocketTest, MulticastOptions) {
-  const int kPort = 9999;
+  const uint16 kPort = 9999;
   IPEndPoint bind_address;
   CreateUDPAddress("0.0.0.0", kPort, &bind_address);
 
   UDPSocket socket(DatagramSocket::DEFAULT_BIND,
                    RandIntCallback(),
                    NULL,
                    NetLog::Source());
   // Before binding.
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(false));
   EXPECT_EQ(OK, socket.SetMulticastLoopbackMode(true));
@@ skipping 156 matching lines @@
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
   client.Close();
 }
 #endif
 
 }  // namespace net