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

net/websockets/websocket_basic_stream_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.
 //
 // Tests for WebSocketBasicStream. Note that we do not attempt to verify that
 // frame parsing itself functions correctly, as that is covered by the
 // WebSocketFrameParser tests.
 
 #include "net/websockets/websocket_basic_stream.h"
 
+#include <stdint.h>
 #include <string.h>  // for memcpy() and memset().
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/big_endian.h"
-#include "base/port.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 #define WEBSOCKET_BASIC_STREAM_TEST_DEFINE_CONSTANT(name, value) \
   const char k##name[] = value;                                  \
@@ skipping 237 matching lines @@
 
 TEST_F(WebSocketBasicStreamSocketTest, ConstructionWorks) {
   CreateNullStream();
 }
 
 TEST_F(WebSocketBasicStreamSocketSingleReadTest, SyncReadWorks) {
   CreateRead(MockRead(SYNCHRONOUS, kSampleFrame, kSampleFrameSize));
   int result = stream_->ReadFrames(&frames_, cb_.callback());
   EXPECT_EQ(OK, result);
   ASSERT_EQ(1U, frames_.size());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
   EXPECT_TRUE(frames_[0]->header.final);
 }
 
 TEST_F(WebSocketBasicStreamSocketSingleReadTest, AsyncReadWorks) {
   CreateRead(MockRead(ASYNC, kSampleFrame, kSampleFrameSize));
   int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
   ASSERT_EQ(1U, frames_.size());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
   // Don't repeat all the tests from SyncReadWorks; just enough to be sure the
   // frame was really read.
 }
 
 // ReadFrames will not return a frame whose header has not been wholly received.
 TEST_F(WebSocketBasicStreamSocketChunkedReadTest, HeaderFragmentedSync) {
   CreateChunkedRead(
       SYNCHRONOUS, kSampleFrame, kSampleFrameSize, 1, 2, LAST_FRAME_BIG);
   int result = stream_->ReadFrames(&frames_, cb_.callback());
   EXPECT_EQ(OK, result);
   ASSERT_EQ(1U, frames_.size());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // The same behaviour applies to asynchronous reads.
 TEST_F(WebSocketBasicStreamSocketChunkedReadTest, HeaderFragmentedAsync) {
   CreateChunkedRead(
       ASYNC, kSampleFrame, kSampleFrameSize, 1, 2, LAST_FRAME_BIG);
   int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
   ASSERT_EQ(1U, frames_.size());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // If it receives an incomplete header in a synchronous call, then has to wait
 // for the rest of the frame, ReadFrames will return ERR_IO_PENDING.
 TEST_F(WebSocketBasicStreamSocketTest, HeaderFragmentedSyncAsync) {
   MockRead reads[] = {MockRead(SYNCHRONOUS, kSampleFrame, 1),
                       MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1)};
   CreateReadOnly(reads);
   int result = stream_->ReadFrames(&frames_, cb_.callback());
   ASSERT_EQ(ERR_IO_PENDING, result);
   EXPECT_EQ(OK, cb_.WaitForResult());
   ASSERT_EQ(1U, frames_.size());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // An extended header should also return ERR_IO_PENDING if it is not completely
 // received.
 TEST_F(WebSocketBasicStreamSocketTest, FragmentedLargeHeader) {
   MockRead reads[] = {
       MockRead(SYNCHRONOUS, kPartialLargeFrame, kLargeFrameHeaderSize - 1),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING)};
   CreateReadOnly(reads);
   EXPECT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
@@ skipping 299 matching lines @@
 
 // If there was a frame read at the same time as the response headers (and the
 // handshake succeeded), then we should parse it.
 TEST_F(WebSocketBasicStreamSocketTest, HttpReadBufferIsUsed) {
   SetHttpReadBuffer(kSampleFrame, kSampleFrameSize);
   CreateNullStream();
 
   EXPECT_EQ(OK, stream_->ReadFrames(&frames_, cb_.callback()));
   ASSERT_EQ(1U, frames_.size());
   ASSERT_TRUE(frames_[0]->data.get());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
 }
 
 // Check that a frame whose header partially arrived at the end of the response
 // headers works correctly.
 TEST_F(WebSocketBasicStreamSocketSingleReadTest,
        PartialFrameHeaderInHttpResponse) {
   SetHttpReadBuffer(kSampleFrame, 1);
   CreateRead(MockRead(ASYNC, kSampleFrame + 1, kSampleFrameSize - 1));
 
   ASSERT_EQ(ERR_IO_PENDING, stream_->ReadFrames(&frames_, cb_.callback()));
   EXPECT_EQ(OK, cb_.WaitForResult());
   ASSERT_EQ(1U, frames_.size());
   ASSERT_TRUE(frames_[0]->data.get());
-  EXPECT_EQ(GG_UINT64_C(6), frames_[0]->header.payload_length);
+  EXPECT_EQ(UINT64_C(6), frames_[0]->header.payload_length);
   EXPECT_EQ(WebSocketFrameHeader::kOpCodeText, frames_[0]->header.opcode);
 }
 
 // Check that a control frame which partially arrives at the end of the response
 // headers works correctly.
 TEST_F(WebSocketBasicStreamSocketSingleReadTest,
        PartialControlFrameInHttpResponse) {
   const size_t kPartialFrameBytes = 3;
   SetHttpReadBuffer(kCloseFrame, kPartialFrameBytes);
   CreateRead(MockRead(ASYNC,
@@ skipping 268 matching lines @@
 
 TEST_F(WebSocketBasicStreamSocketTest, GetSubProtocolWorks) {
   sub_protocol_ = "cyberchat";
   CreateNullStream();
 
   EXPECT_EQ("cyberchat", stream_->GetSubProtocol());
 }
 
 }  // namespace
 }  // namespace net