Switch to standard integer types in content/browser/.

content/browser/download/base_file_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 "content/browser/download/base_file.h"
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/test/test_file_util.h"
+#include "build/build_config.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 namespace {
 
 const char kTestData1[] = "Let's write some data to the file!\n";
@@ skipping 30 matching lines @@
                                   0,
                                   false,
                                   std::string(),
                                   base::File(),
                                   net::BoundNetLog()));
   }
 
   void TearDown() override {
     EXPECT_FALSE(base_file_->in_progress());
     if (!expected_error_) {
-      EXPECT_EQ(static_cast<int64>(expected_data_.size()),
+      EXPECT_EQ(static_cast<int64_t>(expected_data_.size()),
                 base_file_->bytes_so_far());
     }
 
     base::FilePath full_path = base_file_->full_path();
 
     if (!expected_data_.empty() && !expected_error_) {
       // Make sure the data has been properly written to disk.
       std::string disk_data;
       EXPECT_TRUE(base::ReadFileToString(full_path, &disk_data));
       EXPECT_EQ(expected_data_, disk_data);
@@ skipping 44 matching lines @@
     EXPECT_EQ(expect_in_progress_, base_file_->in_progress());
     DownloadInterruptReason result =
         base_file_->AppendDataToFile(data.data(), data.size());
     if (result == DOWNLOAD_INTERRUPT_REASON_NONE)
       EXPECT_TRUE(expect_in_progress_) << " result = " << result;
 
     EXPECT_EQ(expected_error_, result);
     if (base_file_->in_progress()) {
       expected_data_ += data;
       if (expected_error_ == DOWNLOAD_INTERRUPT_REASON_NONE) {
-        EXPECT_EQ(static_cast<int64>(expected_data_.size()),
+        EXPECT_EQ(static_cast<int64_t>(expected_data_.size()),
                   base_file_->bytes_so_far());
       }
     }
     return result == DOWNLOAD_INTERRUPT_REASON_NONE;
   }
 
   void set_expected_data(const std::string& data) { expected_data_ = data; }
 
   // Helper functions.
   // Create a file.  Returns the complete file path.
@@ skipping 34 matching lines @@
                             base::File(),
                             net::BoundNetLog());
     EXPECT_EQ(DOWNLOAD_INTERRUPT_REASON_NONE,
               duplicate_file.Initialize(temp_dir_.path()));
     // Write something into it.
     duplicate_file.AppendDataToFile(kTestData4, kTestDataLength4);
     // Detach the file so it isn't deleted on destruction of |duplicate_file|.
     duplicate_file.Detach();
   }
 
-  int64 CurrentSpeedAtTime(base::TimeTicks current_time) {
+  int64_t CurrentSpeedAtTime(base::TimeTicks current_time) {
     EXPECT_TRUE(base_file_.get());
     return base_file_->CurrentSpeedAtTime(current_time);
   }
 
   base::TimeTicks StartTick() {
     EXPECT_TRUE(base_file_.get());
     return base_file_->start_tick_;
   }
 
   void set_expected_error(DownloadInterruptReason err) {
@@ skipping 489 matching lines @@
 
   const char kData[] = "hello";
   const int kDataLength = static_cast<int>(arraysize(kData) - 1);
   ASSERT_EQ(kDataLength, base::WriteFile(full_path, kData, kDataLength));
   // The file that we created here should stick around when the BaseFile is
   // destroyed during TearDown.
   expect_file_survives_ = true;
 }
 
 }  // namespace content