Replace scoped_ptr with std::unique_ptr in //media/base.

media/base/android/sdk_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/sdk_media_codec_bridge.h"
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <utility>
 
 #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/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "jni/MediaCodecBridge_jni.h"
@@ skipping 16 matching lines @@
 
 namespace media {
 
 enum {
   kBufferFlagSyncFrame = 1,    // BUFFER_FLAG_SYNC_FRAME
   kBufferFlagEndOfStream = 4,  // BUFFER_FLAG_END_OF_STREAM
   kConfigureFlagEncode = 1,    // CONFIGURE_FLAG_ENCODE
 };
 
 static ScopedJavaLocalRef<jintArray>
-ToJavaIntArray(JNIEnv* env, scoped_ptr<jint[]> native_array, int size) {
+ToJavaIntArray(JNIEnv* env, std::unique_ptr<jint[]> native_array, int size) {
   ScopedJavaLocalRef<jintArray> j_array(env, env->NewIntArray(size));
   env->SetIntArrayRegion(j_array.obj(), 0, size, native_array.get());
   return j_array;
 }
 
 static const std::string AudioCodecToAndroidMimeType(const AudioCodec& codec) {
   switch (codec) {
     case kCodecMP3:
       return "audio/mpeg";
     case kCodecVorbis:
@@ skipping 123 matching lines @@
       env, reinterpret_cast<const uint8_t*>(key_id.data()), key_id.size());
   ScopedJavaLocalRef<jbyteArray> j_iv = base::android::ToJavaByteArray(
       env, reinterpret_cast<const uint8_t*>(iv.data()), iv.size());
 
   // MediaCodec.CryptoInfo documentations says passing NULL for |clear_array|
   // to indicate that all data is encrypted. But it doesn't specify what
   // |cypher_array| and |subsamples_size| should be in that case. Passing
   // one subsample here just to be on the safe side.
   int new_subsamples_size = subsamples_size == 0 ? 1 : subsamples_size;
 
-  scoped_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
-  scoped_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
+  std::unique_ptr<jint[]> native_clear_array(new jint[new_subsamples_size]);
+  std::unique_ptr<jint[]> native_cypher_array(new jint[new_subsamples_size]);
 
   if (subsamples_size == 0) {
     DCHECK(!subsamples);
     native_clear_array[0] = 0;
     native_cypher_array[0] = 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_t>::max());
@@ skipping 140 matching lines @@
 
 // static
 AudioCodecBridge* AudioCodecBridge::Create(const AudioCodec& codec) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = AudioCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
-  scoped_ptr<AudioCodecBridge> bridge(new AudioCodecBridge(mime));
+  std::unique_ptr<AudioCodecBridge> bridge(new AudioCodecBridge(mime));
   if (!bridge->media_codec())
     return nullptr;
 
   return bridge.release();
 }
 
 // static
 bool AudioCodecBridge::IsKnownUnaccelerated(const AudioCodec& codec) {
   return MediaCodecUtil::IsKnownUnaccelerated(
       AudioCodecToAndroidMimeType(codec), MEDIA_CODEC_DECODER);
@@ skipping 242 matching lines @@
     jobject surface,
     jobject media_crypto,
     bool allow_adaptive_playback) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
-  scoped_ptr<VideoCodecBridge> bridge(
+  std::unique_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, is_secure, MEDIA_CODEC_DECODER));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoDecoderFormat(
           env, j_mime.obj(), size.width(), size.height()));
   DCHECK(!j_format.is_null());
@@ skipping 13 matching lines @@
                                                   int frame_rate,
                                                   int i_frame_interval,
                                                   int color_format) {
   if (!MediaCodecUtil::IsMediaCodecAvailable())
     return nullptr;
 
   const std::string mime = VideoCodecToAndroidMimeType(codec);
   if (mime.empty())
     return nullptr;
 
-  scoped_ptr<VideoCodecBridge> bridge(
+  std::unique_ptr<VideoCodecBridge> bridge(
       new VideoCodecBridge(mime, false, MEDIA_CODEC_ENCODER));
   if (!bridge->media_codec())
     return nullptr;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> j_mime = ConvertUTF8ToJavaString(env, mime);
   ScopedJavaLocalRef<jobject> j_format(
       Java_MediaCodecBridge_createVideoEncoderFormat(
           env, j_mime.obj(), size.width(), size.height(), bit_rate, frame_rate,
           i_frame_interval, color_format));
@@ skipping 27 matching lines @@
   if (adaptive_playback_supported_for_testing_ == 0)
     return false;
   else if (adaptive_playback_supported_for_testing_ > 0)
     return true;
   JNIEnv* env = AttachCurrentThread();
   return Java_MediaCodecBridge_isAdaptivePlaybackSupported(env, media_codec(),
                                                            width, height);
 }
 
 }  // namespace media