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

net/websockets/websocket_frame_parser_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_parser.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_vector.h"
 #include "net/base/io_buffer.h"
 #include "net/websockets/websocket_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 const char kHello[] = "Hello, world!";
-const uint64 kHelloLength = arraysize(kHello) - 1;
+const uint64_t kHelloLength = arraysize(kHello) - 1;
 const char kHelloFrame[] = "\x81\x0DHello, world!";
-const uint64 kHelloFrameLength = arraysize(kHelloFrame) - 1;
+const uint64_t kHelloFrameLength = arraysize(kHelloFrame) - 1;
 const char kMaskedHelloFrame[] =
     "\x81\x8D\xDE\xAD\xBE\xEF"
     "\x96\xC8\xD2\x83\xB1\x81\x9E\x98\xB1\xDF\xD2\x8B\xFF";
-const uint64 kMaskedHelloFrameLength = arraysize(kMaskedHelloFrame) - 1;
+const uint64_t kMaskedHelloFrameLength = arraysize(kMaskedHelloFrame) - 1;
 
 struct FrameHeaderTestCase {
   const char* frame_header;
   size_t frame_header_length;
-  uint64 frame_length;
+  uint64_t frame_length;
   WebSocketError error_code;
 };
 
 const FrameHeaderTestCase kFrameHeaderTests[] = {
   { "\x81\x00", 2, UINT64_C(0), kWebSocketNormalClosure },
   { "\x81\x7D", 2, UINT64_C(125), kWebSocketNormalClosure },
   { "\x81\x7E\x00\x7E", 4, UINT64_C(126), kWebSocketNormalClosure },
   { "\x81\x7E\xFF\xFF", 4, UINT64_C(0xFFFF), kWebSocketNormalClosure },
   { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, UINT64_C(0x10000),
     kWebSocketNormalClosure },
@@ skipping 99 matching lines @@
   EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error());
   ASSERT_EQ(static_cast<size_t>(kNumInputs), frames.size());
 
   for (int i = 0; i < kNumInputs; ++i) {
     WebSocketFrameChunk* frame = frames[i];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     EXPECT_TRUE(frame->final_chunk);
     ASSERT_EQ(kInputs[i].expected_payload_length,
-              static_cast<uint64>(frame->data->size()));
+              static_cast<uint64_t>(frame->data->size()));
     EXPECT_TRUE(std::equal(
         kInputs[i].expected_payload,
         kInputs[i].expected_payload + kInputs[i].expected_payload_length,
         frame->data->data()));
 
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
@@ skipping 57 matching lines @@
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
     if (expected2.size() == 0) {
       EXPECT_EQ(NULL, frame2->data.get());
     } else {
-      ASSERT_EQ(expected2.size(), static_cast<uint64>(frame2->data->size()));
+      ASSERT_EQ(expected2.size(), static_cast<uint64_t>(frame2->data->size()));
       EXPECT_TRUE(
           std::equal(expected2.begin(), expected2.end(), frame2->data->data()));
     }
     const WebSocketFrameHeader* header2 = frame2->header.get();
     EXPECT_TRUE(header2 == NULL);
   }
 }
 
 TEST(WebSocketFrameParserTest, DecodePartialMaskedFrame) {
   static const size_t kFrameHeaderSize = 6;
@@ skipping 16 matching lines @@
     if (frames1.size() != 1u)
       continue;
     WebSocketFrameChunk* frame1 = frames1[0];
     EXPECT_TRUE(frame1 != NULL);
     if (!frame1)
       continue;
     EXPECT_FALSE(frame1->final_chunk);
     if (expected1.size() == 0) {
       EXPECT_EQ(NULL, frame1->data.get());
     } else {
-      ASSERT_EQ(expected1.size(), static_cast<uint64>(frame1->data->size()));
+      ASSERT_EQ(expected1.size(), static_cast<uint64_t>(frame1->data->size()));
       EXPECT_TRUE(
           std::equal(expected1.begin(), expected1.end(), frame1->data->data()));
     }
     const WebSocketFrameHeader* header1 = frame1->header.get();
     EXPECT_TRUE(header1 != NULL);
     if (!header1)
       continue;
     EXPECT_TRUE(header1->final);
     EXPECT_FALSE(header1->reserved1);
     EXPECT_FALSE(header1->reserved2);
     EXPECT_FALSE(header1->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header1->opcode);
     EXPECT_TRUE(header1->masked);
     EXPECT_EQ(kHelloLength, header1->payload_length);
 
     ScopedVector<WebSocketFrameChunk> frames2;
     EXPECT_TRUE(parser.Decode(&input2.front(), input2.size(), &frames2));
     EXPECT_EQ(kWebSocketNormalClosure, parser.websocket_error());
     EXPECT_EQ(1u, frames2.size());
     if (frames2.size() != 1u)
       continue;
     WebSocketFrameChunk* frame2 = frames2[0];
     EXPECT_TRUE(frame2 != NULL);
     if (!frame2)
       continue;
     EXPECT_TRUE(frame2->final_chunk);
     if (expected2.size() == 0) {
       EXPECT_EQ(NULL, frame2->data.get());
     } else {
-      ASSERT_EQ(expected2.size(), static_cast<uint64>(frame2->data->size()));
+      ASSERT_EQ(expected2.size(), static_cast<uint64_t>(frame2->data->size()));
       EXPECT_TRUE(
           std::equal(expected2.begin(), expected2.end(), frame2->data->data()));
     }
     const WebSocketFrameHeader* header2 = frame2->header.get();
     EXPECT_TRUE(header2 == NULL);
   }
 }
 
 TEST(WebSocketFrameParserTest, DecodeFramesOfVariousLengths) {
   for (int i = 0; i < kNumFrameHeaderTests; ++i) {
     const char* frame_header = kFrameHeaderTests[i].frame_header;
     size_t frame_header_length = kFrameHeaderTests[i].frame_header_length;
-    uint64 frame_length = kFrameHeaderTests[i].frame_length;
+    uint64_t frame_length = kFrameHeaderTests[i].frame_length;
 
     std::vector<char> input(frame_header, frame_header + frame_header_length);
     // Limit the payload size not to flood the console on failure.
-    static const uint64 kMaxPayloadSize = 200;
-    uint64 input_payload_size = std::min(frame_length, kMaxPayloadSize);
+    static const uint64_t kMaxPayloadSize = 200;
+    uint64_t input_payload_size = std::min(frame_length, kMaxPayloadSize);
     input.insert(input.end(), input_payload_size, 'a');
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     EXPECT_EQ(kFrameHeaderTests[i].error_code == kWebSocketNormalClosure,
               parser.Decode(&input.front(), input.size(), &frames));
     EXPECT_EQ(kFrameHeaderTests[i].error_code, parser.websocket_error());
     if (kFrameHeaderTests[i].error_code != kWebSocketNormalClosure) {
       EXPECT_EQ(0u, frames.size());
     } else {
       EXPECT_EQ(1u, frames.size());
     }
     if (frames.size() != 1u)
       continue;
     WebSocketFrameChunk* frame = frames[0];
     EXPECT_TRUE(frame != NULL);
     if (!frame)
       continue;
     if (frame_length == input_payload_size) {
       EXPECT_TRUE(frame->final_chunk);
     } else {
       EXPECT_FALSE(frame->final_chunk);
     }
     std::vector<char> expected_payload(input_payload_size, 'a');
     if (expected_payload.size() == 0) {
       EXPECT_EQ(NULL, frame->data.get());
     } else {
       ASSERT_EQ(expected_payload.size(),
-                static_cast<uint64>(frame->data->size()));
+                static_cast<uint64_t>(frame->data->size()));
       EXPECT_TRUE(std::equal(expected_payload.begin(),
                              expected_payload.end(),
                              frame->data->data()));
     }
     const WebSocketFrameHeader* header = frame->header.get();
     EXPECT_TRUE(header != NULL);
     if (!header)
       continue;
     EXPECT_TRUE(header->final);
     EXPECT_FALSE(header->reserved1);
     EXPECT_FALSE(header->reserved2);
     EXPECT_FALSE(header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(frame_length, header->payload_length);
   }
 }
 
 TEST(WebSocketFrameParserTest, DecodePartialHeader) {
   for (int i = 0; i < kNumFrameHeaderTests; ++i) {
     const char* frame_header = kFrameHeaderTests[i].frame_header;
     size_t frame_header_length = kFrameHeaderTests[i].frame_header_length;
-    uint64 frame_length = kFrameHeaderTests[i].frame_length;
+    uint64_t frame_length = kFrameHeaderTests[i].frame_length;
 
     WebSocketFrameParser parser;
 
     ScopedVector<WebSocketFrameChunk> frames;
     // Feed each byte to the parser to see if the parser behaves correctly
     // when it receives partial frame header.
     size_t last_byte_offset = frame_header_length - 1;
     for (size_t j = 0; j < frame_header_length; ++j) {
       bool failed =
           kFrameHeaderTests[i].error_code != kWebSocketNormalClosure &&
@@ skipping 187 matching lines @@
     EXPECT_EQ(reserved3, header->reserved3);
     EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, header->opcode);
     EXPECT_FALSE(header->masked);
     EXPECT_EQ(0u, header->payload_length);
   }
 }
 
 }  // Unnamed namespace
 
 }  // namespace net