Reduce SpdyHeaderBlock copies with move semantics.

net/spdy/spdy_network_transaction_unittest.cc

 // Copyright (c) 2012 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 <cmath>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 1654 matching lines @@
   helper.VerifyDataConsumed();
 }
 
 // Test that a simple PUT request works.
 TEST_P(SpdyNetworkTransactionTest, Put) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "PUT";
   request.url = GURL(GetDefaultUrl());
 
-  std::unique_ptr<SpdyHeaderBlock> put_headers(
+  SpdyHeaderBlock put_headers(
       spdy_util_.ConstructPutHeaderBlock(GetDefaultUrl(), 0));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *put_headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(put_headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
@@ skipping 11 matching lines @@
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
 }
 
 // Test that a simple HEAD request works.
 TEST_P(SpdyNetworkTransactionTest, Head) {
   // Setup the request
   HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL(GetDefaultUrl());
 
-  std::unique_ptr<SpdyHeaderBlock> head_headers(
+  SpdyHeaderBlock head_headers(
       spdy_util_.ConstructHeadHeaderBlock(GetDefaultUrl(), 0));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *head_headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(head_headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
@@ skipping 216 matching lines @@
   BufferedSpdyFramer framer(spdy_util_.spdy_version());
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   // Create an empty UploadData.
   request.upload_data_stream = NULL;
 
   // When request.upload_data_stream is NULL for post, content-length is
   // expected to be 0.
-  std::unique_ptr<SpdyHeaderBlock> req_block(
+  SpdyHeaderBlock req_block(
       spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), 0));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(req_block), LOWEST, true));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
@@ skipping 21 matching lines @@
   ElementsUploadDataStream stream(std::move(element_readers), 0);
 
   // Setup the request
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL(GetDefaultUrl());
   request.upload_data_stream = &stream;
 
   const uint64_t kContentLength = 0;
 
-  std::unique_ptr<SpdyHeaderBlock> req_block(
+  SpdyHeaderBlock req_block(
       spdy_util_.ConstructPostHeaderBlock(GetDefaultUrl(), kContentLength));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(req_block), LOWEST, true));
 
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
@@ skipping 433 matching lines @@
   ASSERT_EQ(ERR_IO_PENDING, rv);
   data.Resume();
 
   // Finish running rest of tasks.
   base::RunLoop().RunUntilIdle();
   helper.VerifyDataConsumed();
 }
 
 // Send a spdy request to www.example.org that gets redirected to www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectGetRequest) {
-  std::unique_ptr<SpdyHeaderBlock> headers(
-      spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
-  (*headers)["user-agent"] = "";
-  (*headers)["accept-encoding"] = "gzip, deflate";
-  std::unique_ptr<SpdyHeaderBlock> headers2(
-      spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
-  (*headers2)["user-agent"] = "";
-  (*headers2)["accept-encoding"] = "gzip, deflate";
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  headers["user-agent"] = "";
+  headers["accept-encoding"] = "gzip, deflate";
 
   // Setup writes/reads to www.example.org
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, true));
-  std::unique_ptr<SpdySerializedFrame> req2(
-      spdy_util_.ConstructSpdySyn(1, *headers2, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReplyRedirect(1));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     MockRead(ASYNC, 0, 0, 3)  // EOF
   };
+  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
 
   // Setup writes/reads to www.foo.com
