Reduce SpdyHeaderBlock copies with move semantics.

net/spdy/spdy_test_util_common.cc

 // Copyright (c) 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/spdy/spdy_test_util_common.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <memory>
@@ skipping 683 matching lines @@
 
 void SpdyTestUtil::AddUrlToHeaderBlock(base::StringPiece url,
                                        SpdyHeaderBlock* headers) const {
   std::string scheme, host, path;
   ParseUrl(url, &scheme, &host, &path);
   (*headers)[GetHostKey()] = host;
   (*headers)[GetSchemeKey()] = scheme;
   (*headers)[GetPathKey()] = path;
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlock(
+SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlock(
     base::StringPiece url) const {
   return ConstructHeaderBlock("GET", url, NULL);
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructGetHeaderBlockForProxy(
+SpdyHeaderBlock SpdyTestUtil::ConstructGetHeaderBlockForProxy(
     base::StringPiece url) const {
-  std::unique_ptr<SpdyHeaderBlock> headers(ConstructGetHeaderBlock(url));
-  return headers;
+  return ConstructGetHeaderBlock(url);
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeadHeaderBlock(
+SpdyHeaderBlock SpdyTestUtil::ConstructHeadHeaderBlock(
     base::StringPiece url,
     int64_t content_length) const {
   return ConstructHeaderBlock("HEAD", url, nullptr);
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPostHeaderBlock(
+SpdyHeaderBlock SpdyTestUtil::ConstructPostHeaderBlock(
     base::StringPiece url,
     int64_t content_length) const {
   return ConstructHeaderBlock("POST", url, &content_length);
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructPutHeaderBlock(
+SpdyHeaderBlock SpdyTestUtil::ConstructPutHeaderBlock(
     base::StringPiece url,
     int64_t content_length) const {
   return ConstructHeaderBlock("PUT", url, &content_length);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyFrame(
     const SpdyHeaderInfo& header_info,
-    std::unique_ptr<SpdyHeaderBlock> headers) const {
+    SpdyHeaderBlock headers) const {
   BufferedSpdyFramer framer(spdy_version_);
   SpdySerializedFrame* frame = NULL;
   switch (header_info.kind) {
     case DATA:
       frame = framer.CreateDataFrame(header_info.id, header_info.data,
                                      header_info.data_length,
                                      header_info.data_flags);
       break;
     case SYN_STREAM:
-      {
-        frame = framer.CreateSynStream(header_info.id, header_info.assoc_id,
-                                       header_info.priority,
-                                       header_info.control_flags,
-                                       headers.get());
-      }
+      frame = framer.CreateSynStream(
+          header_info.id, header_info.assoc_id, header_info.priority,
+          header_info.control_flags, std::move(headers));
       break;
     case SYN_REPLY:
       frame = framer.CreateSynReply(header_info.id, header_info.control_flags,
-                                    headers.get());
+                                    std::move(headers));
       break;
     case RST_STREAM:
       frame = framer.CreateRstStream(header_info.id, header_info.status);
       break;
     case HEADERS:
       frame = framer.CreateHeaders(header_info.id, header_info.control_flags,
-                                   header_info.weight, headers.get());
+                                   header_info.weight, std::move(headers));
       break;
     default:
       ADD_FAILURE();
       break;
   }
   return frame;
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyFrame(
     const SpdyHeaderInfo& header_info,
     const char* const extra_headers[],
     int extra_header_count,
     const char* const tail_headers[],
     int tail_header_count) const {
-  std::unique_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
-  AppendToHeaderBlock(extra_headers, extra_header_count, headers.get());
+  SpdyHeaderBlock headers;
+  AppendToHeaderBlock(extra_headers, extra_header_count, &headers);
   if (tail_headers && tail_header_count)
-    AppendToHeaderBlock(tail_headers, tail_header_count, headers.get());
+    AppendToHeaderBlock(tail_headers, tail_header_count, &headers);
   return ConstructSpdyFrame(header_info, std::move(headers));
 }
 
 std::string SpdyTestUtil::ConstructSpdyReplyString(
     const SpdyHeaderBlock& headers) const {
   std::string reply_string;
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
     std::string key = it->first.as_string();
     // Remove leading colon from "special" headers (for SPDY3 and
@@ skipping 81 matching lines @@
     SpdyRstStreamStatus status) {
   SpdyRstStreamIR rst_ir(stream_id, status);
   return new SpdySerializedFrame(
       headerless_spdy_framer_.SerializeRstStream(rst_ir));
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGet(
     const char* const url,
     SpdyStreamId stream_id,
     RequestPriority request_priority) {
-  std::unique_ptr<SpdyHeaderBlock> block(ConstructGetHeaderBlock(url));
-  return ConstructSpdySyn(stream_id, *block, request_priority, true);
+  SpdyHeaderBlock block(ConstructGetHeaderBlock(url));
+  return ConstructSpdySyn(stream_id, std::move(block), request_priority, true);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGet(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id,
     RequestPriority request_priority,
     bool direct) {
   SpdyHeaderBlock block;
   MaybeAddVersionHeader(&block);
   block[GetMethodKey()] = "GET";
   AddUrlToHeaderBlock(default_url_.spec(), &block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
-  return ConstructSpdySyn(stream_id, block, request_priority, true);
+  return ConstructSpdySyn(stream_id, std::move(block), request_priority, true);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyConnect(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id,
     RequestPriority priority,
     const HostPortPair& host_port_pair) {
   SpdyHeaderBlock block;
   MaybeAddVersionHeader(&block);
   block[GetMethodKey()] = "CONNECT";
   if (spdy_version() < HTTP2) {
     block[GetHostKey()] = (host_port_pair.port() == 443)
                               ? host_port_pair.host()
                               : host_port_pair.ToString();
     block[GetPathKey()] = host_port_pair.ToString();
   } else {
     block[GetHostKey()] = host_port_pair.ToString();
   }
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
-  return ConstructSpdySyn(stream_id, block, priority, false);
+  return ConstructSpdySyn(stream_id, std::move(block), priority, false);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPush(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id,
     int associated_stream_id,
     const char* url) {
   if (spdy_version() < HTTP2) {
     SpdyHeaderBlock header_block;
@@ skipping 79 matching lines @@
         &push_promise_frame, &headers_frame,
     };
     int combined_size =
         CombineFrames(frames, arraysize(frames), data.get(), joint_data_size);
     DCHECK_EQ(combined_size, joint_data_size);
     return new SpdySerializedFrame(data.release(), joint_data_size, true);
   }
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructInitialSpdyPushFrame(
-    std::unique_ptr<SpdyHeaderBlock> headers,
+    SpdyHeaderBlock headers,
     int stream_id,
     int associated_stream_id) {
   if (spdy_version() < HTTP2) {
-    SpdySynStreamIR syn_stream(stream_id);
+    SpdySynStreamIR syn_stream(stream_id, std::move(headers));
     syn_stream.set_associated_to_stream_id(associated_stream_id);
     SetPriority(LOWEST, &syn_stream);
-    syn_stream.set_header_block(*headers);
     return new SpdySerializedFrame(
         response_spdy_framer_.SerializeFrame(syn_stream));
   } else {
-    SpdyPushPromiseIR push_promise(associated_stream_id, stream_id);
-    push_promise.set_header_block(*headers);
+    SpdyPushPromiseIR push_promise(associated_stream_id, stream_id,
+                                   std::move(headers));
     return new SpdySerializedFrame(
         response_spdy_framer_.SerializeFrame(push_promise));
   }
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPushHeaders(
     int stream_id,
     const char* const extra_headers[],
     int extra_header_count) {
   SpdyHeaderBlock header_block;
   header_block[GetStatusKey()] = "200";
   MaybeAddVersionHeader(&header_block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &header_block);
   SpdyHeadersIR headers(stream_id, std::move(header_block));
   return new SpdySerializedFrame(response_spdy_framer_.SerializeFrame(headers));
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyResponseHeaders(
     int stream_id,
-    const SpdyHeaderBlock& headers,
+    SpdyHeaderBlock headers,
     bool fin) {
-  SpdyHeadersIR spdy_headers(stream_id);
-  spdy_headers.set_header_block(headers);
+  SpdyHeadersIR spdy_headers(stream_id, std::move(headers));
   spdy_headers.set_fin(fin);
   return new SpdySerializedFrame(
       response_spdy_framer_.SerializeFrame(spdy_headers));
 }
 
-SpdySerializedFrame* SpdyTestUtil::ConstructSpdySyn(
-    int stream_id,
-    const SpdyHeaderBlock& block,
-    RequestPriority priority,
-    bool fin) {
+SpdySerializedFrame* SpdyTestUtil::ConstructSpdySyn(int stream_id,
+                                                    SpdyHeaderBlock block,
+                                                    RequestPriority priority,
+                                                    bool fin) {
   // Get the stream id of the next highest priority request
   // (most recent request of the same priority, or last request of
   // an earlier priority).
   // Note that this is a duplicate of the logic in Http2PriorityDependencies
   // (slightly transformed as this is based on RequestPriority and that logic
   // on SpdyPriority, but only slightly transformed) and hence tests using
   // this function do not effectively test that logic.
   // That logic is tested by the Http2PriorityDependencies unit tests.
   int parent_stream_id = 0;
   for (int q = priority; q <= HIGHEST; ++q) {
     if (!priority_to_stream_id_list_[q].empty()) {
       parent_stream_id = priority_to_stream_id_list_[q].back();
       break;
     }
   }
 
   priority_to_stream_id_list_[priority].push_back(stream_id);
 
   if (protocol_ < kProtoHTTP2) {
-    SpdySynStreamIR syn_stream(stream_id);
-    syn_stream.set_header_block(block);
+    SpdySynStreamIR syn_stream(stream_id, std::move(block));
     syn_stream.set_priority(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version()));
     syn_stream.set_fin(fin);
     return new SpdySerializedFrame(
         request_spdy_framer_.SerializeFrame(syn_stream));
   } else {
-    SpdyHeadersIR headers(stream_id);
-    headers.set_header_block(block);
+    SpdyHeadersIR headers(stream_id, std::move(block));
     headers.set_has_priority(true);
     headers.set_weight(Spdy3PriorityToHttp2Weight(
         ConvertRequestPriorityToSpdyPriority(priority, spdy_version())));
     if (dependency_priorities_) {
       headers.set_parent_stream_id(parent_stream_id);
       headers.set_exclusive(true);
     }
     headers.set_fin(fin);
     return new SpdySerializedFrame(
         request_spdy_framer_.SerializeFrame(headers));
   }
 }
 
-SpdySerializedFrame* SpdyTestUtil::ConstructSpdyReply(
-    int stream_id,
-    const SpdyHeaderBlock& headers) {
+SpdySerializedFrame* SpdyTestUtil::ConstructSpdyReply(int stream_id,
+                                                      SpdyHeaderBlock headers) {
   if (protocol_ < kProtoHTTP2) {
-    SpdySynReplyIR syn_reply(stream_id);
-    syn_reply.set_header_block(headers);
+    SpdySynReplyIR syn_reply(stream_id, std::move(headers));
     return new SpdySerializedFrame(
         response_spdy_framer_.SerializeFrame(syn_reply));
   } else {
-    SpdyHeadersIR reply(stream_id);
-    reply.set_header_block(headers);
+    SpdyHeadersIR reply(stream_id, std::move(headers));
     return new SpdySerializedFrame(response_spdy_framer_.SerializeFrame(reply));
   }
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdySynReplyError(
     const char* const status,
     const char* const* const extra_headers,
     int extra_header_count,
     int stream_id) {
   SpdyHeaderBlock block;
   block[GetStatusKey()] = status;
   MaybeAddVersionHeader(&block);
   block["hello"] = "bye";
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 
-  return ConstructSpdyReply(stream_id, block);
+  return ConstructSpdyReply(stream_id, std::move(block));
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGetSynReplyRedirect(
     int stream_id) {
   static const char* const kExtraHeaders[] = {
     "location", "http://www.foo.com/index.php",
   };
   return ConstructSpdySynReplyError("301 Moved Permanently", kExtraHeaders,
                                     arraysize(kExtraHeaders)/2, stream_id);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdySynReplyError(int stream_id) {
   return ConstructSpdySynReplyError("500 Internal Server Error", NULL, 0, 1);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyGetSynReply(
     const char* const extra_headers[],
     int extra_header_count,
     int stream_id) {
   SpdyHeaderBlock block;
   block[GetStatusKey()] = "200";
   MaybeAddVersionHeader(&block);
   block["hello"] = "bye";
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
 
-  return ConstructSpdyReply(stream_id, block);
+  return ConstructSpdyReply(stream_id, std::move(block));
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPost(
     const char* url,
     SpdyStreamId stream_id,
     int64_t content_length,
     RequestPriority priority,
     const char* const extra_headers[],
     int extra_header_count) {
-  std::unique_ptr<SpdyHeaderBlock> block(
-      ConstructPostHeaderBlock(url, content_length));
-  AppendToHeaderBlock(extra_headers, extra_header_count, block.get());
-  return ConstructSpdySyn(stream_id, *block, priority, false);
+  SpdyHeaderBlock block(ConstructPostHeaderBlock(url, content_length));
+  AppendToHeaderBlock(extra_headers, extra_header_count, &block);
+  return ConstructSpdySyn(stream_id, std::move(block), priority, false);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructChunkedSpdyPost(
     const char* const extra_headers[],
     int extra_header_count) {
   SpdyHeaderBlock block;
   MaybeAddVersionHeader(&block);
   block[GetMethodKey()] = "POST";
   AddUrlToHeaderBlock(default_url_.spec(), &block);
   AppendToHeaderBlock(extra_headers, extra_header_count, &block);
-  return ConstructSpdySyn(1, block, LOWEST, false);
+  return ConstructSpdySyn(1, std::move(block), LOWEST, false);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyPostSynReply(
     const char* const extra_headers[],
     int extra_header_count) {
   // TODO(jgraettinger): Remove this method.
   return ConstructSpdyGetSynReply(extra_headers, extra_header_count, 1);
 }
 
 SpdySerializedFrame* SpdyTestUtil::ConstructSpdyBodyFrame(int stream_id,
@@ skipping 72 matching lines @@
 }
 
 const char* SpdyTestUtil::GetVersionKey() const {
   return ":version";
 }
 
 const char* SpdyTestUtil::GetPathKey() const {
   return ":path";
 }
 
-std::unique_ptr<SpdyHeaderBlock> SpdyTestUtil::ConstructHeaderBlock(
+SpdyHeaderBlock SpdyTestUtil::ConstructHeaderBlock(
     base::StringPiece method,
     base::StringPiece url,
     int64_t* content_length) const {
   std::string scheme, host, path;
   ParseUrl(url.data(), &scheme, &host, &path);
-  std::unique_ptr<SpdyHeaderBlock> headers(new SpdyHeaderBlock());
+  SpdyHeaderBlock headers;
   if (include_version_header()) {
-    (*headers)[GetVersionKey()] = "HTTP/1.1";
+    headers[GetVersionKey()] = "HTTP/1.1";
   }
-  (*headers)[GetMethodKey()] = method.as_string();
-  (*headers)[GetHostKey()] = host.c_str();
-  (*headers)[GetSchemeKey()] = scheme.c_str();
-  (*headers)[GetPathKey()] = path.c_str();
+  headers[GetMethodKey()] = method.as_string();
+  headers[GetHostKey()] = host.c_str();
+  headers[GetSchemeKey()] = scheme.c_str();
+  headers[GetPathKey()] = path.c_str();
   if (content_length) {
     std::string length_str = base::Int64ToString(*content_length);
-    (*headers)["content-length"] = length_str;
+    headers["content-length"] = length_str;
   }
   return headers;
 }
 
 void SpdyTestUtil::MaybeAddVersionHeader(SpdyHeaderBlock* block) const {
   if (include_version_header()) {
     (*block)[GetVersionKey()] = "HTTP/1.1";
   }
 }
 
 void SpdyTestUtil::SetPriority(RequestPriority priority,
                                SpdySynStreamIR* ir) const {
   ir->set_priority(ConvertRequestPriorityToSpdyPriority(
       priority, spdy_version()));
 }
 
 }  // namespace net