Fix leak in CronetBidirectionalStreamAdapter::OnDataSent

components/cronet/android/cronet_bidirectional_stream_adapter.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cronet_bidirectional_stream_adapter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 146 matching lines @@
     jboolean jend_of_stream) {
   size_t buffers_array_size = SafeGetArrayLength(env, jbyte_buffers.obj());
   size_t pos_array_size = SafeGetArrayLength(env, jbyte_buffers.obj());
   size_t limit_array_size = SafeGetArrayLength(env, jbyte_buffers.obj());
   if (buffers_array_size != pos_array_size ||
       buffers_array_size != limit_array_size) {
     DLOG(ERROR) << "Illegal arguments.";
     return JNI_FALSE;
   }
 
-  IOByteBufferList buffers;
+  IOBufferWithByteBufferList buffers;
   for (size_t i = 0; i < buffers_array_size; ++i) {
     ScopedJavaLocalRef<jobject> jbuffer(
         env, env->GetObjectArrayElement(jbyte_buffers, i));
     void* data = env->GetDirectBufferAddress(jbuffer.obj());
     if (!data)
       return JNI_FALSE;
     jint pos;
     env->GetIntArrayRegion(jbyte_buffers_pos.obj(), i, 1, &pos);
     jint limit;
     env->GetIntArrayRegion(jbyte_buffers_limit.obj(), i, 1, &limit);
@@ skipping 73 matching lines @@
   // embedder releases it, too.
   read_buffer_ = nullptr;
 }
 
 void CronetBidirectionalStreamAdapter::OnDataSent() {
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(!write_buffer_list_.empty());
 
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jclass> byte_buffer_clazz(
-      env, env->GetObjectClass(write_buffer_list_[0]->byte_buffer()));
+      env, env->FindClass("java/nio/ByteBuffer"));
   size_t size = write_buffer_list_.size();
-  jobjectArray jbuffers =
+  jobjectArray jbuffer_array =
       env->NewObjectArray(size, byte_buffer_clazz.obj(), NULL);
   base::android::CheckException(env);
   std::vector<int> initial_positions;
   std::vector<int> initial_limits;
   for (size_t i = 0; i < size; ++i) {
-    env->SetObjectArrayElement(jbuffers, i,
+    env->SetObjectArrayElement(jbuffer_array, i,
                                write_buffer_list_[i]->byte_buffer());
     initial_positions.push_back(write_buffer_list_[i]->initial_position());
     initial_limits.push_back(write_buffer_list_[i]->initial_limit());
   }
+  ScopedJavaLocalRef<jobjectArray> jbuffers(env, jbuffer_array);
   ScopedJavaLocalRef<jintArray> jinitial_positions =
       base::android::ToJavaIntArray(env, initial_positions);
   ScopedJavaLocalRef<jintArray> jinitial_limits =
       base::android::ToJavaIntArray(env, initial_limits);
   // Call into Java.
   cronet::Java_CronetBidirectionalStream_onWritevCompleted(
-      env, owner_.obj(), jbuffers, jinitial_positions.obj(),
+      env, owner_.obj(), jbuffers.obj(), jinitial_positions.obj(),
       jinitial_limits.obj(), write_end_of_stream_);
   // Free the write buffers. This lets the Java ByteBuffer be freed, if the
   // embedder releases it, too.
   write_buffer_list_.clear();
 }
 
 void CronetBidirectionalStreamAdapter::OnTrailersReceived(
     const net::SpdyHeaderBlock& response_trailers) {
   DCHECK(context_->IsOnNetworkThread());
   JNIEnv* env = base::android::AttachCurrentThread();
@@ skipping 41 matching lines @@
     return;
 
   if (bytes_read < 0) {
     OnFailed(bytes_read);
     return;
   }
   OnDataRead(bytes_read);
 }
 
 void CronetBidirectionalStreamAdapter::WritevDataOnNetworkThread(
-    const IOByteBufferList& write_buffer_list,
+    const IOBufferWithByteBufferList& write_buffer_list,
     bool end_of_stream) {
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(write_buffer_list_.empty());
   DCHECK(!write_buffer_list.empty());
   DCHECK(!write_end_of_stream_);
 
   if (stream_failed_) {
-    // If stream failed between the time when WriteData is invoked and
-    // WriteDataOnNetworkThread is executed, do not call into |bidi_stream_|
+    // If stream failed between the time when WritevData is invoked and
+    // WritevDataOnNetworkThread is executed, do not call into |bidi_stream_|
     // since the underlying stream might have been destroyed. Do not invoke
     // Java callback either, since onError is posted when |stream_failed_| is
     // set to true.
     return;
   }
 
   write_end_of_stream_ = end_of_stream;
   std::vector<net::IOBuffer*> buffers;
   std::vector<int> lengths;
   for (const auto& buffer : write_buffer_list) {
@@ skipping 26 matching lines @@
 
   std::vector<std::string> headers;
   for (const auto& header : header_block) {
     headers.push_back(header.first.as_string());
     headers.push_back(header.second.as_string());
   }
   return base::android::ToJavaArrayOfStrings(env, headers);
 }
 
 }  // namespace cronet