Android: Replace webrtc_jni namespace with nested jni namespace

webrtc/sdk/android/src/jni/video_renderer_jni.cc

 /*
  *  Copyright (c) 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 <jni.h>
 
 #include "webrtc/api/video/video_frame.h"
 #include "webrtc/media/base/videosinkinterface.h"
 #include "webrtc/sdk/android/src/jni/classreferenceholder.h"
 #include "webrtc/sdk/android/src/jni/jni_helpers.h"
 #include "webrtc/sdk/android/src/jni/native_handle_impl.h"
 
-namespace webrtc_jni {
+namespace webrtc {
+namespace jni {
 
 // Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
 // instance.
-class JavaVideoRendererWrapper
-    : public rtc::VideoSinkInterface<webrtc::VideoFrame> {
+class JavaVideoRendererWrapper : public rtc::VideoSinkInterface<VideoFrame> {
  public:
   JavaVideoRendererWrapper(JNIEnv* jni, jobject j_callbacks)
       : j_callbacks_(jni, j_callbacks),
         j_render_frame_id_(
             GetMethodID(jni,
                         GetObjectClass(jni, j_callbacks),
                         "renderFrame",
                         "(Lorg/webrtc/VideoRenderer$I420Frame;)V")),
         j_frame_class_(jni,
                        FindClass(jni, "org/webrtc/VideoRenderer$I420Frame")),
         j_i420_frame_ctor_id_(GetMethodID(jni,
                                           *j_frame_class_,
                                           "<init>",
                                           "(III[I[Ljava/nio/ByteBuffer;J)V")),
         j_texture_frame_ctor_id_(
             GetMethodID(jni, *j_frame_class_, "<init>", "(IIII[FJ)V")),
         j_byte_buffer_class_(jni, FindClass(jni, "java/nio/ByteBuffer")) {
     CHECK_EXCEPTION(jni);
   }
 
   virtual ~JavaVideoRendererWrapper() {}
 
-  void OnFrame(const webrtc::VideoFrame& video_frame) override {
+  void OnFrame(const VideoFrame& video_frame) override {
     ScopedLocalRefFrame local_ref_frame(jni());
 
     jobject j_frame;
     if (video_frame.video_frame_buffer()->type() ==
-        webrtc::VideoFrameBuffer::Type::kNative) {
+        VideoFrameBuffer::Type::kNative) {
       AndroidVideoFrameBuffer* android_buffer =
           static_cast<AndroidVideoFrameBuffer*>(
               video_frame.video_frame_buffer().get());
       switch (android_buffer->android_type()) {
         case AndroidVideoFrameBuffer::AndroidType::kTextureBuffer:
           j_frame = ToJavaTextureFrame(&video_frame);
           break;
         case AndroidVideoFrameBuffer::AndroidType::kJavaBuffer:
           j_frame = static_cast<AndroidVideoBuffer*>(android_buffer)
                         ->ToJavaI420Frame(jni(), video_frame.rotation());
           break;
         default:
           RTC_NOTREACHED();
       }
     } else {
       j_frame = ToJavaI420Frame(&video_frame);
     }
     // |j_callbacks_| is responsible for releasing |j_frame| with
     // VideoRenderer.renderFrameDone().
     jni()->CallVoidMethod(*j_callbacks_, j_render_frame_id_, j_frame);
     CHECK_EXCEPTION(jni());
   }
 
  private:
   // 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));
+  static jlong javaShallowCopy(const VideoFrame* frame) {
+    return jlongFromPointer(new VideoFrame(*frame));
   }
 
   // Return a VideoRenderer.I420Frame referring to the data in |frame|.
-  jobject ToJavaI420Frame(const webrtc::VideoFrame* frame) {
+  jobject ToJavaI420Frame(const VideoFrame* frame) {
     jintArray strides = jni()->NewIntArray(3);
     jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
-    rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =
+    rtc::scoped_refptr<I420BufferInterface> i420_buffer =
         frame->video_frame_buffer()->ToI420();
     strides_array[0] = i420_buffer->StrideY();
     strides_array[1] = i420_buffer->StrideU();
     strides_array[2] = i420_buffer->StrideV();
     jni()->ReleaseIntArrayElements(strides, strides_array, 0);
     jobjectArray planes = jni()->NewObjectArray(3, *j_byte_buffer_class_, NULL);
     jobject y_buffer = jni()->NewDirectByteBuffer(
         const_cast<uint8_t*>(i420_buffer->DataY()),
         i420_buffer->StrideY() * i420_buffer->height());
     size_t chroma_height = i420_buffer->ChromaHeight();
     jobject u_buffer =
         jni()->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataU()),
                                    i420_buffer->StrideU() * chroma_height);
     jobject v_buffer =
         jni()->NewDirectByteBuffer(const_cast<uint8_t*>(i420_buffer->DataV()),
                                    i420_buffer->StrideV() * chroma_height);
 
     jni()->SetObjectArrayElement(planes, 0, y_buffer);
     jni()->SetObjectArrayElement(planes, 1, u_buffer);
     jni()->SetObjectArrayElement(planes, 2, v_buffer);
     return jni()->NewObject(*j_frame_class_, j_i420_frame_ctor_id_,
                             frame->width(), frame->height(),
                             static_cast<int>(frame->rotation()), strides,
                             planes, javaShallowCopy(frame));
   }
 
   // Return a VideoRenderer.I420Frame referring texture object in |frame|.
-  jobject ToJavaTextureFrame(const webrtc::VideoFrame* frame) {
+  jobject ToJavaTextureFrame(const VideoFrame* frame) {
     NativeHandleImpl handle =
         static_cast<AndroidTextureBuffer*>(frame->video_frame_buffer().get())
             ->native_handle_impl();
     jfloatArray sampling_matrix = handle.sampling_matrix.ToJava(jni());
 
     return jni()->NewObject(
         *j_frame_class_, j_texture_frame_ctor_id_, frame->width(),
         frame->height(), static_cast<int>(frame->rotation()),
         handle.oes_texture_id, sampling_matrix, javaShallowCopy(frame));
   }
@@ skipping 14 matching lines @@
                          jclass,
                          jlong j_p) {
   delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
 }
 
 JNI_FUNCTION_DECLARATION(void,
                          VideoRenderer_releaseNativeFrame,
                          JNIEnv* jni,
                          jclass,
                          jlong j_frame_ptr) {
-  delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
+  delete reinterpret_cast<const VideoFrame*>(j_frame_ptr);
 }
 
 JNI_FUNCTION_DECLARATION(jlong,
                          VideoRenderer_nativeWrapVideoRenderer,
                          JNIEnv* jni,
                          jclass,
                          jobject j_callbacks) {
   std::unique_ptr<JavaVideoRendererWrapper> renderer(
       new JavaVideoRendererWrapper(jni, j_callbacks));
   return (jlong)renderer.release();
@@ skipping 25 matching lines @@
     memcpy(dst, src, src_stride * height);
   } else {
     for (int i = 0; i < height; i++) {
       memcpy(dst, src, width);
       src += src_stride;
       dst += dst_stride;
     }
   }
 }
 
-}  // namespace webrtc_jni
+}  // namespace jni
+}  // namespace webrtc