Android: Replace webrtc_jni namespace with nested jni namespace

webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.cc

 /*
  *  Copyright 2017 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.
  */
 
 #include "webrtc/sdk/android/src/jni/pc/peerconnectionobserver_jni.h"
 
 #include <string>
 
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/pc/java_native_conversion.h"
 
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
 // Convenience, used since callbacks occur on the signaling thread, which may
 // be a non-Java thread.
 static JNIEnv* jni() {
   return AttachCurrentThreadIfNeeded();
 }
 
 PeerConnectionObserverJni::PeerConnectionObserverJni(JNIEnv* jni,
                                                      jobject j_observer)
     : j_observer_global_(jni, j_observer),
@@ skipping 16 matching lines @@
 
 PeerConnectionObserverJni::~PeerConnectionObserverJni() {
   ScopedLocalRefFrame local_ref_frame(jni());
   while (!remote_streams_.empty())
     DisposeRemoteStream(remote_streams_.begin());
   while (!rtp_receivers_.empty())
     DisposeRtpReceiver(rtp_receivers_.begin());
 }
 
 void PeerConnectionObserverJni::OnIceCandidate(
-    const webrtc::IceCandidateInterface* candidate) {
+    const IceCandidateInterface* candidate) {
   ScopedLocalRefFrame local_ref_frame(jni());
   std::string sdp;
   RTC_CHECK(candidate->ToString(&sdp)) << "got so far: " << sdp;
   jclass candidate_class = FindClass(jni(), "org/webrtc/IceCandidate");
   jmethodID ctor =
       GetMethodID(jni(), candidate_class, "<init>",
                   "(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;)V");
   jstring j_mid = JavaStringFromStdString(jni(), candidate->sdp_mid());
   jstring j_sdp = JavaStringFromStdString(jni(), sdp);
   jstring j_url = JavaStringFromStdString(jni(), candidate->candidate().url());
@@ skipping 10 matching lines @@
     const std::vector<cricket::Candidate>& candidates) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jobjectArray candidates_array = NativeToJavaCandidateArray(jni(), candidates);
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceCandidatesRemoved",
                             "([Lorg/webrtc/IceCandidate;)V");
   jni()->CallVoidMethod(*j_observer_global_, m, candidates_array);
   CHECK_EXCEPTION(jni()) << "Error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnSignalingChange(
