Switch to standard integer types in net/.

net/quic/quic_framer.h

 // 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.
 
 #ifndef NET_QUIC_QUIC_FRAMER_H_
 #define NET_QUIC_QUIC_FRAMER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "net/base/net_export.h"
 #include "net/quic/quic_protocol.h"
 
 namespace net {
 
 namespace test {
 class QuicFramerPeer;
 }  // namespace test
@@ skipping 327 matching lines @@
   void set_validate_flags(bool value) { validate_flags_ = value; }
 
   Perspective perspective() const { return perspective_; }
 
   static QuicPacketEntropyHash GetPacketEntropyHash(
       const QuicPacketHeader& header);
 
  private:
   friend class test::QuicFramerPeer;
 
-  typedef std::map<QuicPacketNumber, uint8> NackRangeMap;
+  typedef std::map<QuicPacketNumber, uint8_t> NackRangeMap;
 
   struct AckFrameInfo {
     AckFrameInfo();
     ~AckFrameInfo();
 
     // The maximum delta between ranges.
     QuicPacketNumber max_delta;
     // Nack ranges starting with start packet numbers and lengths.
     NackRangeMap nack_ranges;
   };
@@ skipping 22 matching lines @@
   // the current QuicDataReader.  Returns true on success, false on failure.
   bool ProcessAuthenticatedHeader(QuicDataReader* reader,
                                   QuicPacketHeader* header);
 
   bool ProcessPathId(QuicDataReader* reader, QuicPathId* path_id);
   bool ProcessPacketSequenceNumber(QuicDataReader* reader,
                                    QuicPacketNumberLength packet_number_length,
                                    QuicPacketNumber* packet_number);
   bool ProcessFrameData(QuicDataReader* reader, const QuicPacketHeader& header);
   bool ProcessStreamFrame(QuicDataReader* reader,
-                          uint8 frame_type,
+                          uint8_t frame_type,
                           QuicStreamFrame* frame);
   bool ProcessAckFrame(QuicDataReader* reader,
-                       uint8 frame_type,
+                       uint8_t frame_type,
                        QuicAckFrame* frame);
   bool ProcessTimestampsInAckFrame(QuicDataReader* reader, QuicAckFrame* frame);
   bool ProcessStopWaitingFrame(QuicDataReader* reader,
                                const QuicPacketHeader& public_header,
                                QuicStopWaitingFrame* stop_waiting);
   bool ProcessRstStreamFrame(QuicDataReader* reader, QuicRstStreamFrame* frame);
   bool ProcessConnectionCloseFrame(QuicDataReader* reader,
                                    QuicConnectionCloseFrame* frame);
   bool ProcessGoAwayFrame(QuicDataReader* reader, QuicGoAwayFrame* frame);
   bool ProcessWindowUpdateFrame(QuicDataReader* reader,
                                 QuicWindowUpdateFrame* frame);
   bool ProcessBlockedFrame(QuicDataReader* reader, QuicBlockedFrame* frame);
 
   bool DecryptPayload(QuicDataReader* encrypted_reader,
                       const QuicPacketHeader& header,
                       const QuicEncryptedPacket& packet,
                       char* decrypted_buffer,
                       size_t buffer_length,
                       size_t* decrypted_length);
 
   // Returns the full packet number from the truncated
   // wire format version and the last seen packet number.
   QuicPacketNumber CalculatePacketNumberFromWire(
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber packet_number) const;
 
   // Returns the QuicTime::Delta corresponding to the time from when the framer
   // was created.
-  const QuicTime::Delta CalculateTimestampFromWire(uint32 time_delta_us);
+  const QuicTime::Delta CalculateTimestampFromWire(uint32_t time_delta_us);
 
   // Computes the wire size in bytes of the |ack| frame, assuming no truncation.
   size_t GetAckFrameSize(const QuicAckFrame& ack,
                          QuicPacketNumberLength packet_number_length);
 
   // Computes the wire size in bytes of the payload of |frame|.
   size_t ComputeFrameLength(const QuicFrame& frame,
                             bool last_frame_in_packet,
                             InFecGroup is_in_fec_group,
                             QuicPacketNumberLength packet_number_length);
 
   static bool AppendPacketSequenceNumber(
       QuicPacketNumberLength packet_number_length,
       QuicPacketNumber packet_number,
       QuicDataWriter* writer);
 
-  static uint8 GetSequenceNumberFlags(
+  static uint8_t GetSequenceNumberFlags(
       QuicPacketNumberLength packet_number_length);
 
   static AckFrameInfo GetAckFrameInfo(const QuicAckFrame& frame);
 
   // The Append* methods attempt to write the provided header or frame using the
   // |writer|, and return true if successful.
 
   // If header.public_header.version_flag is set, the version in the
   // packet will be set -- but it will be set from quic_version_ not
   // header.public_header.versions.
@@ skipping 69 matching lines @@
   // The time delta computed for the last timestamp frame. This is relative to
   // the creation_time.
   QuicTime::Delta last_timestamp_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicFramer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_QUIC_FRAMER_H_