Switch to standard integer types in net/.

net/tools/quic/quic_server_session.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/tools/quic/quic_server_session.h"
 
 #include "base/logging.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
@@ skipping 42 matching lines @@
   const CachedNetworkParameters* cached_network_params =
       crypto_stream_->PreviousCachedNetworkParams();
   const bool last_bandwidth_resumption =
       ContainsQuicTag(config()->ReceivedConnectionOptions(), kBWRE);
   const bool max_bandwidth_resumption =
       ContainsQuicTag(config()->ReceivedConnectionOptions(), kBWMX);
   bandwidth_resumption_enabled_ =
       last_bandwidth_resumption || max_bandwidth_resumption;
   if (cached_network_params != nullptr && bandwidth_resumption_enabled_ &&
       cached_network_params->serving_region() == serving_region_) {
-    int64 seconds_since_estimate =
+    int64_t seconds_since_estimate =
         connection()->clock()->WallNow().ToUNIXSeconds() -
         cached_network_params->timestamp();
     bool estimate_within_last_hour =
         seconds_since_estimate <= kNumSecondsPerHour;
     if (estimate_within_last_hour) {
       connection()->ResumeConnectionState(*cached_network_params,
                                           max_bandwidth_resumption);
     }
   }
 
@@ skipping 27 matching lines @@
   }
   // Only send updates when the application has no data to write.
   if (HasDataToWrite()) {
     return;
   }
 
   // If not enough time has passed since the last time we sent an update to the
   // client, or not enough packets have been sent, then return early.
   const QuicSentPacketManager& sent_packet_manager =
       connection()->sent_packet_manager();
-  int64 srtt_ms =
+  int64_t srtt_ms =
       sent_packet_manager.GetRttStats()->smoothed_rtt().ToMilliseconds();
-  int64 now_ms = now.Subtract(last_scup_time_).ToMilliseconds();
-  int64 packets_since_last_scup =
+  int64_t now_ms = now.Subtract(last_scup_time_).ToMilliseconds();
+  int64_t packets_since_last_scup =
       connection()->packet_number_of_last_sent_packet() -
       last_scup_packet_number_;
   if (now_ms < (kMinIntervalBetweenServerConfigUpdatesRTTs * srtt_ms) ||
       now_ms < kMinIntervalBetweenServerConfigUpdatesMs ||
       packets_since_last_scup < kMinPacketsBetweenServerConfigUpdates) {
     return;
   }
 
   // If the bandwidth recorder does not have a valid estimate, return early.
   const QuicSustainedBandwidthRecorder& bandwidth_recorder =
       sent_packet_manager.SustainedBandwidthRecorder();
   if (!bandwidth_recorder.HasEstimate()) {
     return;
   }
 
   // The bandwidth recorder has recorded at least one sustained bandwidth
   // estimate. Check that it's substantially different from the last one that
   // we sent to the client, and if so, send the new one.
   QuicBandwidth new_bandwidth_estimate = bandwidth_recorder.BandwidthEstimate();
 
-  int64 bandwidth_delta =
+  int64_t bandwidth_delta =
       std::abs(new_bandwidth_estimate.ToBitsPerSecond() -
                bandwidth_estimate_sent_to_client_.ToBitsPerSecond());
 
   // Define "substantial" difference as a 50% increase or decrease from the
   // last estimate.
   bool substantial_difference =
       bandwidth_delta >
       0.5 * bandwidth_estimate_sent_to_client_.ToBitsPerSecond();
   if (!substantial_difference) {
     return;
   }
 
   bandwidth_estimate_sent_to_client_ = new_bandwidth_estimate;
   DVLOG(1) << "Server: sending new bandwidth estimate (KBytes/s): "
            << bandwidth_estimate_sent_to_client_.ToKBytesPerSecond();
 
   // Include max bandwidth in the update.
   QuicBandwidth max_bandwidth_estimate =
       bandwidth_recorder.MaxBandwidthEstimate();
-  int32 max_bandwidth_timestamp = bandwidth_recorder.MaxBandwidthTimestamp();
+  int32_t max_bandwidth_timestamp = bandwidth_recorder.MaxBandwidthTimestamp();
 
   // Fill the proto before passing it to the crypto stream to send.
   CachedNetworkParameters cached_network_params;
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
       bandwidth_estimate_sent_to_client_.ToBytesPerSecond());
   cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
       max_bandwidth_estimate.ToBytesPerSecond());
   cached_network_params.set_max_bandwidth_timestamp_seconds(
       max_bandwidth_timestamp);
   cached_network_params.set_min_rtt_ms(
@@ skipping 68 matching lines @@
   ActivateStream(stream);
   return stream;
 }
 
 QuicCryptoServerStreamBase* QuicServerSession::GetCryptoStream() {
   return crypto_stream_.get();
 }
 
 }  // namespace tools
 }  // namespace net