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

third_party/zlib/google/zip_reader.h

 // 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.
 #ifndef THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_
 #define THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_
 
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 
 #if defined(USE_SYSTEM_MINIZIP)
 #include <minizip/unzip.h>
 #else
 #include "third_party/zlib/contrib/minizip/unzip.h"
 #endif
 
@@ skipping 33 matching lines @@
 // using LocateAndOpenEntry().
 //
 class ZipReader {
  public:
   // A callback that is called when the operation is successful.
   typedef base::Closure SuccessCallback;
   // A callback that is called when the operation fails.
   typedef base::Closure FailureCallback;
   // A callback that is called periodically during the operation with the number
   // of bytes that have been processed so far.
-  typedef base::Callback<void(int64)> ProgressCallback;
+  typedef base::Callback<void(int64_t)> ProgressCallback;
 
   // This class represents information of an entry (file or directory) in
   // a zip file.
   class EntryInfo {
    public:
     EntryInfo(const std::string& filename_in_zip,
               const unz_file_info& raw_file_info);
 
     // Returns the file path. The path is usually relative like
     // "foo/bar.txt", but if it's absolute, is_unsafe() returns true.
     const base::FilePath& file_path() const { return file_path_; }
 
     // Returns the size of the original file (i.e. after uncompressed).
     // Returns 0 if the entry is a directory.
     // Note: this value should not be trusted, because it is stored as metadata
     // in the zip archive and can be different from the real uncompressed size.
-    int64 original_size() const { return original_size_; }
+    int64_t original_size() const { return original_size_; }
 
     // Returns the last modified time. If the time stored in the zip file was
     // not valid, the unix epoch will be returned.
     //
     // The time stored in the zip archive uses the MS-DOS date and time format.
     // http://msdn.microsoft.com/en-us/library/ms724247(v=vs.85).aspx
     // As such the following limitations apply:
     // * only years from 1980 to 2107 can be represented.
     // * the time stamp has a 2 second resolution.
     // * there's no timezone information, so the time is interpreted as local.
     base::Time last_modified() const { return last_modified_; }
 
     // Returns true if the entry is a directory.
     bool is_directory() const { return is_directory_; }
 
     // Returns true if the entry is unsafe, like having ".." or invalid
     // UTF-8 characters in its file name, or the file path is absolute.
     bool is_unsafe() const { return is_unsafe_; }
 
    private:
     const base::FilePath file_path_;
-    int64 original_size_;
+    int64_t original_size_;
     base::Time last_modified_;
     bool is_directory_;
     bool is_unsafe_;
     DISALLOW_COPY_AND_ASSIGN(EntryInfo);
   };
 
   ZipReader();
   ~ZipReader();
 
   // Opens the zip file specified by |zip_file_path|. Returns true on
@@ skipping 113 matching lines @@
 
   // Resets the internal state.
   void Reset();
 
   // Extracts a chunk of the file to the target.  Will post a task for the next
   // chunk and success/failure/progress callbacks as necessary.
   void ExtractChunk(base::File target_file,
                     const SuccessCallback& success_callback,
                     const FailureCallback& failure_callback,
                     const ProgressCallback& progress_callback,
-                    const int64 offset);
+                    const int64_t offset);
 
   unzFile zip_file_;
   int num_entries_;
   bool reached_end_;
   scoped_ptr<EntryInfo> current_entry_info_;
 
   base::WeakPtrFactory<ZipReader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ZipReader);
 };
@@ skipping 18 matching lines @@
  private:
   base::File* file_;
   int64_t file_length_;
 
   DISALLOW_COPY_AND_ASSIGN(FileWriterDelegate);
 };
 
 }  // namespace zip
 
 #endif  // THIRD_PARTY_ZLIB_GOOGLE_ZIP_READER_H_