Replace scoped_ptr with unique_ptr in webrtc/api/

webrtc/api/java/jni/peerconnection_jni.cc

 /*
  *  Copyright 2013 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 63 matching lines @@
 #include "webrtc/system_wrappers/include/field_trial_default.h"
 #include "webrtc/system_wrappers/include/logcat_trace_context.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/voice_engine/include/voe_base.h"
 
 using cricket::WebRtcVideoDecoderFactory;
 using cricket::WebRtcVideoEncoderFactory;
 using rtc::Bind;
 using rtc::Thread;
 using rtc::ThreadManager;
-using rtc::scoped_ptr;
 using webrtc::AudioSourceInterface;
 using webrtc::AudioTrackInterface;
 using webrtc::AudioTrackVector;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DataBuffer;
 using webrtc::DataChannelInit;
 using webrtc::DataChannelInterface;
 using webrtc::DataChannelObserver;
 using webrtc::IceCandidateInterface;
 using webrtc::LogcatTraceContext;
@@ skipping 326 matching lines @@
   const jmethodID j_media_stream_ctor_;
   const ScopedGlobalRef<jclass> j_audio_track_class_;
   const jmethodID j_audio_track_ctor_;
   const ScopedGlobalRef<jclass> j_video_track_class_;
   const jmethodID j_video_track_ctor_;
   const ScopedGlobalRef<jclass> j_data_channel_class_;
   const jmethodID j_data_channel_ctor_;
   // C++ -> Java remote streams. The stored jobects are global refs and must be
   // manually deleted upon removal. Use DisposeRemoteStream().
   NativeToJavaStreamsMap remote_streams_;
-  scoped_ptr<ConstraintsWrapper> constraints_;
+  std::unique_ptr<ConstraintsWrapper> constraints_;
 };
 
 // Wrapper for a Java MediaConstraints object.  Copies all needed data so when
 // the constructor returns the Java object is no longer needed.
 class ConstraintsWrapper : public MediaConstraintsInterface {
  public:
   ConstraintsWrapper(JNIEnv* jni, jobject j_constraints) {
     PopulateConstraintsFromJavaPairList(
         jni, j_constraints, "mandatory", &mandatory_);
     PopulateConstraintsFromJavaPairList(
@@ skipping 101 matching lines @@
     jstring j_error_string = JavaStringFromStdString(jni(), error);
     jni()->CallVoidMethod(*j_observer_global_, m, j_error_string);
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   }
 
   JNIEnv* jni() {
     return AttachCurrentThreadIfNeeded();
   }
 
  private:
-  scoped_ptr<ConstraintsWrapper> constraints_;
+  std::unique_ptr<ConstraintsWrapper> constraints_;
   const ScopedGlobalRef<jobject> j_observer_global_;
   const ScopedGlobalRef<jclass> j_observer_class_;
 };
 
 class CreateSdpObserverWrapper
     : public SdpObserverWrapper<CreateSessionDescriptionObserver> {
  public:
   CreateSdpObserverWrapper(JNIEnv* jni, jobject j_observer,
                            ConstraintsWrapper* constraints)
       : SdpObserverWrapper(jni, j_observer, constraints) {}
@@ skipping 252 matching lines @@
 
 static DataChannelInterface* ExtractNativeDC(JNIEnv* jni, jobject j_dc) {
   jfieldID native_dc_id = GetFieldID(jni,
       GetObjectClass(jni, j_dc), "nativeDataChannel", "J");
   jlong j_d = GetLongField(jni, j_dc, native_dc_id);
   return reinterpret_cast<DataChannelInterface*>(j_d);
 }
 
 JOW(jlong, DataChannel_registerObserverNative)(
     JNIEnv* jni, jobject j_dc, jobject j_observer) {
-  scoped_ptr<DataChannelObserverWrapper> observer(
+  std::unique_ptr<DataChannelObserverWrapper> observer(
       new DataChannelObserverWrapper(jni, j_observer));
   ExtractNativeDC(jni, j_dc)->RegisterObserver(observer.get());
   return jlongFromPointer(observer.release());
 }
 
 JOW(void, DataChannel_unregisterObserverNative)(
     JNIEnv* jni, jobject j_dc, jlong native_observer) {
   ExtractNativeDC(jni, j_dc)->UnregisterObserver();
   delete reinterpret_cast<DataChannelObserverWrapper*>(native_observer);
 }
@@ skipping 224 matching lines @@
   WebRtcVideoDecoderFactory* decoder_factory() { return decoder_factory_; }
   rtc::NetworkMonitorFactory* network_monitor_factory() {
     return network_monitor_factory_;
   }
   void clear_network_monitor_factory() { network_monitor_factory_ = nullptr; }
   void InvokeJavaCallbacksOnFactoryThreads();
 
  private:
   void JavaCallbackOnFactoryThreads();
 
-  const scoped_ptr<Thread> worker_thread_;
-  const scoped_ptr<Thread> signaling_thread_;
+  const std::unique_ptr<Thread> worker_thread_;
+  const std::unique_ptr<Thread> signaling_thread_;
   WebRtcVideoEncoderFactory* encoder_factory_;
   WebRtcVideoDecoderFactory* decoder_factory_;
   rtc::NetworkMonitorFactory* network_monitor_factory_;
   PeerConnectionFactoryInterface* factory_;  // Const after ctor except dtor.
 };
 
 void OwnedFactoryAndThreads::JavaCallbackOnFactoryThreads() {
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
   jclass j_factory_class = FindClass(jni, "org/webrtc/PeerConnectionFactory");
@@ skipping 136 matching lines @@
   return (jlong)stream.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoSource)(
     JNIEnv* jni, jclass, jlong native_factory, jobject j_egl_context,
     jobject j_video_capturer, jobject j_constraints) {
   // Create a cricket::VideoCapturer from |j_video_capturer|.
   rtc::scoped_refptr<webrtc::AndroidVideoCapturerDelegate> delegate =
       new rtc::RefCountedObject<AndroidVideoCapturerJni>(
           jni, j_video_capturer, j_egl_context);
-  rtc::scoped_ptr<cricket::VideoCapturer> capturer(
+  std::unique_ptr<cricket::VideoCapturer> capturer(
       new webrtc::AndroidVideoCapturer(delegate));
   // Create a webrtc::VideoTrackSourceInterface from the cricket::VideoCapturer,
   // native factory and constraints.
-  scoped_ptr<ConstraintsWrapper> constraints(
+  std::unique_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<VideoTrackSourceInterface> source(
       factory->CreateVideoSource(capturer.release(), constraints.get()));
   return (jlong)source.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateVideoTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
     jlong native_source) {
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<VideoTrackInterface> track(factory->CreateVideoTrack(
       JavaToStdString(jni, id),
       reinterpret_cast<VideoTrackSourceInterface*>(native_source)));
   return (jlong)track.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateAudioSource)(
     JNIEnv* jni, jclass, jlong native_factory, jobject j_constraints) {
-  scoped_ptr<ConstraintsWrapper> constraints(
+  std::unique_ptr<ConstraintsWrapper> constraints(
       new ConstraintsWrapper(jni, j_constraints));
   rtc::scoped_refptr<PeerConnectionFactoryInterface> factory(
       factoryFromJava(native_factory));
   rtc::scoped_refptr<AudioSourceInterface> source(
       factory->CreateAudioSource(constraints.get()));
   return (jlong)source.release();
 }
 
 JOW(jlong, PeerConnectionFactory_nativeCreateAudioTrack)(
     JNIEnv* jni, jclass, jlong native_factory, jstring id,
@@ skipping 434 matching lines @@
   PeerConnectionInterface::RTCConfiguration rtc_config;
   JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config);
   return ExtractNativePC(jni, j_pc)->SetConfiguration(rtc_config);
 }
 
 JOW(jboolean, PeerConnection_nativeAddIceCandidate)(
     JNIEnv* jni, jobject j_pc, jstring j_sdp_mid,
     jint j_sdp_mline_index, jstring j_candidate_sdp) {
   std::string sdp_mid = JavaToStdString(jni, j_sdp_mid);
   std::string sdp = JavaToStdString(jni, j_candidate_sdp);
-  scoped_ptr<IceCandidateInterface> candidate(
+  std::unique_ptr<IceCandidateInterface> candidate(
       webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, NULL));
   return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get());
 }
 
 static cricket::Candidate GetCandidateFromJava(JNIEnv* jni,
                                                jobject j_candidate) {
   jclass j_candidate_class = GetObjectClass(jni, j_candidate);
   jfieldID j_sdp_mid_id =
       GetFieldID(jni, j_candidate_class, "sdpMid", "Ljava/lang/String;");
   std::string sdp_mid =
@@ skipping 144 matching lines @@
 }
 
 JOW(jobject, MediaSource_nativeState)(JNIEnv* jni, jclass, jlong j_p) {
   rtc::scoped_refptr<MediaSourceInterface> p(
       reinterpret_cast<MediaSourceInterface*>(j_p));
   return JavaEnumFromIndex(jni, "MediaSource$State", p->state());
 }
 
 JOW(jlong, VideoRenderer_nativeWrapVideoRenderer)(
     JNIEnv* jni, jclass, jobject j_callbacks) {
-  scoped_ptr<JavaVideoRendererWrapper> renderer(
+  std::unique_ptr<JavaVideoRendererWrapper> renderer(
       new JavaVideoRendererWrapper(jni, j_callbacks));
   return (jlong)renderer.release();
 }
 
 JOW(void, VideoRenderer_nativeCopyPlane)(
     JNIEnv *jni, jclass, jobject j_src_buffer, jint width, jint height,
     jint src_stride, jobject j_dst_buffer, jint dst_stride) {
   size_t src_size = jni->GetDirectBufferCapacity(j_src_buffer);
   size_t dst_size = jni->GetDirectBufferCapacity(j_dst_buffer);
   RTC_CHECK(src_stride >= width) << "Wrong source stride " << src_stride;
@@ skipping 93 matching lines @@
     JNIEnv* jni, jclass, jlong j_sink) {
   rtc::CallSessionFileRotatingLogSink* sink =
       reinterpret_cast<rtc::CallSessionFileRotatingLogSink*>(j_sink);
   rtc::LogMessage::RemoveLogToStream(sink);
   delete sink;
 }
 
 JOW(jbyteArray, CallSessionFileRotatingLogSink_nativeGetLogData)(
     JNIEnv* jni, jclass, jstring j_dirPath) {
   std::string dir_path = JavaToStdString(jni, j_dirPath);
-  rtc::scoped_ptr<rtc::CallSessionFileRotatingStream> stream(
+  std::unique_ptr<rtc::CallSessionFileRotatingStream> stream(
       new rtc::CallSessionFileRotatingStream(dir_path));
   if (!stream->Open()) {
     LOG_V(rtc::LoggingSeverity::LS_WARNING) <<
         "Failed to open CallSessionFileRotatingStream for path " << dir_path;
     return jni->NewByteArray(0);
   }
   size_t log_size = 0;
   if (!stream->GetSize(&log_size) || log_size == 0) {
     LOG_V(rtc::LoggingSeverity::LS_WARNING) <<
         "CallSessionFileRotatingStream returns 0 size for path " << dir_path;
     return jni->NewByteArray(0);
   }
 
   size_t read = 0;
-  rtc::scoped_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size)));
+  std::unique_ptr<jbyte> buffer(static_cast<jbyte*>(malloc(log_size)));
   stream->ReadAll(buffer.get(), log_size, &read, nullptr);
 
   jbyteArray result = jni->NewByteArray(read);
   jni->SetByteArrayRegion(result, 0, read, buffer.get());
 
   return result;
 }
 
 JOW(jboolean, RtpSender_nativeSetTrack)(JNIEnv* jni,
                                     jclass,
@@ skipping 193 matching lines @@
   return JavaStringFromStdString(
       jni,
       reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
 }
 
 JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
 }
 
 }  // namespace webrtc_jni