Switch to standard integer types in content/browser/.

content/browser/fileapi/blob_reader_unittest.cc

 // Copyright 2015 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 "storage/browser/blob/blob_reader.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.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/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/time/time.h"
 #include "content/public/test/async_file_test_helper.h"
 #include "content/public/test/test_file_system_context.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
@@ skipping 51 matching lines @@
   void Close() override { delete this; }  // Note this is required by the API.
 
   std::string GetKey() const override { return entry_->GetKey(); }
 
   base::Time GetLastUsed() const override { return entry_->GetLastUsed(); }
 
   base::Time GetLastModified() const override {
     return entry_->GetLastModified();
   }
 
-  int32 GetDataSize(int index) const override {
+  int32_t GetDataSize(int index) const override {
     return entry_->GetDataSize(index);
   }
 
   int ReadData(int index,
                int offset,
                IOBuffer* buf,
                int buf_len,
                const CompletionCallback& original_callback) override {
     net::TestCompletionCallback callback;
     int rv = entry_->ReadData(index, offset, buf, buf_len, callback.callback());
     DCHECK_NE(rv, net::ERR_IO_PENDING)
         << "Test expects to use a MEMORY_CACHE instance, which is synchronous.";
     pending_read_callbacks_.push_back(base::Bind(original_callback, rv));
     return net::ERR_IO_PENDING;
   }
 
   int WriteData(int index,
                 int offset,
                 IOBuffer* buf,
                 int buf_len,
                 const CompletionCallback& callback,
                 bool truncate) override {
     return entry_->WriteData(index, offset, buf, buf_len, callback, truncate);
   }
 
-  int ReadSparseData(int64 offset,
+  int ReadSparseData(int64_t offset,
                      IOBuffer* buf,
                      int buf_len,
                      const CompletionCallback& callback) override {
     return entry_->ReadSparseData(offset, buf, buf_len, callback);
   }
 
-  int WriteSparseData(int64 offset,
+  int WriteSparseData(int64_t offset,
                       IOBuffer* buf,
                       int buf_len,
                       const CompletionCallback& callback) override {
     return entry_->WriteSparseData(offset, buf, buf_len, callback);
   }
 
-  int GetAvailableRange(int64 offset,
+  int GetAvailableRange(int64_t offset,
                         int len,
-                        int64* start,
+                        int64_t* start,
                         const CompletionCallback& callback) override {
     return entry_->GetAvailableRange(offset, len, start, callback);
   }
 
   bool CouldBeSparse() const override { return entry_->CouldBeSparse(); }
 
   void CancelSparseIO() override { entry_->CancelSparseIO(); }
 
   int ReadyForSparseIO(const CompletionCallback& callback) override {
     return entry_->ReadyForSparseIO(callback);
@@ skipping 82 matching lines @@
           FROM_HERE,
           base::Bind(base::IgnoreResult(&FakeFileStreamReader::ReadImpl),
                      base::Unretained(this), make_scoped_refptr(buf),
                      buf_length, done));
     } else {
       async_task_runner_->PostTask(FROM_HERE, base::Bind(done, net_error_));
     }
     return net::ERR_IO_PENDING;
   }
 
-  int64 GetLength(const net::Int64CompletionCallback& size_callback) override {
+  int64_t GetLength(
+      const net::Int64CompletionCallback& size_callback) override {
     // When async_task_runner_ is not set, return synchronously.
     if (!async_task_runner_.get()) {
       if (net_error_ == net::OK) {
         return size_;
       } else {
         return net_error_;
       }
     }
     if (net_error_ == net::OK) {
       async_task_runner_->PostTask(FROM_HERE, base::Bind(size_callback, size_));
@@ skipping 582 matching lines @@
             reader_->Read(buffer.get(), kReadLength, &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kReadLength, static_cast<size_t>(bytes_read));
   EXPECT_EQ(0, async_bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "st ", kReadLength));
 }
 
 TEST_F(BlobReaderTest, FileSomeAsyncSegmentedOffsetsUnknownSizes) {
   // This tests includes:
-  // * Unknown file sizes (item length of uint64::max) for every other item.
+  // * Unknown file sizes (item length of uint64_t::max) for every other item.
   // * Offsets for every 3rd file item.
   // * Non-async reader for every 4th file item.
   BlobDataBuilder b("uuid");
   const FilePath kPathBase = FilePath::FromUTF8Unsafe("/fake/file.txt");
   const base::Time kTime = base::Time::Now();
   const size_t kNumItems = 10;
   const size_t kItemSize = 6;
   const size_t kBufferSize = 10;
   const size_t kTotalSize = kNumItems * kItemSize;
   char current_value = 0;
@@ skipping 260 matching lines @@
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   buffer = CreateBuffer(kDataSize + 1);
   EXPECT_EQ(BlobReader::Status::NET_ERROR,
             reader_->SetReadRange(0, kDataSize + 1));
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, reader_->net_error());
 }
 
 }  // namespace
 }  // namespace storage