Android: Replace webrtc_jni namespace with nested jni namespace

webrtc/sdk/android/src/jni/pc/java_native_conversion.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/java_native_conversion.h"
 
 #include <string>
 
 #include "webrtc/pc/webrtcsdp.h"
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
-webrtc::DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni,
-                                                    jobject j_init) {
-  webrtc::DataChannelInit init;
+DataChannelInit JavaToNativeDataChannelInit(JNIEnv* jni, jobject j_init) {
+  DataChannelInit init;
 
   jclass j_init_class = FindClass(jni, "org/webrtc/DataChannel$Init");
   jfieldID ordered_id = GetFieldID(jni, j_init_class, "ordered", "Z");
   jfieldID max_retransmit_time_id =
       GetFieldID(jni, j_init_class, "maxRetransmitTimeMs", "I");
   jfieldID max_retransmits_id =
       GetFieldID(jni, j_init_class, "maxRetransmits", "I");
   jfieldID protocol_id =
       GetFieldID(jni, j_init_class, "protocol", "Ljava/lang/String;");
   jfieldID negotiated_id = GetFieldID(jni, j_init_class, "negotiated", "Z");
@@ skipping 53 matching lines @@
   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 (!SdpDeserializeCandidate(sdp_mid, sdp, &candidate, NULL)) {
     LOG(LS_ERROR) << "SdpDescrializeCandidate failed with sdp " << sdp;
   }
   return candidate;
 }
 
 jobject NativeToJavaCandidate(JNIEnv* jni,
                               jclass* candidate_class,
                               const cricket::Candidate& candidate) {
-  std::string sdp = webrtc::SdpSerializeCandidate(candidate);
+  std::string sdp = SdpSerializeCandidate(candidate);
   RTC_CHECK(!sdp.empty()) << "got an empty ICE candidate";
   jmethodID ctor = GetMethodID(jni, *candidate_class, "<init>",
                                "(Ljava/lang/String;ILjava/lang/String;)V");
   jstring j_mid = JavaStringFromStdString(jni, candidate.transport_name());
   jstring j_sdp = JavaStringFromStdString(jni, sdp);
   // sdp_mline_index is not used, pass an invalid value -1.
   jobject j_candidate =
       jni->NewObject(*candidate_class, ctor, j_mid, -1, j_sdp);
   CHECK_EXCEPTION(jni) << "error during Java Candidate NewObject";
   return j_candidate;
 }
 
 jobjectArray NativeToJavaCandidateArray(
     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);
   int i = 0;
   for (const cricket::Candidate& candidate : candidates) {
     jobject j_candidate =
         NativeToJavaCandidate(jni, &candidate_class, candidate);
     jni->SetObjectArrayElement(java_candidates, i++, j_candidate);
   }
   return java_candidates;
 }
 
-webrtc::SessionDescriptionInterface* JavaToNativeSessionDescription(
-    JNIEnv* jni,
-    jobject j_sdp) {
+SessionDescriptionInterface* JavaToNativeSessionDescription(JNIEnv* jni,
+                                                            jobject j_sdp) {
   jfieldID j_type_id = GetFieldID(jni, GetObjectClass(jni, j_sdp), "type",
                                   "Lorg/webrtc/SessionDescription$Type;");
   jobject j_type = GetObjectField(jni, j_sdp, j_type_id);
   jmethodID j_canonical_form_id =
       GetMethodID(jni, GetObjectClass(jni, j_type), "canonicalForm",
                   "()Ljava/lang/String;");
   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 CreateSessionDescription(std_type, std_description, NULL);
 }
 
 jobject NativeToJavaSessionDescription(
     JNIEnv* jni,
-    const webrtc::SessionDescriptionInterface* desc) {
+    const SessionDescriptionInterface* desc) {
   std::string sdp;
   RTC_CHECK(desc->ToString(&sdp)) << "got so far: " << sdp;
   jstring j_description = JavaStringFromStdString(jni, sdp);
 
   jclass j_type_class = FindClass(jni, "org/webrtc/SessionDescription$Type");
   jmethodID j_type_from_canonical = GetStaticMethodID(
       jni, j_type_class, "fromCanonicalForm",
       "(Ljava/lang/String;)Lorg/webrtc/SessionDescription$Type;");
   jstring j_type_string = JavaStringFromStdString(jni, desc->type());
   jobject j_type = jni->CallStaticObjectMethod(
       j_type_class, j_type_from_canonical, j_type_string);
   CHECK_EXCEPTION(jni) << "error during CallObjectMethod";
 
   jclass j_sdp_class = FindClass(jni, "org/webrtc/SessionDescription");
   jmethodID j_sdp_ctor =
       GetMethodID(jni, j_sdp_class, "<init>",
                   "(Lorg/webrtc/SessionDescription$Type;Ljava/lang/String;)V");
   jobject j_sdp =
       jni->NewObject(j_sdp_class, j_sdp_ctor, j_type, j_description);
   CHECK_EXCEPTION(jni) << "error during NewObject";
   return j_sdp;
 }
 
-webrtc::PeerConnectionFactoryInterface::Options
+PeerConnectionFactoryInterface::Options
 JavaToNativePeerConnectionFactoryOptions(JNIEnv* jni, jobject options) {
   jclass options_class = jni->GetObjectClass(options);
   jfieldID network_ignore_mask_field =
       jni->GetFieldID(options_class, "networkIgnoreMask", "I");
   int network_ignore_mask =
       jni->GetIntField(options, network_ignore_mask_field);
 
   jfieldID disable_encryption_field =
       jni->GetFieldID(options_class, "disableEncryption", "Z");
   bool disable_encryption =
       jni->GetBooleanField(options, disable_encryption_field);
 
   jfieldID disable_network_monitor_field =
       jni->GetFieldID(options_class, "disableNetworkMonitor", "Z");
   bool disable_network_monitor =
       jni->GetBooleanField(options, disable_network_monitor_field);
 
-  webrtc::PeerConnectionFactoryInterface::Options native_options;
+  PeerConnectionFactoryInterface::Options native_options;
 
   // This doesn't necessarily match the c++ version of this struct; feel free
   // to add more parameters as necessary.
   native_options.network_ignore_mask = network_ignore_mask;
   native_options.disable_encryption = disable_encryption;
   native_options.disable_network_monitor = disable_network_monitor;
   return native_options;
 }
 
-webrtc::PeerConnectionInterface::IceTransportsType
-JavaToNativeIceTransportsType(JNIEnv* jni, jobject j_ice_transports_type) {
+PeerConnectionInterface::IceTransportsType JavaToNativeIceTransportsType(
+    JNIEnv* jni,
+    jobject j_ice_transports_type) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$IceTransportsType",
                       j_ice_transports_type);
 
   if (enum_name == "ALL")
-    return webrtc::PeerConnectionInterface::kAll;
+    return PeerConnectionInterface::kAll;
 
   if (enum_name == "RELAY")
-    return webrtc::PeerConnectionInterface::kRelay;
+    return PeerConnectionInterface::kRelay;
 
   if (enum_name == "NOHOST")
-    return webrtc::PeerConnectionInterface::kNoHost;
+    return PeerConnectionInterface::kNoHost;
 
   if (enum_name == "NONE")
-    return webrtc::PeerConnectionInterface::kNone;
+    return PeerConnectionInterface::kNone;
 
   RTC_CHECK(false) << "Unexpected IceTransportsType enum_name " << enum_name;
-  return webrtc::PeerConnectionInterface::kAll;
+  return PeerConnectionInterface::kAll;
 }
 
-webrtc::PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
+PeerConnectionInterface::BundlePolicy JavaToNativeBundlePolicy(
     JNIEnv* jni,
     jobject j_bundle_policy) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$BundlePolicy", j_bundle_policy);
 
   if (enum_name == "BALANCED")
-    return webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
+    return PeerConnectionInterface::kBundlePolicyBalanced;
 
   if (enum_name == "MAXBUNDLE")
-    return webrtc::PeerConnectionInterface::kBundlePolicyMaxBundle;
+    return PeerConnectionInterface::kBundlePolicyMaxBundle;
 
   if (enum_name == "MAXCOMPAT")
-    return webrtc::PeerConnectionInterface::kBundlePolicyMaxCompat;
+    return PeerConnectionInterface::kBundlePolicyMaxCompat;
 
   RTC_CHECK(false) << "Unexpected BundlePolicy enum_name " << enum_name;
-  return webrtc::PeerConnectionInterface::kBundlePolicyBalanced;
+  return PeerConnectionInterface::kBundlePolicyBalanced;
 }
 
-webrtc::PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
+PeerConnectionInterface::RtcpMuxPolicy JavaToNativeRtcpMuxPolicy(
     JNIEnv* jni,
     jobject j_rtcp_mux_policy) {
   std::string enum_name = GetJavaEnumName(
       jni, "org/webrtc/PeerConnection$RtcpMuxPolicy", j_rtcp_mux_policy);
 
   if (enum_name == "NEGOTIATE")
-    return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
+    return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
 
   if (enum_name == "REQUIRE")
-    return webrtc::PeerConnectionInterface::kRtcpMuxPolicyRequire;
+    return PeerConnectionInterface::kRtcpMuxPolicyRequire;
 
   RTC_CHECK(false) << "Unexpected RtcpMuxPolicy enum_name " << enum_name;
-  return webrtc::PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
+  return PeerConnectionInterface::kRtcpMuxPolicyNegotiate;
 }
 
-webrtc::PeerConnectionInterface::TcpCandidatePolicy
-JavaToNativeTcpCandidatePolicy(JNIEnv* jni, jobject j_tcp_candidate_policy) {
+PeerConnectionInterface::TcpCandidatePolicy JavaToNativeTcpCandidatePolicy(
+    JNIEnv* jni,
+    jobject j_tcp_candidate_policy) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$TcpCandidatePolicy",
                       j_tcp_candidate_policy);
 
   if (enum_name == "ENABLED")
-    return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled;
+    return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 
   if (enum_name == "DISABLED")
-    return webrtc::PeerConnectionInterface::kTcpCandidatePolicyDisabled;
+    return PeerConnectionInterface::kTcpCandidatePolicyDisabled;
 
   RTC_CHECK(false) << "Unexpected TcpCandidatePolicy enum_name " << enum_name;
-  return webrtc::PeerConnectionInterface::kTcpCandidatePolicyEnabled;
+  return PeerConnectionInterface::kTcpCandidatePolicyEnabled;
 }
 
-webrtc::PeerConnectionInterface::CandidateNetworkPolicy
+PeerConnectionInterface::CandidateNetworkPolicy
 JavaToNativeCandidateNetworkPolicy(JNIEnv* jni,
                                    jobject j_candidate_network_policy) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$CandidateNetworkPolicy",
                       j_candidate_network_policy);
 
   if (enum_name == "ALL")
-    return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll;
+    return PeerConnectionInterface::kCandidateNetworkPolicyAll;
 
   if (enum_name == "LOW_COST")
-    return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
+    return PeerConnectionInterface::kCandidateNetworkPolicyLowCost;
 
   RTC_CHECK(false) << "Unexpected CandidateNetworkPolicy enum_name "
                    << enum_name;
-  return webrtc::PeerConnectionInterface::kCandidateNetworkPolicyAll;
+  return PeerConnectionInterface::kCandidateNetworkPolicyAll;
 }
 
 rtc::KeyType JavaToNativeKeyType(JNIEnv* jni, jobject j_key_type) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$KeyType", j_key_type);
 
   if (enum_name == "RSA")
     return rtc::KT_RSA;
   if (enum_name == "ECDSA")
     return rtc::KT_ECDSA;
 
   RTC_CHECK(false) << "Unexpected KeyType enum_name " << enum_name;
   return rtc::KT_ECDSA;
 }
 
-webrtc::PeerConnectionInterface::ContinualGatheringPolicy
+PeerConnectionInterface::ContinualGatheringPolicy
 JavaToNativeContinualGatheringPolicy(JNIEnv* jni, jobject j_gathering_policy) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$ContinualGatheringPolicy",
                       j_gathering_policy);
   if (enum_name == "GATHER_ONCE")
-    return webrtc::PeerConnectionInterface::GATHER_ONCE;
+    return PeerConnectionInterface::GATHER_ONCE;
 
   if (enum_name == "GATHER_CONTINUALLY")
-    return webrtc::PeerConnectionInterface::GATHER_CONTINUALLY;
+    return PeerConnectionInterface::GATHER_CONTINUALLY;
 
   RTC_CHECK(false) << "Unexpected ContinualGatheringPolicy enum name "
                    << enum_name;
-  return webrtc::PeerConnectionInterface::GATHER_ONCE;
+  return PeerConnectionInterface::GATHER_ONCE;
 }
 
