Android: Replace webrtc_jni namespace with nested jni namespace

webrtc/sdk/android/src/jni/pc/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 27 matching lines @@
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/jni_helpers.h"
 #include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
 #include "webrtc/sdk/android/src/jni/pc/mediaconstraints_jni.h"
 #include "webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h"
 #include "webrtc/sdk/android/src/jni/pc/rtcstatscollectorcallbackwrapper.h"
 #include "webrtc/sdk/android/src/jni/pc/sdpobserver_jni.h"
 #include "webrtc/sdk/android/src/jni/pc/statsobserver_jni.h"
 #include "webrtc/system_wrappers/include/trace.h"
 
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
-static rtc::scoped_refptr<webrtc::PeerConnectionInterface> ExtractNativePC(
+static rtc::scoped_refptr<PeerConnectionInterface> ExtractNativePC(
     JNIEnv* jni,
     jobject j_pc) {
   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<webrtc::PeerConnectionInterface>(
-      reinterpret_cast<webrtc::PeerConnectionInterface*>(j_p));
+  return rtc::scoped_refptr<PeerConnectionInterface>(
+      reinterpret_cast<PeerConnectionInterface*>(j_p));
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          PeerConnection_freeObserver,
                          JNIEnv*,
                          jclass,
                          jlong j_p) {
   PeerConnectionObserverJni* p =
       reinterpret_cast<PeerConnectionObserverJni*>(j_p);
   delete p;
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_getLocalDescription,
                          JNIEnv* jni,
                          jobject j_pc) {
-  const webrtc::SessionDescriptionInterface* sdp =
+  const SessionDescriptionInterface* sdp =
       ExtractNativePC(jni, j_pc)->local_description();
   return sdp ? NativeToJavaSessionDescription(jni, sdp) : NULL;
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_getRemoteDescription,
                          JNIEnv* jni,
                          jobject j_pc) {
-  const webrtc::SessionDescriptionInterface* sdp =
+  const SessionDescriptionInterface* sdp =
       ExtractNativePC(jni, j_pc)->remote_description();
   return sdp ? NativeToJavaSessionDescription(jni, sdp) : NULL;
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_createDataChannel,
                          JNIEnv* jni,
                          jobject j_pc,
                          jstring j_label,
                          jobject j_init) {
-  webrtc::DataChannelInit init = JavaToNativeDataChannelInit(jni, j_init);
-  rtc::scoped_refptr<webrtc::DataChannelInterface> channel(
+  DataChannelInit init = JavaToNativeDataChannelInit(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
   // 32-bit parameter.
   jlong nativeChannelPtr = jlongFromPointer(channel.get());
   if (!nativeChannelPtr) {
     LOG(LS_ERROR) << "Failed to create DataChannel";
     return nullptr;
   }
@@ skipping 64 matching lines @@
 JNI_FUNCTION_DECLARATION(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.
   PeerConnectionObserverJni* observer =
       reinterpret_cast<PeerConnectionObserverJni*>(native_observer);
-  webrtc::PeerConnectionInterface::RTCConfiguration rtc_config(
-      webrtc::PeerConnectionInterface::RTCConfigurationType::kAggressive);
+  PeerConnectionInterface::RTCConfiguration rtc_config(
+      PeerConnectionInterface::RTCConfigurationType::kAggressive);
   JavaToNativeRTCConfiguration(jni, j_rtc_config, &rtc_config);
   CopyConstraintsIntoRtcConfiguration(observer->constraints(), &rtc_config);
   return ExtractNativePC(jni, j_pc)->SetConfiguration(rtc_config);
 }
 
 JNI_FUNCTION_DECLARATION(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<webrtc::IceCandidateInterface> candidate(
-      webrtc::CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
+  std::unique_ptr<IceCandidateInterface> candidate(
+      CreateIceCandidate(sdp_mid, j_sdp_mline_index, sdp, nullptr));
   return ExtractNativePC(jni, j_pc)->AddIceCandidate(candidate.get());
 }
 
 JNI_FUNCTION_DECLARATION(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) {
     jobject j_candidate = jni->GetObjectArrayElement(j_candidates, i);
     candidates.push_back(JavaToNativeCandidate(jni, j_candidate));
   }
   return ExtractNativePC(jni, j_pc)->RemoveIceCandidates(candidates);
 }
 
 JNI_FUNCTION_DECLARATION(jboolean,
                          PeerConnection_nativeAddLocalStream,
                          JNIEnv* jni,
                          jobject j_pc,
                          jlong native_stream) {
   return ExtractNativePC(jni, j_pc)->AddStream(
-      reinterpret_cast<webrtc::MediaStreamInterface*>(native_stream));
+      reinterpret_cast<MediaStreamInterface*>(native_stream));
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          PeerConnection_nativeRemoveLocalStream,
                          JNIEnv* jni,
                          jobject j_pc,
                          jlong native_stream) {
   ExtractNativePC(jni, j_pc)->RemoveStream(
-      reinterpret_cast<webrtc::MediaStreamInterface*>(native_stream));
+      reinterpret_cast<MediaStreamInterface*>(native_stream));
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_nativeCreateSender,
                          JNIEnv* jni,
                          jobject j_pc,
                          jstring j_kind,
                          jstring j_stream_id) {
   jclass j_rtp_sender_class = FindClass(jni, "org/webrtc/RtpSender");
   jmethodID j_rtp_sender_ctor =
       GetMethodID(jni, j_rtp_sender_class, "<init>", "(J)V");
 
   std::string kind = JavaToStdString(jni, j_kind);
   std::string stream_id = JavaToStdString(jni, j_stream_id);
-  rtc::scoped_refptr<webrtc::RtpSenderInterface> sender =
+  rtc::scoped_refptr<RtpSenderInterface> sender =
       ExtractNativePC(jni, j_pc)->CreateSender(kind, stream_id);
   if (!sender.get()) {
     return nullptr;
   }
   jlong nativeSenderPtr = jlongFromPointer(sender.get());
   jobject j_sender =
       jni->NewObject(j_rtp_sender_class, j_rtp_sender_ctor, nativeSenderPtr);
   CHECK_EXCEPTION(jni) << "error during NewObject";
   // Sender is now owned by the Java object, and will be freed from
   // RtpSender.dispose(), called by PeerConnection.dispose() or getSenders().
@@ skipping 64 matching lines @@
 
 JNI_FUNCTION_DECLARATION(bool,
                          PeerConnection_nativeOldGetStats,
                          JNIEnv* jni,
                          jobject j_pc,
                          jobject j_observer,
                          jlong native_track) {
   rtc::scoped_refptr<StatsObserverJni> observer(
       new rtc::RefCountedObject<StatsObserverJni>(jni, j_observer));
   return ExtractNativePC(jni, j_pc)->GetStats(
-      observer,
-      reinterpret_cast<webrtc::MediaStreamTrackInterface*>(native_track),
-      webrtc::PeerConnectionInterface::kStatsOutputLevelStandard);
+      observer, reinterpret_cast<MediaStreamTrackInterface*>(native_track),
+      PeerConnectionInterface::kStatsOutputLevelStandard);
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          PeerConnection_nativeNewGetStats,
                          JNIEnv* jni,
                          jobject j_pc,
                          jobject j_callback) {
   rtc::scoped_refptr<RTCStatsCollectorCallbackWrapper> callback(
       new rtc::RefCountedObject<RTCStatsCollectorCallbackWrapper>(jni,
                                                                   j_callback));
   ExtractNativePC(jni, j_pc)->GetStats(callback);
 }
 
 JNI_FUNCTION_DECLARATION(jboolean,
                          PeerConnection_setBitrate,
                          JNIEnv* jni,
                          jobject j_pc,
                          jobject j_min,
                          jobject j_current,
                          jobject j_max) {
-  webrtc::PeerConnectionInterface::BitrateParameters params;
+  PeerConnectionInterface::BitrateParameters params;
   jclass j_integer_class = jni->FindClass("java/lang/Integer");
   jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I");
   if (!IsNull(jni, j_min)) {
     int min_value = jni->CallIntMethod(j_min, int_value_id);
     params.min_bitrate_bps = rtc::Optional<int>(min_value);
   }
   if (!IsNull(jni, j_current)) {
     int current_value = jni->CallIntMethod(j_current, int_value_id);
     params.current_bitrate_bps = rtc::Optional<int>(current_value);
   }
@@ skipping 18 matching lines @@
                          PeerConnection_nativeStopRtcEventLog,
                          JNIEnv* jni,
                          jobject j_pc) {
   ExtractNativePC(jni, j_pc)->StopRtcEventLog();
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_signalingState,
                          JNIEnv* jni,
                          jobject j_pc) {
-  webrtc::PeerConnectionInterface::SignalingState state =
+  PeerConnectionInterface::SignalingState state =
       ExtractNativePC(jni, j_pc)->signaling_state();
   return JavaEnumFromIndexAndClassName(jni, "PeerConnection$SignalingState",
                                        state);
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_iceConnectionState,
                          JNIEnv* jni,
                          jobject j_pc) {
-  webrtc::PeerConnectionInterface::IceConnectionState state =
+  PeerConnectionInterface::IceConnectionState state =
       ExtractNativePC(jni, j_pc)->ice_connection_state();
   return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceConnectionState",
                                        state);
 }
 
 JNI_FUNCTION_DECLARATION(jobject,
                          PeerConnection_iceGatheringState,
                          JNIEnv* jni,
                          jobject j_pc) {
-  webrtc::PeerConnectionInterface::IceGatheringState state =
+  PeerConnectionInterface::IceGatheringState state =
       ExtractNativePC(jni, j_pc)->ice_gathering_state();
   return JavaEnumFromIndexAndClassName(jni, "PeerConnection$IceGatheringState",
                                        state);
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          PeerConnection_close,
                          JNIEnv* jni,
                          jobject j_pc) {
   ExtractNativePC(jni, j_pc)->Close();
   return;
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc