Remove kint32min.

media/blink/buffered_resource_loader.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_resource_loader.h"
 
+#include <stdint.h>
+
+#include <limits>
+
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "media/base/media_log.h"
 #include "media/blink/cache_util.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ skipping 70 matching lines @@
   *out_backward_capacity = std::max(
       kTargetSecondsBufferedBehind * bytes_per_second, kMinBufferCapacity);
 
   *out_forward_capacity = std::min(*out_forward_capacity, kMaxBufferCapacity);
   *out_backward_capacity = std::min(*out_backward_capacity, kMaxBufferCapacity);
 
   if (backward_playback)
     std::swap(*out_forward_capacity, *out_backward_capacity);
 }
 
-BufferedResourceLoader::BufferedResourceLoader(
-    const GURL& url,
-    CORSMode cors_mode,
-    int64 first_byte_position,
-    int64 last_byte_position,
-    DeferStrategy strategy,
-    int bitrate,
-    double playback_rate,
-    MediaLog* media_log)
+BufferedResourceLoader::BufferedResourceLoader(const GURL& url,
+                                               CORSMode cors_mode,
+                                               int64_t first_byte_position,
+                                               int64_t last_byte_position,
+                                               DeferStrategy strategy,
+                                               int bitrate,
+                                               double playback_rate,
+                                               MediaLog* media_log)
     : buffer_(kMinBufferCapacity, kMinBufferCapacity),
       loader_failed_(false),
       defer_strategy_(strategy),
       might_be_reused_from_cache_in_future_(true),
       range_supported_(false),
       saved_forward_capacity_(0),
       url_(url),
       cors_mode_(cors_mode),
       first_byte_position_(first_byte_position),
       last_byte_position_(last_byte_position),
       single_origin_(true),
       offset_(0),
       content_length_(kPositionNotSpecified),
       instance_size_(kPositionNotSpecified),
       read_position_(0),
       read_size_(0),
       read_buffer_(NULL),
       first_offset_(0),
       last_offset_(0),
       bitrate_(bitrate),
       playback_rate_(playback_rate),
       media_log_(media_log),
       cancel_upon_deferral_(false) {
-
   // Set the initial capacity of |buffer_| based on |bitrate_| and
   // |playback_rate_|.
   UpdateBufferWindow();
 }
 
 BufferedResourceLoader::~BufferedResourceLoader() {}
 
 void BufferedResourceLoader::Start(
     const StartCB& start_cb,
     const LoadingStateChangedCB& loading_cb,
@@ skipping 69 matching lines @@
   // Reset callbacks.
   start_cb_.Reset();
   loading_cb_.Reset();
   progress_cb_.Reset();
   read_cb_.Reset();
 
   // Cancel and reset any active loaders.
   active_loader_.reset();
 }
 
