Use uint16 for port numbers, extensions/ edition

extensions/browser/api/socket/udp_socket.cc

 // Copyright 2014 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 "extensions/browser/api/socket/udp_socket.h"
 
 #include <algorithm>
 
 #include "base/lazy_instance.h"
 #include "extensions/browser/api/api_resource.h"
@@ skipping 18 matching lines @@
 UDPSocket::UDPSocket(const std::string& owner_extension_id)
     : Socket(owner_extension_id),
       socket_(net::DatagramSocket::DEFAULT_BIND,
               net::RandIntCallback(),
               NULL,
               net::NetLog::Source()) {}
 
 UDPSocket::~UDPSocket() { Disconnect(); }
 
 void UDPSocket::Connect(const std::string& address,
-                        int port,
+                        uint16 port,
                         const CompletionCallback& callback) {
   int result = net::ERR_CONNECTION_FAILED;
   do {
     if (is_connected_)
       break;
 
     net::IPEndPoint ip_end_point;
     if (!StringAndPortToIPEndPoint(address, port, &ip_end_point)) {
       result = net::ERR_ADDRESS_INVALID;
       break;
     }
 
     result = socket_.Connect(ip_end_point);
     is_connected_ = (result == net::OK);
   } while (false);
 
   callback.Run(result);
 }
 
-int UDPSocket::Bind(const std::string& address, int port) {
+int UDPSocket::Bind(const std::string& address, uint16 port) {
   if (IsBound())
     return net::ERR_CONNECTION_FAILED;
 
   net::IPEndPoint ip_end_point;
   if (!StringAndPortToIPEndPoint(address, port, &ip_end_point))
     return net::ERR_INVALID_ARGUMENT;
 
   return socket_.Bind(ip_end_point);
 }
 
@@ skipping 86 matching lines @@
                                          address));
   } while (false);
 
   if (result != net::ERR_IO_PENDING)
     OnRecvFromComplete(io_buffer, address, result);
 }
 
 void UDPSocket::SendTo(scoped_refptr<net::IOBuffer> io_buffer,
                        int byte_count,
                        const std::string& address,
-                       int port,
+                       uint16 port,
                        const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   if (!send_to_callback_.is_null()) {
     // TODO(penghuang): Put requests in a pending queue to support multiple
     // sendTo calls.
     callback.Run(net::ERR_IO_PENDING);
     return;
   } else {
     send_to_callback_ = callback;
@@ skipping 40 matching lines @@
   DCHECK(!read_callback_.is_null());
   read_callback_.Run(result, io_buffer);
   read_callback_.Reset();
 }
 
 void UDPSocket::OnRecvFromComplete(scoped_refptr<net::IOBuffer> io_buffer,
                                    scoped_refptr<IPEndPoint> address,
                                    int result) {
   DCHECK(!recv_from_callback_.is_null());
   std::string ip;
-  int port = 0;
+  uint16 port = 0;
   if (result > 0 && address.get()) {
     IPEndPointToStringAndPort(address->data, &ip, &port);
   }
   recv_from_callback_.Run(result, io_buffer, ip, port);
   recv_from_callback_.Reset();
 }
 
 void UDPSocket::OnSendToComplete(int result) {
   DCHECK(!send_to_callback_.is_null());
   send_to_callback_.Run(result);
@@ skipping 50 matching lines @@
 
 ResumableUDPSocket::ResumableUDPSocket(const std::string& owner_extension_id)
     : UDPSocket(owner_extension_id),
       persistent_(false),
       buffer_size_(0),
       paused_(false) {}
 
 bool ResumableUDPSocket::IsPersistent() const { return persistent(); }
 
 }  // namespace extensions