Switch to standard integer types in net/.

net/http/http_cache_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_cache.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "net/base/cache_type.h"
 #include "net/base/elements_upload_data_stream.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/ip_endpoint.h"
@@ skipping 460 matching lines @@
 // Verifies the response headers (|response|) match a partial content
 // response for the range starting at |start| and ending at |end|.
 void Verify206Response(const std::string& response, int start, int end) {
   std::string raw_headers(
       HttpUtil::AssembleRawHeaders(response.data(), response.size()));
   scoped_refptr<HttpResponseHeaders> headers(
       new HttpResponseHeaders(raw_headers));
 
   ASSERT_EQ(206, headers->response_code());
 
-  int64 range_start, range_end, object_size;
+  int64_t range_start, range_end, object_size;
   ASSERT_TRUE(
       headers->GetContentRange(&range_start, &range_end, &object_size));
-  int64 content_length = headers->GetContentLength();
+  int64_t content_length = headers->GetContentLength();
 
   int length = end - start + 1;
   ASSERT_EQ(length, content_length);
   ASSERT_EQ(start, range_start);
   ASSERT_EQ(end, range_end);
 }
 
 // Creates a truncated entry that can be resumed using byte ranges.
 void CreateTruncatedEntry(std::string raw_headers, MockHttpCache* cache) {
   // Create a disk cache entry that stores an incomplete resource.
@@ skipping 2409 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Hit) {
   MockHttpCache cache;
 
   // Test that we hit the cache for POST requests.
 
   MockTransaction transaction(kSimplePOST_Transaction);
 
-  const int64 kUploadId = 1;  // Just a dummy value.
+  const int64_t kUploadId = 1;  // Just a dummy value.
 
   std::vector<scoped_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       make_scoped_ptr(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers),
                                               kUploadId);
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
   // Populate the cache.
@@ skipping 12 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Test that we don't hit the cache for POST requests if there is a byte range.
 TEST(HttpCache, SimplePOST_WithRanges) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.request_headers = "Range: bytes = 0-4\r\n";
 
-  const int64 kUploadId = 1;  // Just a dummy value.
+  const int64_t kUploadId = 1;  // Just a dummy value.
 
   std::vector<scoped_ptr<UploadElementReader>> element_readers;
   element_readers.push_back(
       make_scoped_ptr(new UploadBytesElementReader("hello", 5)));
   ElementsUploadDataStream upload_data_stream(std::move(element_readers),
                                               kUploadId);
 
   MockHttpRequest request(transaction);
   request.upload_data_stream = &upload_data_stream;
 
@@ skipping 4760 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   EXPECT_TRUE(response_info.was_cached);
 
   // The new SSL state is reported.
   EXPECT_EQ(status2, response_info.ssl_info.connection_status);
   EXPECT_TRUE(cert2->Equals(response_info.ssl_info.cert.get()));
 }
 
 }  // namespace net