Switch to standard integer types in net/.

net/quic/reliable_quic_stream_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 "net/quic/reliable_quic_stream.h"
 
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/quic_write_blocked_list.h"
@@ skipping 33 matching lines @@
 const bool kShouldNotProcessData = false;
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session, bool should_process_data)
       : ReliableQuicStream(id, session),
         should_process_data_(should_process_data) {}
 
   void OnDataAvailable() override {}
 
-  uint32 ProcessRawData(const char* data, uint32 data_len) {
+  uint32_t ProcessRawData(const char* data, uint32_t data_len) {
     EXPECT_NE(0u, data_len);
     DVLOG(1) << "ProcessData data_len: " << data_len;
     data_ += string(data, data_len);
     return should_process_data_ ? data_len : 0;
   }
 
   SpdyPriority Priority() const override { return net::kV3HighestPriority; }
 
   using ReliableQuicStream::WriteOrBufferData;
   using ReliableQuicStream::CloseWriteSide;
@@ skipping 57 matching lines @@
     EXPECT_CALL(*session_, SendRstStream(kTestStreamId, _, _))
         .Times(AnyNumber());
     write_blocked_list_ =
         QuicSessionPeer::GetWriteBlockedStreams(session_.get());
     write_blocked_list_->RegisterStream(kTestStreamId, kV3HighestPriority);
   }
 
   bool fin_sent() { return ReliableQuicStreamPeer::FinSent(stream_); }
   bool rst_sent() { return ReliableQuicStreamPeer::RstSent(stream_); }
 
-  void set_initial_flow_control_window_bytes(uint32 val) {
+  void set_initial_flow_control_window_bytes(uint32_t val) {
     initial_flow_control_window_bytes_ = val;
   }
 
   bool HasWriteBlockedStreams() {
     return write_blocked_list_->HasWriteBlockedCryptoOrHeadersStream() ||
            write_blocked_list_->HasWriteBlockedDataStreams();
   }
 
   QuicConsumedData CloseStreamOnWriteError(
       QuicStreamId id,
       QuicIOVector /*iov*/,
       QuicStreamOffset /*offset*/,
       bool /*fin*/,
       FecProtection /*fec_protection*/,
       QuicAckListenerInterface* /*ack_notifier_delegate*/) {
     session_->CloseStream(id);
     return QuicConsumedData(1, false);
   }
 
  protected:
   MockConnectionHelper helper_;
   MockConnection* connection_;
   scoped_ptr<MockQuicSpdySession> session_;
   TestStream* stream_;
   SpdyHeaderBlock headers_;
   QuicWriteBlockedList* write_blocked_list_;
-  uint32 initial_flow_control_window_bytes_;
+  uint32_t initial_flow_control_window_bytes_;
   QuicTime::Delta zero_;
   QuicVersionVector supported_versions_;
   const QuicStreamId kTestStreamId = 5u;
 };
 
 TEST_F(ReliableQuicStreamTest, WriteAllData) {
   Initialize(kShouldProcessData);
 
   size_t length = 1 + QuicPacketCreator::StreamFramePacketOverhead(
                           PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
@@ skipping 575 matching lines @@
   // Receive remaining data and FIN for the request.
   QuicStreamFrame frame2(stream_->id(), true, 0, StringPiece("End"));
   stream_->OnStreamFrame(frame2);
   EXPECT_TRUE(stream_->fin_received());
   EXPECT_TRUE(stream_->HasFinalReceivedByteOffset());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net