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

net/websockets/websocket_frame_test.cc

 // Copyright 2013 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 <stdint.h>
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/aligned_memory.h"
 #include "net/base/net_errors.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 TEST(WebSocketFrameHeaderTest, FrameLengths) {
   struct TestCase {
     const char* frame_header;
     size_t frame_header_length;
-    uint64 frame_length;
+    uint64_t frame_length;
   };
   static const TestCase kTests[] = {
     { "\x81\x00", 2, UINT64_C(0) },
     { "\x81\x7D", 2, UINT64_C(125) },
     { "\x81\x7E\x00\x7E", 4, UINT64_C(126) },
     { "\x81\x7E\xFF\xFF", 4, UINT64_C(0xFFFF) },
     { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, UINT64_C(0x10000) },
     { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
       UINT64_C(0x7FFFFFFFFFFFFFFF) }
   };
@@ skipping 17 matching lines @@
 
 TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) {
   static const char kMaskingKey[] = "\xDE\xAD\xBE\xEF";
   static_assert(
       arraysize(kMaskingKey) - 1 == WebSocketFrameHeader::kMaskingKeyLength,
       "incorrect masking key size");
 
   struct TestCase {
     const char* frame_header;
     size_t frame_header_length;
-    uint64 frame_length;
+    uint64_t frame_length;
   };
   static const TestCase kTests[] = {
     { "\x81\x80\xDE\xAD\xBE\xEF", 6, UINT64_C(0) },
     { "\x81\xFD\xDE\xAD\xBE\xEF", 6, UINT64_C(125) },
     { "\x81\xFE\x00\x7E\xDE\xAD\xBE\xEF", 8, UINT64_C(126) },
     { "\x81\xFE\xFF\xFF\xDE\xAD\xBE\xEF", 8, UINT64_C(0xFFFF) },
     { "\x81\xFF\x00\x00\x00\x00\x00\x01\x00\x00\xDE\xAD\xBE\xEF", 14,
       UINT64_C(0x10000) },
     { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14,
       UINT64_C(0x7FFFFFFFFFFFFFFF) }
@@ skipping 99 matching lines @@
     std::vector<char> output(expected_output.size());
     EXPECT_EQ(static_cast<int>(expected_output.size()),
               WriteWebSocketFrameHeader(
                   header, NULL, &output.front(), output.size()));
     EXPECT_EQ(expected_output, output);
   }
 }
 
 TEST(WebSocketFrameHeaderTest, InsufficientBufferSize) {
   struct TestCase {
-    uint64 payload_length;
+    uint64_t payload_length;
     bool masked;
     size_t expected_header_size;
   };
   static const TestCase kTests[] = {
     { UINT64_C(0), false, 2u },
     { UINT64_C(125), false, 2u },
     { UINT64_C(126), false, 4u },
     { UINT64_C(0xFFFF), false, 4u },
     { UINT64_C(0x10000), false, 10u },
     { UINT64_C(0x7FFFFFFFFFFFFFFF), false, 10u },
@@ skipping 18 matching lines @@
     EXPECT_EQ(
         ERR_INVALID_ARGUMENT,
         WriteWebSocketFrameHeader(
             header, NULL, dummy_buffer, kTests[i].expected_header_size - 1));
   }
 }
 
 TEST(WebSocketFrameTest, MaskPayload) {
   struct TestCase {
     const char* masking_key;
-    uint64 frame_offset;
+    uint64_t frame_offset;
     const char* input;
     const char* output;
     size_t data_length;
   };
   static const TestCase kTests[] = {
     { "\xDE\xAD\xBE\xEF", 0, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 },
     { "\xDE\xAD\xBE\xEF", 1, "FooBar", "\xEB\xD1\x80\x9C\xCC\xCC", 6 },
     { "\xDE\xAD\xBE\xEF", 2, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 },
     { "\xDE\xAD\xBE\xEF", 3, "FooBar", "\xA9\xB1\xC2\xFC\x8E\xAC", 6 },
     { "\xDE\xAD\xBE\xEF", 4, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 },
@@ skipping 154 matching lines @@
   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xF));
 
   // Check that out-of-range opcodes return false
   EXPECT_FALSE(Frame::IsKnownControlOpCode(-1));
   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xFF));
 }
 
 }  // namespace
 
 }  // namespace net