Remove unnecessary array allocation in cronet_bidirectional_stream_adapter.cc

net/http/bidirectional_stream_unittest.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 "net/http/bidirectional_stream.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 114 matching lines @@
              HttpNetworkSession* session,
              const CompletionCallback& cb) {
     callback_ = cb;
     stream_.reset(new BidirectionalStream(std::move(request_info), session,
                                           disable_auto_flush_, this,
                                           std::move(timer_)));
     if (run_until_completion_)
       loop_->Run();
   }
 
-  void SendData(IOBuffer* data, int length, bool end_of_stream) {
+  void SendData(const scoped_refptr<IOBuffer>& data,
+                int length,
+                bool end_of_stream) {
     not_expect_callback_ = true;
     stream_->SendData(data, length, end_of_stream);
     not_expect_callback_ = false;
   }
 
-  void SendvData(const std::vector<IOBuffer*>& data,
+  void SendvData(const std::vector<scoped_refptr<IOBuffer>>& data,
                  const std::vector<int>& length,
                  bool end_of_stream) {
     not_expect_callback_ = true;
     stream_->SendvData(data, length, end_of_stream);
     not_expect_callback_ = false;
   }
 
   // Starts or continues reading data from |stream_| until no more bytes
   // can be read synchronously.
   void StartOrContinueReading() {
@@ skipping 381 matching lines @@
       read_buffer.get(), kReadBufferSize, base::WrapUnique(timer)));
   delegate->set_do_not_start_read(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Send the request and receive response headers.
   sequenced_data_->RunUntilPaused();
   EXPECT_FALSE(timer->IsRunning());
 
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
   // Send a DATA frame.
-  delegate->SendData(buf.get(), buf->size(), true);
+  delegate->SendData(buf, buf->size(), true);
   // ReadData returns asynchronously because no data is buffered.
   int rv = delegate->ReadData();
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Deliver the first DATA frame.
   sequenced_data_->Resume();
   sequenced_data_->RunUntilPaused();
   // |sequenced_data_| is now stopped after delivering first DATA frame but
   // before the second DATA frame.
   // Fire the timer to allow the first ReadData to complete asynchronously.
   timer->Fire();
@@ skipping 110 matching lines @@
   delegate->Start(std::move(request_info), http_session_.get());
   // Send the request and receive response headers.
   sequenced_data_->RunUntilPaused();
   EXPECT_FALSE(timer->IsRunning());
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
 
   // Send a DATA frame.
-  delegate->SendData(buf.get(), buf->size(), false);
+  delegate->SendData(buf, buf->size(), false);
   // ReadData and it should return asynchronously because no data is buffered.
   int rv = delegate->ReadData();
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Deliver a DATA frame, and fire the timer.
   sequenced_data_->Resume();
   sequenced_data_->RunUntilPaused();
   timer->Fire();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(1, delegate->on_data_read_count());
 
   // Send a DATA frame.
-  delegate->SendData(buf.get(), buf->size(), false);
+  delegate->SendData(buf, buf->size(), false);
   // ReadData and it should return asynchronously because no data is buffered.
   rv = delegate->ReadData();
   EXPECT_EQ(ERR_IO_PENDING, rv);
   // Deliver a DATA frame, and fire the timer.
   sequenced_data_->Resume();
   sequenced_data_->RunUntilPaused();
   timer->Fire();
   base::RunLoop().RunUntilIdle();
   // Last DATA frame is read. Server half closes.
   EXPECT_EQ(2, delegate->on_data_read_count());
   EXPECT_EQ(2, delegate->on_data_sent_count());
 
   // Send the last body frame. Client half closes.
-  delegate->SendData(buf.get(), buf->size(), true);
+  delegate->SendData(buf, buf->size(), true);
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(3, delegate->on_data_sent_count());
 
   // OnClose is invoked since both sides are closed.
   rv = delegate->ReadData();
   EXPECT_EQ(OK, rv);
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(2, delegate->on_data_read_count());
@@ skipping 48 matching lines @@
   delegate->DisableAutoFlush();
   TestCompletionCallback callback;
   delegate->Start(std::move(request_info), http_session_.get(),
                   callback.callback());
   // Wait until the stream is ready.
   callback.WaitForResult();
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(body_data.substr(0, 5)));
   scoped_refptr<StringIOBuffer> buf2(
       new StringIOBuffer(body_data.substr(5, body_data.size() - 5)));
-  delegate->SendvData({buf.get(), buf2.get()}, {buf->size(), buf2->size()},
-                      true);
+  delegate->SendvData({buf, buf2.get()}, {buf->size(), buf2->size()}, true);
   sequenced_data_->RunUntilPaused();  // OnHeadersReceived.
   // ReadData and it should return asynchronously because no data is buffered.
   EXPECT_EQ(ERR_IO_PENDING, delegate->ReadData());
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(1, delegate->on_data_sent_count());
   EXPECT_EQ(1, delegate->on_data_read_count());
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(1, delegate->on_data_read_count());
@@ skipping 277 matching lines @@
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->set_do_not_start_read(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Send the request and receive response headers.
   sequenced_data_->RunUntilPaused();
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
-  delegate->SendData(buf.get(), buf->size(), false);
+  delegate->SendData(buf, buf->size(), false);
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
   // Cancel the stream.
   delegate->CancelStream();
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(0, delegate->on_data_read_count());
   // EXPECT_EQ(1, delegate->on_data_send_count());
@@ skipping 420 matching lines @@
   AlternativeServiceVector alternative_service_vector =
       http_session_->http_server_properties()->GetAlternativeServices(server);
   ASSERT_EQ(1u, alternative_service_vector.size());
   EXPECT_EQ(AlternateProtocolFromNextProto(kProtoQUIC1SPDY3),
             alternative_service_vector[0].protocol);
   EXPECT_EQ("www.example.org", alternative_service_vector[0].host);
   EXPECT_EQ(443, alternative_service_vector[0].port);
 }
 
 }  // namespace net