-webrtc::PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
+PeerConnectionInterface::TlsCertPolicy JavaToNativeTlsCertPolicy(
     JNIEnv* jni,
     jobject j_ice_server_tls_cert_policy) {
   std::string enum_name =
       GetJavaEnumName(jni, "org/webrtc/PeerConnection$TlsCertPolicy",
                       j_ice_server_tls_cert_policy);
 
   if (enum_name == "TLS_CERT_POLICY_SECURE")
-    return webrtc::PeerConnectionInterface::kTlsCertPolicySecure;
+    return PeerConnectionInterface::kTlsCertPolicySecure;
 
   if (enum_name == "TLS_CERT_POLICY_INSECURE_NO_CHECK")
-    return webrtc::PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
+    return PeerConnectionInterface::kTlsCertPolicyInsecureNoCheck;
 
   RTC_CHECK(false) << "Unexpected TlsCertPolicy enum_name " << enum_name;
-  return webrtc::PeerConnectionInterface::kTlsCertPolicySecure;
+  return PeerConnectionInterface::kTlsCertPolicySecure;
 }
 
-void JavaToNativeIceServers(
-    JNIEnv* jni,
-    jobject j_ice_servers,
-    webrtc::PeerConnectionInterface::IceServers* ice_servers) {
+void JavaToNativeIceServers(JNIEnv* jni,
+                            jobject j_ice_servers,
+                            PeerConnectionInterface::IceServers* ice_servers) {
   for (jobject j_ice_server : Iterable(jni, j_ice_servers)) {
     jclass j_ice_server_class = GetObjectClass(jni, j_ice_server);
     jfieldID j_ice_server_uri_id =
         GetFieldID(jni, j_ice_server_class, "uri", "Ljava/lang/String;");
     jfieldID j_ice_server_username_id =
         GetFieldID(jni, j_ice_server_class, "username", "Ljava/lang/String;");
     jfieldID j_ice_server_password_id =
         GetFieldID(jni, j_ice_server_class, "password", "Ljava/lang/String;");
     jfieldID j_ice_server_tls_cert_policy_id =
         GetFieldID(jni, j_ice_server_class, "tlsCertPolicy",
                    "Lorg/webrtc/PeerConnection$TlsCertPolicy;");
     jobject j_ice_server_tls_cert_policy =
         GetObjectField(jni, j_ice_server, j_ice_server_tls_cert_policy_id);
     jfieldID j_ice_server_hostname_id =
         GetFieldID(jni, j_ice_server_class, "hostname", "Ljava/lang/String;");
     jstring uri = reinterpret_cast<jstring>(
         GetObjectField(jni, j_ice_server, j_ice_server_uri_id));
     jstring username = reinterpret_cast<jstring>(
         GetObjectField(jni, j_ice_server, j_ice_server_username_id));
     jstring password = reinterpret_cast<jstring>(
         GetObjectField(jni, j_ice_server, j_ice_server_password_id));
-    webrtc::PeerConnectionInterface::TlsCertPolicy tls_cert_policy =
+    PeerConnectionInterface::TlsCertPolicy tls_cert_policy =
         JavaToNativeTlsCertPolicy(jni, j_ice_server_tls_cert_policy);
     jstring hostname = reinterpret_cast<jstring>(
         GetObjectField(jni, j_ice_server, j_ice_server_hostname_id));
-    webrtc::PeerConnectionInterface::IceServer server;
+    PeerConnectionInterface::IceServer server;
     server.uri = JavaToStdString(jni, uri);
     server.username = JavaToStdString(jni, username);
     server.password = JavaToStdString(jni, password);
     server.tls_cert_policy = tls_cert_policy;
     server.hostname = JavaToStdString(jni, hostname);
     ice_servers->push_back(server);
   }
 }
 
 void JavaToNativeRTCConfiguration(
     JNIEnv* jni,
     jobject j_rtc_config,
-    webrtc::PeerConnectionInterface::RTCConfiguration* rtc_config) {
+    PeerConnectionInterface::RTCConfiguration* rtc_config) {
   jclass j_rtc_config_class = GetObjectClass(jni, j_rtc_config);
 
   jfieldID j_ice_transports_type_id =
       GetFieldID(jni, j_rtc_config_class, "iceTransportsType",
                  "Lorg/webrtc/PeerConnection$IceTransportsType;");
   jobject j_ice_transports_type =
       GetObjectField(jni, j_rtc_config, j_ice_transports_type_id);
 
   jfieldID j_bundle_policy_id =
       GetFieldID(jni, j_rtc_config_class, "bundlePolicy",
@@ skipping 110 matching lines @@
       jni, j_rtc_config, j_ice_regather_interval_range_id);
   if (!IsNull(jni, j_ice_regather_interval_range)) {
     int min = jni->CallIntMethod(j_ice_regather_interval_range, get_min_id);
     int max = jni->CallIntMethod(j_ice_regather_interval_range, get_max_id);
     rtc_config->ice_regather_interval_range.emplace(min, max);
   }
 }
 
 void JavaToNativeRtpParameters(JNIEnv* jni,
                                jobject j_parameters,
-                               webrtc::RtpParameters* parameters) {
+                               RtpParameters* parameters) {
   RTC_CHECK(parameters != nullptr);
   jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
   jfieldID encodings_id =
       GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
   jfieldID codecs_id =
       GetFieldID(jni, parameters_class, "codecs", "Ljava/util/LinkedList;");
 
   // Convert encodings.
   jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
   jclass j_encoding_parameters_class =
       jni->FindClass("org/webrtc/RtpParameters$Encoding");
   jfieldID active_id =
       GetFieldID(jni, j_encoding_parameters_class, "active", "Z");
   jfieldID bitrate_id = GetFieldID(jni, j_encoding_parameters_class,
                                    "maxBitrateBps", "Ljava/lang/Integer;");
   jfieldID ssrc_id =
       GetFieldID(jni, j_encoding_parameters_class, "ssrc", "Ljava/lang/Long;");
   jclass j_integer_class = jni->FindClass("java/lang/Integer");
   jclass j_long_class = jni->FindClass("java/lang/Long");
   jmethodID int_value_id = GetMethodID(jni, j_integer_class, "intValue", "()I");
   jmethodID long_value_id = GetMethodID(jni, j_long_class, "longValue", "()J");
 
   for (jobject j_encoding_parameters : Iterable(jni, j_encodings)) {
-    webrtc::RtpEncodingParameters encoding;
+    RtpEncodingParameters encoding;
     encoding.active = GetBooleanField(jni, j_encoding_parameters, active_id);
     jobject j_bitrate =
         GetNullableObjectField(jni, j_encoding_parameters, bitrate_id);
     if (!IsNull(jni, j_bitrate)) {
       int bitrate_value = jni->CallIntMethod(j_bitrate, int_value_id);
       CHECK_EXCEPTION(jni) << "error during CallIntMethod";
       encoding.max_bitrate_bps = rtc::Optional<int>(bitrate_value);
     }
     jobject j_ssrc =
         GetNullableObjectField(jni, j_encoding_parameters, ssrc_id);
@@ skipping 11 matching lines @@
   jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
   jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;");
   jfieldID kind_id = GetFieldID(jni, codec_class, "kind",
                                 "Lorg/webrtc/MediaStreamTrack$MediaType;");
   jfieldID clock_rate_id =
       GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;");
   jfieldID num_channels_id =
       GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
 
   for (jobject j_codec : Iterable(jni, j_codecs)) {
-    webrtc::RtpCodecParameters codec;
+    RtpCodecParameters codec;
     codec.payload_type = GetIntField(jni, j_codec, payload_type_id);
     codec.name = JavaToStdString(jni, GetStringField(jni, j_codec, name_id));
     codec.kind =
         JavaToNativeMediaType(jni, GetObjectField(jni, j_codec, kind_id));
     jobject j_clock_rate = GetNullableObjectField(jni, j_codec, clock_rate_id);
     if (!IsNull(jni, j_clock_rate)) {
       int clock_rate_value = jni->CallIntMethod(j_clock_rate, int_value_id);
       CHECK_EXCEPTION(jni) << "error during CallIntMethod";
       codec.clock_rate = rtc::Optional<int>(clock_rate_value);
     }
     jobject j_num_channels =
         GetNullableObjectField(jni, j_codec, num_channels_id);
     if (!IsNull(jni, j_num_channels)) {
       int num_channels_value = jni->CallIntMethod(j_num_channels, int_value_id);
       CHECK_EXCEPTION(jni) << "error during CallIntMethod";
       codec.num_channels = rtc::Optional<int>(num_channels_value);
     }
     parameters->codecs.push_back(codec);
   }
 }
 
 jobject NativeToJavaRtpParameters(JNIEnv* jni,
-                                  const webrtc::RtpParameters& parameters) {
+                                  const RtpParameters& parameters) {
   jclass parameters_class = jni->FindClass("org/webrtc/RtpParameters");
   jmethodID parameters_ctor =
       GetMethodID(jni, parameters_class, "<init>", "()V");
   jobject j_parameters = jni->NewObject(parameters_class, parameters_ctor);
   CHECK_EXCEPTION(jni) << "error during NewObject";
 
   // Add encodings.
   jclass encoding_class = jni->FindClass("org/webrtc/RtpParameters$Encoding");
   jmethodID encoding_ctor = GetMethodID(jni, encoding_class, "<init>", "()V");
   jfieldID encodings_id =
       GetFieldID(jni, parameters_class, "encodings", "Ljava/util/LinkedList;");
   jobject j_encodings = GetObjectField(jni, j_parameters, encodings_id);
   jmethodID encodings_add = GetMethodID(jni, GetObjectClass(jni, j_encodings),
                                         "add", "(Ljava/lang/Object;)Z");
   jfieldID active_id = GetFieldID(jni, encoding_class, "active", "Z");
   jfieldID bitrate_id =
       GetFieldID(jni, encoding_class, "maxBitrateBps", "Ljava/lang/Integer;");
   jfieldID ssrc_id =
       GetFieldID(jni, encoding_class, "ssrc", "Ljava/lang/Long;");
 
   jclass integer_class = jni->FindClass("java/lang/Integer");
   jclass long_class = jni->FindClass("java/lang/Long");
   jmethodID integer_ctor = GetMethodID(jni, integer_class, "<init>", "(I)V");
   jmethodID long_ctor = GetMethodID(jni, long_class, "<init>", "(J)V");
 
-  for (const webrtc::RtpEncodingParameters& encoding : parameters.encodings) {
+  for (const RtpEncodingParameters& encoding : parameters.encodings) {
     jobject j_encoding_parameters =
         jni->NewObject(encoding_class, encoding_ctor);
     CHECK_EXCEPTION(jni) << "error during NewObject";
     jni->SetBooleanField(j_encoding_parameters, active_id, encoding.active);
     CHECK_EXCEPTION(jni) << "error during SetBooleanField";
     if (encoding.max_bitrate_bps) {
       jobject j_bitrate_value = jni->NewObject(integer_class, integer_ctor,
                                                *(encoding.max_bitrate_bps));
       CHECK_EXCEPTION(jni) << "error during NewObject";
       jni->SetObjectField(j_encoding_parameters, bitrate_id, j_bitrate_value);
@@ skipping 22 matching lines @@
                                      "(Ljava/lang/Object;)Z");
   jfieldID payload_type_id = GetFieldID(jni, codec_class, "payloadType", "I");
   jfieldID name_id = GetFieldID(jni, codec_class, "name", "Ljava/lang/String;");
   jfieldID kind_id = GetFieldID(jni, codec_class, "kind",
                                 "Lorg/webrtc/MediaStreamTrack$MediaType;");
   jfieldID clock_rate_id =
       GetFieldID(jni, codec_class, "clockRate", "Ljava/lang/Integer;");
   jfieldID num_channels_id =
       GetFieldID(jni, codec_class, "numChannels", "Ljava/lang/Integer;");
 
-  for (const webrtc::RtpCodecParameters& codec : parameters.codecs) {
+  for (const RtpCodecParameters& codec : parameters.codecs) {
     jobject j_codec = jni->NewObject(codec_class, codec_ctor);
     CHECK_EXCEPTION(jni) << "error during NewObject";
     jni->SetIntField(j_codec, payload_type_id, codec.payload_type);
     CHECK_EXCEPTION(jni) << "error during SetIntField";
     jni->SetObjectField(j_codec, name_id,
                         JavaStringFromStdString(jni, codec.name));
     CHECK_EXCEPTION(jni) << "error during SetObjectField";
     jni->SetObjectField(j_codec, kind_id,
                         NativeToJavaMediaType(jni, codec.kind));
     CHECK_EXCEPTION(jni) << "error during SetObjectField";
@@ skipping 12 matching lines @@
       CHECK_EXCEPTION(jni) << "error during SetObjectField";
     }
     jboolean added = jni->CallBooleanMethod(j_codecs, codecs_add, j_codec);
     CHECK_EXCEPTION(jni) << "error during CallBooleanMethod";
     RTC_CHECK(added);
   }
 
   return j_parameters;
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc