Switch to standard integer types in net/.

net/http/transport_security_state.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/http/transport_security_state.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/build_time.h"
@@ skipping 204 matching lines @@
       new_host[i + 1 + j] = static_cast<char>(tolower(new_host[i + 1 + j]));
     }
   }
 
   return new_host;
 }
 
 // BitReader is a class that allows a bytestring to be read bit-by-bit.
 class BitReader {
  public:
-  BitReader(const uint8* bytes, size_t num_bits)
+  BitReader(const uint8_t* bytes, size_t num_bits)
       : bytes_(bytes),
         num_bits_(num_bits),
         num_bytes_((num_bits + 7) / 8),
         current_byte_index_(0),
         num_bits_used_(8) {}
 
   // Next sets |*out| to the next bit from the input. It returns false if no
   // more bits are available or true otherwise.
   bool Next(bool* out) {
     if (num_bits_used_ == 8) {
       if (current_byte_index_ >= num_bytes_) {
         return false;
       }
       current_byte_ = bytes_[current_byte_index_++];
       num_bits_used_ = 0;
     }
 
     *out = 1 & (current_byte_ >> (7 - num_bits_used_));
     num_bits_used_++;
     return true;
   }
 
   // Read sets the |num_bits| least-significant bits of |*out| to the value of
   // the next |num_bits| bits from the input. It returns false if there are
   // insufficient bits in the input or true otherwise.
-  bool Read(unsigned num_bits, uint32* out) {
+  bool Read(unsigned num_bits, uint32_t* out) {
     DCHECK_LE(num_bits, 32u);
 
-    uint32 ret = 0;
+    uint32_t ret = 0;
     for (unsigned i = 0; i < num_bits; ++i) {
       bool bit;
       if (!Next(&bit)) {
         return false;
       }
-      ret |= static_cast<uint32>(bit) << (num_bits - 1 - i);
+      ret |= static_cast<uint32_t>(bit) << (num_bits - 1 - i);
     }
 
     *out = ret;
     return true;
   }
 
   // Unary sets |*out| to the result of decoding a unary value from the input.
   // It returns false if there were insufficient bits in the input and true
   // otherwise.
   bool Unary(size_t* out) {
@@ skipping 21 matching lines @@
     if (offset >= num_bits_) {
       return false;
     }
     current_byte_index_ = offset / 8;
     current_byte_ = bytes_[current_byte_index_++];
     num_bits_used_ = offset % 8;
     return true;
   }
 
  private:
-  const uint8* const bytes_;
+  const uint8_t* const bytes_;
   const size_t num_bits_;
   const size_t num_bytes_;
   // current_byte_index_ contains the current byte offset in |bytes_|.
   size_t current_byte_index_;
   // current_byte_ contains the current byte of the input.
-  uint8 current_byte_;
+  uint8_t current_byte_;
   // num_bits_used_ contains the number of bits of |current_byte_| that have
   // been read.
   unsigned num_bits_used_;
 };
 
 // HuffmanDecoder is a very simple Huffman reader. The input Huffman tree is
 // simply encoded as a series of two-byte structures. The first byte determines
 // the "0" pointer for that node and the second the "1" pointer. Each byte
 // either has the MSB set, in which case the bottom 7 bits are the value for
 // that position, or else the bottom seven bits contain the index of a node.
 //
 // The tree is decoded by walking rather than a table-driven approach.
 class HuffmanDecoder {
  public:
-  HuffmanDecoder(const uint8* tree, size_t tree_bytes)
+  HuffmanDecoder(const uint8_t* tree, size_t tree_bytes)
       : tree_(tree), tree_bytes_(tree_bytes) {}
 
   bool Decode(BitReader* reader, char* out) {
-    const uint8* current = &tree_[tree_bytes_ - 2];
+    const uint8_t* current = &tree_[tree_bytes_ - 2];
 
     for (;;) {
       bool bit;
       if (!reader->Next(&bit)) {
         return false;
       }
 
-      uint8 b = current[bit];
+      uint8_t b = current[bit];
       if (b & 0x80) {
         *out = static_cast<char>(b & 0x7f);
         return true;
       }
 
       unsigned offset = static_cast<unsigned>(b) * 2;
       DCHECK_LT(offset, tree_bytes_);
       if (offset >= tree_bytes_) {
         return false;
       }
 
       current = &tree_[offset];
     }
   }
 
  private:
-  const uint8* const tree_;
+  const uint8_t* const tree_;
   const size_t tree_bytes_;
 };
 
 // PreloadResult is the result of resolving a specific name in the preloaded
 // data.
 struct PreloadResult {
-  uint32 pinset_id;
-  uint32 domain_id;
+  uint32_t pinset_id;
+  uint32_t domain_id;
   // hostname_offset contains the number of bytes from the start of the given
   // hostname where the name of the matching entry starts.
   size_t hostname_offset;
   bool sts_include_subdomains;
   bool pkp_include_subdomains;
   bool force_https;
   bool has_pins;
   bool expect_ct;
-  uint32 expect_ct_report_uri_id;
+  uint32_t expect_ct_report_uri_id;
 };
 
 // DecodeHSTSPreloadRaw resolves |hostname| in the preloaded data. It returns
 // false on internal error and true otherwise. After a successful return,
 // |*out_found| is true iff a relevant entry has been found. If so, |*out|
 // contains the details.
 //
 // Don't call this function, call DecodeHSTSPreload, below.
 //
 // Although this code should be robust, it never processes attacker-controlled
@@ skipping 140 matching lines @@
       }
 
       // The entries in a dispatch table are in order thus we can tell if there
       // will be no match if the current character past the one that we want.
       if (hostname_offset == 0 || hostname[hostname_offset - 1] < c) {
         return true;
       }
 
       if (is_first_offset) {
         // The first offset is backwards from the current position.
-        uint32 jump_delta_bits;
-        uint32 jump_delta;
+        uint32_t jump_delta_bits;
+        uint32_t jump_delta;
         if (!reader.Read(5, &jump_delta_bits) ||
             !reader.Read(jump_delta_bits, &jump_delta)) {
           return false;
         }
 
         if (bit_offset < jump_delta) {
           return false;
         }
 
         current_offset = bit_offset - jump_delta;
         is_first_offset = false;
       } else {
         // Subsequent offsets are forward from the target of the first offset.
-        uint32 is_long_jump;
+        uint32_t is_long_jump;
         if (!reader.Read(1, &is_long_jump)) {
           return false;
         }
 
-        uint32 jump_delta;
+        uint32_t jump_delta;
         if (!is_long_jump) {
           if (!reader.Read(7, &jump_delta)) {
             return false;
           }
         } else {
-          uint32 jump_delta_bits;
+          uint32_t jump_delta_bits;
           if (!reader.Read(4, &jump_delta_bits) ||
               !reader.Read(jump_delta_bits + 8, &jump_delta)) {
             return false;
           }
         }
 
         current_offset += jump_delta;
         if (current_offset >= bit_offset) {
           return false;
         }
@@ skipping 730 matching lines @@
 TransportSecurityState::PKPStateIterator::PKPStateIterator(
     const TransportSecurityState& state)
     : iterator_(state.enabled_pkp_hosts_.begin()),
       end_(state.enabled_pkp_hosts_.end()) {
 }
 
 TransportSecurityState::PKPStateIterator::~PKPStateIterator() {
 }
 
 }  // namespace