+  SpdyHeaderBlock headers2(
+      spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
+  headers2["user-agent"] = "";
+  headers2["accept-encoding"] = "gzip, deflate";
+  std::unique_ptr<SpdySerializedFrame> req2(
+      spdy_util_.ConstructSpdySyn(1, std::move(headers2), LOWEST, true));
+  MockWrite writes2[] = {
+      CreateMockWrite(*req2, 1),
+  };
+
   std::unique_ptr<SpdySerializedFrame> resp2(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body2(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
-  MockWrite writes2[] = {
-    CreateMockWrite(*req2, 1),
-  };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
     MockRead(ASYNC, 0, 0, 4)  // EOF
   };
-  SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+
   SequencedSocketData data2(reads2, arraysize(reads2), writes2,
                             arraysize(writes2));
 
   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
   TestDelegate d;
   {
     SpdyURLRequestContext spdy_url_request_context(GetParam().protocol);
     std::unique_ptr<URLRequest> r(spdy_url_request_context.CreateRequest(
         GURL(GetDefaultUrl()), DEFAULT_PRIORITY, &d));
     spdy_url_request_context.socket_factory().
@@ skipping 17 matching lines @@
   }
   EXPECT_TRUE(data.AllReadDataConsumed());
   EXPECT_TRUE(data.AllWriteDataConsumed());
   EXPECT_TRUE(data2.AllReadDataConsumed());
   EXPECT_TRUE(data2.AllWriteDataConsumed());
 }
 
 // Send a spdy request to www.example.org. Get a pushed stream that redirects to
 // www.foo.com.
 TEST_P(SpdyNetworkTransactionTest, DISABLED_RedirectServerPush) {
-  std::unique_ptr<SpdyHeaderBlock> headers(
-      spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
-  (*headers)["user-agent"] = "";
-  (*headers)["accept-encoding"] = "gzip, deflate";
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  headers["user-agent"] = "";
+  headers["accept-encoding"] = "gzip, deflate";
 
   // Setup writes/reads to www.example.org
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> rep(spdy_util_.ConstructSpdyPush(
       NULL, 0, 2, 1, GetDefaultUrlWithPath("/foo.dat").c_str(),
       "301 Moved Permanently", "http://www.foo.com/index.php"));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   std::unique_ptr<SpdySerializedFrame> rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
   MockWrite writes[] = {
     CreateMockWrite(*req, 1),
     CreateMockWrite(*rst, 6),
   };
   MockRead reads[] = {
     CreateMockRead(*resp, 2),
     CreateMockRead(*rep, 3),
     CreateMockRead(*body, 4),
     MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
     MockRead(ASYNC, 0, 0, 7)  // EOF
   };
 
   // Setup writes/reads to www.foo.com
-  std::unique_ptr<SpdyHeaderBlock> headers2(
+  SpdyHeaderBlock headers2(
       spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
-  (*headers2)["user-agent"] = "";
-  (*headers2)["accept-encoding"] = "gzip, deflate";
+  headers2["user-agent"] = "";
+  headers2["accept-encoding"] = "gzip, deflate";
   std::unique_ptr<SpdySerializedFrame> req2(
-      spdy_util_.ConstructSpdySyn(1, *headers2, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers2), LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> resp2(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body2(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes2[] = {
     CreateMockWrite(*req2, 1),
   };
   MockRead reads2[] = {
     CreateMockRead(*resp2, 2),
     CreateMockRead(*body2, 3),
@@ skipping 484 matching lines @@
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   std::unique_ptr<SpdySerializedFrame> stream2_rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
   MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 0), CreateMockWrite(*stream2_rst, 3),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  std::unique_ptr<SpdyHeaderBlock> incomplete_headers(new SpdyHeaderBlock());
-  (*incomplete_headers)[spdy_util_.GetStatusKey()] = "200 OK";
-  (*incomplete_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
-  (*incomplete_headers)["hello"] = "bye";
+  SpdyHeaderBlock incomplete_headers;
+  incomplete_headers[spdy_util_.GetStatusKey()] = "200 OK";
+  incomplete_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  incomplete_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(incomplete_headers), 2,
                                                1));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),
       CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 4),
       MockRead(SYNCHRONOUS, ERR_IO_PENDING, 5)  // Force a pause
   };
 
@@ skipping 309 matching lines @@
 
     MockWrite writes[] = {
         CreateMockWrite(*frame_req, 0),
     };
 
     // Construct the reply.
     SpdyHeaderBlock reply_headers;
     AppendToHeaderBlock(test_cases[i].extra_headers[1],
                         test_cases[i].num_headers[1],
                         &reply_headers);
+    // Construct the expected header reply string before moving |reply_headers|.
+    std::string expected_reply =
+        spdy_test_util.ConstructSpdyReplyString(reply_headers);
+
     std::unique_ptr<SpdySerializedFrame> frame_reply(
-        spdy_test_util.ConstructSpdyReply(1, reply_headers));
+        spdy_test_util.ConstructSpdyReply(1, std::move(reply_headers)));
 
     std::unique_ptr<SpdySerializedFrame> body(
         spdy_test_util.ConstructSpdyBodyFrame(1, true));
     MockRead reads[] = {
         CreateMockRead(*frame_reply, 1),
         CreateMockRead(*body, 2),
         MockRead(ASYNC, 0, 3)  // EOF
     };
 
     // Attach the headers to the request.
@@ skipping 26 matching lines @@
     ASSERT_TRUE(headers) << i;
     size_t iter = 0;
     std::string name, value, lines;
     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
       lines.append(name);
       lines.append(": ");
       lines.append(value);
       lines.append("\n");
     }
 
-    // Construct the expected header reply string.
-    std::string expected_reply =
-        spdy_test_util.ConstructSpdyReplyString(reply_headers);
     EXPECT_EQ(expected_reply, lines) << i;
   }
 }
 
 // Verify that we don't crash on invalid SynReply responses.
 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
   struct InvalidSynReplyTests {
     int num_headers;
     const char* headers[10];
   } test_cases[] = {
@@ skipping 24 matching lines @@
         spdy_test_util.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
     MockWrite writes[] = {
         CreateMockWrite(*req, 0), CreateMockWrite(*rst, 2),
     };
 
     // Construct the reply.
     SpdyHeaderBlock reply_headers;
     AppendToHeaderBlock(
         test_cases[i].headers, test_cases[i].num_headers, &reply_headers);
     std::unique_ptr<SpdySerializedFrame> resp(
-        spdy_test_util.ConstructSpdyReply(1, reply_headers));
+        spdy_test_util.ConstructSpdyReply(1, std::move(reply_headers)));
     MockRead reads[] = {
         CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 3)  // EOF
     };
 
     SequencedSocketData data(reads, arraysize(reads), writes,
                              arraysize(writes));
     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
                                        BoundNetLog(), GetParam(), NULL);
     helper.RunToCompletion(&data);
     TransactionHelperResult out = helper.output();
