Switch to standard integer types in net/.

net/tools/quic/end_to_end_test.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 <stddef.h>
 #include <sys/epoll.h>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/null_encrypter.h"
@@ skipping 276 matching lines @@
   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
     QuicTestClient* client =
         new QuicTestClient(server_address_, server_hostname_, client_config_,
                            client_supported_versions_);
     client->UseWriter(writer);
     client->Connect();
     return client;
   }
 
   void set_smaller_flow_control_receive_window() {
-    const uint32 kClientIFCW = 64 * 1024;
-    const uint32 kServerIFCW = 1024 * 1024;
+    const uint32_t kClientIFCW = 64 * 1024;
+    const uint32_t kServerIFCW = 1024 * 1024;
     set_client_initial_stream_flow_control_receive_window(kClientIFCW);
     set_client_initial_session_flow_control_receive_window(
         kSessionToStreamRatio * kClientIFCW);
     set_server_initial_stream_flow_control_receive_window(kServerIFCW);
     set_server_initial_session_flow_control_receive_window(
         kSessionToStreamRatio * kServerIFCW);
   }
 
-  void set_client_initial_stream_flow_control_receive_window(uint32 window) {
+  void set_client_initial_stream_flow_control_receive_window(uint32_t window) {
     CHECK(client_.get() == nullptr);
     DVLOG(1) << "Setting client initial stream flow control window: " << window;
     client_config_.SetInitialStreamFlowControlWindowToSend(window);
   }
 
-  void set_client_initial_session_flow_control_receive_window(uint32 window) {
+  void set_client_initial_session_flow_control_receive_window(uint32_t window) {
     CHECK(client_.get() == nullptr);
     DVLOG(1) << "Setting client initial session flow control window: "
              << window;
     client_config_.SetInitialSessionFlowControlWindowToSend(window);
   }
 
-  void set_server_initial_stream_flow_control_receive_window(uint32 window) {
+  void set_server_initial_stream_flow_control_receive_window(uint32_t window) {
     CHECK(server_thread_.get() == nullptr);
     DVLOG(1) << "Setting server initial stream flow control window: " << window;
     server_config_.SetInitialStreamFlowControlWindowToSend(window);
   }
 
-  void set_server_initial_session_flow_control_receive_window(uint32 window) {
+  void set_server_initial_session_flow_control_receive_window(uint32_t window) {
     CHECK(server_thread_.get() == nullptr);
     DVLOG(1) << "Setting server initial session flow control window: "
              << window;
     server_config_.SetInitialSessionFlowControlWindowToSend(window);
   }
 
   const QuicSentPacketManager* GetSentPacketManagerFromFirstServerSession()
       const {
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
@@ skipping 93 matching lines @@
       server_thread_->Quit();
       server_thread_->Join();
     }
   }
 
   void AddToCache(StringPiece path, int response_code, StringPiece body) {
     QuicInMemoryCache::GetInstance()->AddSimpleResponse("www.google.com", path,
                                                         response_code, body);
   }
 
-  void SetPacketLossPercentage(int32 loss) {
+  void SetPacketLossPercentage(int32_t loss) {
     // TODO(rtenneti): enable when we can do random packet loss tests in
     // chrome's tree.
     if (loss != 0 && loss != 100)
       return;
     client_writer_->set_fake_packet_loss_percentage(loss);
     server_writer_->set_fake_packet_loss_percentage(loss);
   }
 
   void SetPacketSendDelay(QuicTime::Delta delay) {
     // TODO(rtenneti): enable when we can do random packet send delay tests in
     // chrome's tree.
     // client_writer_->set_fake_packet_delay(delay);
     // server_writer_->set_fake_packet_delay(delay);
   }
 
-  void SetReorderPercentage(int32 reorder) {
+  void SetReorderPercentage(int32_t reorder) {
     // TODO(rtenneti): enable when we can do random packet reorder tests in
     // chrome's tree.
     // client_writer_->set_fake_reorder_percentage(reorder);
     // server_writer_->set_fake_reorder_percentage(reorder);
   }
 
   // Verifies that the client and server connections were both free of packets
   // being discarded, based on connection stats.
   // Calls server_thread_ Pause() and Resume(), which may only be called once
   // per test.
@@ skipping 556 matching lines @@
   // Regression test for b/14677858.
   // Test that the resume write alarm is not set in QuicConnection::OnCanWrite
   // if currently connection level flow control blocked. If set, this results in
   // an infinite loop in the EpollServer, as the alarm fires and is immediately
   // rescheduled.
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // Ensure both stream and connection level are flow control blocked by setting
   // the send window offset to 0.
-  const uint64 flow_control_window =
+  const uint64_t flow_control_window =
       server_config_.GetInitialStreamFlowControlWindowToSend();
   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
   QuicSession* session = client_->client()->session();
   QuicFlowControllerPeer::SetSendWindowOffset(stream->flow_controller(), 0);
   QuicFlowControllerPeer::SetSendWindowOffset(session->flow_controller(), 0);
   EXPECT_TRUE(stream->flow_controller()->IsBlocked());
   EXPECT_TRUE(session->flow_controller()->IsBlocked());
 
   // Make sure that the stream has data pending so that it will be marked as
   // write blocked when it receives a stream level WINDOW_UPDATE.
@@ skipping 160 matching lines @@
   client_config_.SetMaxStreamsPerConnection(10, 5);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   QuicConfig* client_negotiated_config = client_->client()->session()->config();
   EXPECT_EQ(2u, client_negotiated_config->MaxStreamsPerConnection());
 }
 
 TEST_P(EndToEndTest, ClientSuggestsRTT) {
   // Client suggests initial RTT, verify it is used.
-  const uint32 kInitialRTT = 20000;
+  const uint32_t kInitialRTT = 20000;
   client_config_.SetInitialRoundTripTimeUsToSend(kInitialRTT);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
@@ skipping 28 matching lines @@
   QuicSession* session = dispatcher->session_map().begin()->second;
   const QuicSentPacketManager& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
 
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(
       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
   const RttStats& server_rtt_stats =
       *session->connection()->sent_packet_manager().GetRttStats();
-  EXPECT_EQ(static_cast<int64>(kMaxInitialRoundTripTimeUs),
+  EXPECT_EQ(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.initial_rtt_us());
-  EXPECT_GE(static_cast<int64>(kMaxInitialRoundTripTimeUs),
+  EXPECT_GE(static_cast<int64_t>(kMaxInitialRoundTripTimeUs),
             server_rtt_stats.smoothed_rtt().ToMicroseconds());
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, MinInitialRTT) {
   // Client tries to suggest 0 and the server uses the default.
   client_config_.SetInitialRoundTripTimeUsToSend(0);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
   // Pause the server so we can access the server's internals without races.
   server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   QuicSession* session = dispatcher->session_map().begin()->second;
   const QuicSentPacketManager& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManager& server_sent_packet_manager =
       session->connection()->sent_packet_manager();
 
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(
       client_sent_packet_manager.GetRttStats()->smoothed_rtt().IsInfinite());
   // Expect the default rtt of 100ms.
-  EXPECT_EQ(static_cast<int64>(100 * kNumMicrosPerMilli),
+  EXPECT_EQ(static_cast<int64_t>(100 * kNumMicrosPerMilli),
             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
   // Ensure the bandwidth is valid.
   client_sent_packet_manager.BandwidthEstimate();
   server_sent_packet_manager.BandwidthEstimate();
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, 0ByteConnectionId) {
   client_config_.SetBytesForConnectionIdToSend(0);
   ASSERT_TRUE(Initialize());
@@ skipping 213 matching lines @@
   // Verify that the client's ephemeral port is different.
   IPEndPoint new_address = client_->client()->client_address();
   EXPECT_EQ(old_address.address(), new_address.address());
   EXPECT_NE(old_address.port(), new_address.port());
 }
 
 TEST_P(EndToEndTest, DifferentFlowControlWindows) {
   // Client and server can set different initial flow control receive windows.
   // These are sent in CHLO/SHLO. Tests that these values are exchanged properly
   // in the crypto handshake.
-  const uint32 kClientStreamIFCW = 123456;
-  const uint32 kClientSessionIFCW = 234567;
+  const uint32_t kClientStreamIFCW = 123456;
+  const uint32_t kClientSessionIFCW = 234567;
   set_client_initial_stream_flow_control_receive_window(kClientStreamIFCW);
   set_client_initial_session_flow_control_receive_window(kClientSessionIFCW);
 
-  uint32 kServerStreamIFCW =
+  uint32_t kServerStreamIFCW =
       GetParam().auto_tune_flow_control_window ? 32 * 1024 : 654321;
-  uint32 kServerSessionIFCW =
+  uint32_t kServerSessionIFCW =
       GetParam().auto_tune_flow_control_window ? 48 * 1024 : 765432;
   set_server_initial_stream_flow_control_receive_window(kServerStreamIFCW);
   set_server_initial_session_flow_control_receive_window(kServerSessionIFCW);
 
   ASSERT_TRUE(Initialize());
 
   // Values are exchanged during crypto handshake, so wait for that to finish.
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(kClientSessionIFCW,
             session->config()->ReceivedInitialSessionFlowControlWindowBytes());
   EXPECT_EQ(kClientSessionIFCW, QuicFlowControllerPeer::SendWindowOffset(
                                     session->flow_controller()));
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, HeadersAndCryptoStreamsNoConnectionFlowControl) {
   // The special headers and crypto streams should be subject to per-stream flow
   // control limits, but should not be subject to connection level flow control.
-  const uint32 kStreamIFCW =
+  const uint32_t kStreamIFCW =
       GetParam().auto_tune_flow_control_window ? 32 * 1024 : 123456;
-  const uint32 kSessionIFCW =
+  const uint32_t kSessionIFCW =
       GetParam().auto_tune_flow_control_window ? 48 * 1024 : 234567;
   set_client_initial_stream_flow_control_receive_window(kStreamIFCW);
   set_client_initial_session_flow_control_receive_window(kSessionIFCW);
   set_server_initial_stream_flow_control_receive_window(kStreamIFCW);
   set_server_initial_session_flow_control_receive_window(kSessionIFCW);
 
   ASSERT_TRUE(Initialize());
 
   // Wait for crypto handshake to finish. This should have contributed to the
   // crypto stream flow control window, but not affected the session flow
@@ skipping 406 matching lines @@
   // locally_close_streams_highest_offset_ (which will never be deleted).
   // To set up the test condition, the server must do the following in order:
   // start sending the response and call CloseReadSide
   // receive the FIN of the request
   // send the FIN of the response
 
   string response_body;
   // The response body must be larger than the flow control window so the server
   // must receive a window update from the client before it can finish sending
   // it.
-  uint32 response_body_size =
+  uint32_t response_body_size =
       2 * client_config_.GetInitialStreamFlowControlWindowToSend();
   GenerateBody(&response_body, response_body_size);
 
   StreamWithErrorFactory stream_factory(response_body);
   SetSpdyStreamFactory(&stream_factory);
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // A POST that gets an early error response, after the headers are received
   // and before the body is received, due to invalid content-length.
   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/garbage");
   // The body must be large enough that the FIN will be in a different packet
   // than the end of the headers, but short enough to not require a flow control
   // update.  This allows headers processing to trigger the error response
   // before the request FIN is processed but receive the request FIN before the
   // response is sent completely.
-  const uint32 kRequestBodySize = kMaxPacketSize + 10;
+  const uint32_t kRequestBodySize = kMaxPacketSize + 10;
   string request_body;
   GenerateBody(&request_body, kRequestBodySize);
   request.AddBody(request_body, false);
   // Set an invalid content-length, so the request will receive an early 500
   // response.  Must be done after AddBody, which also sets content-length.
   request.AddHeader("content-length", "-1");
   request.set_skip_message_validation(true);
 
   // Send the request.
   client_->SendMessage(request);
@@ skipping 13 matching lines @@
 
   // The stream is not waiting for the arrival of the peer's final offset.
   EXPECT_EQ(
       0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(server_session)
               .size());
 
   server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, LargePostEarlyResponse) {
-  const uint32 kWindowSize = 65536;
+  const uint32_t kWindowSize = 65536;
   set_client_initial_stream_flow_control_receive_window(kWindowSize);
   set_client_initial_session_flow_control_receive_window(kWindowSize);
   set_server_initial_stream_flow_control_receive_window(kWindowSize);
   set_server_initial_session_flow_control_receive_window(kWindowSize);
 
   ASSERT_TRUE(Initialize());
 
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   // POST to a URL that gets an early error response, after the headers are
   // received and before the body is received.
   HTTPMessage request(HttpConstants::HTTP_1_1, HttpConstants::POST, "/garbage");
-  const uint32 kBodySize = 2 * kWindowSize;
+  const uint32_t kBodySize = 2 * kWindowSize;
   // Invalid content-length so the request will receive an early 500 response.
   request.AddHeader("content-length", "-1");
   request.set_skip_message_validation(true);
   request.set_has_complete_message(false);
 
   // Tell the client to not close the stream if it receives an early response.
   client_->set_allow_bidirectional_data(true);
   // Send the headers.
   client_->SendMessage(request);
   // Receive the response and let the server close writing.
@@ skipping 50 matching lines @@
 
   EXPECT_EQ(kBody, client_->SendSynchronousRequest("/trailer_url"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   EXPECT_EQ(trailers, client_->response_trailers());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net