Switch to standard integer types in net/.

net/quic/quic_stream_factory.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/quic/quic_stream_factory.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
@@ skipping 43 matching lines @@
 namespace {
 
 enum CreateSessionFailure {
   CREATION_ERROR_CONNECTING_SOCKET,
   CREATION_ERROR_SETTING_RECEIVE_BUFFER,
   CREATION_ERROR_SETTING_SEND_BUFFER,
   CREATION_ERROR_MAX
 };
 
 // The maximum receive window sizes for QUIC sessions and streams.
-const int32 kQuicSessionMaxRecvWindowSize = 15 * 1024 * 1024;  // 15 MB
-const int32 kQuicStreamMaxRecvWindowSize = 6 * 1024 * 1024;    // 6 MB
+const int32_t kQuicSessionMaxRecvWindowSize = 15 * 1024 * 1024;  // 15 MB
+const int32_t kQuicStreamMaxRecvWindowSize = 6 * 1024 * 1024;    // 6 MB
 
 // Set the maximum number of undecryptable packets the connection will store.
-const int32 kMaxUndecryptablePackets = 100;
+const int32_t kMaxUndecryptablePackets = 100;
 
 void HistogramCreateSessionFailure(enum CreateSessionFailure error) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicSession.CreationError", error,
                             CREATION_ERROR_MAX);
 }
 
 bool IsEcdsaSupported() {
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_VISTA)
     return false;