-    webrtc::PeerConnectionInterface::SignalingState new_state) {
+    PeerConnectionInterface::SignalingState new_state) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onSignalingChange",
                             "(Lorg/webrtc/PeerConnection$SignalingState;)V");
   jobject new_state_enum = JavaEnumFromIndexAndClassName(
       jni(), "PeerConnection$SignalingState", new_state);
   jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnIceConnectionChange(
-    webrtc::PeerConnectionInterface::IceConnectionState new_state) {
+    PeerConnectionInterface::IceConnectionState new_state) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jmethodID m =
       GetMethodID(jni(), *j_observer_class_, "onIceConnectionChange",
                   "(Lorg/webrtc/PeerConnection$IceConnectionState;)V");
   jobject new_state_enum = JavaEnumFromIndexAndClassName(
       jni(), "PeerConnection$IceConnectionState", new_state);
   jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnIceConnectionReceivingChange(bool receiving) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jmethodID m = GetMethodID(jni(), *j_observer_class_,
                             "onIceConnectionReceivingChange", "(Z)V");
   jni()->CallVoidMethod(*j_observer_global_, m, receiving);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnIceGatheringChange(
-    webrtc::PeerConnectionInterface::IceGatheringState new_state) {
+    PeerConnectionInterface::IceGatheringState new_state) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onIceGatheringChange",
                             "(Lorg/webrtc/PeerConnection$IceGatheringState;)V");
   jobject new_state_enum = JavaEnumFromIndexAndClassName(
       jni(), "PeerConnection$IceGatheringState", new_state);
   jni()->CallVoidMethod(*j_observer_global_, m, new_state_enum);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnAddStream(
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+    rtc::scoped_refptr<MediaStreamInterface> stream) {
   ScopedLocalRefFrame local_ref_frame(jni());
   // The stream could be added into the remote_streams_ map when calling
   // OnAddTrack.
   jobject j_stream = GetOrCreateJavaStream(stream);
 
   for (const auto& track : stream->GetAudioTracks()) {
     jstring id = JavaStringFromStdString(jni(), track->id());
     // Java AudioTrack holds one reference. Corresponding Release() is in
     // MediaStreamTrack_free, triggered by AudioTrack.dispose().
     track->AddRef();
@@ skipping 30 matching lines @@
     RTC_CHECK(added);
   }
 
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onAddStream",
                             "(Lorg/webrtc/MediaStream;)V");
   jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnRemoveStream(
-    rtc::scoped_refptr<webrtc::MediaStreamInterface> stream) {
+    rtc::scoped_refptr<MediaStreamInterface> stream) {
   ScopedLocalRefFrame local_ref_frame(jni());
   NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
   RTC_CHECK(it != remote_streams_.end())
       << "unexpected stream: " << std::hex << stream;
   jobject j_stream = it->second;
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onRemoveStream",
                             "(Lorg/webrtc/MediaStream;)V");
   jni()->CallVoidMethod(*j_observer_global_, m, j_stream);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
   // Release the refptr reference so that DisposeRemoteStream can assert
   // it removes the final reference.
   stream = nullptr;
   DisposeRemoteStream(it);
 }
 
 void PeerConnectionObserverJni::OnDataChannel(
-    rtc::scoped_refptr<webrtc::DataChannelInterface> channel) {
+    rtc::scoped_refptr<DataChannelInterface> channel) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jobject j_channel =
       jni()->NewObject(*j_data_channel_class_, j_data_channel_ctor_,
                        jlongFromPointer(channel.get()));
   CHECK_EXCEPTION(jni()) << "error during NewObject";
 
   jmethodID m = GetMethodID(jni(), *j_observer_class_, "onDataChannel",
                             "(Lorg/webrtc/DataChannel;)V");
   jni()->CallVoidMethod(*j_observer_global_, m, j_channel);
 
   // Channel is now owned by Java object, and will be freed from
   // DataChannel.dispose().  Important that this be done _after_ the
   // CallVoidMethod above as Java code might call back into native code and be
   // surprised to see a refcount of 2.
   int bumped_count = channel->AddRef();
   RTC_CHECK(bumped_count == 2) << "Unexpected refcount OnDataChannel";
 
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnRenegotiationNeeded() {
   ScopedLocalRefFrame local_ref_frame(jni());
   jmethodID m =
       GetMethodID(jni(), *j_observer_class_, "onRenegotiationNeeded", "()V");
   jni()->CallVoidMethod(*j_observer_global_, m);
   CHECK_EXCEPTION(jni()) << "error during CallVoidMethod";
 }
 
 void PeerConnectionObserverJni::OnAddTrack(
-    rtc::scoped_refptr<webrtc::RtpReceiverInterface> receiver,
-    const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
-        streams) {
+    rtc::scoped_refptr<RtpReceiverInterface> receiver,
+    const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
   ScopedLocalRefFrame local_ref_frame(jni());
   jobject j_rtp_receiver =
       jni()->NewObject(*j_rtp_receiver_class_, j_rtp_receiver_ctor_,
                        jlongFromPointer(receiver.get()));
   CHECK_EXCEPTION(jni()) << "error during NewObject";
   receiver->AddRef();
   rtp_receivers_[receiver] = NewGlobalRef(jni(), j_rtp_receiver);
 
   jobjectArray j_stream_array = NativeToJavaMediaStreamArray(jni(), streams);
   jmethodID m =
@@ skipping 26 matching lines @@
   jni()->CallVoidMethod(
       j_rtp_receiver,
       GetMethodID(jni(), *j_rtp_receiver_class_, "dispose", "()V"));
   CHECK_EXCEPTION(jni()) << "error during RtpReceiver.dispose()";
   DeleteGlobalRef(jni(), j_rtp_receiver);
 }
 
 // If the NativeToJavaStreamsMap contains the stream, return it.
 // Otherwise, create a new Java MediaStream.
 jobject PeerConnectionObserverJni::GetOrCreateJavaStream(
-    const rtc::scoped_refptr<webrtc::MediaStreamInterface>& stream) {
+    const rtc::scoped_refptr<MediaStreamInterface>& stream) {
   NativeToJavaStreamsMap::iterator it = remote_streams_.find(stream);
   if (it != remote_streams_.end()) {
     return it->second;
   }
 
   // Java MediaStream holds one reference. Corresponding Release() is in
   // MediaStream_free, triggered by MediaStream.dispose().
   stream->AddRef();
   jobject j_stream =
       jni()->NewObject(*j_media_stream_class_, j_media_stream_ctor_,
                        reinterpret_cast<jlong>(stream.get()));
   CHECK_EXCEPTION(jni()) << "error during NewObject";
 
   remote_streams_[stream] = NewGlobalRef(jni(), j_stream);
   return j_stream;
 }
 
 jobjectArray PeerConnectionObserverJni::NativeToJavaMediaStreamArray(
     JNIEnv* jni,
-    const std::vector<rtc::scoped_refptr<webrtc::MediaStreamInterface>>&
-        streams) {
+    const std::vector<rtc::scoped_refptr<MediaStreamInterface>>& streams) {
   jobjectArray java_streams =
       jni->NewObjectArray(streams.size(), *j_media_stream_class_, nullptr);
   CHECK_EXCEPTION(jni) << "error during NewObjectArray";
   for (size_t i = 0; i < streams.size(); ++i) {
     jobject j_stream = GetOrCreateJavaStream(streams[i]);
     jni->SetObjectArrayElement(java_streams, i, j_stream);
   }
   return java_streams;
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc