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

net/spdy/spdy_http_stream_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 "net/spdy/spdy_http_stream.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 170 matching lines @@
   SpdyHttpStream stream(session_, false);
   UploadProgress progress = stream.GetUploadProgress();
   EXPECT_EQ(0u, progress.size());
   EXPECT_EQ(0u, progress.position());
 
   // Pump the event loop so |reads| is consumed before the function returns.
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_P(SpdyHttpStreamTest, SendRequest) {
-  std::unique_ptr<SpdySerializedFrame> req(
+  SpdySerializedFrame req(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
   MockWrite writes[] = {
-      CreateMockWrite(*req.get(), 0),
+      CreateMockWrite(req, 0),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
   MockRead reads[] = {
-      CreateMockRead(*resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
+      CreateMockRead(resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.example.org/");
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
@@ skipping 23 matching lines @@
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   TestLoadTimingNotReused(*http_stream);
   http_stream->Close(true);
   // Test that there's no crash when trying to get the load timing after the
   // stream has been closed.
   TestLoadTimingNotReused(*http_stream);
 
-  EXPECT_EQ(static_cast<int64_t>(req->size()),
-            http_stream->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size()), http_stream->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(resp.size()),
             http_stream->GetTotalReceivedBytes());
 }
 
 TEST_P(SpdyHttpStreamTest, LoadTimingTwoRequests) {
-  std::unique_ptr<SpdySerializedFrame> req1(
+  SpdySerializedFrame req1(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST, true));
-  std::unique_ptr<SpdySerializedFrame> req2(
+  SpdySerializedFrame req2(
       spdy_util_.ConstructSpdyGet(nullptr, 0, 3, LOWEST, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req1, 0),
-    CreateMockWrite(*req2, 1),
+      CreateMockWrite(req1, 0), CreateMockWrite(req2, 1),
   };
-  std::unique_ptr<SpdySerializedFrame> resp1(
-      spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
-  std::unique_ptr<SpdySerializedFrame> body1(
-      spdy_util_.ConstructSpdyBodyFrame(1, "", 0, true));
-  std::unique_ptr<SpdySerializedFrame> resp2(
-      spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
-  std::unique_ptr<SpdySerializedFrame> body2(
-      spdy_util_.ConstructSpdyBodyFrame(3, "", 0, true));
+  SpdySerializedFrame resp1(spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
+  SpdySerializedFrame body1(spdy_util_.ConstructSpdyDataFrame(1, "", 0, true));
+  SpdySerializedFrame resp2(spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
+  SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(3, "", 0, true));
   MockRead reads[] = {
-    CreateMockRead(*resp1, 2),
-    CreateMockRead(*body1, 3),
-    CreateMockRead(*resp2, 4),
-    CreateMockRead(*body2, 5),
-    MockRead(ASYNC, 0, 6)  // EOF
+      CreateMockRead(resp1, 2), CreateMockRead(body1, 3),
+      CreateMockRead(resp2, 4), CreateMockRead(body2, 5),
+      MockRead(ASYNC, 0, 6)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("http://www.example.org/");
   TestCompletionCallback callback1;
   HttpResponseInfo response1;
   HttpRequestHeaders headers1;
@@ skipping 42 matching lines @@
 
   // Read stream 1 to completion, before making sure we can still read load
   // timing from both streams.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(1));
   ASSERT_EQ(
       0, http_stream1->ReadResponseBody(buf1.get(), 1, callback1.callback()));
 
   // Stream 1 has been read to completion.
   TestLoadTimingNotReused(*http_stream1);
 
-  EXPECT_EQ(static_cast<int64_t>(req1->size()),
+  EXPECT_EQ(static_cast<int64_t>(req1.size()),
             http_stream1->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp1->size() + body1->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp1.size() + body1.size()),
             http_stream1->GetTotalReceivedBytes());
 
   // Stream 2 still has queued body data.
   TestLoadTimingReused(*http_stream2);
 
-  EXPECT_EQ(static_cast<int64_t>(req2->size()),
+  EXPECT_EQ(static_cast<int64_t>(req2.size()),
             http_stream2->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp2->size() + body2->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp2.size() + body2.size()),
             http_stream2->GetTotalReceivedBytes());
 }
 
 TEST_P(SpdyHttpStreamTest, SendChunkedPost) {
-  BufferedSpdyFramer framer;
-
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> body(
-      framer.CreateDataFrame(1, kUploadData, kUploadDataSize, DATA_FLAG_FIN));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, kUploadData,
+                                                             kUploadDataSize,
+                                                             /*fin=*/true));
   MockWrite writes[] = {
-      CreateMockWrite(*req, 0),  // request
-      CreateMockWrite(*body, 1)  // POST upload frame
+      CreateMockWrite(req, 0),  // request
+      CreateMockWrite(body, 1)  // POST upload frame
   };
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
-      CreateMockRead(*resp, 2),
-      CreateMockRead(*body, 3),
+      CreateMockRead(resp, 2), CreateMockRead(body, 3),
       MockRead(SYNCHRONOUS, 0, 4)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
   const int kFirstChunkSize = kUploadDataSize/2;
   upload_stream.AppendData(kUploadData, kFirstChunkSize, false);
   upload_stream.AppendData(kUploadData + kFirstChunkSize,
                             kUploadDataSize - kFirstChunkSize, true);
@@ skipping 14 matching lines @@
       OK,
       http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                    net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream.SendRequest(
       headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + body->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + body.size()),
             http_stream.GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size() + body->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + body.size()),
             http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, we there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // This unittest tests the request callback is properly called and handled.
 TEST_P(SpdyHttpStreamTest, SendChunkedPostLastEmpty) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> chunk(
-      spdy_util_.ConstructSpdyBodyFrame(1, nullptr, 0, true));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame chunk(
+      spdy_util_.ConstructSpdyDataFrame(1, nullptr, 0, true));
   MockWrite writes[] = {
-      CreateMockWrite(*req, 0),  // request
-      CreateMockWrite(*chunk, 1),
+      CreateMockWrite(req, 0),  // request
+      CreateMockWrite(chunk, 1),
   };
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
-      CreateMockRead(*resp, 2),
-      CreateMockRead(*chunk, 3),
+      CreateMockRead(resp, 2), CreateMockRead(chunk, 3),
       MockRead(SYNCHRONOUS, 0, 4)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
   upload_stream.AppendData(nullptr, 0, true);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
 
   ASSERT_THAT(upload_stream.Init(TestCompletionCallback().callback()), IsOk());
 
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
   EXPECT_EQ(ERR_IO_PENDING,
             http_stream.SendRequest(headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk.size()),
             http_stream.GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + chunk.size()),
             http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 TEST_P(SpdyHttpStreamTest, ConnectionClosedDuringChunkedPost) {
-  BufferedSpdyFramer framer;
-
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> body(
-      framer.CreateDataFrame(1, kUploadData, kUploadDataSize, DATA_FLAG_NONE));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, kUploadData,
+                                                             kUploadDataSize,
+                                                             /*fin=*/false));
   MockWrite writes[] = {
-      CreateMockWrite(*req, 0),  // Request
-      CreateMockWrite(*body, 1)  // First POST upload frame
+      CreateMockWrite(req, 0),  // Request
+      CreateMockWrite(body, 1)  // First POST upload frame
   };
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
       MockRead(ASYNC, ERR_CONNECTION_CLOSED, 2)  // Server hangs up early.
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
   // Append first chunk.
   upload_stream.AppendData(kUploadData, kUploadDataSize, false);
 
@@ skipping 11 matching lines @@
   SpdyHttpStream http_stream(session_, true);
   ASSERT_EQ(OK, http_stream.InitializeStream(&request, DEFAULT_PRIORITY,
                                              net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING,
             http_stream.SendRequest(headers, &response, callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   EXPECT_THAT(callback.WaitForResult(), IsError(ERR_CONNECTION_CLOSED));
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + body->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + body.size()),
             http_stream.GetTotalSentBytes());
   EXPECT_EQ(0, http_stream.GetTotalReceivedBytes());
 
   // Because the server closed the connection, we there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Appending a second chunk now should not result in a crash.
   upload_stream.AppendData(kUploadData, kUploadDataSize, true);
   // Appending data is currently done synchronously, but seems best to be
   // paranoid.
   base::RunLoop().RunUntilIdle();
 
   // The total sent and received bytes should be unchanged.
-  EXPECT_EQ(static_cast<int64_t>(req->size() + body->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + body.size()),
             http_stream.GetTotalSentBytes());
   EXPECT_EQ(0, http_stream.GetTotalReceivedBytes());
 }
 
 // Test to ensure the SpdyStream state machine does not get confused when a
 // chunk becomes available while a write is pending.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPost) {
   const char kUploadData1[] = "12345678";
   const int kUploadData1Size = arraysize(kUploadData1)-1;
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> chunk1(
-      spdy_util_.ConstructSpdyBodyFrame(1, false));
-  std::unique_ptr<SpdySerializedFrame> chunk2(spdy_util_.ConstructSpdyBodyFrame(
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame chunk1(spdy_util_.ConstructSpdyDataFrame(1, false));
+  SpdySerializedFrame chunk2(spdy_util_.ConstructSpdyDataFrame(
       1, kUploadData1, kUploadData1Size, false));
-  std::unique_ptr<SpdySerializedFrame> chunk3(
-      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  SpdySerializedFrame chunk3(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req.get(), 0),
-    CreateMockWrite(*chunk1, 1),  // POST upload frames
-    CreateMockWrite(*chunk2, 2),
-    CreateMockWrite(*chunk3, 3),
+      CreateMockWrite(req, 0),
+      CreateMockWrite(chunk1, 1),  // POST upload frames
+      CreateMockWrite(chunk2, 2), CreateMockWrite(chunk3, 3),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp, 4),
-    CreateMockRead(*chunk1, 5),
-    CreateMockRead(*chunk2, 6),
-    CreateMockRead(*chunk3, 7),
-    MockRead(ASYNC, 0, 8)  // EOF
+      CreateMockRead(resp, 4), CreateMockRead(chunk1, 5),
+      CreateMockRead(chunk2, 6), CreateMockRead(chunk3, 7),
+      MockRead(ASYNC, 0, 8)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
@@ skipping 22 matching lines @@
 
   // Now append the final two chunks which will enqueue two more writes.
   upload_stream.AppendData(kUploadData1, kUploadData1Size, false);
   upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   // Finish writing all the chunks and do all reads.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size() + chunk2->size() +
-                                 chunk3->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk1.size() + chunk2.size() +
+                                 chunk3.size()),
             http_stream->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk1->size() +
-                                 chunk2->size() + chunk3->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + chunk1.size() + chunk2.size() +
+                                 chunk3.size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
   ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
@@ skipping 13 matching lines @@
                 buf3.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf3->data(), kUploadDataSize));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
 
 // Test that the SpdyStream state machine can handle sending a final empty data
 // frame when uploading a chunked data stream.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithEmptyFinalDataFrame) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> chunk1(
-      spdy_util_.ConstructSpdyBodyFrame(1, false));
-  std::unique_ptr<SpdySerializedFrame> chunk2(
-      spdy_util_.ConstructSpdyBodyFrame(1, "", 0, true));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame chunk1(spdy_util_.ConstructSpdyDataFrame(1, false));
+  SpdySerializedFrame chunk2(spdy_util_.ConstructSpdyDataFrame(1, "", 0, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req.get(), 0),
-    CreateMockWrite(*chunk1, 1),  // POST upload frames
-    CreateMockWrite(*chunk2, 2),
+      CreateMockWrite(req, 0),
+      CreateMockWrite(chunk1, 1),  // POST upload frames
+      CreateMockWrite(chunk2, 2),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp, 3),
-    CreateMockRead(*chunk1, 4),
-    CreateMockRead(*chunk2, 5),
-    MockRead(ASYNC, 0, 6)  // EOF
+      CreateMockRead(resp, 3), CreateMockRead(chunk1, 4),
+      CreateMockRead(chunk2, 5), MockRead(ASYNC, 0, 6)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
@@ skipping 13 matching lines @@
   // This will attempt to Write() the initial request and headers, which will
   // complete asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete the initial request write and the first chunk.
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk1.size()),
             http_stream->GetTotalSentBytes());
   EXPECT_EQ(0, http_stream->GetTotalReceivedBytes());
 
   // Now end the stream with an empty data frame and the FIN set.
   upload_stream.AppendData(nullptr, 0, true);
 
   // Finish writing the final frame, and perform all reads.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Check response headers.
   ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size() + chunk2->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk1.size() + chunk2.size()),
             http_stream->GetTotalSentBytes());
-  EXPECT_EQ(
-      static_cast<int64_t>(resp->size() + chunk1->size() + chunk2->size()),
-      http_stream->GetTotalReceivedBytes());
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + chunk1.size() + chunk2.size()),
+            http_stream->GetTotalReceivedBytes());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   // Check |chunk2| response.
   ASSERT_EQ(0,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
 
 // Test that the SpdyStream state machine handles a chunked upload with no
 // payload. Unclear if this is a case worth supporting.
 TEST_P(SpdyHttpStreamTest, ChunkedPostWithEmptyPayload) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> chunk(
-      spdy_util_.ConstructSpdyBodyFrame(1, "", 0, true));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame chunk(spdy_util_.ConstructSpdyDataFrame(1, "", 0, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req.get(), 0),
-    CreateMockWrite(*chunk, 1),
+      CreateMockWrite(req, 0), CreateMockWrite(chunk, 1),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
   MockRead reads[] = {
-    CreateMockRead(*resp, 2),
-    CreateMockRead(*chunk, 3),
-    MockRead(ASYNC, 0, 4)  // EOF
+      CreateMockRead(resp, 2), CreateMockRead(chunk, 3),
+      MockRead(ASYNC, 0, 4)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
   request.upload_data_stream = &upload_stream;
@@ skipping 14 matching lines @@
   // complete asynchronously.
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete writing request, followed by a FIN.
   base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk.size()),
             http_stream->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + chunk.size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
   ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk| response.
   scoped_refptr<IOBuffer> buf(new IOBuffer(1));
   ASSERT_EQ(0,
             http_stream->ReadResponseBody(
                 buf.get(), 1, callback.callback()));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
 
 // Test case for bug: http://code.google.com/p/chromium/issues/detail?id=50058
 TEST_P(SpdyHttpStreamTest, SpdyURLTest) {
   const char* const full_url = "http://www.example.org/foo?query=what#anchor";
   const char* const base_url = "http://www.example.org/foo?query=what";
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructSpdyGet(base_url, 1, LOWEST));
+  SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(base_url, 1, LOWEST));
   MockWrite writes[] = {
-      CreateMockWrite(*req.get(), 0),
+      CreateMockWrite(req, 0),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
   MockRead reads[] = {
-      CreateMockRead(*resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
+      CreateMockRead(resp, 1), MockRead(SYNCHRONOUS, 0, 2)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL(full_url);
   TestCompletionCallback callback;
   HttpResponseInfo response;
   HttpRequestHeaders headers;
   BoundNetLog net_log;
   std::unique_ptr<SpdyHttpStream> http_stream(
       new SpdyHttpStream(session_, true));
   ASSERT_EQ(OK,
             http_stream->InitializeStream(
                 &request, DEFAULT_PRIORITY, net_log, CompletionCallback()));
 
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
 
   EXPECT_EQ(base_url, http_stream->stream()->GetUrlFromHeaders().spec());
 
   callback.WaitForResult();
 
-  EXPECT_EQ(static_cast<int64_t>(req->size()),
-            http_stream->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size()), http_stream->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(resp.size()),
             http_stream->GetTotalReceivedBytes());
 
   // Because we abandoned the stream, we don't expect to find a session in the
   // pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // Test the receipt of a WINDOW_UPDATE frame while waiting for a chunk to be
 // made available is handled correctly.
 TEST_P(SpdyHttpStreamTest, DelayedSendChunkedPostWithWindowUpdate) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> chunk1(
-      spdy_util_.ConstructSpdyBodyFrame(1, true));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame chunk1(spdy_util_.ConstructSpdyDataFrame(1, true));
   MockWrite writes[] = {
-    CreateMockWrite(*req.get(), 0),
-    CreateMockWrite(*chunk1, 1),
+      CreateMockWrite(req, 0), CreateMockWrite(chunk1, 1),
   };
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
-  std::unique_ptr<SpdySerializedFrame> window_update(
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame window_update(
       spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize));
   MockRead reads[] = {
-      CreateMockRead(*window_update, 2),
-      MockRead(ASYNC, ERR_IO_PENDING, 3),
-      CreateMockRead(*resp, 4),
-      CreateMockRead(*chunk1, 5),
+      CreateMockRead(window_update, 2), MockRead(ASYNC, ERR_IO_PENDING, 3),
+      CreateMockRead(resp, 4), CreateMockRead(chunk1, 5),
       MockRead(ASYNC, 0, 6)  // EOF
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ChunkedUploadDataStream upload_stream(0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.example.org/");
@@ skipping 13 matching lines @@
   // complete asynchronously.
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING, http_stream->SendRequest(headers, &response,
                                                      callback.callback()));
   EXPECT_TRUE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 
   // Complete the initial request write and first chunk.
   base::RunLoop().RunUntilIdle();
   ASSERT_FALSE(callback.have_result());
 
-  EXPECT_EQ(static_cast<int64_t>(req->size()),
-            http_stream->GetTotalSentBytes());
+  EXPECT_EQ(static_cast<int64_t>(req.size()), http_stream->GetTotalSentBytes());
   EXPECT_EQ(0, http_stream->GetTotalReceivedBytes());
 
   upload_stream.AppendData(kUploadData, kUploadDataSize, true);
 
   ASSERT_TRUE(callback.have_result());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   // Verify that the window size has decreased.
   ASSERT_TRUE(http_stream->stream() != nullptr);
   EXPECT_NE(static_cast<int>(kDefaultInitialWindowSize),
             http_stream->stream()->send_window_size());
 
   // Read window update.
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk1.size()),
             http_stream->GetTotalSentBytes());
   // The window update is not counted in the total received bytes.
   EXPECT_EQ(0, http_stream->GetTotalReceivedBytes());
 
   // Verify the window update.
   ASSERT_TRUE(http_stream->stream() != nullptr);
   EXPECT_EQ(static_cast<int>(kDefaultInitialWindowSize),
             http_stream->stream()->send_window_size());
 
   // Read rest of data.
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(static_cast<int64_t>(req->size() + chunk1->size()),
+  EXPECT_EQ(static_cast<int64_t>(req.size() + chunk1.size()),
             http_stream->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(resp->size() + chunk1->size()),
+  EXPECT_EQ(static_cast<int64_t>(resp.size() + chunk1.size()),
             http_stream->GetTotalReceivedBytes());
 
   // Check response headers.
   ASSERT_THAT(http_stream->ReadResponseHeaders(callback.callback()), IsOk());
 
   // Check |chunk1| response.
   scoped_refptr<IOBuffer> buf1(new IOBuffer(kUploadDataSize));
   ASSERT_EQ(kUploadDataSize,
             http_stream->ReadResponseBody(
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
 
 TEST_P(SpdyHttpStreamTest, DataReadErrorSynchronous) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
 
   // Server receives RST_STREAM_INTERNAL_ERROR on client's internal failure.
   // The failure is a reading error in this case caused by
   // UploadDataStream::Read().
-  std::unique_ptr<SpdySerializedFrame> rst_frame(
+  SpdySerializedFrame rst_frame(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_INTERNAL_ERROR));
 
   MockWrite writes[] = {
-      CreateMockWrite(*req, 0, SYNCHRONOUS),       // Request
-      CreateMockWrite(*rst_frame, 1, SYNCHRONOUS)  // Reset frame
+      CreateMockWrite(req, 0, SYNCHRONOUS),       // Request
+      CreateMockWrite(rst_frame, 1, SYNCHRONOUS)  // Reset frame
   };
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
 
   MockRead reads[] = {
-      CreateMockRead(*resp, 2), MockRead(SYNCHRONOUS, 0, 3),
+      CreateMockRead(resp, 2), MockRead(SYNCHRONOUS, 0, 3),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::SYNC);
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
               IsOk());
 
   HttpRequestInfo request;
@@ skipping 11 matching lines @@
 
   int result = http_stream.SendRequest(headers, &response, callback.callback());
   EXPECT_THAT(callback.GetResult(result), IsError(ERR_FAILED));
 
   // Because the server has not closed the connection yet, there shouldn't be
   // a stream but a session in the pool
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 TEST_P(SpdyHttpStreamTest, DataReadErrorAsynchronous) {
-  std::unique_ptr<SpdySerializedFrame> req(
-      spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
+  SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
 
   // Server receives RST_STREAM_INTERNAL_ERROR on client's internal failure.
   // The failure is a reading error in this case caused by
   // UploadDataStream::Read().
-  std::unique_ptr<SpdySerializedFrame> rst_frame(
+  SpdySerializedFrame rst_frame(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_INTERNAL_ERROR));
 
   MockWrite writes[] = {
-      CreateMockWrite(*req, 0),       // Request
-      CreateMockWrite(*rst_frame, 1)  // Reset frame
+      CreateMockWrite(req, 0),       // Request
+      CreateMockWrite(rst_frame, 1)  // Reset frame
   };
 
-  std::unique_ptr<SpdySerializedFrame> resp(
-      spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
+  SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostSynReply(nullptr, 0));
 
   MockRead reads[] = {
       MockRead(ASYNC, 0, 2),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   ReadErrorUploadDataStream upload_data_stream(
       ReadErrorUploadDataStream::FailureMode::ASYNC);
   ASSERT_THAT(upload_data_stream.Init(TestCompletionCallback().callback()),
@@ skipping 18 matching lines @@
 
   // Because the server has closed the connection, there shouldn't be a session
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace net