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

chrome/browser/chromeos/drive/drive_file_stream_reader.cc

 // 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.
 
 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 #include <cstring>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/sequenced_task_runner.h"
 #include "components/drive/drive.pb.h"
 #include "components/drive/file_system_interface.h"
 #include "components/drive/local_file_reader.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 13 matching lines @@
 }
 
 // Computes the concrete |start| offset and the |length| of |range| in a file
 // of |total| size.
 //
 // This is a thin wrapper of HttpByteRange::ComputeBounds, extended to allow
 // an empty range at the end of the file, like "Range: bytes 0-" on a zero byte
 // file. This is for convenience in unifying implementation with the seek
 // operation of stream reader. HTTP doesn't allow such ranges but we want to
 // treat such seeking as valid.
-bool ComputeConcretePosition(net::HttpByteRange range, int64 total,
-                             int64* start, int64* length) {
+bool ComputeConcretePosition(net::HttpByteRange range,
+                             int64_t total,
+                             int64_t* start,
+                             int64_t* length) {
   // The special case when empty range in the end of the file is selected.
   if (range.HasFirstBytePosition() && range.first_byte_position() == total) {
     *start = range.first_byte_position();
     *length = 0;
     return true;
   }
 
   // Otherwise forward to HttpByteRange::ComputeBounds.
   if (!range.ComputeBounds(total))
     return false;
@@ skipping 33 matching lines @@
 
   // Consume the copied data.
   pending_data->erase(pending_data->begin(), pending_data->begin() + index);
 
   return offset;
 }
 
 }  // namespace
 
 LocalReaderProxy::LocalReaderProxy(
-    scoped_ptr<util::LocalFileReader> file_reader, int64 length)
+    scoped_ptr<util::LocalFileReader> file_reader,
+    int64_t length)
     : file_reader_(file_reader.Pass()),
       remaining_length_(length),
       weak_ptr_factory_(this) {
   DCHECK(file_reader_);
 }
 
 LocalReaderProxy::~LocalReaderProxy() {
 }
 
 int LocalReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
@@ skipping 35 matching lines @@
     // |read_result| bytes data is read.
     DCHECK_LE(read_result, remaining_length_);
     remaining_length_ -= read_result;
   } else {
     // An error occurs. Close the |file_reader_|.
     file_reader_.reset();
   }
   callback.Run(read_result);
 }
 
-NetworkReaderProxy::NetworkReaderProxy(
-    int64 offset,
-    int64 content_length,
-    int64 full_content_length,
-    const base::Closure& job_canceller)
+NetworkReaderProxy::NetworkReaderProxy(int64_t offset,
+                                       int64_t content_length,
+                                       int64_t full_content_length,
+                                       const base::Closure& job_canceller)
     : remaining_offset_(offset),
       remaining_content_length_(content_length),
       is_full_download_(offset + content_length == full_content_length),
       error_code_(net::OK),
       buffer_length_(0),
-      job_canceller_(job_canceller) {
-}
+      job_canceller_(job_canceller) {}
 
 NetworkReaderProxy::~NetworkReaderProxy() {
   if (!job_canceller_.is_null()) {
     job_canceller_.Run();
   }
 }
 
 int NetworkReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
                              const net::CompletionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 39 matching lines @@
   if (is_full_download_ && remaining_content_length_ == 0)
     job_canceller_.Reset();
 
   return result;
 }
 
 void NetworkReaderProxy::OnGetContent(scoped_ptr<std::string> data) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(data && !data->empty());
 
-  if (remaining_offset_ >= static_cast<int64>(data->length())) {
+  if (remaining_offset_ >= static_cast<int64_t>(data->length())) {
     // Skip unneeded leading data.
     remaining_offset_ -= data->length();
     return;
   }
 
   if (remaining_offset_ > 0) {
     // Erase unnecessary leading bytes.
     data->erase(0, static_cast<size_t>(remaining_offset_));
     remaining_offset_ = 0;
   }
@@ skipping 156 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   // StoreCancelDownloadClosure() should be called before this function.
   DCHECK(!cancel_download_closure_.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
-  int64 range_start = 0, range_length = 0;
+  int64_t range_start = 0, range_length = 0;
   if (!ComputeConcretePosition(byte_range, entry->file_info().size(),
                                &range_start, &range_length)) {
     // If |byte_range| is invalid (e.g. out of bounds), return with an error.
     // At the same time, we cancel the in-flight downloading operation if
     // needed and and invalidate weak pointers so that we won't
     // receive unwanted callbacks.
     cancel_download_closure_.Run();
     weak_ptr_factory_.InvalidateWeakPtrs();
     callback.Run(
         net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, scoped_ptr<ResourceEntry>());
@@ skipping 20 matching lines @@
       base::Bind(
           &DriveFileStreamReader::InitializeAfterLocalFileOpen,
           weak_ptr_factory_.GetWeakPtr(),
           range_length,
           callback,
           base::Passed(&entry),
           base::Passed(&file_reader)));
 }
 
 void DriveFileStreamReader::InitializeAfterLocalFileOpen(
-    int64 length,
+    int64_t length,
     const InitializeCompletionCallback& callback,
     scoped_ptr<ResourceEntry> entry,
     scoped_ptr<util::LocalFileReader> file_reader,
     int open_result) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (open_result != net::OK) {
     callback.Run(net::ERR_FAILED, scoped_ptr<ResourceEntry>());
     return;
   }
@@ skipping 29 matching lines @@
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
       callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive