net/websockets: Convert int types from basictypes.h to the ones from stdint.h

net/websockets/websocket_frame.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/websockets/websocket_frame.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 17 matching lines @@
 
 using PackedMaskType = uint32_t __attribute__((vector_size(16)));
 
 #else
 
 using PackedMaskType = size_t;
 
 #endif  // defined(COMPILER_GCC) && defined(ARCH_CPU_X86_FAMILY) &&
         // !defined(OS_NACL)
 
-const uint8 kFinalBit = 0x80;
-const uint8 kReserved1Bit = 0x40;
-const uint8 kReserved2Bit = 0x20;
-const uint8 kReserved3Bit = 0x10;
-const uint8 kOpCodeMask = 0xF;
-const uint8 kMaskBit = 0x80;
-const uint64 kMaxPayloadLengthWithoutExtendedLengthField = 125;
-const uint64 kPayloadLengthWithTwoByteExtendedLengthField = 126;
-const uint64 kPayloadLengthWithEightByteExtendedLengthField = 127;
+const uint8_t kFinalBit = 0x80;
+const uint8_t kReserved1Bit = 0x40;
+const uint8_t kReserved2Bit = 0x20;
+const uint8_t kReserved3Bit = 0x10;
+const uint8_t kOpCodeMask = 0xF;
+const uint8_t kMaskBit = 0x80;
+const uint64_t kMaxPayloadLengthWithoutExtendedLengthField = 125;
+const uint64_t kPayloadLengthWithTwoByteExtendedLengthField = 126;
+const uint64_t kPayloadLengthWithEightByteExtendedLengthField = 127;
 
 inline void MaskWebSocketFramePayloadByBytes(
     const WebSocketMaskingKey& masking_key,
     size_t masking_key_offset,
     char* const begin,
     char* const end) {
   for (char* masked = begin; masked != end; ++masked) {
     *masked ^= masking_key.key[masking_key_offset++];
     if (masking_key_offset == WebSocketFrameHeader::kMaskingKeyLength)
       masking_key_offset = 0;
@@ skipping 39 matching lines @@
   return (WebSocketFrameHeader::kBaseHeaderSize + extended_length_size +
           (header.masked ? WebSocketFrameHeader::kMaskingKeyLength : 0));
 }
 
 int WriteWebSocketFrameHeader(const WebSocketFrameHeader& header,
                               const WebSocketMaskingKey* masking_key,
                               char* buffer,
                               int buffer_size) {
   DCHECK((header.opcode & kOpCodeMask) == header.opcode)
       << "header.opcode must fit to kOpCodeMask.";
-  DCHECK(header.payload_length <= static_cast<uint64>(kint64max))
+  DCHECK(header.payload_length <= static_cast<uint64_t>(kint64max))
       << "WebSocket specification doesn't allow a frame longer than "
       << "kint64max (0x7FFFFFFFFFFFFFFF) bytes.";
   DCHECK_GE(buffer_size, 0);
 
   // WebSocket frame format is as follows:
   // - Common header (2 bytes)
   // - Optional extended payload length
   //   (2 or 8 bytes, present if actual payload length is more than 125 bytes)
   // - Optional masking key (4 bytes, present if MASK bit is on)
   // - Actual payload (XOR masked with masking key if MASK bit is on)
   //
   // This function constructs frame header (the first three in the list
   // above).
 
   int header_size = GetWebSocketFrameHeaderSize(header);
   if (header_size > buffer_size)
     return ERR_INVALID_ARGUMENT;
 
   int buffer_index = 0;
 
-  uint8 first_byte = 0u;
+  uint8_t first_byte = 0u;
   first_byte |= header.final ? kFinalBit : 0u;
   first_byte |= header.reserved1 ? kReserved1Bit : 0u;
   first_byte |= header.reserved2 ? kReserved2Bit : 0u;
   first_byte |= header.reserved3 ? kReserved3Bit : 0u;
   first_byte |= header.opcode & kOpCodeMask;
   buffer[buffer_index++] = first_byte;
 
   int extended_length_size = 0;
-  uint8 second_byte = 0u;
+  uint8_t second_byte = 0u;
   second_byte |= header.masked ? kMaskBit : 0u;
   if (header.payload_length <= kMaxPayloadLengthWithoutExtendedLengthField) {
     second_byte |= header.payload_length;
   } else if (header.payload_length <= kuint16max) {
     second_byte |= kPayloadLengthWithTwoByteExtendedLengthField;
     extended_length_size = 2;
   } else {
     second_byte |= kPayloadLengthWithEightByteExtendedLengthField;
     extended_length_size = 8;
   }
   buffer[buffer_index++] = second_byte;
 
   // Writes "extended payload length" field.
   if (extended_length_size == 2) {
-    uint16 payload_length_16 = static_cast<uint16>(header.payload_length);
+    uint16_t payload_length_16 = static_cast<uint16_t>(header.payload_length);
     base::WriteBigEndian(buffer + buffer_index, payload_length_16);
     buffer_index += sizeof(payload_length_16);
   } else if (extended_length_size == 8) {
     base::WriteBigEndian(buffer + buffer_index, header.payload_length);
     buffer_index += sizeof(header.payload_length);
   }
 
   // Writes "masking key" field, if needed.
   if (header.masked) {
     DCHECK(masking_key);
@@ skipping 12 matching lines @@
 WebSocketMaskingKey GenerateWebSocketMaskingKey() {
   // Masking keys should be generated from a cryptographically secure random
   // number generator, which means web application authors should not be able
   // to guess the next value of masking key.
   WebSocketMaskingKey masking_key;
   base::RandBytes(masking_key.key, WebSocketFrameHeader::kMaskingKeyLength);
   return masking_key;
 }
 
 void MaskWebSocketFramePayload(const WebSocketMaskingKey& masking_key,
-                               uint64 frame_offset,
+                               uint64_t frame_offset,
                                char* const data,
                                int data_size) {
   static const size_t kMaskingKeyLength =
       WebSocketFrameHeader::kMaskingKeyLength;
 
   DCHECK_GE(data_size, 0);
 
   // Most of the masking is done in chunks of sizeof(PackedMaskType), except for
   // the beginning and the end of the buffer which may be unaligned.
   // PackedMaskType must be a multiple of kMaskingKeyLength in size.
@@ skipping 51 matching lines @@
   }
 
   MaskWebSocketFramePayloadByBytes(
       masking_key,
       (frame_offset + (aligned_end - data)) % kMaskingKeyLength,
       aligned_end,
       end);
 }
 
 }  // namespace net