Update Bind to match its comments and always capture by value.

talk/app/webrtc/java/jni/androidmediaencoder_jni.cc

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 101 matching lines @@
   void ResetCodec();
 
   // Implementation of webrtc::VideoEncoder methods above, all running on the
   // codec thread exclusively.
   //
   // If width==0 then this is assumed to be a re-initialization and the
   // previously-current values are reused instead of the passed parameters
   // (makes it easier to reason about thread-safety).
   int32_t InitEncodeOnCodecThread(int width, int height, int kbps, int fps);
   int32_t EncodeOnCodecThread(
-      const webrtc::VideoFrame& input_image,
+      const webrtc::VideoFrame* input_image,

[magjed_webrtc, 2015/10/23 05:17:01]

Leave this unchanged - implicit copies of webrtc::VideoFrame is fine and we do
it elsewhere.

[noahric, 2015/10/23 06:02:16]

SGTM. Done.

       const std::vector<webrtc::FrameType>* frame_types);
   int32_t RegisterEncodeCompleteCallbackOnCodecThread(
       webrtc::EncodedImageCallback* callback);
   int32_t ReleaseOnCodecThread();
   int32_t SetRatesOnCodecThread(uint32_t new_bit_rate, uint32_t frame_rate);
 
   // Helper accessors for MediaCodecVideoEncoder$OutputBufferInfo members.
   int GetOutputBufferInfoIndex(JNIEnv* jni, jobject j_output_buffer_info);
   jobject GetOutputBufferInfoBuffer(JNIEnv* jni, jobject j_output_buffer_info);
   bool GetOutputBufferInfoIsKeyFrame(JNIEnv* jni, jobject j_output_buffer_info);
@@ skipping 199 matching lines @@
            codec_settings->height,
            codec_settings->startBitrate,
            codec_settings->maxFramerate));
 }
 
 int32_t MediaCodecVideoEncoder::Encode(
     const webrtc::VideoFrame& frame,
     const webrtc::CodecSpecificInfo* /* codec_specific_info */,
     const std::vector<webrtc::FrameType>* frame_types) {
   return codec_thread_->Invoke<int32_t>(Bind(
-      &MediaCodecVideoEncoder::EncodeOnCodecThread, this, frame, frame_types));
+      &MediaCodecVideoEncoder::EncodeOnCodecThread, this, &frame, frame_types));
 }
 
 int32_t MediaCodecVideoEncoder::RegisterEncodeCompleteCallback(
     webrtc::EncodedImageCallback* callback) {
   return codec_thread_->Invoke<int32_t>(
       Bind(&MediaCodecVideoEncoder::RegisterEncodeCompleteCallbackOnCodecThread,
            this,
            callback));
 }
 
@@ skipping 139 matching lines @@
     CHECK_EXCEPTION(jni);
     RTC_CHECK(yuv_buffer_capacity >= yuv_size_) << "Insufficient capacity";
   }
   CHECK_EXCEPTION(jni);
 
   codec_thread_->PostDelayed(kMediaCodecPollMs, this);
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t MediaCodecVideoEncoder::EncodeOnCodecThread(
-    const webrtc::VideoFrame& frame,
+    const webrtc::VideoFrame* frame,
     const std::vector<webrtc::FrameType>* frame_types) {
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   if (!inited_) {
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   frames_received_++;
   if (!DeliverPendingOutputs(jni)) {
     ResetCodec();
     // Continue as if everything's fine.
   }
 
   if (drop_next_input_frame_) {
     ALOGV("Encoder drop frame - failed callback.");
     drop_next_input_frame_ = false;
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   RTC_CHECK(frame_types->size() == 1) << "Unexpected stream count";
   // Check framerate before spatial resolution change.
   if (scale_)
-    quality_scaler_.OnEncodeFrame(frame);
+    quality_scaler_.OnEncodeFrame(*frame);
 
   const VideoFrame& input_frame =
-      scale_ ? quality_scaler_.GetScaledFrame(frame) : frame;
+      scale_ ? quality_scaler_.GetScaledFrame(*frame) : *frame;
 
   if (input_frame.width() != width_ || input_frame.height() != height_) {
     ALOGD << "Frame resolution change from " << width_ << " x " << height_ <<
         " to " << input_frame.width() << " x " << input_frame.height();
     width_ = input_frame.width();
     height_ = input_frame.height();
     ResetCodec();
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
@@ skipping 415 matching lines @@
 }
 
 void MediaCodecVideoEncoderFactory::DestroyVideoEncoder(
     webrtc::VideoEncoder* encoder) {
   ALOGD << "Destroy video encoder.";
   delete encoder;
 }
 
 }  // namespace webrtc_jni