Refactor base/safe_numerics.h

media/base/android/media_codec_bridge.cc

 // Copyright (c) 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/base/android/media_codec_bridge.h"
 
 #include <jni.h>
 #include <string>
 
 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/safe_numerics.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "jni/MediaCodecBridge_jni.h"
 #include "media/base/bit_reader.h"
 #include "media/base/decrypt_config.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
@@ skipping 190 matching lines @@
   *width = Java_MediaCodecBridge_getOutputWidth(env, j_media_codec_.obj());
   *height = Java_MediaCodecBridge_getOutputHeight(env, j_media_codec_.obj());
 }
 
 MediaCodecStatus MediaCodecBridge::QueueInputBuffer(
     int index,
     const uint8* data,
     size_t data_size,
     const base::TimeDelta& presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
-  if (data_size > base::checked_numeric_cast<size_t>(kint32max))
+  if (data_size > base::checked_cast<size_t>(kint32max))
     return MEDIA_CODEC_ERROR;
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
   JNIEnv* env = AttachCurrentThread();
   return static_cast<MediaCodecStatus>(
       Java_MediaCodecBridge_queueInputBuffer(env,
                                              j_media_codec_.obj(),
                                              index,
                                              0,
                                              data_size,
                                              presentation_time.InMicroseconds(),
                                              0));
 }
 
 MediaCodecStatus MediaCodecBridge::QueueSecureInputBuffer(
     int index,
     const uint8* data,
     size_t data_size,
     const uint8* key_id,
     int key_id_size,
     const uint8* iv,
     int iv_size,
     const SubsampleEntry* subsamples,
     int subsamples_size,
     const base::TimeDelta& presentation_time) {
   DVLOG(3) << __PRETTY_FUNCTION__ << index << ": " << data_size;
-  if (data_size > base::checked_numeric_cast<size_t>(kint32max))
+  if (data_size > base::checked_cast<size_t>(kint32max))
     return MEDIA_CODEC_ERROR;
   if (data && !FillInputBuffer(index, data, data_size))
     return MEDIA_CODEC_ERROR;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jbyteArray> j_key_id =
       base::android::ToJavaByteArray(env, key_id, key_id_size);
   ScopedJavaLocalRef<jbyteArray> j_iv =
       base::android::ToJavaByteArray(env, iv, iv_size);
 
@@ skipping 76 matching lines @@
     size_t* offset,
     size_t* size,
     base::TimeDelta* presentation_time,
     bool* end_of_stream,
     bool* key_frame) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> result =
       Java_MediaCodecBridge_dequeueOutputBuffer(
           env, j_media_codec_.obj(), timeout.InMicroseconds());
   *index = Java_DequeueOutputResult_index(env, result.obj());
-  *offset = base::checked_numeric_cast<size_t>(
+  *offset = base::checked_cast<size_t>(
       Java_DequeueOutputResult_offset(env, result.obj()));
-  *size = base::checked_numeric_cast<size_t>(
+  *size = base::checked_cast<size_t>(
       Java_DequeueOutputResult_numBytes(env, result.obj()));
   if (presentation_time) {
     *presentation_time = base::TimeDelta::FromMicroseconds(
         Java_DequeueOutputResult_presentationTimeMicroseconds(env,
                                                               result.obj()));
   }
   int flags = Java_DequeueOutputResult_flags(env, result.obj());
   if (end_of_stream)
     *end_of_stream = flags & kBufferFlagEndOfStream;
   if (key_frame)
@@ skipping 36 matching lines @@
   return Java_MediaCodecBridge_getOutputBuffers(env, j_media_codec_.obj());
 }
 
 void MediaCodecBridge::GetInputBuffer(int input_buffer_index,
                                       uint8** data,
                                       size_t* capacity) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(Java_MediaCodecBridge_getInputBuffer(
       env, j_media_codec_.obj(), input_buffer_index));
   *data = static_cast<uint8*>(env->GetDirectBufferAddress(j_buffer.obj()));
-  *capacity = base::checked_numeric_cast<size_t>(
+  *capacity = base::checked_cast<size_t>(
       env->GetDirectBufferCapacity(j_buffer.obj()));
 }
 
 bool MediaCodecBridge::CopyFromOutputBuffer(int index,
                                             size_t offset,
                                             void* dst,
                                             int dst_size) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_buffer(
       Java_MediaCodecBridge_getOutputBuffer(env, j_media_codec_.obj(), index));
@@ skipping 161 matching lines @@
     default:
       LOG(ERROR) << "Invalid header encountered for codec: "
                  << AudioCodecToAndroidMimeType(codec);
       return false;
   }
   return true;
 }
 
 void AudioCodecBridge::PlayOutputBuffer(int index, size_t size) {
   DCHECK_LE(0, index);
-  int numBytes = base::checked_numeric_cast<int>(size);
+  int numBytes = base::checked_cast<int>(size);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> buf =
       Java_MediaCodecBridge_getOutputBuffer(env, media_codec(), index);
   uint8* buffer = static_cast<uint8*>(env->GetDirectBufferAddress(buf.obj()));
 
   ScopedJavaLocalRef<jbyteArray> byte_array =
       base::android::ToJavaByteArray(env, buffer, numBytes);
   Java_MediaCodecBridge_playOutputBuffer(env, media_codec(), byte_array.obj());
 }
 
@@ skipping 104 matching lines @@
 void VideoCodecBridge::RequestKeyFrameSoon() {
   JNIEnv* env = AttachCurrentThread();
   Java_MediaCodecBridge_requestKeyFrameSoon(env, media_codec());
 }
 
 bool MediaCodecBridge::RegisterMediaCodecBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace media