Reduce SpdyHeaderBlock copies with move semantics.

net/quic/bidirectional_stream_quic_impl_unittest.cc

 // Copyright 2016 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/quic/bidirectional_stream_quic_impl.h"
 
+#include <utility>
+
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/http/bidirectional_stream_request_info.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_util.h"
@@ skipping 432 matching lines @@
 
   std::unique_ptr<QuicReceivedPacket> ConstructRequestHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
       RequestPriority request_priority,
       size_t* spdy_headers_frame_length) {
     SpdyPriority priority =
         ConvertRequestPriorityToQuicPriority(request_priority);
     return client_maker_.MakeRequestHeadersPacket(
         packet_number, stream_id_, kIncludeVersion, fin, priority,
-        request_headers_, spdy_headers_frame_length);
+        std::move(request_headers_), spdy_headers_frame_length);
   }
 
   std::unique_ptr<QuicReceivedPacket>
   ConstructRequestHeadersAndMultipleDataFramesPacket(
       QuicPacketNumber packet_number,
       bool fin,
       RequestPriority request_priority,
       size_t* spdy_headers_frame_length,
       const std::vector<std::string>& data) {
     SpdyPriority priority =
         ConvertRequestPriorityToQuicPriority(request_priority);
     std::unique_ptr<QuicReceivedPacket> packet(
         client_maker_.MakeRequestHeadersAndMultipleDataFramesPacket(
             packet_number, stream_id_, kIncludeVersion, fin, priority,
-            request_headers_, spdy_headers_frame_length, data));
+            std::move(request_headers_), spdy_headers_frame_length, data));
     DVLOG(2) << "packet(" << packet_number << "): " << std::endl
              << QuicUtils::StringToHexASCIIDump(packet->AsStringPiece());
     return packet;
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructResponseHeadersPacket(
       QuicPacketNumber packet_number,
       bool fin,
-      const SpdyHeaderBlock& response_headers,
+      SpdyHeaderBlock response_headers,
       size_t* spdy_headers_frame_length,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacket(
-        packet_number, stream_id_, !kIncludeVersion, fin, response_headers,
-        spdy_headers_frame_length, offset);
+        packet_number, stream_id_, !kIncludeVersion, fin,
+        std::move(response_headers), spdy_headers_frame_length, offset);
   }
 
   std::unique_ptr<QuicReceivedPacket> ConstructResponseTrailersPacket(
       QuicPacketNumber packet_number,
       bool fin,
       const SpdyHeaderBlock& trailers,
       size_t* spdy_headers_frame_length,
       QuicStreamOffset* offset) {
     return server_maker_.MakeResponseHeadersPacket(
         packet_number, stream_id_, !kIncludeVersion, fin, trailers,
@@ skipping 127 matching lines @@
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 96 matching lines @@
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 77 matching lines @@
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 78 matching lines @@
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 67 matching lines @@
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 55 matching lines @@
   delegate->WaitUntilNextCallback();  // OnDataSent
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
   ProcessPacket(
       ConstructServerDataPacket(3, !kIncludeVersion, !kFin, 0, kResponseBody));
@@ skipping 49 matching lines @@
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
   ConfirmHandshake();
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
-  ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
+  ProcessPacket(
+      ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
+                                     &spdy_response_headers_frame_length, 0));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Client sends a data packet.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf, buf->size(), false);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
@@ skipping 100 matching lines @@
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   // Server sends a Rst.
   ProcessPacket(ConstructServerRstStreamPacket(3));
@@ skipping 34 matching lines @@
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
   ConfirmHandshake();
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
-  ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
+  ProcessPacket(
+      ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
+                                     &spdy_response_headers_frame_length, 0));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
 
   delegate->SendData(buf, buf->size(), false);
   delegate->WaitUntilNextCallback();  // OnDataSent
 
@@ skipping 37 matching lines @@
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   QuicStreamOffset offset = 0;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   session()->connection()->CloseConnection(
       QUIC_NO_ERROR, "test", ConnectionCloseBehavior::SILENT_CLOSE);
   delegate->WaitUntilNextCallback();  // OnFailed
   EXPECT_TRUE(delegate->on_failed_called());
 
@@ skipping 34 matching lines @@
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
   ConfirmHandshake();
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
   size_t spdy_response_headers_frame_length;
-  ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length, 0));
+  ProcessPacket(
+      ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
+                                     &spdy_response_headers_frame_length, 0));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Cancel the stream after ReadData returns ERR_IO_PENDING.
   TestCompletionCallback cb;
   EXPECT_EQ(ERR_IO_PENDING, delegate->ReadData(cb.callback()));
   delegate->CancelStream();
 
   base::RunLoop().RunUntilIdle();
@@ skipping 31 matching lines @@
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      nullptr));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, nullptr));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
@@ skipping 21 matching lines @@
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      nullptr));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, nullptr));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
@@ skipping 31 matching lines @@
 
   // Server acks the request.
   ProcessPacket(ConstructServerAckPacket(1, 0, 0));
 
   // Server sends the response headers.
   SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
 
   QuicStreamOffset offset = 0;
   size_t spdy_response_headers_frame_length;
   ProcessPacket(ConstructResponseHeadersPacket(
-      2, !kFin, response_headers, &spdy_response_headers_frame_length,
-      &offset));
+      2, !kFin, std::move(response_headers),
+      &spdy_response_headers_frame_length, &offset));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   TestCompletionCallback cb;
   int rv = delegate->ReadData(cb.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   const char kResponseBody[] = "Hello world!";
   // Server sends data.
@@ skipping 17 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net