Switch to standard integer types in media/.

media/blink/multibuffer_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/multibuffer_data_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "media/base/media_log.h"
 #include "media/blink/multibuffer_reader.h"
 #include "net/base/net_errors.h"
 
 using blink::WebFrame;
 
 namespace {
 
 // Minimum preload buffer.
-const int64 kMinBufferPreload = 2 << 20;  // 2 Mb
+const int64_t kMinBufferPreload = 2 << 20;  // 2 Mb
 // Maxmimum preload buffer.
-const int64 kMaxBufferPreload = 20 << 20;  // 20 Mb
+const int64_t kMaxBufferPreload = 20 << 20;  // 20 Mb
 
 // Preload this much extra, then stop preloading until we fall below the
 // kTargetSecondsBufferedAhead.
-const int64 kPreloadHighExtra = 1 << 20;  // 1 Mb
+const int64_t kPreloadHighExtra = 1 << 20;  // 1 Mb
 
 // Total size of the pinned region in the cache.
-const int64 kMaxBufferSize = 25 << 20;  // 25 Mb
+const int64_t kMaxBufferSize = 25 << 20;  // 25 Mb
 
 // If bitrate is not known, use this.
-const int64 kDefaultBitrate = 200 * 8 << 10;  // 200 Kbps.
+const int64_t kDefaultBitrate = 200 * 8 << 10;  // 200 Kbps.
 
 // Maximum bitrate for buffer calculations.
-const int64 kMaxBitrate = 20 * 8 << 20;  // 20 Mbps.
+const int64_t kMaxBitrate = 20 * 8 << 20;  // 20 Mbps.
 
 // Maximum playback rate for buffer calculations.
 const double kMaxPlaybackRate = 25.0;
 
 // Preload this many seconds of data by default.
-const int64 kTargetSecondsBufferedAhead = 10;
+const int64_t kTargetSecondsBufferedAhead = 10;
 
 // Keep this many seconds of data for going back by default.
-const int64 kTargetSecondsBufferedBehind = 2;
+const int64_t kTargetSecondsBufferedBehind = 2;
 
 }  // namespace
 
 namespace media {
 
 template <typename T>
 T clamp(T value, T min, T max) {
   return std::max(std::min(value, max), min);
 }
 
 class MultibufferDataSource::ReadOperation {
  public:
-  ReadOperation(int64 position,
+  ReadOperation(int64_t position,
                 int size,
-                uint8* data,
+                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);
 
-  int64 position() { return position_; }
+  int64_t position() { return position_; }
   int size() { return size_; }
-  uint8* data() { return data_; }
+  uint8_t* data() { return data_; }
 
  private:
-  const int64 position_;
+  const int64_t position_;
   const int size_;
-  uint8* data_;
+  uint8_t* data_;
   DataSource::ReadCB callback_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ReadOperation);
 };
 
 MultibufferDataSource::ReadOperation::ReadOperation(
-    int64 position,
+    int64_t position,
     int size,
-    uint8* data,
+    uint8_t* data,
     const DataSource::ReadCB& callback)
     : position_(position), size_(size), data_(data), callback_(callback) {
   DCHECK(!callback_.is_null());
 }
 
 MultibufferDataSource::ReadOperation::~ReadOperation() {
   DCHECK(callback_.is_null());
 }
 
 // static
@@ skipping 47 matching lines @@
 }
 
 bool MultibufferDataSource::media_has_played() const {
   return media_has_played_;
 }
 
 bool MultibufferDataSource::assume_fully_buffered() {
   return !url_data_->url().SchemeIsHTTPOrHTTPS();
 }
 
-void MultibufferDataSource::CreateResourceLoader(int64 first_byte_position,
-                                                 int64 last_byte_position) {
+void MultibufferDataSource::CreateResourceLoader(int64_t first_byte_position,
+                                                 int64_t last_byte_position) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   reader_.reset(new MultiBufferReader(
       url_data_->multibuffer(), first_byte_position, last_byte_position,
       base::Bind(&MultibufferDataSource::ProgressCallback, weak_ptr_)));
   UpdateBufferSizes();
 }
 
 void MultibufferDataSource::Initialize(const InitializeCB& init_cb) {
   DCHECK(render_task_runner_->BelongsToCurrentThread());
@@ skipping 156 matching lines @@
       reader_.reset(nullptr);
   }
 }
 
 int64_t MultibufferDataSource::GetMemoryUsage() const {
   // TODO(hubbe): Make more accurate when url_data_ is shared.
   return url_data_->CachedSize()
          << url_data_->multibuffer()->block_size_shift();
 }
 
-void MultibufferDataSource::Read(int64 position,
+void MultibufferDataSource::Read(int64_t position,
                                  int size,
-                                 uint8* data,
+                                 uint8_t* data,
                                  const DataSource::ReadCB& read_cb) {
   DVLOG(1) << "Read: " << position << " offset, " << size << " bytes";
   // Reading is not allowed until after initialization.
   DCHECK(init_cb_.is_null());
   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(&MultibufferDataSource::ReadTask, weak_factory_.GetWeakPtr()));
 }
 
-bool MultibufferDataSource::GetSize(int64* size_out) {
+bool MultibufferDataSource::GetSize(int64_t* size_out) {
   *size_out = url_data_->length();
   return *size_out != kPositionNotSpecified;
 }
 
 bool MultibufferDataSource::IsStreaming() {
   return streaming_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // This method is the place where actual read happens,
@@ skipping 111 matching lines @@
   }
 
   render_task_runner_->PostTask(
       FROM_HERE, base::Bind(base::ResetAndReturn(&init_cb_), success));
 
   // Even if data is cached, say that we're loading at this point for
   // compatibility.
   UpdateLoadingState(true);
 }
 
-void MultibufferDataSource::ProgressCallback(int64 begin, int64 end) {
+void MultibufferDataSource::ProgressCallback(int64_t begin, int64_t end) {
   DVLOG(1) << __FUNCTION__ << "(" << begin << ", " << end << ")";
   DCHECK(render_task_runner_->BelongsToCurrentThread());
 
   if (assume_fully_buffered())
     return;
 
   if (end > begin) {
     // TODO(scherkus): we shouldn't have to lock to signal host(), see
     // http://crbug.com/113712 for details.
     base::AutoLock auto_lock(lock_);
@@ skipping 35 matching lines @@
     // why bother?)
     bool aggressive = (buffering_strategy_ == BUFFERING_STRATEGY_AGGRESSIVE);
     if (media_has_played_ && aggressive && url_data_ &&
         url_data_->range_supported() && url_data_->cacheable()) {
       reader_->SetPreload(1LL << 40, 1LL << 40);  // 1 Tb
       return;
     }
   }
 
   // Use a default bit rate if unknown and clamp to prevent overflow.
-  int64 bitrate = clamp<int64>(bitrate_, 0, kMaxBitrate);
+  int64_t bitrate = clamp<int64_t>(bitrate_, 0, kMaxBitrate);
   if (bitrate == 0)
     bitrate = kDefaultBitrate;
 
   // Only scale the buffer window for playback rates greater than 1.0 in
   // magnitude and clamp to prevent overflow.
   double playback_rate = playback_rate_;
 
   playback_rate = std::max(playback_rate, 1.0);
   playback_rate = std::min(playback_rate, kMaxPlaybackRate);
 
-  int64 bytes_per_second = (bitrate / 8.0) * playback_rate;
+  int64_t bytes_per_second = (bitrate / 8.0) * playback_rate;
 
-  int64 preload = clamp(kTargetSecondsBufferedAhead * bytes_per_second,
-                        kMinBufferPreload, kMaxBufferPreload);
-  int64 back_buffer = clamp(kTargetSecondsBufferedBehind * bytes_per_second,
-                            kMinBufferPreload, kMaxBufferPreload);
-  int64 pin_forwards = kMaxBufferSize - back_buffer;
+  int64_t preload = clamp(kTargetSecondsBufferedAhead * bytes_per_second,
+                          kMinBufferPreload, kMaxBufferPreload);
+  int64_t back_buffer = clamp(kTargetSecondsBufferedBehind * bytes_per_second,
+                              kMinBufferPreload, kMaxBufferPreload);
+  int64_t pin_forwards = kMaxBufferSize - back_buffer;
   DCHECK_LE(preload_ + kPreloadHighExtra, pin_forwards);
   reader_->SetMaxBuffer(back_buffer, pin_forwards);
 
   if (preload_ == METADATA) {
     reader_->SetPreload(0, 0);
   } else {
     reader_->SetPreload(preload + kPreloadHighExtra, preload);
   }
 }
 
 }  // namespace media