Use the exact-width integer types defined in <stdint.h> rather than

net/base/elements_upload_data_stream_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/base/elements_upload_data_stream.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 50 matching lines @@
       : content_length_(content_length),
         bytes_remaining_(content_length),
         is_in_memory_(is_in_memory),
         init_result_(OK),
         read_result_(OK) {}
 
   ~MockUploadElementReader() override {}
 
   // UploadElementReader overrides.
   MOCK_METHOD1(Init, int(const CompletionCallback& callback));
-  uint64 GetContentLength() const override { return content_length_; }
-  uint64 BytesRemaining() const override { return bytes_remaining_; }
+  uint64_t GetContentLength() const override { return content_length_; }
+  uint64_t BytesRemaining() const override { return bytes_remaining_; }
   bool IsInMemory() const override { return is_in_memory_; }
   MOCK_METHOD3(Read, int(IOBuffer* buf,
                          int buf_length,
                          const CompletionCallback& callback));
 
   // Sets expectation to return the specified result from Init() asynchronously.
   void SetAsyncInitExpectation(int result) {
     init_result_ = result;
     EXPECT_CALL(*this, Init(_))
         .WillOnce(DoAll(Invoke(this, &MockUploadElementReader::OnInit),
@@ skipping 123 matching lines @@
   EXPECT_EQ(kTestDataSize, stream->position());
   ASSERT_TRUE(stream->IsEOF());
 }
 
 TEST_F(ElementsUploadDataStreamTest, FileSmallerThanLength) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
-  const uint64 kFakeSize = kTestDataSize*2;
+  const uint64_t kFakeSize = kTestDataSize * 2;
 
   UploadFileElementReader::ScopedOverridingContentLengthForTests
       overriding_content_length(kFakeSize);
 
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   0,
                                   kuint64max,
                                   base::Time()));
 
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(element_readers_.Pass(), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kFakeSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
-  uint64 read_counter = 0;
+  uint64_t read_counter = 0;
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
   while (!stream->IsEOF()) {
     TestCompletionCallback read_callback;
     ASSERT_EQ(
         ERR_IO_PENDING,
         stream->Read(buf.get(), kTestBufferSize, read_callback.callback()));
     int bytes_read = read_callback.WaitForResult();
     ASSERT_LE(0, bytes_read);  // Not an error.
     read_counter += bytes_read;
     EXPECT_EQ(read_counter, stream->position());
@@ skipping 80 matching lines @@
             std::count(buf->data(), buf->data() + kTestBufferSize, 0));
 }
 
 TEST_F(ElementsUploadDataStreamTest, FileAndBytes) {
   base::FilePath temp_file_path;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir_.path(),
                                              &temp_file_path));
   ASSERT_EQ(static_cast<int>(kTestDataSize),
             base::WriteFile(temp_file_path, kTestData, kTestDataSize));
 
-  const uint64 kFileRangeOffset = 1;
-  const uint64 kFileRangeLength = 4;
+  const uint64_t kFileRangeOffset = 1;
+  const uint64_t kFileRangeLength = 4;
   element_readers_.push_back(
       new UploadFileElementReader(base::MessageLoopProxy::current().get(),
                                   temp_file_path,
                                   kFileRangeOffset,
                                   kFileRangeLength,
                                   base::Time()));
 
   element_readers_.push_back(new UploadBytesElementReader(
       kTestData, kTestDataSize));
 
-  const uint64 kStreamSize = kTestDataSize + kFileRangeLength;
+  const uint64_t kStreamSize = kTestDataSize + kFileRangeLength;
   TestCompletionCallback init_callback;
   scoped_ptr<UploadDataStream> stream(
       new ElementsUploadDataStream(element_readers_.Pass(), 0));
   ASSERT_EQ(ERR_IO_PENDING, stream->Init(init_callback.callback()));
   ASSERT_EQ(OK, init_callback.WaitForResult());
   EXPECT_FALSE(stream->IsInMemory());
   EXPECT_EQ(kStreamSize, stream->size());
   EXPECT_EQ(0U, stream->position());
   EXPECT_FALSE(stream->IsEOF());
   scoped_refptr<IOBuffer> buf = new IOBuffer(kTestBufferSize);
@@ skipping 451 matching lines @@
                 wrapped_buffer2.get(), buf2.size(), read_callback2.callback()));
   EXPECT_EQ(static_cast<int>(buf2.size()), read_callback2.WaitForResult());
   EXPECT_EQ(expected_data, buf2);
   EXPECT_TRUE(stream->IsEOF());
 
   // Make sure callbacks are not called for cancelled operations.
   EXPECT_FALSE(read_callback1.have_result());
 }
 
 }  // namespace net