Replace NULL with nullptr in all C++ files.

webrtc/sdk/android/src/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 98 matching lines @@
 using webrtc::StatsReport;
 using webrtc::StatsReports;
 using webrtc::VideoTrackSourceInterface;
 using webrtc::VideoTrackInterface;
 using webrtc::VideoTrackVector;
 using webrtc::kVideoCodecVP8;
 
 namespace webrtc_jni {
 
 // Field trials initialization string
-static char *field_trials_init_string = NULL;
+static char* field_trials_init_string = nullptr;
 
 // Set in PeerConnectionFactory_initializeAndroidGlobals().
 static bool factory_static_initialized = false;
 static bool video_hw_acceleration_enabled = true;
 static jobject j_application_context = nullptr;
 
 // Return the (singleton) Java Enum object corresponding to |index|;
 // |state_class_fragment| is something like "MediaSource$State".
 static jobject JavaEnumFromIndex(
     JNIEnv* jni, const std::string& state_class_fragment, int index) {
@@ skipping 352 matching lines @@
         jni->NewObject(*candidate_class, ctor, j_mid, -1, j_sdp);
     CHECK_EXCEPTION(jni) << "error during Java Candidate NewObject";
     return j_candidate;
   }
 
   jobjectArray ToJavaCandidateArray(
       JNIEnv* jni,
       const std::vector<cricket::Candidate>& candidates) {
     jclass candidate_class = FindClass(jni, "org/webrtc/IceCandidate");
     jobjectArray java_candidates =
-        jni->NewObjectArray(candidates.size(), candidate_class, NULL);
+        jni->NewObjectArray(candidates.size(), candidate_class, nullptr);
     int i = 0;
     for (const cricket::Candidate& candidate : candidates) {
       jobject j_candidate = ToJavaCandidate(jni, &candidate_class, candidate);
       jni->SetObjectArrayElement(java_candidates, i++, j_candidate);
     }
     return java_candidates;
   }
 
   jobjectArray ToJavaMediaStreamArray(
       JNIEnv* jni,
@@ skipping 284 matching lines @@
     jobjectArray j_reports = ReportsToJava(jni(), reports);
     jmethodID m = GetMethodID(jni(), *j_observer_class_, "onComplete",
                               "([Lorg/webrtc/StatsReport;)V");
     jni()->CallVoidMethod(*j_observer_global_, m, j_reports);
     CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   }
 
  private:
   jobjectArray ReportsToJava(
       JNIEnv* jni, const StatsReports& reports) {
-    jobjectArray reports_array = jni->NewObjectArray(
-        reports.size(), *j_stats_report_class_, NULL);
+    jobjectArray reports_array =
+        jni->NewObjectArray(reports.size(), *j_stats_report_class_, nullptr);
     int i = 0;
     for (const auto* report : reports) {
       ScopedLocalRefFrame local_ref_frame(jni);
       jstring j_id = JavaStringFromStdString(jni, report->id()->ToString());
       jstring j_type = JavaStringFromStdString(jni, report->TypeToString());
       jobjectArray j_values = ValuesToJava(jni, report->values());
       jobject j_report = jni->NewObject(*j_stats_report_class_,
                                         j_stats_report_ctor_,
                                         j_id,
                                         j_type,
                                         report->timestamp(),
                                         j_values);
       jni->SetObjectArrayElement(reports_array, i++, j_report);
     }
     return reports_array;
   }
 
   jobjectArray ValuesToJava(JNIEnv* jni, const StatsReport::Values& values) {
-    jobjectArray j_values = jni->NewObjectArray(
-        values.size(), *j_value_class_, NULL);
+    jobjectArray j_values =
+        jni->NewObjectArray(values.size(), *j_value_class_, nullptr);
     int i = 0;
     for (const auto& it : values) {
       ScopedLocalRefFrame local_ref_frame(jni);
       // Should we use the '.name' enum value here instead of converting the
       // name to a string?
       jstring j_name = JavaStringFromStdString(jni, it.second->display_name());
       jstring j_value = JavaStringFromStdString(jni, it.second->ToString());
       jobject j_element_value =
           jni->NewObject(*j_value_class_, j_value_ctor_, j_name, j_value);
       jni->SetObjectArrayElement(j_values, i++, j_element_value);
@@ skipping 52 matching lines @@
   // Make a shallow copy of |frame| to be used with Java. The callee has
   // ownership of the frame, and the frame should be released with
   // VideoRenderer.releaseNativeFrame().
   static jlong javaShallowCopy(const webrtc::VideoFrame* frame) {
     return jlongFromPointer(new webrtc::VideoFrame(*frame));
   }
 
   // Return a VideoRenderer.I420Frame referring to the data in |frame|.
   jobject CricketToJavaI420Frame(const webrtc::VideoFrame* frame) {
     jintArray strides = jni()->NewIntArray(3);
-    jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
+    jint* strides_array = jni()->GetIntArrayElements(strides, nullptr);
     strides_array[0] = frame->video_frame_buffer()->StrideY();
     strides_array[1] = frame->video_frame_buffer()->StrideU();
     strides_array[2] = frame->video_frame_buffer()->StrideV();
     jni()->ReleaseIntArrayElements(strides, strides_array, 0);
-    jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
+    jobjectArray planes =
+        jni()->NewObjectArray(3, *j_byte_buffer_class_, nullptr);
     jobject y_buffer = jni()->NewDirectByteBuffer(
         const_cast<uint8_t*>(frame->video_frame_buffer()->DataY()),
         frame->video_frame_buffer()->StrideY() *
             frame->video_frame_buffer()->height());
     size_t chroma_height = (frame->height() + 1) / 2;
     jobject u_buffer = jni()->NewDirectByteBuffer(
         const_cast<uint8_t*>(frame->video_frame_buffer()->DataU()),
         frame->video_frame_buffer()->StrideU() * chroma_height);
     jobject v_buffer = jni()->NewDirectByteBuffer(
         const_cast<uint8_t*>(frame->video_frame_buffer()->DataV()),
@@ skipping 105 matching lines @@
       << "buffered_amount overflowed jlong!";
   return static_cast<jlong>(buffered_amount);
 }
 
 JOW(void, DataChannel_close)(JNIEnv* jni, jobject j_dc) {
   ExtractNativeDC(jni, j_dc)->Close();
 }
 
 JOW(jboolean, DataChannel_sendNative)(JNIEnv* jni, jobject j_dc,
                                       jbyteArray data, jboolean binary) {
-  jbyte* bytes = jni->GetByteArrayElements(data, NULL);
+  jbyte* bytes = jni->GetByteArrayElements(data, nullptr);
   bool ret = ExtractNativeDC(jni, j_dc)->Send(DataBuffer(
       rtc::CopyOnWriteBuffer(bytes, jni->GetArrayLength(data)),
       binary));
   jni->ReleaseByteArrayElements(data, bytes, JNI_ABORT);
   return ret;
 }
 
 JOW(void, DataChannel_dispose)(JNIEnv* jni, jobject j_dc) {
   CHECK_RELEASE(ExtractNativeDC(jni, j_dc));
 }
@@ skipping 117 matching lines @@
 
     if (initialize_audio)
       failure |= webrtc::VoiceEngine::SetAndroidObjects(GetJVM(), context);
     factory_static_initialized = true;
   }
   return !failure;
 }
 
 JOW(void, PeerConnectionFactory_initializeFieldTrials)(
     JNIEnv* jni, jclass, jstring j_trials_init_string) {
-  field_trials_init_string = NULL;
-  if (j_trials_init_string != NULL) {
+  field_trials_init_string = nullptr;
+  if (j_trials_init_string != nullptr) {
     const char* init_string =
-        jni->GetStringUTFChars(j_trials_init_string, NULL);
+        jni->GetStringUTFChars(j_trials_init_string, nullptr);
     int init_string_length = jni->GetStringUTFLength(j_trials_init_string);
     field_trials_init_string = new char[init_string_length + 1];
     rtc::strcpyn(field_trials_init_string, init_string_length + 1, init_string);
     jni->ReleaseStringUTFChars(j_trials_init_string, init_string);
     LOG(LS_INFO) << "initializeFieldTrials: " << field_trials_init_string;
   }
   webrtc::field_trial::InitFieldTrialsFromString(field_trials_init_string);
 }
 
 JOW(void, PeerConnectionFactory_initializeInternalTracer)(JNIEnv* jni, jclass) {
   rtc::tracing::SetupInternalTracer();
 }
 
 JOW(jstring, PeerConnectionFactory_nativeFieldTrialsFindFullName)
 (JNIEnv* jni, jclass, jstring j_name) {
   return JavaStringFromStdString(
       jni, webrtc::field_trial::FindFullName(JavaToStdString(jni, j_name)));
 }
 
 JOW(jboolean, PeerConnectionFactory_startInternalTracingCapture)(
     JNIEnv* jni, jclass, jstring j_event_tracing_filename) {
   if (!j_event_tracing_filename)
     return false;
 
   const char* init_string =
-      jni->GetStringUTFChars(j_event_tracing_filename, NULL);
+      jni->GetStringUTFChars(j_event_tracing_filename, nullptr);
   LOG(LS_INFO) << "Starting internal tracing to: " << init_string;
   bool ret = rtc::tracing::StartInternalCapture(init_string);
   jni->ReleaseStringUTFChars(j_event_tracing_filename, init_string);
   return ret;
 }
 
 JOW(void, PeerConnectionFactory_stopInternalTracingCapture)(
     JNIEnv* jni, jclass) {
   rtc::tracing::StopInternalCapture();
 }
@@ skipping 130 matching lines @@
   std::unique_ptr<Thread> network_thread =
       rtc::Thread::CreateWithSocketServer();
   network_thread->SetName("network_thread", nullptr);
   RTC_CHECK(network_thread->Start()) << "Failed to start thread";
 
   std::unique_ptr<Thread> worker_thread = rtc::Thread::Create();
   worker_thread->SetName("worker_thread", nullptr);
   RTC_CHECK(worker_thread->Start()) << "Failed to start thread";
 
   std::unique_ptr<Thread> signaling_thread = rtc::Thread::Create();
-  signaling_thread->SetName("signaling_thread", NULL);
+  signaling_thread->SetName("signaling_thread", nullptr);
   RTC_CHECK(signaling_thread->Start()) << "Failed to start thread";
 
   WebRtcVideoEncoderFactory* encoder_factory = nullptr;
   WebRtcVideoDecoderFactory* decoder_factory = nullptr;
   rtc::NetworkMonitorFactory* network_monitor_factory = nullptr;
 
   PeerConnectionFactoryInterface::Options options;
-  bool has_options = joptions != NULL;
+  bool has_options = joptions != nullptr;
   if (has_options) {
     options = ParseOptionsFromJava(jni, joptions);
   }
 
   if (video_hw_acceleration_enabled) {
     encoder_factory = new MediaCodecVideoEncoderFactory();
     decoder_factory = new MediaCodecVideoDecoderFactory();
   }
   // Do not create network_monitor_factory only if the options are
   // provided and disable_network_monitor therein is set to true.
@@ skipping 17 matching lines @@
       std::move(network_thread), std::move(worker_thread),
       std::move(signaling_thread), encoder_factory, decoder_factory,
       network_monitor_factory, factory.release());
   owned_factory->InvokeJavaCallbacksOnFactoryThreads();
   return jlongFromPointer(owned_factory);
 }
 
 JOW(void, PeerConnectionFactory_nativeFreeFactory)(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<OwnedFactoryAndThreads*>(j_p);
   if (field_trials_init_string) {
-    webrtc::field_trial::InitFieldTrialsFromString(NULL);
+    webrtc::field_trial::InitFieldTrialsFromString(nullptr);
     delete field_trials_init_string;
-    field_trials_init_string = NULL;
+    field_trials_init_string = nullptr;
   }
   webrtc::Trace::ReturnTrace();
 }
 
 static PeerConnectionFactoryInterface* factoryFromJava(jlong j_p) {
   return reinterpret_cast<OwnedFactoryAndThreads*>(j_p)->factory();
 }
 
 JOW(void, PeerConnectionFactory_nativeThreadsCallbacks)(
     JNIEnv*, jclass, jlong j_p) {
@@ skipping 473 matching lines @@
   jfieldID native_pc_id = GetFieldID(jni,
       GetObjectClass(jni, j_pc), "nativePeerConnection", "J");
   jlong j_p = GetLongField(jni, j_pc, native_pc_id);
   return rtc::scoped_refptr<PeerConnectionInterface>(
       reinterpret_cast<PeerConnectionInterface*>(j_p));
 }
 
 JOW(jobject, PeerConnection_getLocalDescription)(JNIEnv* jni, jobject j_pc) {
   const SessionDescriptionInterface* sdp =
       ExtractNativePC(jni, j_pc)->local_description();
-  return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL;
+  return sdp ? JavaSdpFromNativeSdp(jni, sdp) : nullptr;
 }
 
 JOW(jobject, PeerConnection_getRemoteDescription)(JNIEnv* jni, jobject j_pc) {
   const SessionDescriptionInterface* sdp =
       ExtractNativePC(jni, j_pc)->remote_description();
-  return sdp ? JavaSdpFromNativeSdp(jni, sdp) : NULL;
+  return sdp ? JavaSdpFromNativeSdp(jni, sdp) : nullptr;
 }
 
 JOW(jobject, PeerConnection_createDataChannel)(
     JNIEnv* jni, jobject j_pc, jstring j_label, jobject j_init) {
   DataChannelInit init = JavaDataChannelInitToNative(jni, j_init);
   rtc::scoped_refptr<DataChannelInterface> channel(
       ExtractNativePC(jni, j_pc)->CreateDataChannel(
           JavaToStdString(jni, j_label), &init));
   // Mustn't pass channel.get() directly through NewObject to avoid reading its
   // vararg parameter as 64-bit and reading memory that doesn't belong to the
@@ skipping 48 matching lines @@
   jstring j_type_string = (jstring)jni->CallObjectMethod(
       j_type, j_canonical_form_id);
   CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
   std::string std_type = JavaToStdString(jni, j_type_string);
 
   jfieldID j_description_id = GetFieldID(
       jni, GetObjectClass(jni, j_sdp), "description", "Ljava/lang/String;");
   jstring j_description = (jstring)GetObjectField(jni, j_sdp, j_description_id);
   std::string std_description = JavaToStdString(jni, j_description);
 
-  return webrtc::CreateSessionDescription(
-      std_type, std_description, NULL);
+  return webrtc::CreateSessionDescription(std_type, std_description, nullptr);
 }
 
 JOW(void, PeerConnection_setLocalDescription)(
     JNIEnv* jni, jobject j_pc,
     jobject j_observer, jobject j_sdp) {
   rtc::scoped_refptr<SetSdpObserverWrapper> observer(
-      new rtc::RefCountedObject<SetSdpObserverWrapper>(
-          jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
+      new rtc::RefCountedObject<SetSdpObserverWrapper>(jni, j_observer,
+                                                       nullptr));
   ExtractNativePC(jni, j_pc)->SetLocalDescription(
       observer, JavaSdpToNativeSdp(jni, j_sdp));
 }
 
 JOW(void, PeerConnection_setRemoteDescription)(
     JNIEnv* jni, jobject j_pc,
     jobject j_observer, jobject j_sdp) {
   rtc::scoped_refptr<SetSdpObserverWrapper> observer(
-      new rtc::RefCountedObject<SetSdpObserverWrapper>(
-          jni, j_observer, reinterpret_cast<ConstraintsWrapper*>(NULL)));
+      new rtc::RefCountedObject<SetSdpObserverWrapper>(jni, j_observer,
+                                                       nullptr));
   ExtractNativePC(jni, j_pc)->SetRemoteDescription(
       observer, JavaSdpToNativeSdp(jni, j_sdp));
 }
 
 JOW(jboolean, PeerConnection_nativeSetConfiguration)(
     JNIEnv* jni, jobject j_pc, jobject j_rtc_config, jlong native_observer) {
   // Need to merge constraints into RTCConfiguration again, which are stored
   // in the observer object.
   PCOJava* observer = reinterpret_cast<PCOJava*>(native_observer);
   PeerConnectionInterface::RTCConfiguration rtc_config(
       PeerConnectionInterface::RTCConfigurationType::kAggressive);
   JavaRTCConfigurationToJsepRTCConfiguration(jni, j_rtc_config, &rtc_config);
   CopyConstraintsIntoRtcConfiguration(observer->constraints(), &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);
   std::unique_ptr<IceCandidateInterface> candidate(
-      webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, NULL));
+      webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
   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 =
       JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_mid_id));
   jfieldID j_sdp_id =
       GetFieldID(jni, j_candidate_class, "sdp", "Ljava/lang/String;");
   std::string sdp =
       JavaToStdString(jni, GetStringField(jni, j_candidate, j_sdp_id));
   cricket::Candidate candidate;
-  if (!webrtc::SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
+  if (!webrtc::SdpDeserializeCandidate(sdp_mid, sdp, &candidate, nullptr)) {
     LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
   }
   return candidate;
 }
 
 JOW(jboolean, PeerConnection_nativeRemoveIceCandidates)
 (JNIEnv* jni, jobject j_pc, jobjectArray j_candidates) {
   std::vector<cricket::Candidate> candidates;
   size_t num_candidates = jni->GetArrayLength(j_candidates);
   for (size_t i = 0; i < num_candidates; ++i) {
@@ skipping 699 matching lines @@
   return reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)
       ->inter_tone_gap();
 }
 
 JOW(void, DtmfSender_free)
 (JNIEnv* jni, jclass, jlong j_dtmf_sender_pointer) {
   reinterpret_cast<DtmfSenderInterface*>(j_dtmf_sender_pointer)->Release();
 }
 
 }  // namespace webrtc_jni