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

talk/app/webrtc/java/jni/androidmediadecoder_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 78 matching lines @@
   int32_t Reset() override;
   // rtc::MessageHandler implementation.
   void OnMessage(rtc::Message* msg) override;
 
  private:
   // CHECK-fail if not running on |codec_thread_|.
   void CheckOnCodecThread();
 
   int32_t InitDecodeOnCodecThread();
   int32_t ReleaseOnCodecThread();
-  int32_t DecodeOnCodecThread(const EncodedImage& inputImage);
+  int32_t DecodeOnCodecThread(const EncodedImage* inputImage);
   // Deliver any outputs pending in the MediaCodec to our |callback_| and return
   // true on success.
   bool DeliverPendingOutputs(JNIEnv* jni, int dequeue_timeout_us);
   int32_t ProcessHWErrorOnCodecThread();
 
   // Type of video codec.
   VideoCodecType codecType_;
 
   bool key_frame_required_;
   bool inited_;
@@ skipping 372 matching lines @@
       ALOGE << "Decode() - complete frame is required";
       return WEBRTC_VIDEO_CODEC_ERROR;
     }
     key_frame_required_ = false;
   }
   if (inputImage._length == 0) {
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   return codec_thread_->Invoke<int32_t>(Bind(
-      &MediaCodecVideoDecoder::DecodeOnCodecThread, this, inputImage));
+      &MediaCodecVideoDecoder::DecodeOnCodecThread, this, &inputImage));
 }
 
 int32_t MediaCodecVideoDecoder::DecodeOnCodecThread(
-    const EncodedImage& inputImage) {
+    const EncodedImage* inputImage) {
   CheckOnCodecThread();
   JNIEnv* jni = AttachCurrentThreadIfNeeded();
   ScopedLocalRefFrame local_ref_frame(jni);
 
   // Try to drain the decoder and wait until output is not too
   // much behind the input.
   if (frames_received_ > frames_decoded_ + max_pending_frames_) {
     ALOGV("Received: %d. Decoded: %d. Wait for output...",
         frames_received_, frames_decoded_);
     if (!DeliverPendingOutputs(jni, kMediaCodecTimeoutMs * 1000)) {
@@ skipping 13 matching lines @@
     ALOGE << "dequeueInputBuffer error";
     return ProcessHWErrorOnCodecThread();
   }
 
   // Copy encoded data to Java ByteBuffer.
   jobject j_input_buffer = input_buffers_[j_input_buffer_index];
   uint8_t* buffer =
       reinterpret_cast<uint8_t*>(jni->GetDirectBufferAddress(j_input_buffer));
   RTC_CHECK(buffer) << "Indirect buffer??";
   int64_t buffer_capacity = jni->GetDirectBufferCapacity(j_input_buffer);
-  if (CheckException(jni) || buffer_capacity < inputImage._length) {
-    ALOGE << "Input frame size "<<  inputImage._length <<
+  if (CheckException(jni) || buffer_capacity < inputImage->_length) {
+    ALOGE << "Input frame size "<<  inputImage->_length <<
         " is bigger than buffer size " << buffer_capacity;
     return ProcessHWErrorOnCodecThread();
   }
   jlong timestamp_us = (frames_received_ * 1000000) / codec_.maxFramerate;
   ALOGV("Decoder frame in # %d. Type: %d. Buffer # %d. TS: %lld. Size: %d",
-      frames_received_, inputImage._frameType, j_input_buffer_index,
-      timestamp_us / 1000, inputImage._length);
-  memcpy(buffer, inputImage._buffer, inputImage._length);
+      frames_received_, inputImage->_frameType, j_input_buffer_index,
+      timestamp_us / 1000, inputImage->_length);
+  memcpy(buffer, inputImage->_buffer, inputImage->_length);
 
   // Save input image timestamps for later output.
   frames_received_++;
-  current_bytes_ += inputImage._length;
-  timestamps_.push_back(inputImage._timeStamp);
-  ntp_times_ms_.push_back(inputImage.ntp_time_ms_);
+  current_bytes_ += inputImage->_length;
+  timestamps_.push_back(inputImage->_timeStamp);
+  ntp_times_ms_.push_back(inputImage->ntp_time_ms_);
   frame_rtc_times_ms_.push_back(GetCurrentTimeMs());
 
   // Feed input to decoder.
   bool success = jni->CallBooleanMethod(*j_media_codec_video_decoder_,
                                         j_queue_input_buffer_method_,
                                         j_input_buffer_index,
-                                        inputImage._length,
+                                        inputImage->_length,
                                         timestamp_us);
   if (CheckException(jni) || !success) {
     ALOGE << "queueInputBuffer error";
     return ProcessHWErrorOnCodecThread();
   }
 
   // Try to drain the decoder
   if (!DeliverPendingOutputs(jni, 0)) {
     ALOGE << "DeliverPendingOutputs error";
     return ProcessHWErrorOnCodecThread();
@@ skipping 283 matching lines @@
 }
 
 void MediaCodecVideoDecoderFactory::DestroyVideoDecoder(
     webrtc::VideoDecoder* decoder) {
   ALOGD << "Destroy video decoder.";
   delete decoder;
 }
 
 }  // namespace webrtc_jni