Use uint16 for port numbers, content/ edition

content/browser/devtools/protocol/tethering_handler.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 "content/browser/devtools/protocol/tethering_handler.h"
 
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_http_handler_delegate.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 137 matching lines @@
   scoped_ptr<net::StreamSocket> client_socket_;
   scoped_ptr<net::ServerSocket> server_socket_;
   scoped_ptr<net::StreamSocket> accepted_socket_;
   DevToolsHttpHandlerDelegate* delegate_;
   int pending_writes_;
   bool pending_destruction_;
 };
 
 class BoundSocket {
  public:
-  typedef base::Callback<void(int, const std::string&)> AcceptedCallback;
+  typedef base::Callback<void(uint16, const std::string&)> AcceptedCallback;
 
   BoundSocket(AcceptedCallback accepted_callback,
               DevToolsHttpHandlerDelegate* delegate)
       : accepted_callback_(accepted_callback),
         delegate_(delegate),
         socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
         port_(0) {
   }
 
   virtual ~BoundSocket() {
   }
 
-  bool Listen(int port) {
+  bool Listen(uint16 port) {
     port_ = port;
     net::IPAddressNumber ip_number;
     if (!net::ParseIPLiteralToNumber(kLocalhost, &ip_number))
       return false;
 
     net::IPEndPoint end_point(ip_number, port);
     int result = socket_->Listen(end_point, kListenBacklog);
     if (result < 0)
       return false;
 
@@ skipping 34 matching lines @@
     SocketPump* pump = new SocketPump(delegate_, accept_socket_.release());
     std::string name = pump->Init();
     if (!name.empty())
       accepted_callback_.Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
   DevToolsHttpHandlerDelegate* delegate_;
   scoped_ptr<net::ServerSocket> socket_;
   scoped_ptr<net::StreamSocket> accept_socket_;
-  int port_;
+  uint16 port_;
 };
 
 }  // namespace
 
 // TetheringHandler::TetheringImpl -------------------------------------------
 
 class TetheringHandler::TetheringImpl {
  public:
   TetheringImpl(
       base::WeakPtr<TetheringHandler> handler,
       DevToolsHttpHandlerDelegate* delegate);
   ~TetheringImpl();
 
-  void Bind(scoped_refptr<DevToolsProtocol::Command> command, int port);
-  void Unbind(scoped_refptr<DevToolsProtocol::Command> command, int port);
-  void Accepted(int port, const std::string& name);
+  void Bind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port);
+  void Unbind(scoped_refptr<DevToolsProtocol::Command> command, uint16 port);
+  void Accepted(uint16 port, const std::string& name);
 
  private:
   void SendInternalError(scoped_refptr<DevToolsProtocol::Command> command,
                          const std::string& message);
 
   base::WeakPtr<TetheringHandler> handler_;
   DevToolsHttpHandlerDelegate* delegate_;
 
-  typedef std::map<int, BoundSocket*> BoundSockets;
+  typedef std::map<uint16, BoundSocket*> BoundSockets;
   BoundSockets bound_sockets_;
 };
 
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
     DevToolsHttpHandlerDelegate* delegate)
     : handler_(handler),
       delegate_(delegate) {
 }
 
 TetheringHandler::TetheringImpl::~TetheringImpl() {
   STLDeleteContainerPairSecondPointers(bound_sockets_.begin(),
                                        bound_sockets_.end());
 }
 
 void TetheringHandler::TetheringImpl::Bind(
-    scoped_refptr<DevToolsProtocol::Command> command, int port) {
+    scoped_refptr<DevToolsProtocol::Command> command, uint16 port) {
   if (bound_sockets_.find(port) != bound_sockets_.end()) {
     SendInternalError(command, "Port already bound");
     return;
   }
 
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
   scoped_ptr<BoundSocket> bound_socket(new BoundSocket(callback, delegate_));
   if (!bound_socket->Listen(port)) {
     SendInternalError(command, "Could not bind port");
     return;
   }
 
   bound_sockets_[port] = bound_socket.release();
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::SendBindSuccess, handler_, command));
 }
 
 void TetheringHandler::TetheringImpl::Unbind(
-    scoped_refptr<DevToolsProtocol::Command> command, int port) {
+    scoped_refptr<DevToolsProtocol::Command> command, uint16 port) {
 
   BoundSockets::iterator it = bound_sockets_.find(port);
   if (it == bound_sockets_.end()) {
     SendInternalError(command, "Port is not bound");
     return;
   }
 
   delete it->second;
   bound_sockets_.erase(it);
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::SendUnbindSuccess, handler_, command));
 }
 
 void TetheringHandler::TetheringImpl::Accepted(
-    int port, const std::string& name) {
+    uint16 port, const std::string& name) {
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&TetheringHandler::Accepted, handler_, port, name));
 }
 
 void TetheringHandler::TetheringImpl::SendInternalError(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::string& message) {
   BrowserThread::PostTask(
@@ skipping 22 matching lines @@
   if (is_active_) {
     message_loop_proxy_->DeleteSoon(FROM_HERE, impl_);
     impl_ = nullptr;
   }
 }
 
 void TetheringHandler::SetClient(scoped_ptr<Client> client) {
   client_.swap(client);
 }
 
-void TetheringHandler::Accepted(int port, const std::string& name) {
+void TetheringHandler::Accepted(uint16 port, const std::string& name) {
   client_->Accepted(AcceptedParams::Create()->set_port(port)
                                             ->set_connection_id(name));
 }
 
 bool TetheringHandler::Activate() {
   if (is_active_)
     return true;
   if (impl_)
     return false;
   is_active_ = true;
   impl_ = new TetheringImpl(weak_factory_.GetWeakPtr(), delegate_);
   return true;
 }
 
 scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Bind(
-    int port, scoped_refptr<DevToolsProtocol::Command> command) {
+    uint16 port, scoped_refptr<DevToolsProtocol::Command> command) {
   if (port < kMinTetheringPort || port > kMaxTetheringPort)
     return command->InvalidParamResponse("port");
 
   if (!Activate()) {
     return command->ServerErrorResponse(
         "Tethering is used by another connection");
   }
   DCHECK(impl_);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&TetheringImpl::Bind, base::Unretained(impl_),
                  command, port));
   return command->AsyncResponsePromise();
 }
 
 scoped_refptr<DevToolsProtocol::Response> TetheringHandler::Unbind(
-    int port, scoped_refptr<DevToolsProtocol::Command> command) {
+    uint16 port, scoped_refptr<DevToolsProtocol::Command> command) {
   if (!Activate()) {
     return command->ServerErrorResponse(
         "Tethering is used by another connection");
   }
   DCHECK(impl_);
   message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&TetheringImpl::Unbind, base::Unretained(impl_),
                  command, port));
   return command->AsyncResponsePromise();
@@ skipping 11 matching lines @@
 
 void TetheringHandler::SendInternalError(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::string& message) {
   client_->SendInternalErrorResponse(command, message);
 }
 
 }  // namespace tethering
 }  // namespace devtools
 }  // namespace content