Switch to standard integer types in remoting/.

remoting/protocol/pseudotcp_adapter.cc

 // Copyright 2015 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 "remoting/protocol/pseudotcp_adapter.h"
 
+#include <stddef.h>
+
 #include "base/compiler_specific.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "remoting/protocol/p2p_datagram_socket.h"
 
 using cricket::PseudoTcp;
 
 namespace {
 const int kReadBufferSize = 65536;  // Maximum size of a packet.
-const uint16 kDefaultMtu = 1280;
+const uint16_t kDefaultMtu = 1280;
 }  // namespace
 
 namespace remoting {
 namespace protocol {
 
 class PseudoTcpAdapter::Core : public cricket::IPseudoTcpNotify,
                                public base::RefCounted<Core> {
  public:
   explicit Core(scoped_ptr<P2PDatagramSocket> socket);
 
   // Functions used to implement net::StreamSocket.
   int Read(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
            const net::CompletionCallback& callback);
   int Write(const scoped_refptr<net::IOBuffer>& buffer, int buffer_size,
             const net::CompletionCallback& callback);
   int Connect(const net::CompletionCallback& callback);
 
   // cricket::IPseudoTcpNotify interface.
   // These notifications are triggered from NotifyPacket.
   void OnTcpOpen(cricket::PseudoTcp* tcp) override;
   void OnTcpReadable(cricket::PseudoTcp* tcp) override;
   void OnTcpWriteable(cricket::PseudoTcp* tcp) override;
   // This is triggered by NotifyClock or NotifyPacket.
-  void OnTcpClosed(cricket::PseudoTcp* tcp, uint32 error) override;
+  void OnTcpClosed(cricket::PseudoTcp* tcp, uint32_t error) override;
   // This is triggered by NotifyClock, NotifyPacket, Recv and Send.
   WriteResult TcpWritePacket(cricket::PseudoTcp* tcp,
                              const char* buffer,
                              size_t len) override;
 
   void SetAckDelay(int delay_ms);
   void SetNoDelay(bool no_delay);
-  void SetReceiveBufferSize(int32 size);
-  void SetSendBufferSize(int32 size);
+  void SetReceiveBufferSize(int32_t size);
+  void SetSendBufferSize(int32_t size);
   void SetWriteWaitsForSend(bool write_waits_for_send);
 
   void DeleteSocket();
 
  private:
   friend class base::RefCounted<Core>;
   ~Core() override;
 
   // These are invoked by the underlying Socket, and may trigger callbacks.
   // They hold a reference to |this| while running, to protect from deletion.
@@ skipping 204 matching lines @@
     last_write_result_ = result;
     return;
   }
 
   net::CompletionCallback callback = write_callback_;
   write_callback_.Reset();
   write_buffer_ = NULL;
   callback.Run(result);
 }
 
-void PseudoTcpAdapter::Core::OnTcpClosed(PseudoTcp* tcp, uint32 error) {
+void PseudoTcpAdapter::Core::OnTcpClosed(PseudoTcp* tcp, uint32_t error) {
   DCHECK_EQ(tcp, &pseudo_tcp_);
 
   if (!connect_callback_.is_null()) {
     net::CompletionCallback callback = connect_callback_;
     connect_callback_.Reset();
     callback.Run(net::MapSystemError(error));
   }
 
   if (!read_callback_.is_null()) {
     net::CompletionCallback callback = read_callback_;
     read_callback_.Reset();
     callback.Run(net::MapSystemError(error));
   }
 
   if (!write_callback_.is_null()) {
     net::CompletionCallback callback = write_callback_;
     write_callback_.Reset();
     callback.Run(net::MapSystemError(error));
   }
 }
 
 void PseudoTcpAdapter::Core::SetAckDelay(int delay_ms) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_ACKDELAY, delay_ms);
 }
 
 void PseudoTcpAdapter::Core::SetNoDelay(bool no_delay) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_NODELAY, no_delay ? 1 : 0);
 }
 
-void PseudoTcpAdapter::Core::SetReceiveBufferSize(int32 size) {
+void PseudoTcpAdapter::Core::SetReceiveBufferSize(int32_t size) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_RCVBUF, size);
 }
 
-void PseudoTcpAdapter::Core::SetSendBufferSize(int32 size) {
+void PseudoTcpAdapter::Core::SetSendBufferSize(int32_t size) {
   pseudo_tcp_.SetOption(cricket::PseudoTcp::OPT_SNDBUF, size);
 }
 
 void PseudoTcpAdapter::Core::SetWriteWaitsForSend(bool write_waits_for_send) {
   write_waits_for_send_ = write_waits_for_send;
 }
 
 void PseudoTcpAdapter::Core::DeleteSocket() {
   // Don't dispatch outstanding callbacks when the socket is deleted.
   read_callback_.Reset();
@@ skipping 139 matching lines @@
   return core_->Read(buffer, buffer_size, callback);
 }
 
 int PseudoTcpAdapter::Write(const scoped_refptr<net::IOBuffer>& buffer,
                             int buffer_size,
                             const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Write(buffer, buffer_size, callback);
 }
 
-int PseudoTcpAdapter::SetReceiveBufferSize(int32 size) {
+int PseudoTcpAdapter::SetReceiveBufferSize(int32_t size) {
   DCHECK(CalledOnValidThread());
   core_->SetReceiveBufferSize(size);
   return net::OK;
 }
 
-int PseudoTcpAdapter::SetSendBufferSize(int32 size) {
+int PseudoTcpAdapter::SetSendBufferSize(int32_t size) {
   DCHECK(CalledOnValidThread());
   core_->SetSendBufferSize(size);
   return net::OK;
 }
 
 int PseudoTcpAdapter::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   return core_->Connect(callback);
 }
 
 void PseudoTcpAdapter::SetAckDelay(int delay_ms) {
   DCHECK(CalledOnValidThread());
   core_->SetAckDelay(delay_ms);
 }
 
 void PseudoTcpAdapter::SetNoDelay(bool no_delay) {
   DCHECK(CalledOnValidThread());
   core_->SetNoDelay(no_delay);
 }
 
 void PseudoTcpAdapter::SetWriteWaitsForSend(bool write_waits_for_send) {
   DCHECK(CalledOnValidThread());
   core_->SetWriteWaitsForSend(write_waits_for_send);
 }
 
 }  // namespace protocol
 }  // namespace remoting