Switch to standard integer types in media/.

media/blink/resource_multibuffer_data_provider.cc

 // Copyright 2015 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/resource_multibuffer_data_provider.h"
 
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 199 matching lines @@
   base::Time last_modified;
   if (base::Time::FromString(
           response.httpHeaderField("Last-Modified").utf8().data(),
           &last_modified)) {
     destination_url_data->set_last_modified(last_modified);
   }
 
   destination_url_data->set_valid_until(base::Time::Now() +
                                         GetCacheValidUntil(response));
 
-  uint32 reasons = GetReasonsForUncacheability(response);
+  uint32_t reasons = GetReasonsForUncacheability(response);
   destination_url_data->set_cacheable(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
     }
 
     reasons >>= 1;
     ++shift;
   }
 
   // Expected content length can be |kPositionNotSpecified|, in that case
   // |content_length_| is not specified and this is a streaming response.
-  int64 content_length = response.expectedContentLength();
+  int64_t content_length = response.expectedContentLength();
 
   // We make a strong assumption that when we reach here we have either
   // received a response from HTTP/HTTPS protocol or the request was
   // successful (in particular range request). So we only verify the partial
   // response for HTTP and HTTPS protocol.
   if (destination_url_data->url().SchemeIsHTTPOrHTTPS()) {
     bool partial_response = (response.httpStatusCode() == kHttpPartialContent);
     bool ok_response = (response.httpStatusCode() == kHttpOK);
 
     // Check to see whether the server supports byte ranges.
@@ skipping 164 matching lines @@
     // We don't need to continue loading after failure.
     //
     // Keep it alive until we exit this method so that |error| remains valid.
     scoped_ptr<ActiveLoader> active_loader = active_loader_.Pass();
     url_data_->Fail();
   }
 }
 
 bool ResourceMultiBufferDataProvider::ParseContentRange(
     const std::string& content_range_str,
-    int64* first_byte_position,
-    int64* last_byte_position,
-    int64* instance_size) {
+    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 34 matching lines @@
   return ret;
 }
 
 int64_t ResourceMultiBufferDataProvider::block_size() const {
   int64_t ret = 1;
   return ret << url_data_->multibuffer()->block_size_shift();
 }
 
 bool ResourceMultiBufferDataProvider::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 (url_data_->length() == kPositionNotSpecified) {
     url_data_->set_length(instance_size);
   }
 
   if (byte_pos() != first_byte_position) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace media