Reland of Delete all use of cricket::VideoFrame and cricket::WebRtcVideoFrame.

webrtc/api/android/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 715 matching lines @@
   const ScopedGlobalRef<jclass> j_observer_class_;
   const ScopedGlobalRef<jclass> j_stats_report_class_;
   const jmethodID j_stats_report_ctor_;
   const ScopedGlobalRef<jclass> j_value_class_;
   const jmethodID j_value_ctor_;
 };
 
 // Wrapper dispatching rtc::VideoSinkInterface to a Java VideoRenderer
 // instance.
 class JavaVideoRendererWrapper
-    : public rtc::VideoSinkInterface<cricket::VideoFrame> {
+    : public rtc::VideoSinkInterface<webrtc::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 cricket::VideoFrame& video_frame) override {
+  void OnFrame(const webrtc::VideoFrame& video_frame) override {
     ScopedLocalRefFrame local_ref_frame(jni());
     jobject j_frame =
         (video_frame.video_frame_buffer()->native_handle() != nullptr)
             ? CricketToJavaTextureFrame(&video_frame)
             : CricketToJavaI420Frame(&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 cricket::VideoFrame* frame) {
-    return jlongFromPointer(new cricket::WebRtcVideoFrame(
-        frame->video_frame_buffer(), frame->rotation(), frame->timestamp_us()));
+  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 cricket::VideoFrame* frame) {
+  jobject CricketToJavaI420Frame(const webrtc::VideoFrame* frame) {
     jintArray strides = jni()->NewIntArray(3);
     jint* strides_array = jni()->GetIntArrayElements(strides, NULL);
     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);
     jobject y_buffer = jni()->NewDirectByteBuffer(
         const_cast<uint8_t*>(frame->video_frame_buffer()->DataY()),
         frame->video_frame_buffer()->StrideY() *
@@ skipping 10 matching lines @@
     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 CricketToJavaTextureFrame(const cricket::VideoFrame* frame) {
+  jobject CricketToJavaTextureFrame(const webrtc::VideoFrame* frame) {
     NativeHandleImpl* handle = reinterpret_cast<NativeHandleImpl*>(
         frame->video_frame_buffer()->native_handle());
     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 124 matching lines @@
 JOW(void, MediaSource_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<rtc::RefCountInterface*>(j_p)->Release();
 }
 
 JOW(void, VideoRenderer_freeWrappedVideoRenderer)(JNIEnv*, jclass, jlong j_p) {
   delete reinterpret_cast<JavaVideoRendererWrapper*>(j_p);
 }
 
 JOW(void, VideoRenderer_releaseNativeFrame)(
     JNIEnv* jni, jclass, jlong j_frame_ptr) {
-  delete reinterpret_cast<const cricket::VideoFrame*>(j_frame_ptr);
+  delete reinterpret_cast<const webrtc::VideoFrame*>(j_frame_ptr);
 }
 
 JOW(void, MediaStreamTrack_free)(JNIEnv*, jclass, jlong j_p) {
   reinterpret_cast<MediaStreamTrackInterface*>(j_p)->Release();
 }
 
 JOW(jboolean, MediaStream_nativeAddAudioTrack)(
     JNIEnv* jni, jclass, jlong pointer, jlong j_audio_track_pointer) {
   return reinterpret_cast<MediaStreamInterface*>(pointer)->AddTrack(
       reinterpret_cast<AudioTrackInterface*>(j_audio_track_pointer));
@@ skipping 1151 matching lines @@
   return reinterpret_cast<MediaStreamTrackInterface*>(j_p)
       ->set_enabled(enabled);
 }
 
 JOW(void, VideoTrack_nativeAddRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
   LOG(LS_INFO) << "VideoTrack::nativeAddRenderer";
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
       ->AddOrUpdateSink(
-          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
+          reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
               j_renderer_pointer),
           rtc::VideoSinkWants());
 }
 
 JOW(void, VideoTrack_nativeRemoveRenderer)(
     JNIEnv* jni, jclass,
     jlong j_video_track_pointer, jlong j_renderer_pointer) {
   reinterpret_cast<VideoTrackInterface*>(j_video_track_pointer)
       ->RemoveSink(
-          reinterpret_cast<rtc::VideoSinkInterface<cricket::VideoFrame>*>(
+          reinterpret_cast<rtc::VideoSinkInterface<webrtc::VideoFrame>*>(
               j_renderer_pointer));
 }
 
 JOW(jlong, CallSessionFileRotatingLogSink_nativeAddSink)(
     JNIEnv* jni, jclass,
     jstring j_dirPath, jint j_maxFileSize, jint j_severity) {
   std::string dir_path = JavaToStdString(jni, j_dirPath);
   rtc::CallSessionFileRotatingLogSink* sink =
       new rtc::CallSessionFileRotatingLogSink(dir_path, j_maxFileSize);
   if (!sink->Init()) {
@@ skipping 259 matching lines @@
   return JavaStringFromStdString(
       jni,
       reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->id());
 }
 
 JOW(void, RtpReceiver_free)(JNIEnv* jni, jclass, jlong j_rtp_receiver_pointer) {
   reinterpret_cast<RtpReceiverInterface*>(j_rtp_receiver_pointer)->Release();
 }
 
 }  // namespace webrtc_jni