Switch to standard integer types in chrome/browser/chromeos/.

chrome/browser/chromeos/drive/drive_file_stream_reader.h

 // Copyright 2013 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 CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_
 #define CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_
 
+#include <stdint.h>
+
 #include <string>
 
-#include "base/basictypes.h"
 #include "base/callback.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/threading/thread_checker.h"
 #include "components/drive/file_errors.h"
 #include "google_apis/drive/drive_api_error_codes.h"
 #include "net/base/completion_callback.h"
 
 namespace base {
 class SequencedTaskRunner;
@@ skipping 29 matching lines @@
   virtual void OnCompleted(FileError error) = 0;
 };
 
 // The read operation implementation for the locally cached files.
 class LocalReaderProxy : public ReaderProxy {
  public:
   // The |file_reader| should be the instance which is already opened.
   // This class takes its ownership.
   // |length| is the number of bytes to be read. It must be equal or
   // smaller than the remaining data size in the |file_reader|.
-  LocalReaderProxy(
-      scoped_ptr<util::LocalFileReader> file_reader, int64 length);
+  LocalReaderProxy(scoped_ptr<util::LocalFileReader> file_reader,
+                   int64_t length);
   ~LocalReaderProxy() override;
 
   // ReaderProxy overrides.
   int Read(net::IOBuffer* buffer,
            int buffer_length,
            const net::CompletionCallback& callback) override;
   void OnGetContent(scoped_ptr<std::string> data) override;
   void OnCompleted(FileError error) override;
 
  private:
   scoped_ptr<util::LocalFileReader> file_reader_;
 
   // Callback for the LocalFileReader::Read.
   void OnReadCompleted(
       const net::CompletionCallback& callback, int read_result);
 
   // The number of remaining bytes to be read.
-  int64 remaining_length_;
+  int64_t remaining_length_;
 
   base::ThreadChecker thread_checker_;
 
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<LocalReaderProxy> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(LocalReaderProxy);
 };
 
 // The read operation implementation for the file which is being downloaded.
 class NetworkReaderProxy : public ReaderProxy {
  public:
   // If the instance is deleted during the download process, it is necessary
   // to cancel the job. |job_canceller| should be the callback to run the
   // cancelling. |full_content_length| is necessary for determining whether the
   // deletion is done in the middle of download process.
-  NetworkReaderProxy(
-      int64 offset, int64 content_length, int64 full_content_length,
-      const base::Closure& job_canceller);
+  NetworkReaderProxy(int64_t offset,
+                     int64_t content_length,
+                     int64_t full_content_length,
+                     const base::Closure& job_canceller);
   ~NetworkReaderProxy() override;
 
   // ReaderProxy overrides.
   int Read(net::IOBuffer* buffer,
            int buffer_length,
            const net::CompletionCallback& callback) override;
   void OnGetContent(scoped_ptr<std::string> data) override;
   void OnCompleted(FileError error) override;
 
  private:
   // The data received from the server, but not yet read.
   ScopedVector<std::string> pending_data_;
 
   // The number of bytes to be skipped.
-  int64 remaining_offset_;
+  int64_t remaining_offset_;
 
   // The number of bytes of remaining data (including the data not yet
   // received from the server).
-  int64 remaining_content_length_;
+  int64_t remaining_content_length_;
 
   // Flag to remember whether this read request is for reading till the end of
   // the file.
   const bool is_full_download_;
 
   int error_code_;
 
   // To support pending Read(), it is necessary to keep its arguments.
   scoped_refptr<net::IOBuffer> buffer_;
   int buffer_length_;
@@ skipping 63 matching lines @@
   // is done.
   void InitializeAfterGetFileContentInitialized(
       const net::HttpByteRange& byte_range,
       const InitializeCompletionCallback& callback,
       FileError error,
       const base::FilePath& local_cache_file_path,
       scoped_ptr<ResourceEntry> entry);
 
   // Part of Initialize. Called when the local file open process is done.
   void InitializeAfterLocalFileOpen(
-      int64 length,
+      int64_t length,
       const InitializeCompletionCallback& callback,
       scoped_ptr<ResourceEntry> entry,
       scoped_ptr<util::LocalFileReader> file_reader,
       int open_result);
 
   // Called when the data is received from the server.
   void OnGetContent(google_apis::DriveApiErrorCode error_code,
                     scoped_ptr<std::string> data);
 
   // Called when GetFileContent is completed.
@@ skipping 10 matching lines @@
 
   // This should remain the last member so it'll be destroyed first and
   // invalidate its weak pointers before other members are destroyed.
   base::WeakPtrFactory<DriveFileStreamReader> weak_ptr_factory_;
   DISALLOW_COPY_AND_ASSIGN(DriveFileStreamReader);
 };
 
 }  // namespace drive
 
 #endif  // CHROME_BROWSER_CHROMEOS_DRIVE_DRIVE_FILE_STREAM_READER_H_