Switch to standard integer types in media/.

media/blink/buffered_data_source.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 "media/blink/buffered_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 15 matching lines @@
 
 // The number of milliseconds to wait before retrying a failed load.
 const int kLoaderFailedRetryDelayMs = 250;
 
 }  // namespace
 
 namespace media {
 
 class BufferedDataSource::ReadOperation {
  public:
-  ReadOperation(int64 position, int size, uint8* data,
+  ReadOperation(int64_t position,
+                int size,
+                uint8_t* data,
                 const DataSource::ReadCB& callback);
   ~ReadOperation();
 
   // Runs |callback_| with the given |result|, deleting the operation
   // afterwards.
   static void Run(scoped_ptr<ReadOperation> read_op, int result);
 
   // State for the number of times this read operation has been retried.
   int retries() { return retries_; }
   void IncrementRetries() { ++retries_; }
 
-  int64 position() { return position_; }
+  int64_t position() { return position_; }
   int size() { return size_; }
-  uint8* data() { return data_; }
+  uint8_t* data() { return data_; }
 
  private:
   int retries_;
 
-  const int64 position_;
+  const int64_t position_;
   const int size_;
-  uint8* data_;
+  uint8_t* data_;
   DataSource::ReadCB callback_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReadOperation);
 };
 
 BufferedDataSource::ReadOperation::ReadOperation(
-    int64 position, int size, uint8* data,
+    int64_t position,
+    int size,
+    uint8_t* data,
     const DataSource::ReadCB& callback)
     : retries_(0),
       position_(position),
       size_(size),
       data_(data),
       callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 BufferedDataSource::ReadOperation::~ReadOperation() {
@@ skipping 46 matching lines @@
 }
 
 bool BufferedDataSource::assume_fully_buffered() {
   return !url_.SchemeIsHTTPOrHTTPS();
 }
 
 // A factory method to create BufferedResourceLoader using the read parameters.
 // This method can be overridden to inject mock BufferedResourceLoader object
 // for testing purpose.
 BufferedResourceLoader* BufferedDataSource::CreateResourceLoader(
-    int64 first_byte_position, int64 last_byte_position) {
+    int64_t first_byte_position,
+    int64_t last_byte_position) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   BufferedResourceLoader::DeferStrategy strategy = preload_ == METADATA ?
       BufferedResourceLoader::kReadThenDefer :
       BufferedResourceLoader::kCapacityDefer;
 
   return new BufferedResourceLoader(url_,
                                     cors_mode_,
                                     first_byte_position,
                                     last_byte_position,
@@ skipping 104 matching lines @@
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   if (loader_ && preload_ == METADATA && !media_has_played_ && !IsStreaming())
     loader_->CancelUponDeferral();
 }
 
 int64_t BufferedDataSource::GetMemoryUsage() const {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
   return loader_ ? loader_->GetMemoryUsage() : 0;
 }
 
-void BufferedDataSource::Read(
-    int64 position, int size, uint8* data,
-    const DataSource::ReadCB& read_cb) {
+void BufferedDataSource::Read(int64_t position,
+                              int size,
+                              uint8_t* data,
+                              const DataSource::ReadCB& read_cb) {
   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   DCHECK(!read_cb.is_null());
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK(!read_op_);
 
     if (stop_signal_received_) {
       read_cb.Run(kReadError);
       return;
     }
 
     read_op_.reset(new ReadOperation(position, size, data, read_cb));
   }
 
   render_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&BufferedDataSource::ReadTask, weak_factory_.GetWeakPtr()));
 }
 
-bool BufferedDataSource::GetSize(int64* size_out) {
+bool BufferedDataSource::GetSize(int64_t* size_out) {
   if (total_bytes_ != kPositionNotSpecified) {
     *size_out = total_bytes_;
     return true;
   }
   *size_out = 0;
   return false;
 }
 
 bool BufferedDataSource::IsStreaming() {
   return streaming_;
@@ skipping 33 matching lines @@
   DCHECK(loader_.get());
 
   bitrate_ = bitrate;
   loader_->SetBitrate(bitrate);
 }
 
 // This method is the place where actual read happens, |loader_| must be valid
 // prior to make this method call.
 void BufferedDataSource::ReadInternal() {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
-  int64 position = 0;
+  int64_t position = 0;
   int size = 0;
   {
     base::AutoLock auto_lock(lock_);
     if (stop_signal_received_)
       return;
 
     position = read_op_->position();
     size = read_op_->size();
   }
 
@@ skipping 203 matching lines @@
     // we should consider changing DownloadingCB to also propagate loading
     // state. For example there isn't any signal today to notify the client that
     // loading has failed (we only get errors on subsequent reads).
     case BufferedResourceLoader::kLoadingFailed:
       return;
   }
 
   downloading_cb_.Run(is_downloading_data);
 }
 
-void BufferedDataSource::ProgressCallback(int64 position) {
+void BufferedDataSource::ProgressCallback(int64_t position) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
 
   // TODO(scherkus): we shouldn't have to lock to signal host(), see
   // http://crbug.com/113712 for details.
   base::AutoLock auto_lock(lock_);
   if (stop_signal_received_)
     return;
@@ skipping 23 matching lines @@
   }
 
   // If media is currently playing or the page indicated preload=auto or the
   // the server does not support the byte range request or we do not want to go
   // too far ahead of the read head, use threshold strategy to enable/disable
   // deferring when the buffer is full/depleted.
   loader_->UpdateDeferStrategy(BufferedResourceLoader::kCapacityDefer);
 }
 
 }  // namespace media