Use uint16 for port numbers more pervasively.

chrome/browser/extensions/api/dial/dial_service.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 "chrome/browser/extensions/api/dial/dial_service.h"
 
 #include <algorithm>
 #include <set>
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 using net::HttpResponseHeaders;
 using net::HttpUtil;
 using net::IOBufferWithSize;
 using net::IPAddressNumber;
-using net::IPEndPoint;
 using net::NetworkInterface;
 using net::NetworkInterfaceList;
 using net::StringIOBuffer;
 using net::UDPSocket;
 
 namespace extensions {
 
 namespace {
 
 // The total number of requests to make per discovery cycle.
 const int kDialMaxRequests = 4;
 
 // The interval to wait between successive requests.
 const int kDialRequestIntervalMillis = 1000;
 
 // The maximum delay a device may wait before responding (MX).
 const int kDialMaxResponseDelaySecs = 1;
 
 // The maximum time a response is expected after a M-SEARCH request.
 const int kDialResponseTimeoutSecs = 2;
 
 // The multicast IP address for discovery.
 const char kDialRequestAddress[] = "239.255.255.250";
 
 // The UDP port number for discovery.
-const int kDialRequestPort = 1900;
+const uint16 kDialRequestPort = 1900;
 
 // The DIAL service type as part of the search request.
 const char kDialSearchType[] = "urn:dial-multiscreen-org:service:dial:1";
 
 // SSDP headers parsed from the response.
 const char kSsdpLocationHeader[] = "LOCATION";
 const char kSsdpCacheControlHeader[] = "CACHE-CONTROL";
 const char kSsdpConfigIdHeader[] = "CONFIGID.UPNP.ORG";
 const char kSsdpUsnHeader[] = "USN";
 
 // The receive buffer size, in bytes.
 const int kDialRecvBufferSize = 1500;
 
 // Gets a specific header from |headers| and puts it in |value|.
 bool GetHeader(HttpResponseHeaders* headers, const char* name,
                std::string* value) {
   return headers->EnumerateHeader(NULL, std::string(name), value);
 }
 
 // Returns the request string.
 std::string BuildRequest() {
   // Extra line at the end to make UPnP lib happy.
   chrome::VersionInfo version;
   std::string request(base::StringPrintf(
       "M-SEARCH * HTTP/1.1\r\n"
-      "HOST: %s:%i\r\n"
+      "HOST: %s:%u\r\n"
       "MAN: \"ssdp:discover\"\r\n"
       "MX: %d\r\n"
       "ST: %s\r\n"
       "USER-AGENT: %s/%s %s\r\n"
       "\r\n",
       kDialRequestAddress,
       kDialRequestPort,
       kDialMaxResponseDelaySecs,
       kDialSearchType,
       version.Name().c_str(),
@@ skipping 64 matching lines @@
   DCHECK(bind_ip_address.size() == net::kIPv4AddressSize);
 
   net::RandIntCallback rand_cb = base::Bind(&base::RandInt);
   socket_.reset(new UDPSocket(net::DatagramSocket::RANDOM_BIND,
                               rand_cb,
                               net_log,
                               net_log_source));
   socket_->AllowBroadcast();
 
   // 0 means bind a random port
-  IPEndPoint address(bind_ip_address, 0);
+  net::IPEndPoint address(bind_ip_address, 0);
 
   if (!CheckResult("Bind", socket_->Bind(address)))
     return false;
 
   DCHECK(socket_.get());
 
   recv_buffer_ = new IOBufferWithSize(kDialRecvBufferSize);
   return ReadSocket();
 }
 
@@ skipping 189 matching lines @@
       num_requests_sent_(0),
       max_requests_(kDialMaxRequests),
       finish_delay_(TimeDelta::FromMilliseconds((kDialMaxRequests - 1) *
                                                 kDialRequestIntervalMillis) +
                     TimeDelta::FromSeconds(kDialResponseTimeoutSecs)),
       request_interval_(
           TimeDelta::FromMilliseconds(kDialRequestIntervalMillis)) {
   IPAddressNumber address;
   bool success = net::ParseIPLiteralToNumber(kDialRequestAddress, &address);
   DCHECK(success);
-  send_address_ = IPEndPoint(address, kDialRequestPort);
+  send_address_ = net::IPEndPoint(address, kDialRequestPort);
   send_buffer_ = new StringIOBuffer(BuildRequest());
   net_log_ = net_log;
   net_log_source_.type = net::NetLog::SOURCE_UDP_SOCKET;
   net_log_source_.id = net_log_->NextID();
 }
 
 DialServiceImpl::~DialServiceImpl() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
@@ skipping 215 matching lines @@
   for (ScopedVector<DialSocket>::const_iterator iter = dial_sockets_.begin();
        iter != dial_sockets_.end();
        ++iter) {
     if (!((*iter)->IsClosed()))
       return true;
   }
   return false;
 }
 
 }  // namespace extensions