Remove unnecessary array allocation in cronet_bidirectional_stream_adapter.cc

components/cronet/android/cronet_bidirectional_stream_adapter.h

 // 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.
 
 #ifndef COMPONENTS_CRONET_ANDROID_CRONET_BIDIRECTIONAL_STREAM_ADAPTER_H_
 #define COMPONENTS_CRONET_ANDROID_CRONET_BIDIRECTIONAL_STREAM_ADAPTER_H_
 
 #include <jni.h>
 
 #include <memory>
@@ skipping 10 matching lines @@
 namespace net {
 struct BidirectionalStreamRequestInfo;
 class SpdyHeaderBlock;
 }  // namespace net
 
 namespace cronet {
 
 class CronetURLRequestContextAdapter;
 class IOBufferWithByteBuffer;
 
+// Convenient wrapper to hold Java references and data to represent the pending
+// data to be written.
+struct PendingWriteData {
+  PendingWriteData(JNIEnv* env,
+                   jobjectArray jwrite_buffer_list,
+                   jintArray jwrite_buffer_pos_list,
+                   jintArray jwrite_buffer_limit_list,
+                   jboolean jwrite_end_of_stream);
+  ~PendingWriteData();
+
+  base::android::ScopedJavaGlobalRef<jobjectArray> jwrite_buffer_list;
+  base::android::ScopedJavaGlobalRef<jintArray> jwrite_buffer_pos_list;
+  base::android::ScopedJavaGlobalRef<jintArray> jwrite_buffer_limit_list;
+  jboolean jwrite_end_of_stream;
+  std::vector<scoped_refptr<net::IOBuffer>> write_buffer_list;

[mef, 2016/05/13 15:12:58]

My concern about using net::IOBuffer insted of IOBufferWithByteBuffer is that it
is theoretically possible to destroy ByteBuffer making memory backing IOBuffer
invalid.

[xunjieli, 2016/05/13 15:35:22]

But the Java ByteBuffer is not going to be destroyed/GC-ed since we retain a
global reference to it as |jwrite_buffer_list|, right?

[mef, 2016/05/16 13:54:18]

Yeah, that's fine.

+  std::vector<int> write_buffer_len_list;
+
+  DISALLOW_COPY_AND_ASSIGN(PendingWriteData);
+};
+
 // An adapter from Java BidirectionalStream object to net::BidirectionalStream.
 // Created and configured from a Java thread. Start, ReadData, WritevData and
 // Destroy can be called on any thread (including network thread), and post
 // calls to corresponding {Start|ReadData|WritevData|Destroy}OnNetworkThread to
 // the network thread. The object is always deleted on network thread. All
 // callbacks into the Java BidirectionalStream are done on the network thread.
 // Java BidirectionalStream is expected to initiate the next step like ReadData
 // or Destroy. Public methods can be called on any thread.
 class CronetBidirectionalStreamAdapter
     : public net::BidirectionalStream::Delegate {
@@ skipping 46 matching lines @@
       jboolean jend_of_stream);
 
   // Releases all resources for the request and deletes the object itself.
   // |jsend_on_canceled| indicates if Java onCanceled callback should be
   // issued to indicate that no more callbacks will be issued.
   void Destroy(JNIEnv* env,
                const base::android::JavaParamRef<jobject>& jcaller,
                jboolean jsend_on_canceled);
 
  private:
-  typedef std::vector<scoped_refptr<IOBufferWithByteBuffer>>
-      IOBufferWithByteBufferList;
   // net::BidirectionalStream::Delegate implementations:
   void OnStreamReady() override;
   void OnHeadersReceived(const net::SpdyHeaderBlock& response_headers) override;
   void OnDataRead(int bytes_read) override;
   void OnDataSent() override;
   void OnTrailersReceived(const net::SpdyHeaderBlock& trailers) override;
   void OnFailed(int error) override;
 
   void StartOnNetworkThread(
       std::unique_ptr<net::BidirectionalStreamRequestInfo> request_info);
   void ReadDataOnNetworkThread(
       scoped_refptr<IOBufferWithByteBuffer> read_buffer,
       int buffer_size);
-  void WritevDataOnNetworkThread(const IOBufferWithByteBufferList& buffers,
-                                 bool end_of_stream);
+  void WritevDataOnNetworkThread(
+      std::unique_ptr<PendingWriteData> pending_write_data);
   void DestroyOnNetworkThread(bool send_on_canceled);
   // Gets headers as a Java array.
   base::android::ScopedJavaLocalRef<jobjectArray> GetHeadersArray(
       JNIEnv* env,
       const net::SpdyHeaderBlock& header_block);
 
   CronetURLRequestContextAdapter* const context_;
 
   // Java object that owns this CronetBidirectionalStreamAdapter.
   base::android::ScopedJavaGlobalRef<jobject> owner_;
   const bool disable_auto_flush_;
   // Whether an end of stream flag is passed in through a write call.
   // Not applicable to HTTP methods that do not send data.
   bool write_end_of_stream_;
 
   scoped_refptr<IOBufferWithByteBuffer> read_buffer_;
-  IOBufferWithByteBufferList write_buffer_list_;
+  std::unique_ptr<PendingWriteData> pending_write_data_;
   std::unique_ptr<net::BidirectionalStream> bidi_stream_;
 
   // Whether BidirectionalStream::Delegate::OnFailed callback is invoked.
   bool stream_failed_;
 
   DISALLOW_COPY_AND_ASSIGN(CronetBidirectionalStreamAdapter);
 };
 
 }  // namespace cronet
 
 #endif  // COMPONENTS_CRONET_ANDROID_CRONET_BIDIRECTIONAL_STREAM_ADAPTER_H_