@@ skipping 739 matching lines @@
   EXPECT_TRUE(spdy_session_pool->http_server_properties()
                   ->GetSpdySettings(spdy_server)
                   .empty());
 
   // Construct the request.
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {CreateMockWrite(*req, 0)};
 
   // Construct the reply.
-  std::unique_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
-  (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
-  (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  SpdyHeaderBlock reply_headers;
+  reply_headers[spdy_util_.GetStatusKey()] = "200";
+  reply_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyFrame(kSynReplyInfo, std::move(reply_headers)));
 
   const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
   unsigned int kSampleValue1 = 0x0a0a0a0a;
   const SpdySettingsIds kSampleId2 = SETTINGS_DOWNLOAD_BANDWIDTH;
   unsigned int kSampleValue2 = 0x0b0b0b0b;
   const SpdySettingsIds kSampleId3 = SETTINGS_ROUND_TRIP_TIME;
   unsigned int kSampleValue3 = 0x0c0c0c0c;
   std::unique_ptr<SpdySerializedFrame> settings_frame;
@@ skipping 125 matching lines @@
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
 
   MockWrite writes[] = {
       CreateMockWrite(*initial_settings_frame, 0),
       CreateMockWrite(*settings_frame, 1),
       CreateMockWrite(*req, 2),
   };
 
   // Construct the reply.
-  std::unique_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
-  (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
-  (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
+  SpdyHeaderBlock reply_headers;
+  reply_headers[spdy_util_.GetStatusKey()] = "200";
+  reply_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   std::unique_ptr<SpdySerializedFrame> reply(
       spdy_util_.ConstructSpdyFrame(kSynReplyInfo, std::move(reply_headers)));
 
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*reply, 3),
       CreateMockRead(*body, 4),
       MockRead(ASYNC, 0, 5)  // EOF
   };
@@ skipping 124 matching lines @@
   request.method = "GET";
   request.url = GURL("https://www.example.org/");
   std::unique_ptr<SpdySessionDependencies> session_deps(
       CreateSpdySessionDependencies(GetParam()));
   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), std::move(session_deps));
 
   // First socket: HTTP/2 request rejected with HTTP_1_1_REQUIRED.
   const char* url = request.url.spec().c_str();
-  std::unique_ptr<SpdyHeaderBlock> headers(
-      spdy_util_.ConstructGetHeaderBlock(url));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(url));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes0[] = {CreateMockWrite(*req, 0)};
   std::unique_ptr<SpdySerializedFrame> go_away(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
   MockRead reads0[] = {CreateMockRead(*go_away, 1)};
   SequencedSocketData data0(reads0, arraysize(reads0), writes0,
                             arraysize(writes0));
 
   std::unique_ptr<SSLSocketDataProvider> ssl_provider0(
       new SSLSocketDataProvider(ASYNC, OK));
   // Expect HTTP/2 protocols too in SSLConfig.
@@ skipping 598 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*stream1_syn, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
 
-  std::unique_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
+  SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
-                                 initial_headers.get());
+                                 &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
   late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers(
-      spdy_util_.ConstructSpdyResponseHeaders(2, late_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
+                                              false));
 
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
 
   MockRead reads[] = {
@@ skipping 26 matching lines @@
 TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) {
   // We push a stream and attempt to claim it before the headers come down.
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
-  std::unique_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
+  SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
-                                 initial_headers.get());
+                                 &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
   late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers(
-      spdy_util_.ConstructSpdyResponseHeaders(2, late_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
+                                              false));
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),   CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 3),    MockRead(ASYNC, ERR_IO_PENDING, 4),
       CreateMockRead(*stream2_headers, 5), CreateMockRead(*stream2_body, 6),
       MockRead(ASYNC, ERR_IO_PENDING, 7),  MockRead(ASYNC, 0, 8),  // EOF
   };
@@ skipping 75 matching lines @@
   // We push a stream and attempt to claim it before the headers come down.
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
 
-  std::unique_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
+  SpdyHeaderBlock initial_headers;
   if (spdy_util_.spdy_version() < HTTP2) {
     // In HTTP/2 PUSH_PROMISE headers won't show up in the response headers.
-    (*initial_headers)["alpha"] = "beta";
+    initial_headers["alpha"] = "beta";
   }
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
-                                 initial_headers.get());
+                                 &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
 
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   SpdyHeaderBlock middle_headers;
   middle_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers1(
-      spdy_util_.ConstructSpdyResponseHeaders(2, middle_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(2, std::move(middle_headers),
+                                              false));
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "200";
   if (spdy_util_.spdy_version() < HTTP2) {
     // HTTP/2 eliminates use of the :version header.
     late_headers[spdy_util_.GetVersionKey()] = "HTTP/1.1";
   }
   std::unique_ptr<SpdySerializedFrame> stream2_headers2(
-      spdy_util_.ConstructSpdyResponseHeaders(2, late_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(2, std::move(late_headers),
+                                              false));
 
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
 
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1), CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 3), MockRead(ASYNC, ERR_IO_PENDING, 4),
       CreateMockRead(*stream2_headers1, 5),
@@ skipping 85 matching lines @@
   // We push a stream and attempt to claim it before the headers come down.
   std::unique_ptr<SpdySerializedFrame> stream1_syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
 
-  std::unique_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
+  SpdyHeaderBlock initial_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/foo.dat"),
-                                 initial_headers.get());
+                                 &initial_headers);
   std::unique_ptr<SpdySerializedFrame> stream2_syn(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(initial_headers), 2,
                                                1));
 
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
 
   SpdyHeaderBlock middle_headers;
   middle_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream2_headers1(
-      spdy_util_.ConstructSpdyResponseHeaders(2, middle_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(2, std::move(middle_headers),
+                                              false));
 
   const char kPushedData[] = "pushed";
   std::unique_ptr<SpdySerializedFrame> stream2_body(
       spdy_util_.ConstructSpdyBodyFrame(2, kPushedData, strlen(kPushedData),
                                         true));
 
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),    CreateMockRead(*stream2_syn, 2),
       CreateMockRead(*stream1_body, 3),     MockRead(ASYNC, ERR_IO_PENDING, 4),
       CreateMockRead(*stream2_headers1, 5), CreateMockRead(*stream2_body, 6),
@@ skipping 69 matching lines @@
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 
   SpdyHeaderBlock late_headers;
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream1_headers(
-      spdy_util_.ConstructSpdyResponseHeaders(1, late_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(1, std::move(late_headers),
+                                              false));
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1),
       CreateMockRead(*stream1_headers, 2),
       CreateMockRead(*stream1_body, 3),
       MockRead(ASYNC, 0, 5)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
@@ skipping 17 matching lines @@
   };
 
   std::unique_ptr<SpdySerializedFrame> stream1_reply(
       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
   std::unique_ptr<SpdySerializedFrame> stream1_body(
       spdy_util_.ConstructSpdyBodyFrame(1, false));
 
   SpdyHeaderBlock late_headers;
   late_headers["hello"] = "bye";
   std::unique_ptr<SpdySerializedFrame> stream1_headers(
-      spdy_util_.ConstructSpdyResponseHeaders(1, late_headers, false));
+      spdy_util_.ConstructSpdyResponseHeaders(1, std::move(late_headers),
+                                              false));
   std::unique_ptr<SpdySerializedFrame> stream1_body2(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*stream1_reply, 1), CreateMockRead(*stream1_body, 2),
       CreateMockRead(*stream1_headers, 3), CreateMockRead(*stream1_body2, 4),
       MockRead(ASYNC, 0, 6)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
