net: Remove the remaining use of GG_(U)INTn_C macros.

net/quic/quic_framer.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/quic_framer.h"
 
+#include <stdint.h>
+
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_socket_address_coder.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
 using std::map;
 using std::max;
 using std::min;
 using std::numeric_limits;
 using std::string;
 
 namespace net {
 
 namespace {
 
 // Mask to select the lowest 48 bits of a sequence number.
 const QuicPacketSequenceNumber k6ByteSequenceNumberMask =
-    GG_UINT64_C(0x0000FFFFFFFFFFFF);
+    UINT64_C(0x0000FFFFFFFFFFFF);
 const QuicPacketSequenceNumber k4ByteSequenceNumberMask =
-    GG_UINT64_C(0x00000000FFFFFFFF);
+    UINT64_C(0x00000000FFFFFFFF);
 const QuicPacketSequenceNumber k2ByteSequenceNumberMask =
-    GG_UINT64_C(0x000000000000FFFF);
+    UINT64_C(0x000000000000FFFF);
 const QuicPacketSequenceNumber k1ByteSequenceNumberMask =
-    GG_UINT64_C(0x00000000000000FF);
+    UINT64_C(0x00000000000000FF);
 
-const QuicConnectionId k1ByteConnectionIdMask = GG_UINT64_C(0x00000000000000FF);
-const QuicConnectionId k4ByteConnectionIdMask = GG_UINT64_C(0x00000000FFFFFFFF);
+const QuicConnectionId k1ByteConnectionIdMask = UINT64_C(0x00000000000000FF);
+const QuicConnectionId k4ByteConnectionIdMask = UINT64_C(0x00000000FFFFFFFF);
 
 // Number of bits the sequence number length bits are shifted from the right
 // edge of the public header.
 const uint8 kPublicHeaderSequenceNumberShift = 4;
 
 // New Frame Types, QUIC v. >= 10:
 // There are two interpretations for the Frame Type byte in the QUIC protocol,
 // resulting in two Frame Types: Special Frame Types and Regular Frame Types.
 //
 // Regular Frame Types use the Frame Type byte simply. Currently defined
@@ skipping 749 matching lines @@
 
 const QuicTime::Delta QuicFramer::CalculateTimestampFromWire(
     uint32 time_delta_us) {
   // The new time_delta might have wrapped to the next epoch, or it
   // might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch. Select the time closest to the previous
   // time.
   //
   // epoch_delta is the delta between epochs. A delta is 4 bytes of
   // microseconds.
-  const uint64 epoch_delta = GG_UINT64_C(1) << 32;
+  const uint64 epoch_delta = UINT64_C(1) << 32;
   uint64 epoch = last_timestamp_.ToMicroseconds() & ~(epoch_delta - 1);
   // Wrapping is safe here because a wrapped value will not be ClosestTo below.
   uint64 prev_epoch = epoch - epoch_delta;
   uint64 next_epoch = epoch + epoch_delta;
 
   uint64 time = ClosestTo(last_timestamp_.ToMicroseconds(),
                           epoch + time_delta_us,
                           ClosestTo(last_timestamp_.ToMicroseconds(),
                                     prev_epoch + time_delta_us,
                                     next_epoch + time_delta_us));
 
   return QuicTime::Delta::FromMicroseconds(time);
 }
 
 QuicPacketSequenceNumber QuicFramer::CalculatePacketSequenceNumberFromWire(
     QuicSequenceNumberLength sequence_number_length,
     QuicPacketSequenceNumber packet_sequence_number) const {
   // The new sequence number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the sequence number closest to the
   // next expected sequence number, the previous sequence number plus 1.
 
   // epoch_delta is the delta between epochs the sequence number was serialized
   // with, so the correct value is likely the same epoch as the last sequence
   // number or an adjacent epoch.
   const QuicPacketSequenceNumber epoch_delta =
-      GG_UINT64_C(1) << (8 * sequence_number_length);
+      UINT64_C(1) << (8 * sequence_number_length);
   QuicPacketSequenceNumber next_sequence_number = last_sequence_number_ + 1;
   QuicPacketSequenceNumber epoch = last_sequence_number_ & ~(epoch_delta - 1);
   QuicPacketSequenceNumber prev_epoch = epoch - epoch_delta;
   QuicPacketSequenceNumber next_epoch = epoch + epoch_delta;
 
   return ClosestTo(next_sequence_number,
                    epoch + packet_sequence_number,
                    ClosestTo(next_sequence_number,
                              prev_epoch + packet_sequence_number,
                              next_epoch + packet_sequence_number));
@@ skipping 97 matching lines @@
 }
 
 // static
 QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) {
   if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_1BYTE_SEQUENCE_NUMBER;
   } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_2BYTE_SEQUENCE_NUMBER;
   } else if (sequence_number <
-             GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
+             UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_4BYTE_SEQUENCE_NUMBER;
   } else {
     return PACKET_6BYTE_SEQUENCE_NUMBER;
   }
 }
 
 // static
 uint8 QuicFramer::GetSequenceNumberFlags(
     QuicSequenceNumberLength sequence_number_length) {
   switch (sequence_number_length) {
@@ skipping 1124 matching lines @@
   if (delta_from_largest_observed > numeric_limits<uint8>::max()) {
     return false;
   }
 
   if (!writer->WriteUInt8(
     delta_from_largest_observed & k1ByteSequenceNumberMask)) {
     return false;
   }
 
   // Use the lowest 4 bytes of the time delta from the creation_time_.
-  const uint64 time_epoch_delta_us = GG_UINT64_C(1) << 32;
+  const uint64 time_epoch_delta_us = UINT64_C(1) << 32;
   uint32 time_delta_us =
       static_cast<uint32>(it->second.Subtract(creation_time_).ToMicroseconds()
                           & (time_epoch_delta_us - 1));
   if (!writer->WriteBytes(&time_delta_us, sizeof(time_delta_us))) {
     return false;
   }
 
   QuicTime prev_time = it->second;
 
   for (++it; it != frame.received_packet_times.end(); ++it) {
@@ skipping 126 matching lines @@
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(nullptr);
   return false;
 }
 
 }  // namespace net