Switch to standard integer types in third_party/zlib/google/.

third_party/zlib/google/zip_reader_unittest.cc

 // Copyright (c) 2011 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 "third_party/zlib/google/zip_reader.h"
 
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
 #include <set>
 #include <string>
 
 #include "base/bind.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/md5.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "third_party/zlib/google/zip_internal.h"
@@ skipping 48 matching lines @@
   void OnUnzipSuccess() {
     success_calls_++;
   }
 
   // Failure callback for async functions.
   void OnUnzipFailure() {
     failure_calls_++;
   }
 
   // Progress callback for async functions.
-  void OnUnzipProgress(int64 progress) {
+  void OnUnzipProgress(int64_t progress) {
     DCHECK(progress > current_progress_);
     progress_calls_++;
     current_progress_ = progress;
   }
 
   int success_calls() { return success_calls_; }
   int failure_calls() { return failure_calls_; }
   int progress_calls() { return progress_calls_; }
   int current_progress() { return current_progress_; }
 
  private:
   int success_calls_;
   int failure_calls_;
   int progress_calls_;
 
-  int64 current_progress_;
+  int64_t current_progress_;
 };
 
 class MockWriterDelegate : public zip::WriterDelegate {
  public:
   MOCK_METHOD0(PrepareOutput, bool());
   MOCK_METHOD2(WriteBytes, bool(const char*, int));
 };
 
 }   // namespace
 
@@ skipping 390 matching lines @@
   EXPECT_EQ(1, listener.success_calls());
   EXPECT_EQ(0, listener.failure_calls());
   EXPECT_LE(1, listener.progress_calls());
 
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
   EXPECT_EQ(kQuuxExpectedMD5, md5);
 
-  int64 file_size = 0;
+  int64_t file_size = 0;
   ASSERT_TRUE(base::GetFileSize(target_file, &file_size));
 
   EXPECT_EQ(file_size, listener.current_progress());
 }
 
 // Verifies that the asynchronous extraction to a file works.
 TEST_F(ZipReaderTest, ExtractToFileAsync_Directory) {
   MockUnzipListener listener;
 
   ZipReader reader;
@@ skipping 157 matching lines @@
     ASSERT_TRUE(writer.PrepareOutput());
     ASSERT_TRUE(writer.WriteBytes(kSomeData, kSomeDataLen));
   }
   ASSERT_EQ(kSomeDataLen, file_.GetLength());
   char buf[kSomeDataLen] = {};
   ASSERT_EQ(kSomeDataLen, file_.Read(0LL, buf, kSomeDataLen));
   ASSERT_EQ(std::string(kSomeData), std::string(buf, kSomeDataLen));
 }
 
 }  // namespace zip