Move ~1000 SpdySerializedFrame instances from heap to stack in tests.

net/spdy/spdy_stream_unittest.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/spdy/spdy_stream.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <limits>
@@ skipping 136 matching lines @@
 };
 
 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend,
                         SpdyStreamTest,
                         testing::Values(kTestCaseNoPriorityDependencies,
                                         kTestCasePriorityDependencies));
 
 TEST_P(SpdyStreamTest, SendDataAfterOpen) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
+  AddRead(resp);
 
-  std::unique_ptr<SpdySerializedFrame> msg(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddWrite(*msg);
+  SpdySerializedFrame msg(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddWrite(msg);
 
-  std::unique_ptr<SpdySerializedFrame> echo(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddRead(*echo);
+  SpdySerializedFrame echo(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddRead(echo);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 41 matching lines @@
   const SpdyHeaderBlock& trailers() const { return trailers_; }
 
  private:
   SpdyHeaderBlock trailers_;
 };
 
 // Regression test for crbug.com/481033.
 TEST_P(SpdyStreamTest, Trailers) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
-  std::unique_ptr<SpdySerializedFrame> msg(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, true));
-  AddWrite(*msg);
+  SpdySerializedFrame msg(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, true));
+  AddWrite(msg);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
+  AddRead(resp);
 
-  std::unique_ptr<SpdySerializedFrame> echo(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddRead(*echo);
+  SpdySerializedFrame echo(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddRead(echo);
 
   SpdyHeaderBlock late_headers;
   late_headers["foo"] = "bar";
-  std::unique_ptr<SpdySerializedFrame> trailers(
-      spdy_util_.ConstructSpdyResponseHeaders(1, std::move(late_headers),
-                                              false));
-  AddRead(*trailers);
+  SpdySerializedFrame trailers(spdy_util_.ConstructSpdyResponseHeaders(
+      1, std::move(late_headers), false));
+  AddRead(trailers);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 89 matching lines @@
 
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ("beta", delegate.GetResponseHeaderValue("alpha"));
 
   EXPECT_FALSE(spdy_session);
 }
 
 TEST_P(SpdyStreamTest, StreamError) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(resp);
 
-  std::unique_ptr<SpdySerializedFrame> msg(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddWrite(*msg);
+  SpdySerializedFrame msg(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddWrite(msg);
 
-  std::unique_ptr<SpdySerializedFrame> echo(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddRead(*echo);
+  SpdySerializedFrame echo(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddRead(echo);
 
   AddReadEOF();
 
   BoundTestNetLog log;
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
@@ skipping 41 matching lines @@
   ASSERT_TRUE(entries[pos].GetIntegerValue("stream_id", &stream_id2));
   EXPECT_EQ(static_cast<int>(stream_id), stream_id2);
 }
 
 // Make sure that large blocks of data are properly split up into
 // frame-sized chunks for a request/response (i.e., an HTTP-like)
 // stream.
 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenRequestResponse) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
-  std::unique_ptr<SpdySerializedFrame> chunk(spdy_util_.ConstructSpdyBodyFrame(
+  SpdySerializedFrame chunk(spdy_util_.ConstructSpdyDataFrame(
       1, chunk_data.data(), chunk_data.length(), false));
-  AddWrite(*chunk);
-  AddWrite(*chunk);
+  AddWrite(chunk);
+  AddWrite(chunk);
 
-  std::unique_ptr<SpdySerializedFrame> last_chunk(
-      spdy_util_.ConstructSpdyBodyFrame(1, chunk_data.data(),
-                                        chunk_data.length(), true));
-  AddWrite(*last_chunk);
+  SpdySerializedFrame last_chunk(spdy_util_.ConstructSpdyDataFrame(
+      1, chunk_data.data(), chunk_data.length(), true));
+  AddWrite(last_chunk);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
+  AddRead(resp);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 24 matching lines @@
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Make sure that large blocks of data are properly split up into
 // frame-sized chunks for a bidirectional (i.e., non-HTTP-like)
 // stream.
 TEST_P(SpdyStreamTest, SendLargeDataAfterOpenBidirectional) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
+  AddRead(resp);
 
   std::string chunk_data(kMaxSpdyFrameChunkSize, 'x');
-  std::unique_ptr<SpdySerializedFrame> chunk(spdy_util_.ConstructSpdyBodyFrame(
+  SpdySerializedFrame chunk(spdy_util_.ConstructSpdyDataFrame(
       1, chunk_data.data(), chunk_data.length(), false));
-  AddWrite(*chunk);
-  AddWrite(*chunk);
-  AddWrite(*chunk);
+  AddWrite(chunk);
+  AddWrite(chunk);
+  AddWrite(chunk);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 23 matching lines @@
   EXPECT_EQ("200", delegate.GetResponseHeaderValue(spdy_util_.GetStatusKey()));
   EXPECT_EQ(std::string(), delegate.TakeReceivedData());
   EXPECT_TRUE(data.AllWriteDataConsumed());
 }
 
 // Receiving a header with uppercase ASCII should result in a protocol
 // error.
 TEST_P(SpdyStreamTest, UpperCaseHeaders) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> syn(
+  SpdySerializedFrame syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  AddWrite(*syn);
+  AddWrite(syn);
 
   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
-  std::unique_ptr<SpdySerializedFrame> reply(
+  SpdySerializedFrame reply(
       spdy_util_.ConstructSpdyGetSynReply(kExtraHeaders, 1, 1));
-  AddRead(*reply);
+  AddRead(reply);
 
-  std::unique_ptr<SpdySerializedFrame> rst(
+  SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
-  AddWrite(*rst);
+  AddWrite(rst);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 17 matching lines @@
   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
 // Receiving a header with uppercase ASCII should result in a protocol
 // error even for a push stream.
 TEST_P(SpdyStreamTest, UpperCaseHeadersOnPush) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> syn(
+  SpdySerializedFrame syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  AddWrite(*syn);
+  AddWrite(syn);
 
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*reply);
+  SpdySerializedFrame reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(reply);
 
   const char* const extra_headers[] = {"X-UpperCase", "yes"};
-  std::unique_ptr<SpdySerializedFrame> push(
+  SpdySerializedFrame push(
       spdy_util_.ConstructSpdyPush(extra_headers, 1, 2, 1, kStreamUrl));
-  AddRead(*push);
+  AddRead(push);
 
-  std::unique_ptr<SpdySerializedFrame> rst(
+  SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
-  AddWrite(*rst);
+  AddWrite(rst);
 
   AddReadPause();
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
@@ skipping 27 matching lines @@
   data.Resume();
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 // Receiving a header with uppercase ASCII in a HEADERS frame should
 // result in a protocol error.
 TEST_P(SpdyStreamTest, UpperCaseHeadersInHeadersFrame) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> syn(
+  SpdySerializedFrame syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  AddWrite(*syn);
+  AddWrite(syn);
 
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*reply);
+  SpdySerializedFrame reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(reply);
 
-  std::unique_ptr<SpdySerializedFrame> push(
+  SpdySerializedFrame push(
       spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
-  AddRead(*push);
+  AddRead(push);
 
   AddReadPause();
 
   SpdyHeaderBlock late_headers;
   late_headers["X-UpperCase"] = "yes";
-  std::unique_ptr<SpdySerializedFrame> headers_frame(
+  SpdySerializedFrame headers_frame(
       spdy_util_.ConstructSpdyReply(2, std::move(late_headers)));
-  AddRead(*headers_frame);
+  AddRead(headers_frame);
 
   AddWritePause();
 
-  std::unique_ptr<SpdySerializedFrame> rst(
+  SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
-  AddWrite(*rst);
+  AddWrite(rst);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 31 matching lines @@
   data.Resume();
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 // Receiving a duplicate header in a HEADERS frame should result in a
 // protocol error.
 TEST_P(SpdyStreamTest, DuplicateHeaders) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> syn(
+  SpdySerializedFrame syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  AddWrite(*syn);
+  AddWrite(syn);
 
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*reply);
+  SpdySerializedFrame reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(reply);
 
-  std::unique_ptr<SpdySerializedFrame> push(
+  SpdySerializedFrame push(
       spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kStreamUrl));
-  AddRead(*push);
+  AddRead(push);
 
   AddReadPause();
 
   SpdyHeaderBlock late_headers;
   late_headers[spdy_util_.GetStatusKey()] = "500 Server Error";
-  std::unique_ptr<SpdySerializedFrame> headers_frame(
+  SpdySerializedFrame headers_frame(
       spdy_util_.ConstructSpdyReply(2, std::move(late_headers)));
-  AddRead(*headers_frame);
+  AddRead(headers_frame);
 
   AddReadPause();
 
-  std::unique_ptr<SpdySerializedFrame> rst(
+  SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
-  AddWrite(*rst);
+  AddWrite(rst);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 30 matching lines @@
 
   data.Resume();
 
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 // Call IncreaseSendWindowSize on a stream with a large enough delta
 // to overflow an int32_t. The SpdyStream should handle that case
 // gracefully.
 TEST_P(SpdyStreamTest, IncreaseSendWindowSizeOverflow) {
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
   AddReadPause();
 
   // Triggered by the overflowing call to IncreaseSendWindowSize
   // below.
-  std::unique_ptr<SpdySerializedFrame> rst(
+  SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
-  AddWrite(*rst);
+  AddWrite(rst);
 
   AddReadEOF();
 
   BoundTestNetLog log;
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
@@ skipping 61 matching lines @@
   EXPECT_FALSE(stream->send_stalled_by_flow_control());
 }
 
 // Given an unstall function, runs a test to make sure that a
 // request/response (i.e., an HTTP-like) stream resumes after a stall
 // and unstall.
 void SpdyStreamTest::RunResumeAfterUnstallRequestResponseTest(
     const UnstallFunction& unstall_function) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
-  std::unique_ptr<SpdySerializedFrame> body(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, true));
-  AddWrite(*body);
+  SpdySerializedFrame body(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, true));
+  AddWrite(body);
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(resp);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 45 matching lines @@
       base::Bind(&AdjustStreamSendWindowSize));
 }
 
 // Given an unstall function, runs a test to make sure that a
 // bidirectional (i.e., non-HTTP-like) stream resumes after a stall
 // and unstall.
 void SpdyStreamTest::RunResumeAfterUnstallBidirectionalTest(
     const UnstallFunction& unstall_function) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> req(spdy_util_.ConstructSpdyPost(
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kStreamUrl, 1, kPostBodyLength, LOWEST, NULL, 0));
-  AddWrite(*req);
+  AddWrite(req);
 
   AddReadPause();
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*resp);
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(resp);
 
-  std::unique_ptr<SpdySerializedFrame> msg(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddWrite(*msg);
+  SpdySerializedFrame msg(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddWrite(msg);
 
-  std::unique_ptr<SpdySerializedFrame> echo(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddRead(*echo);
+  SpdySerializedFrame echo(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddRead(echo);
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
@@ skipping 47 matching lines @@
 
 TEST_P(SpdyStreamTest, ResumeAfterSendWindowSizeAdjustBidirectional) {
   RunResumeAfterUnstallBidirectionalTest(
       base::Bind(&AdjustStreamSendWindowSize));
 }
 
 // Test calculation of amount of bytes received from network.
 TEST_P(SpdyStreamTest, ReceivedBytes) {
   GURL url(kStreamUrl);
 
-  std::unique_ptr<SpdySerializedFrame> syn(
+  SpdySerializedFrame syn(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  AddWrite(*syn);
+  AddWrite(syn);
 
   AddReadPause();
 
-  std::unique_ptr<SpdySerializedFrame> reply(
-      spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
-  AddRead(*reply);
+  SpdySerializedFrame reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+  AddRead(reply);
 
   AddReadPause();
 
-  std::unique_ptr<SpdySerializedFrame> msg(
-      spdy_util_.ConstructSpdyBodyFrame(1, kPostBody, kPostBodyLength, false));
-  AddRead(*msg);
+  SpdySerializedFrame msg(
+      spdy_util_.ConstructSpdyDataFrame(1, kPostBody, kPostBodyLength, false));
+  AddRead(msg);
 
   AddReadPause();
 
   AddReadEOF();
 
   SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(),
                            GetNumWrites());
   MockConnect connect_data(SYNCHRONOUS, OK);
   data.set_connect_data(connect_data);
 
@@ skipping 11 matching lines @@
 
   EXPECT_FALSE(stream->HasUrlFromHeaders());
 
   std::unique_ptr<SpdyHeaderBlock> headers(
       new SpdyHeaderBlock(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)));
   EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers),
                                                        NO_MORE_DATA_TO_SEND));
   EXPECT_TRUE(stream->HasUrlFromHeaders());
   EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec());
 
-  int64_t reply_frame_len = reply->size();
+  int64_t reply_frame_len = reply.size();
   int64_t data_header_len = SpdyConstants::GetDataFrameMinimumSize(HTTP2);
   int64_t data_frame_len = data_header_len + kPostBodyLength;
   int64_t response_len = reply_frame_len + data_frame_len;
 
   EXPECT_EQ(0, stream->raw_received_bytes());
 
   // SYN
   data.RunUntilPaused();
   EXPECT_EQ(0, stream->raw_received_bytes());
 
   // REPLY
   data.Resume();
   data.RunUntilPaused();
   EXPECT_EQ(reply_frame_len, stream->raw_received_bytes());
 
   // DATA
   data.Resume();
   data.RunUntilPaused();
   EXPECT_EQ(response_len, stream->raw_received_bytes());
 
   // FIN
   data.Resume();
   EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED));
 }
 
 }  // namespace test
 
 }  // namespace net