-void BufferedResourceLoader::Read(
-    int64 position,
-    int read_size,
-    uint8* buffer,
-    const ReadCB& read_cb) {
+void BufferedResourceLoader::Read(int64_t position,
+                                  int read_size,
+                                  uint8_t* buffer,
+                                  const ReadCB& read_cb) {
   DCHECK(start_cb_.is_null());
   DCHECK(read_cb_.is_null());
   DCHECK(!read_cb.is_null());
   DCHECK(buffer);
   DCHECK_GT(read_size, 0);
 
   // Save the parameter of reading.
   read_cb_ = read_cb;
   read_position_ = position;
   read_size_ = read_size;
@@ skipping 13 matching lines @@
   // of the file.
   if (instance_size_ != kPositionNotSpecified &&
       instance_size_ <= read_position_) {
     DVLOG(1) << "Appear to have seeked beyond EOS; returning 0.";
     DoneRead(kOk, 0);
     return;
   }
 
   // Make sure |offset_| and |read_position_| does not differ by a large
   // amount.
-  if (read_position_ > offset_ + kint32max ||
-      read_position_ < offset_ + kint32min) {
+  if (read_position_ > offset_ + std::numeric_limits<int32_t>::max() ||
+      read_position_ < offset_ + std::numeric_limits<int32_t>::min()) {
     DoneRead(kCacheMiss, 0);
     return;
   }
 
   // Make sure |read_size_| is not too large for the buffer to ever be able to
   // fulfill the read request.
   if (read_size_ > kMaxBufferCapacity) {
     DoneRead(kFailed, 0);
     return;
   }
@@ skipping 36 matching lines @@
         << "Capacity was not adjusted properly to prevent deferring.";
     UpdateDeferBehavior();
 
     return;
   }
 
   // Make a callback to report failure.
   DoneRead(kCacheMiss, 0);
 }
 
-int64 BufferedResourceLoader::content_length() {
+int64_t BufferedResourceLoader::content_length() {
   return content_length_;
 }
 
-int64 BufferedResourceLoader::instance_size() {
+int64_t BufferedResourceLoader::instance_size() {
   return instance_size_;
 }
 
 bool BufferedResourceLoader::range_supported() {
   return range_supported_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // blink::WebURLLoaderClient implementation.
 void BufferedResourceLoader::willFollowRedirect(
@@ skipping 42 matching lines @@
   DCHECK(active_loader_.get());
   response_original_url_ = response.wasFetchedViaServiceWorker()
                                ? response.originalURLViaServiceWorker()
                                : response.url();
 
   // The loader may have been stopped and |start_cb| is destroyed.
   // In this case we shouldn't do anything.
   if (start_cb_.is_null())
     return;
 
-  uint32 reasons = GetReasonsForUncacheability(response);
+  uint32_t reasons = GetReasonsForUncacheability(response);
   might_be_reused_from_cache_in_future_ = reasons == 0;
   UMA_HISTOGRAM_BOOLEAN("Media.CacheUseful", reasons == 0);
   int shift = 0;
   int max_enum = base::bits::Log2Ceiling(kMaxReason);
   while (reasons) {
     DCHECK_LT(shift, max_enum);  // Sanity check.
     if (reasons & 0x1) {
       UMA_HISTOGRAM_ENUMERATION("Media.UncacheableReason",
                                 shift,
                                 max_enum); // PRESUBMIT_IGNORE_UMA_MAX
@@ skipping 68 matching lines @@
 
 void BufferedResourceLoader::didReceiveData(
     WebURLLoader* loader,
     const char* data,
     int data_length,
     int encoded_data_length) {
   DVLOG(1) << "didReceiveData: " << data_length << " bytes";
   DCHECK(active_loader_.get());
   DCHECK_GT(data_length, 0);
 
-  buffer_.Append(reinterpret_cast<const uint8*>(data), data_length);
+  buffer_.Append(reinterpret_cast<const uint8_t*>(data), data_length);
 
   // If there is an active read request, try to fulfill the request.
   if (HasPendingRead() && CanFulfillRead())
     ReadInternal();
 
   // At last see if the buffer is full and we need to defer the downloading.
   UpdateDeferBehavior();
 
   // Consume excess bytes from our in-memory buffer if necessary.
   if (buffer_.forward_bytes() > buffer_.forward_capacity()) {
@@ skipping 226 matching lines @@
   DCHECK(ret);
 
   // Then do the read.
   int read = buffer_.Read(read_buffer_, read_size_);
   offset_ += first_offset_ + read;
 
   // And report with what we have read.
   DoneRead(kOk, read);
 }
 
-int64 BufferedResourceLoader::first_byte_position() const {
+int64_t BufferedResourceLoader::first_byte_position() const {
   return first_byte_position_;
 }
 
 // static
 bool BufferedResourceLoader::ParseContentRange(
-    const std::string& content_range_str, int64* first_byte_position,
-    int64* last_byte_position, int64* instance_size) {
+    const std::string& content_range_str,
+    int64_t* first_byte_position,
+    int64_t* last_byte_position,
+    int64_t* instance_size) {
   const std::string kUpThroughBytesUnit = "bytes ";
   if (content_range_str.find(kUpThroughBytesUnit) != 0)
     return false;
   std::string range_spec =
       content_range_str.substr(kUpThroughBytesUnit.length());
   size_t dash_offset = range_spec.find("-");
   size_t slash_offset = range_spec.find("/");
 
   if (dash_offset == std::string::npos || slash_offset == std::string::npos ||
       slash_offset < dash_offset || slash_offset + 1 == range_spec.length()) {
@@ skipping 29 matching lines @@
   if (active_loader_ && active_loader_->deferred())
     active_loader_.reset();
 }
 
 int64_t BufferedResourceLoader::GetMemoryUsage() const {
   return buffer_.forward_bytes() + buffer_.backward_bytes();
 }
 
 bool BufferedResourceLoader::VerifyPartialResponse(
     const WebURLResponse& response) {
-  int64 first_byte_position, last_byte_position, instance_size;
+  int64_t first_byte_position, last_byte_position, instance_size;
   if (!ParseContentRange(response.httpHeaderField("Content-Range").utf8(),
                          &first_byte_position, &last_byte_position,
                          &instance_size)) {
     return false;
   }
 
   if (instance_size != kPositionNotSpecified) {
     instance_size_ = instance_size;
   }
 
@@ skipping 33 matching lines @@
 
 void BufferedResourceLoader::Log() {
   media_log_->AddEvent(
       media_log_->CreateBufferedExtentsChangedEvent(
           offset_ - buffer_.backward_bytes(),
           offset_,
           offset_ + buffer_.forward_bytes()));
 }
 
 }  // namespace media