Switch to standard integer types in net/.

net/http/http_stream_parser_unittest.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/http/http_stream_parser.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 1017 matching lines @@
 TEST(HttpStreamParser, ReceivedBytesNormal) {
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   std::string body = "content";
   std::string response = headers + body;
 
   SimpleGetRunner get_runner;
   get_runner.AddRead(response);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
-  int64 headers_size = headers.size();
+  int64_t headers_size = headers.size();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int body_size = body.size();
   int read_lengths[] = {body_size, 0};
   get_runner.ReadBody(body_size, read_lengths);
-  int64 response_size = response.size();
+  int64_t response_size = response.size();
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
 }
 
 // Test that bytes that represent "next" response are not counted
 // as current response "received_bytes".
 TEST(HttpStreamParser, ReceivedBytesExcludesNextResponse) {
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length:  8\r\n\r\n";
   std::string body = "content8";
   std::string response = headers + body;
   std::string next_response = "HTTP/1.1 200 OK\r\n\r\nFOO";
   std::string data = response + next_response;
 
   SimpleGetRunner get_runner;
   get_runner.AddRead(data);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
   EXPECT_EQ(39, get_runner.parser()->received_bytes());
-  int64 headers_size = headers.size();
+  int64_t headers_size = headers.size();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int body_size = body.size();
   int read_lengths[] = {body_size, 0};
   get_runner.ReadBody(body_size, read_lengths);
-  int64 response_size = response.size();
+  int64_t response_size = response.size();
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
-  int64 next_response_size = next_response.size();
+  int64_t next_response_size = next_response.size();
   EXPECT_EQ(next_response_size, get_runner.read_buffer()->offset());
 }
 
 // Test that "received_bytes" calculation works fine when last read
 // contains more data than requested by user.
 // We send data in two reads:
 // 1) Headers + beginning of response
 // 2) remaining part of response + next response start
 // We setup user read buffer so it fully accepts the beginnig of response
 // body, but it is larger that remaining part of body.
 TEST(HttpStreamParser, ReceivedBytesMultiReadExcludesNextResponse) {
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 36\r\n\r\n";
-  int64 user_buf_len = 32;
+  int64_t user_buf_len = 32;
   std::string body_start = std::string(user_buf_len, '#');
   int body_start_size = body_start.size();
   EXPECT_EQ(user_buf_len, body_start_size);
   std::string response_start = headers + body_start;
   std::string body_end = "abcd";
   std::string next_response = "HTTP/1.1 200 OK\r\n\r\nFOO";
   std::string response_end = body_end + next_response;
 
   SimpleGetRunner get_runner;
   get_runner.AddRead(response_start);
   get_runner.AddRead(response_end);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
-  int64 headers_size = headers.size();
+  int64_t headers_size = headers.size();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int body_end_size = body_end.size();
   int read_lengths[] = {body_start_size, body_end_size, 0};
   get_runner.ReadBody(body_start_size, read_lengths);
-  int64 response_size = response_start.size() + body_end_size;
+  int64_t response_size = response_start.size() + body_end_size;
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
-  int64 next_response_size = next_response.size();
+  int64_t next_response_size = next_response.size();
   EXPECT_EQ(next_response_size, get_runner.read_buffer()->offset());
 }
 
 // Test that "received_bytes" calculation works fine when there is no
 // network activity at all; that is when all data is read from read buffer.
 // In this case read buffer contains two responses. We expect that only
 // bytes that correspond to the first one are taken into account.
 TEST(HttpStreamParser, ReceivedBytesFromReadBufExcludesNextResponse) {
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
   std::string body = "content";
   std::string response = headers + body;
   std::string next_response = "HTTP/1.1 200 OK\r\n\r\nFOO";
   std::string data = response + next_response;
 
   SimpleGetRunner get_runner;
   get_runner.AddInitialData(data);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
-  int64 headers_size = headers.size();
+  int64_t headers_size = headers.size();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int body_size = body.size();
   int read_lengths[] = {body_size, 0};
   get_runner.ReadBody(body_size, read_lengths);
-  int64 response_size = response.size();
+  int64_t response_size = response.size();
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
-  int64 next_response_size = next_response.size();
+  int64_t next_response_size = next_response.size();
   EXPECT_EQ(next_response_size, get_runner.read_buffer()->offset());
 }
 
 // Test calculating "received_bytes" when part of request has been already
 // loaded and placed to read buffer by previous stream parser.
 TEST(HttpStreamParser, ReceivedBytesUseReadBuf) {
   std::string buffer = "HTTP/1.1 200 OK\r\n";
   std::string remaining_headers = "Content-Length: 7\r\n\r\n";
-  int64 headers_size = buffer.size() + remaining_headers.size();
+  int64_t headers_size = buffer.size() + remaining_headers.size();
   std::string body = "content";
   std::string response = remaining_headers + body;
 
   SimpleGetRunner get_runner;
   get_runner.AddInitialData(buffer);
   get_runner.AddRead(response);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int body_size = body.size();
@@ skipping 14 matching lines @@
       "0\r\n\r\n";
   std::string next_response = "foo bar\r\n";
   std::string data = response + next_response;
 
   SimpleGetRunner get_runner;
   get_runner.AddInitialData(data);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
   int read_lengths[] = {4, 3, 6, 2, 6, 0};
   get_runner.ReadBody(7, read_lengths);
-  int64 response_size = response.size();
+  int64_t response_size = response.size();
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
-  int64 next_response_size = next_response.size();
+  int64_t next_response_size = next_response.size();
   EXPECT_EQ(next_response_size, get_runner.read_buffer()->offset());
 }
 
 // Test that data transfered in multiple reads is correctly processed.
 // We feed data into 4-bytes reads. Also we set length of read
 // buffer to 5-bytes to test all possible buffer misaligments.
 TEST(HttpStreamParser, ReceivedBytesMultipleReads) {
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 33\r\n\r\n";
   std::string body = "foo bar baz\r\n"
       "sputnik mir babushka";
   std::string response = headers + body;
 
   size_t receive_length = 4;
   std::vector<std::string> blocks;
   for (size_t i = 0; i < response.size(); i += receive_length) {
     size_t length = std::min(receive_length, response.size() - i);
     blocks.push_back(response.substr(i, length));
   }
 
   SimpleGetRunner get_runner;
   for (std::vector<std::string>::size_type i = 0; i < blocks.size(); ++i)
     get_runner.AddRead(blocks[i]);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
-  int64 headers_size = headers.size();
+  int64_t headers_size = headers.size();
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
   int read_lengths[] = {1, 4, 4, 4, 4, 4, 4, 4, 4, 0};
   get_runner.ReadBody(receive_length + 1, read_lengths);
-  int64 response_size = response.size();
+  int64_t response_size = response.size();
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
 }
 
 // Test that "continue" HTTP header is counted as "received_bytes".
 TEST(HttpStreamParser, ReceivedBytesIncludesContinueHeader) {
   std::string status100 = "HTTP/1.1 100 OK\r\n\r\n";
   std::string headers = "HTTP/1.1 200 OK\r\n"
       "Content-Length: 7\r\n\r\n";
-  int64 headers_size = status100.size() + headers.size();
+  int64_t headers_size = status100.size() + headers.size();
   std::string body = "content";
   std::string response = headers + body;
 
   SimpleGetRunner get_runner;
   get_runner.AddRead(status100);
   get_runner.AddRead(response);
   get_runner.SetupParserAndSendRequest();
   get_runner.ReadHeaders();
   EXPECT_EQ(100, get_runner.response_info()->headers->response_code());
-  int64 status100_size = status100.size();
+  int64_t status100_size = status100.size();
   EXPECT_EQ(status100_size, get_runner.parser()->received_bytes());
   get_runner.ReadHeaders();
   EXPECT_EQ(200, get_runner.response_info()->headers->response_code());
   EXPECT_EQ(headers_size, get_runner.parser()->received_bytes());
-  int64 response_size = headers_size + body.size();
+  int64_t response_size = headers_size + body.size();
   int body_size = body.size();
   int read_lengths[] = {body_size, 0};
   get_runner.ReadBody(body_size, read_lengths);
   EXPECT_EQ(response_size, get_runner.parser()->received_bytes());
 }
 
 // Test that an HttpStreamParser can be read from after it's received headers
 // and data structures owned by its owner have been deleted.  This happens
 // when a ResponseBodyDrainer is used.
 TEST(HttpStreamParser, ReadAfterUnownedObjectsDestroyed) {
@@ skipping 40 matching lines @@
   ASSERT_EQ(kBodySize, parser.ReadResponseBody(
       body_buffer.get(), kBodySize, callback.callback()));
 
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)), parser.sent_bytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)), parser.received_bytes());
 }
 
 }  // namespace
 
 }  // namespace net