@@ skipping 1380 matching lines @@
   }
 
   // Read in WINDOW_UPDATE or SETTINGS frame.
   data.Resume();
   base::RunLoop().RunUntilIdle();
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 TEST_P(SpdyNetworkTransactionTest, GoAwayOnOddPushStreamId) {
-  std::unique_ptr<SpdyHeaderBlock> push_headers(new SpdyHeaderBlock);
-  spdy_util_.AddUrlToHeaderBlock("http://www.example.org/a.dat",
-                                 push_headers.get());
+  SpdyHeaderBlock push_headers;
+  spdy_util_.AddUrlToHeaderBlock("http://www.example.org/a.dat", &push_headers);
   std::unique_ptr<SpdySerializedFrame> push(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_headers), 3, 1));
   MockRead reads[] = {CreateMockRead(*push, 1)};
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
       0, GOAWAY_PROTOCOL_ERROR, "Odd push stream id."));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2),
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(
       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
 }
 
 TEST_P(SpdyNetworkTransactionTest,
        GoAwayOnPushStreamIdLesserOrEqualThanLastAccepted) {
   std::unique_ptr<SpdySerializedFrame> push_a(spdy_util_.ConstructSpdyPush(
       NULL, 0, 4, 1, GetDefaultUrlWithPath("/a.dat").c_str()));
-  std::unique_ptr<SpdyHeaderBlock> push_b_headers(new SpdyHeaderBlock);
+  SpdyHeaderBlock push_b_headers;
   spdy_util_.AddUrlToHeaderBlock(GetDefaultUrlWithPath("/b.dat"),
-                                 push_b_headers.get());
+                                 &push_b_headers);
   std::unique_ptr<SpdySerializedFrame> push_b(
       spdy_util_.ConstructInitialSpdyPushFrame(std::move(push_b_headers), 2,
                                                1));
   MockRead reads[] = {
       CreateMockRead(*push_a, 1), CreateMockRead(*push_b, 2),
   };
 
   std::unique_ptr<SpdySerializedFrame> req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   std::unique_ptr<SpdySerializedFrame> goaway(spdy_util_.ConstructSpdyGoAway(
@@ skipping 15 matching lines @@
 // and thus sent in multiple frames when using HTTP/2.
 TEST_P(SpdyNetworkTransactionTest, LargeRequest) {
   const std::string kKey("foo");
   const std::string kValue(1 << 15, 'z');
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(GetDefaultUrl());
   request.extra_headers.SetHeader(kKey, kValue);
 
-  std::unique_ptr<SpdyHeaderBlock> headers(
-      spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
-  (*headers)[kKey] = kValue;
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  headers[kKey] = kValue;
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   std::unique_ptr<SpdySerializedFrame> resp(
       spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
   std::unique_ptr<SpdySerializedFrame> body(
       spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockRead reads[] = {
       CreateMockRead(*resp, 1),
       CreateMockRead(*body, 2),
       MockRead(ASYNC, 0, 3)  // EOF
   };
 
   SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
                                      GetParam(), nullptr);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
 
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
 // Regression test for https://crbug.com/535629: response header exceeds 16 kB.
 TEST_P(SpdyNetworkTransactionTest, LargeResponseHeader) {
-  std::unique_ptr<SpdyHeaderBlock> headers(
-      spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
+  SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(GetDefaultUrl()));
   std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, true));
+      spdy_util_.ConstructSpdySyn(1, std::move(headers), LOWEST, true));
   MockWrite writes[] = {
       CreateMockWrite(*req, 0),
   };
 
   // HPACK decoder implementation limits string literal length to 16 kB.
   const char* response_headers[2];
   const std::string kKey(16 * 1024, 'a');
   response_headers[0] = kKey.data();
   const std::string kValue(16 * 1024, 'b');
   response_headers[1] = kValue.data();
@@ skipping 132 matching lines @@
 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
   std::unique_ptr<SSLSocketDataProvider> ssl_provider(
       new SSLSocketDataProvider(ASYNC, OK));
   // Set to TLS_RSA_WITH_NULL_MD5
   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
 
   RunTLSUsageCheckTest(std::move(ssl_provider));
 }
 
 }  // namespace net