Switch to standard integer types in net/.

net/quic/stream_sequencer_buffer_test.cc

 // Copyright (c) 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 "net/quic/stream_sequencer_buffer.h"
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "net/quic/test_tools/mock_clock.h"
@@ skipping 745 matching lines @@
 
   void SetUp() override {
     // Test against a larger capacity then above tests. Also make sure the last
     // block is partially available to use.
     max_capacity_bytes_ = 6.25 * kBlockSizeBytes;
     // Stream to be buffered should be larger than the capacity to test wrap
     // around.
     bytes_to_buffer_ = 2 * max_capacity_bytes_;
     Initialize();
 
-    uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max());
+    uint32_t seed = base::RandInt(0, std::numeric_limits<int32_t>::max());
     LOG(INFO) << "RandomWriteAndProcessInPlace test seed is " << seed;
     rng_.set_seed(seed);
   }
 
   // Create an out-of-order source stream with given size to populate
   // shuffled_buf_.
   void CreateSourceAndShuffle(size_t max_chunk_size_bytes) {
     max_chunk_size_bytes_ = max_chunk_size_bytes;
     std::unique_ptr<OffsetSizePair[]> chopped_stream(
         new OffsetSizePair[bytes_to_buffer_]);
@@ skipping 71 matching lines @@
   const size_t kNumReads = 2;
   // Since write and read operation have equal possibility to be called. Bytes
   // to be written into and read out of should roughly the same.
   const size_t kMaxWriteSize = kNumReads * kMaxReadSize;
   size_t iterations = 0;
 
   CreateSourceAndShuffle(kMaxWriteSize);
 
   while ((!shuffled_buf_.empty() || total_bytes_read_ < bytes_to_buffer_) &&
          iterations <= 2 * bytes_to_buffer_) {
-    uint8 next_action =
-        shuffled_buf_.empty() ? uint8{1} : rng_.RandUint64() % 2;
+    uint8_t next_action =
+        shuffled_buf_.empty() ? uint8_t{1} : rng_.RandUint64() % 2;
     DVLOG(1) << "iteration: " << iterations;
     switch (next_action) {
       case 0: {  // write
         WriteNextChunkToBuffer();
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
       case 1: {  // readv
         std::unique_ptr<char[][kMaxReadSize]> read_buf{
             new char[kNumReads][kMaxReadSize]};
@@ skipping 36 matching lines @@
   const size_t kMaxNumReads = 4;
   // Adjust write amount be roughly equal to that GetReadableRegions() can get.
   const size_t kMaxWriteSize = kMaxNumReads * kBlockSizeBytes;
   ASSERT_LE(kMaxWriteSize, max_capacity_bytes_);
   size_t iterations = 0;
 
   CreateSourceAndShuffle(kMaxWriteSize);
 
   while ((!shuffled_buf_.empty() || total_bytes_read_ < bytes_to_buffer_) &&
          iterations <= 2 * bytes_to_buffer_) {
-    uint8 next_action =
-        shuffled_buf_.empty() ? uint8{1} : rng_.RandUint64() % 2;
+    uint8_t next_action =
+        shuffled_buf_.empty() ? uint8_t{1} : rng_.RandUint64() % 2;
     DVLOG(1) << "iteration: " << iterations;
     switch (next_action) {
       case 0: {  // write
         WriteNextChunkToBuffer();
         ASSERT_TRUE(helper_->CheckBufferInvariants());
         break;
       }
       case 1: {  // GetReadableRegions and then MarkConsumed
         size_t num_read = rng_.RandUint64() % kMaxNumReads + 1;
         iovec dest_iov[kMaxNumReads];
@@ skipping 44 matching lines @@
   EXPECT_LE(bytes_to_buffer_, total_bytes_read_) << "iterations: "
                                                  << iterations;
   EXPECT_LE(bytes_to_buffer_, total_bytes_written_);
 }
 
 }  // anonymous namespace
 
 }  // namespace test
 
 }  // namespace net