@@ skipping 277 matching lines @@
 int QuicStreamFactory::Job::DoLoadServerInfo() {
   io_state_ = STATE_LOAD_SERVER_INFO_COMPLETE;
 
   DCHECK(server_info_);
 
   // To mitigate the effects of disk cache taking too long to load QUIC server
   // information, set up a timer to cancel WaitForDataReady's callback.
   if (factory_->load_server_info_timeout_srtt_multiplier_ > 0) {
     const int kMaxLoadServerInfoTimeoutMs = 50;
     // Wait for DiskCache a maximum of 50ms.
-    int64 load_server_info_timeout_ms =
+    int64_t load_server_info_timeout_ms =
         min(static_cast<int>(
                 (factory_->load_server_info_timeout_srtt_multiplier_ *
                  factory_->GetServerNetworkStatsSmoothedRttInMicroseconds(
                      server_id_)) /
                 1000),
             kMaxLoadServerInfoTimeoutMs);
     if (load_server_info_timeout_ms > 0) {
       factory_->task_runner_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&QuicStreamFactory::Job::CancelWaitForDataReadyCallback,
@@ skipping 299 matching lines @@
 }
 
 bool QuicStreamFactory::ZeroRTTEnabledFor(const QuicServerId& quic_server_id) {
   return !(require_confirmation_ || CryptoConfigCacheIsEmpty(quic_server_id));
 }
 
 base::TimeDelta QuicStreamFactory::GetTimeDelayForWaitingJob(
     const QuicServerId& server_id) {
   if (!delay_tcp_race_ || require_confirmation_)
     return base::TimeDelta();
-  int64 srtt = 1.5 * GetServerNetworkStatsSmoothedRttInMicroseconds(server_id);
+  int64_t srtt =
+      1.5 * GetServerNetworkStatsSmoothedRttInMicroseconds(server_id);
   // Picked 300ms based on mean time from
   // Net.QuicSession.HostResolution.HandshakeConfirmedTime histogram.
   const int kDefaultRTT = 300 * kNumMicrosPerMilli;
   if (!srtt)
     srtt = kDefaultRTT;
   return base::TimeDelta::FromMicroseconds(srtt);
 }
 
 void QuicStreamFactory::set_quic_server_info_factory(
     QuicServerInfoFactory* quic_server_info_factory) {
@@ skipping 174 matching lines @@
   active_jobs_.erase(server_id);
   job_requests_map_.erase(server_id);
 }
 
 scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateFromSession(
     QuicChromiumClientSession* session) {
   return scoped_ptr<QuicHttpStream>(new QuicHttpStream(session->GetWeakPtr()));
 }
 
 QuicChromiumClientSession::QuicDisabledReason
-QuicStreamFactory::QuicDisabledReason(uint16 port) const {
+QuicStreamFactory::QuicDisabledReason(uint16_t port) const {
   if (max_number_of_lossy_connections_ > 0 &&
       number_of_lossy_connections_.find(port) !=
           number_of_lossy_connections_.end() &&
       number_of_lossy_connections_.at(port) >=
           max_number_of_lossy_connections_) {
     return QuicChromiumClientSession::QUIC_DISABLED_BAD_PACKET_LOSS_RATE;
   }
   if (threshold_public_resets_post_handshake_ > 0 &&
       num_public_resets_post_handshake_ >=
           threshold_public_resets_post_handshake_) {
     return QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE;
   }
   if (threshold_timeouts_with_open_streams_ > 0 &&
       num_timeouts_with_open_streams_ >=
           threshold_timeouts_with_open_streams_) {
     return QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS;
   }
   return QuicChromiumClientSession::QUIC_DISABLED_NOT;
 }
 
 const char* QuicStreamFactory::QuicDisabledReasonString() const {
   // TODO(ckrasic) - better solution for port/lossy connections?
-  const uint16 port = 443;
+  const uint16_t port = 443;
   switch (QuicDisabledReason(port)) {
     case QuicChromiumClientSession::QUIC_DISABLED_BAD_PACKET_LOSS_RATE:
       return "Bad packet loss rate.";
     case QuicChromiumClientSession::QUIC_DISABLED_PUBLIC_RESET_POST_HANDSHAKE:
       return "Public resets after successful handshakes.";
     case QuicChromiumClientSession::QUIC_DISABLED_TIMEOUT_WITH_OPEN_STREAMS:
       return "Connection timeouts with streams open.";
     default:
       return "";
   }
 }
 
-bool QuicStreamFactory::IsQuicDisabled(uint16 port) {
+bool QuicStreamFactory::IsQuicDisabled(uint16_t port) {
   return QuicDisabledReason(port) !=
          QuicChromiumClientSession::QUIC_DISABLED_NOT;
 }
 
 bool QuicStreamFactory::OnHandshakeConfirmed(QuicChromiumClientSession* session,
                                              float packet_loss_rate) {
   DCHECK(session);
-  uint16 port = session->server_id().port();
+  uint16_t port = session->server_id().port();
   if (packet_loss_rate < packet_loss_threshold_) {
     number_of_lossy_connections_[port] = 0;
     return false;
   }
 
   // We mark it as recently broken, which means that 0-RTT will be disabled
   // but we'll still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       AlternativeService(QUIC, session->server_id().host(), port));
 
@@ skipping 45 matching lines @@
     ip_aliases_[peer_address].erase(session);
     if (ip_aliases_[peer_address].empty()) {
       ip_aliases_.erase(peer_address);
     }
   }
   session_aliases_.erase(session);
 }
 
 void QuicStreamFactory::MaybeDisableQuic(QuicChromiumClientSession* session) {
   DCHECK(session);
-  uint16 port = session->server_id().port();
+  uint16_t port = session->server_id().port();
   if (IsQuicDisabled(port))
     return;
 
   // Expire the oldest disabled_reason if appropriate.  This enforces that we
   // only consider the max_disabled_reasons_ most recent sessions.
   QuicChromiumClientSession::QuicDisabledReason disabled_reason;
   if (static_cast<int>(disabled_reasons_.size()) == max_disabled_reasons_) {
     disabled_reason = disabled_reasons_.front();
     disabled_reasons_.pop_front();
     if (disabled_reason ==
@@ skipping 252 matching lines @@
   connection->SetMaxPacketLength(max_packet_length_);
 
   InitializeCachedStateInCryptoConfig(server_id, server_info);
 
   QuicConfig config = config_;
   config.SetSocketReceiveBufferToSend(socket_receive_buffer_size_);
   config.set_max_undecryptable_packets(kMaxUndecryptablePackets);
   config.SetInitialSessionFlowControlWindowToSend(
       kQuicSessionMaxRecvWindowSize);
   config.SetInitialStreamFlowControlWindowToSend(kQuicStreamMaxRecvWindowSize);
-  int64 srtt = GetServerNetworkStatsSmoothedRttInMicroseconds(server_id);
+  int64_t srtt = GetServerNetworkStatsSmoothedRttInMicroseconds(server_id);
   if (srtt > 0)
-    config.SetInitialRoundTripTimeUsToSend(static_cast<uint32>(srtt));
+    config.SetInitialRoundTripTimeUsToSend(static_cast<uint32_t>(srtt));
   config.SetBytesForConnectionIdToSend(0);
 
   if (quic_server_info_factory_.get() && !server_info) {
     // Start the disk cache loading so that we can persist the newer QUIC server
     // information and/or inform the disk cache that we have reused
     // |server_info|.
     server_info.reset(quic_server_info_factory_->GetForServer(server_id));
     server_info->Start();
   }
 
@@ skipping 33 matching lines @@
                                         QuicChromiumClientSession* session) {
   DCHECK(!HasActiveSession(server_id));
   UMA_HISTOGRAM_COUNTS("Net.QuicActiveSessions", active_sessions_.size());
   active_sessions_[server_id] = session;
   session_aliases_[session].insert(server_id);
   const IPEndPoint peer_address = session->connection()->peer_address();
   DCHECK(!ContainsKey(ip_aliases_[peer_address], session));
   ip_aliases_[peer_address].insert(session);
 }
 
-int64 QuicStreamFactory::GetServerNetworkStatsSmoothedRttInMicroseconds(
+int64_t QuicStreamFactory::GetServerNetworkStatsSmoothedRttInMicroseconds(
     const QuicServerId& server_id) const {
   const ServerNetworkStats* stats =
       http_server_properties_->GetServerNetworkStats(
           server_id.host_port_pair());
   if (stats == nullptr)
     return 0;
   return stats->srtt.InMicroseconds();
 }
 
 bool QuicStreamFactory::WasQuicRecentlyBroken(
@@ skipping 112 matching lines @@
   // Since the session was active, there's no longer an
   // HttpStreamFactoryImpl::Job running which can mark it broken, unless the TCP
   // job also fails. So to avoid not using QUIC when we otherwise could, we mark
   // it as recently broken, which means that 0-RTT will be disabled but we'll
   // still race.
   http_server_properties_->MarkAlternativeServiceRecentlyBroken(
       alternative_service);
 }
 
 }  // namespace net