Remove kint32max.

media/base/android/ndk_media_codec_bridge.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/base/android/ndk_media_codec_bridge.h"
 
 #include <media/NdkMediaError.h>
 #include <media/NdkMediaFormat.h>
 
+#include <limits>
+
 #include "base/strings/string_util.h"
 #include "media/base/decrypt_config.h"
 
 namespace {
 const char kMediaFormatKeyCropLeft[] = "crop-left";
 const char kMediaFormatKeyCropRight[] = "crop-right";
 const char kMediaFormatKeyCropBottom[] = "crop-bottom";
 const char kMediaFormatKeyCropTop[] = "crop-top";
 }
 
@@ skipping 64 matching lines @@
 int NdkMediaCodecBridge::GetOutputSamplingRate() {
   AMediaFormat* format = AMediaCodec_getOutputFormat(media_codec_.get());
   int sample_rate = 0;
   AMediaFormat_getInt32(format, AMEDIAFORMAT_KEY_SAMPLE_RATE, &sample_rate);
   DCHECK(sample_rate != 0);
   return sample_rate;
 }
 
 MediaCodecStatus NdkMediaCodecBridge::QueueInputBuffer(
     int index,
-    const uint8* data,
+    const uint8_t* data,
     size_t data_size,
     const base::TimeDelta& presentation_time) {
-  if (data_size > base::checked_cast<size_t>(kint32max))
+  if (data_size >
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
+  }
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   media_status_t status =
       AMediaCodec_queueInputBuffer(media_codec_.get(), index, 0, data_size,
                                    presentation_time.InMicroseconds(), 0);
   return TranslateMediaCodecStatus(status);
 }
 
 MediaCodecStatus NdkMediaCodecBridge::QueueSecureInputBuffer(
     int index,
-    const uint8* data,
+    const uint8_t* data,
     size_t data_size,
     const std::vector<char>& key_id,
     const std::vector<char>& iv,
     const SubsampleEntry* subsamples,
     int subsamples_size,
     const base::TimeDelta& presentation_time) {
-  if (data_size > base::checked_cast<size_t>(kint32max))
+  if (data_size >
+      base::checked_cast<size_t>(std::numeric_limits<int32_t>::max())) {
     return MEDIA_CODEC_ERROR;
+  }
   if (key_id.size() > 16 || iv.size())
     return MEDIA_CODEC_ERROR;
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
   std::vector<size_t> clear_data, encrypted_data;
   if (subsamples_size == 0) {
     DCHECK(!subsamples);
     clear_data.push_back(0);
     encrypted_data.push_back(data_size);
   } else {
     DCHECK_GT(subsamples_size, 0);
     DCHECK(subsamples);
     for (int i = 0; i < subsamples_size; ++i) {
-      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16>::max());
+      DCHECK(subsamples[i].clear_bytes <= std::numeric_limits<uint16_t>::max());
       if (subsamples[i].cypher_bytes >
-          static_cast<uint32>(std::numeric_limits<int32>::max())) {
+          static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
         return MEDIA_CODEC_ERROR;
       }
       clear_data.push_back(subsamples[i].clear_bytes);
       encrypted_data.push_back(subsamples[i].cypher_bytes);
     }
   }
 
   AMediaCodecCryptoInfo* crypto_info = AMediaCodecCryptoInfo_new(
       new_subsamples_size,
-      reinterpret_cast<uint8*>(const_cast<char*>(key_id.data())),
-      reinterpret_cast<uint8*>(const_cast<char*>(iv.data())),
+      reinterpret_cast<uint8_t*>(const_cast<char*>(key_id.data())),
+      reinterpret_cast<uint8_t*>(const_cast<char*>(iv.data())),
       AMEDIACODECRYPTOINFO_MODE_AES_CTR, clear_data.data(),
       encrypted_data.data());
 
   media_status_t status = AMediaCodec_queueSecureInputBuffer(
       media_codec_.get(), index, 0, crypto_info,
       presentation_time.InMicroseconds(), 0);
   return TranslateMediaCodecStatus(status);
 }
 
 void NdkMediaCodecBridge::QueueEOS(int input_buffer_index) {
@@ skipping 39 matching lines @@
     return MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER;
   else
     return MEDIA_CODEC_ERROR;
 }
 
 void NdkMediaCodecBridge::ReleaseOutputBuffer(int index, bool render) {
   AMediaCodec_releaseOutputBuffer(media_codec_.get(), index, render);
 }
 
 void NdkMediaCodecBridge::GetInputBuffer(int input_buffer_index,
-                                         uint8** data,
+                                         uint8_t** data,
                                          size_t* capacity) {
   *data = AMediaCodec_getInputBuffer(media_codec_.get(), input_buffer_index,
                                      capacity);
 }
 
 bool NdkMediaCodecBridge::CopyFromOutputBuffer(int index,
                                                size_t offset,
                                                void* dst,
                                                int dst_size) {
   size_t capacity;
   uint8_t* src_data =
       AMediaCodec_getOutputBuffer(media_codec_.get(), index, &capacity);
 
   if (capacity < offset || capacity - offset < static_cast<size_t>(dst_size))
     return false;
 
   memcpy(dst, src_data + offset, dst_size);
   return true;
 }
 
 }  // namespace media