Reduce SpdyHeaderBlock copies with move semantics.

net/quic/test_tools/quic_test_packet_maker.cc

 // Copyright 2013 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/test_tools/quic_test_packet_maker.h"
 
 #include <list>
+#include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_http_utils.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using std::make_pair;
 
 namespace net {
@@ skipping 338 matching lines @@
   return MakeMultipleFramesPacket(header_, frames);
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeRequestHeadersAndMultipleDataFramesPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length,
     const std::vector<std::string>& data_writes) {
   InitializeHeader(packet_number, should_include_version);
   SpdySerializedFrame spdy_frame;
   if (spdy_request_framer_.protocol_version() == SPDY3) {
-    SpdySynStreamIR syn_stream(stream_id);
-    syn_stream.set_header_block(headers);
+    SpdySynStreamIR syn_stream(stream_id, std::move(headers));
     syn_stream.set_fin(fin);
     syn_stream.set_priority(priority);
     spdy_frame = spdy_request_framer_.SerializeSynStream(syn_stream);
   } else {
-    SpdyHeadersIR headers_frame(stream_id);
-    headers_frame.set_header_block(headers);
+    SpdyHeadersIR headers_frame(stream_id, std::move(headers));
     headers_frame.set_fin(fin);
     headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
     headers_frame.set_has_priority(true);
     spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
   }
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   QuicStreamFrame frame(
       kHeadersStreamId, false, 0,
@@ skipping 20 matching lines @@
   return MakeMultipleFramesPacket(header_, frames);
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeRequestHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length) {
-  return MakeRequestHeadersPacket(packet_number, stream_id,
-                                  should_include_version, fin, priority,
-                                  headers, spdy_headers_frame_length, nullptr);
+  return MakeRequestHeadersPacket(
+      packet_number, stream_id, should_include_version, fin, priority,
+      std::move(headers), spdy_headers_frame_length, nullptr);
 }
 
 // If |offset| is provided, will use the value when creating the packet.
 // Will also update the value after packet creation.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeRequestHeadersPacket(QuicPacketNumber packet_number,
                                               QuicStreamId stream_id,
                                               bool should_include_version,
                                               bool fin,
                                               SpdyPriority priority,
-                                              const SpdyHeaderBlock& headers,
+                                              SpdyHeaderBlock headers,
                                               size_t* spdy_headers_frame_length,
                                               QuicStreamOffset* offset) {
   InitializeHeader(packet_number, should_include_version);
   SpdySerializedFrame spdy_frame;
   if (spdy_request_framer_.protocol_version() == SPDY3) {
-    SpdySynStreamIR syn_stream(stream_id);
-    syn_stream.set_header_block(headers);
+    SpdySynStreamIR syn_stream(stream_id, std::move(headers));
     syn_stream.set_fin(fin);
     syn_stream.set_priority(priority);
     spdy_frame = spdy_request_framer_.SerializeSynStream(syn_stream);
   } else {
-    SpdyHeadersIR headers_frame(stream_id);
-    headers_frame.set_header_block(headers);
+    SpdyHeadersIR headers_frame(stream_id, std::move(headers));
     headers_frame.set_fin(fin);
     headers_frame.set_weight(Spdy3PriorityToHttp2Weight(priority));
     headers_frame.set_has_priority(true);
     spdy_frame = spdy_request_framer_.SerializeFrame(headers_frame);
   }
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   if (offset != nullptr) {
     QuicStreamFrame frame(
@@ skipping 12 matching lines @@
 
 // Convenience method for calling MakeRequestHeadersPacket with nullptr for
 // |spdy_headers_frame_length|.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeRequestHeadersPacketWithOffsetTracking(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
     SpdyPriority priority,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     QuicStreamOffset* offset) {
   return MakeRequestHeadersPacket(packet_number, stream_id,
                                   should_include_version, fin, priority,
-                                  headers, nullptr, offset);
+                                  std::move(headers), nullptr, offset);
 }
 
 // If |offset| is provided, will use the value when creating the packet.
 // Will also update the value after packet creation.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length,
     QuicStreamOffset* offset) {
   InitializeHeader(packet_number, should_include_version);
   SpdySerializedFrame spdy_frame;
   if (spdy_response_framer_.protocol_version() == SPDY3) {
-    SpdySynReplyIR syn_reply(stream_id);
-    syn_reply.set_header_block(headers);
+    SpdySynReplyIR syn_reply(stream_id, std::move(headers));
     syn_reply.set_fin(fin);
     spdy_frame = spdy_response_framer_.SerializeSynReply(syn_reply);
   } else {
-    SpdyHeadersIR headers_frame(stream_id);
-    headers_frame.set_header_block(headers);
+    SpdyHeadersIR headers_frame(stream_id, std::move(headers));
     headers_frame.set_fin(fin);
     spdy_frame = spdy_response_framer_.SerializeFrame(headers_frame);
   }
   if (spdy_headers_frame_length) {
     *spdy_headers_frame_length = spdy_frame.size();
   }
   if (offset != nullptr) {
     QuicStreamFrame frame(
         kHeadersStreamId, false, *offset,
         base::StringPiece(spdy_frame.data(), spdy_frame.size()));
     *offset += spdy_frame.size();
     return MakePacket(header_, QuicFrame(&frame));
   } else {
     QuicStreamFrame frame(
         kHeadersStreamId, false, 0,
         base::StringPiece(spdy_frame.data(), spdy_frame.size()));
     return MakePacket(header_, QuicFrame(&frame));
   }
 }
 
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacket(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     size_t* spdy_headers_frame_length) {
-  return MakeResponseHeadersPacket(packet_number, stream_id,
-                                   should_include_version, fin, headers,
-                                   spdy_headers_frame_length, nullptr);
+  return MakeResponseHeadersPacket(
+      packet_number, stream_id, should_include_version, fin, std::move(headers),
+      spdy_headers_frame_length, nullptr);
 }
 
 // Convenience method for calling MakeResponseHeadersPacket with nullptr for
 // |spdy_headers_frame_length|.
 std::unique_ptr<QuicReceivedPacket>
 QuicTestPacketMaker::MakeResponseHeadersPacketWithOffsetTracking(
     QuicPacketNumber packet_number,
     QuicStreamId stream_id,
     bool should_include_version,
     bool fin,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     QuicStreamOffset* offset) {
   return MakeResponseHeadersPacket(packet_number, stream_id,
-                                   should_include_version, fin, headers,
-                                   nullptr, offset);
+                                   should_include_version, fin,
+                                   std::move(headers), nullptr, offset);
 }
 
 SpdyHeaderBlock QuicTestPacketMaker::GetRequestHeaders(
     const std::string& method,
     const std::string& scheme,
     const std::string& path) {
   SpdyHeaderBlock headers;
   headers[":method"] = method;
   headers[":authority"] = host_;
   headers[":scheme"] = scheme;
@@ skipping 48 matching lines @@
   header_.public_header.reset_flag = false;
   header_.public_header.version_flag = should_include_version;
   header_.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
   header_.packet_number = packet_number;
   header_.entropy_flag = false;
   header_.fec_flag = false;
 }
 
 }  // namespace test
 }  // namespace net