Implement SpdySerializedFrame move semantics.

net/spdy/spdy_framer_test.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_framer.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 37 matching lines @@
                                               size_t frame_len));
 };
 
 class SpdyFramerTestUtil {
  public:
   // Decompress a single frame using the decompression context held by
   // the SpdyFramer.  The implemention is meant for use only in tests
   // and will CHECK fail if the input is anything other than a single,
   // well-formed compressed frame.
   //
-  // Returns a new decompressed SpdyFrame.
-  template<class SpdyFrameType> static SpdyFrame* DecompressFrame(
-      SpdyFramer* framer, const SpdyFrameType& frame) {
+  // Returns a new decompressed SpdySerializedFrame.
+  template <class SpdyFrameType>
+  static SpdySerializedFrame DecompressFrame(SpdyFramer* framer,
+                                             const SpdyFrameType& frame) {
     DecompressionVisitor visitor(framer->protocol_version());
     framer->set_visitor(&visitor);
     CHECK_EQ(frame.size(), framer->ProcessInput(frame.data(), frame.size()));
     CHECK_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer->state());
     framer->set_visitor(NULL);
 
     char* buffer = visitor.ReleaseBuffer();
     CHECK(buffer != NULL);
-    SpdyFrame* decompressed_frame = new SpdyFrame(buffer, visitor.size(), true);
-    SetFrameLength(decompressed_frame,
+    SpdySerializedFrame decompressed_frame(buffer, visitor.size(), true);
+    SetFrameLength(&decompressed_frame,
                    visitor.size() - framer->GetControlFrameHeaderSize(),
                    framer->protocol_version());
     return decompressed_frame;
   }
 
   class DecompressionVisitor : public SpdyFramerVisitorInterface {
    public:
     explicit DecompressionVisitor(SpdyMajorVersion version)
         : version_(version), size_(0), finished_(false) {}
 
@@ skipping 54 matching lines @@
                      SpdyPriority priority,
                      bool fin,
                      bool unidirectional) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdySynStreamIR syn_stream(stream_id);
       syn_stream.set_associated_to_stream_id(associated_stream_id);
       syn_stream.set_priority(priority);
       syn_stream.set_fin(fin);
       syn_stream.set_unidirectional(unidirectional);
-      scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+      SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
       ResetBuffer();
-      memcpy(buffer_.get(), frame->data(), framer.GetSynStreamMinimumSize());
+      memcpy(buffer_.get(), frame.data(), framer.GetSynStreamMinimumSize());
       size_ += framer.GetSynStreamMinimumSize();
     }
 
     void OnSynReply(SpdyStreamId stream_id, bool fin) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
       headers.set_fin(fin);
-      scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
+      SpdySerializedFrame frame(framer.SerializeHeaders(headers));
       ResetBuffer();
-      memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
+      memcpy(buffer_.get(), frame.data(), framer.GetHeadersMinimumSize());
       size_ += framer.GetSynStreamMinimumSize();
     }
 
     void OnRstStream(SpdyStreamId stream_id,
                      SpdyRstStreamStatus status) override {
       LOG(FATAL);
     }
     void OnSetting(SpdySettingsIds id, uint8_t flags, uint32_t value) override {
       LOG(FATAL);
     }
@@ skipping 12 matching lines @@
                    bool fin,
                    bool end) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyHeadersIR headers(stream_id);
       headers.set_has_priority(has_priority);
       headers.set_priority(priority);
       headers.set_parent_stream_id(parent_stream_id);
       headers.set_exclusive(exclusive);
       headers.set_fin(fin);
-      scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
+      SpdySerializedFrame frame(framer.SerializeHeaders(headers));
       ResetBuffer();
-      memcpy(buffer_.get(), frame->data(), framer.GetHeadersMinimumSize());
+      memcpy(buffer_.get(), frame.data(), framer.GetHeadersMinimumSize());
       size_ += framer.GetHeadersMinimumSize();
     }
 
     void OnWindowUpdate(SpdyStreamId stream_id,
                         int delta_window_size) override {
       LOG(FATAL);
     }
 
     void OnPushPromise(SpdyStreamId stream_id,
                        SpdyStreamId promised_stream_id,
                        bool end) override {
       SpdyFramer framer(version_);
       framer.set_enable_compression(false);
       SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
-      scoped_ptr<SpdyFrame> frame(framer.SerializePushPromise(push_promise));
+      SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
       ResetBuffer();
-      memcpy(buffer_.get(), frame->data(), framer.GetPushPromiseMinimumSize());
+      memcpy(buffer_.get(), frame.data(), framer.GetPushPromiseMinimumSize());
       size_ += framer.GetPushPromiseMinimumSize();
     }
 
     void OnContinuation(SpdyStreamId stream_id, bool end) override {
       LOG(FATAL);
     }
 
     void OnPriority(SpdyStreamId stream_id,
                     SpdyStreamId parent_stream_id,
                     uint8_t weight,
@@ skipping 397 matching lines @@
   static size_t ControlFrameBufferSize() {
     return SpdyFramer::kControlFrameBufferSize;
   }
   static size_t GetNumberRequiredContinuationFrames(SpdyFramer* framer,
                                                     size_t size) {
     return framer->GetNumberRequiredContinuationFrames(size);
   }
 };
 
 // Retrieves serialized headers from a HEADERS or SYN_STREAM frame.
-StringPiece GetSerializedHeaders(const SpdyFrame* frame,
+StringPiece GetSerializedHeaders(const SpdySerializedFrame& frame,
                                  const SpdyFramer& framer) {
-  SpdyFrameReader reader(frame->data(), frame->size());
+  SpdyFrameReader reader(frame.data(), frame.size());
   if (framer.protocol_version() == SPDY3) {
     reader.Seek(2);  // Seek past the frame length.
   } else {
     reader.Seek(3);  // Seek past the frame length.
   }
   SpdyFrameType frame_type;
   if (framer.protocol_version() == SPDY3) {
     uint16_t serialized_type;
     reader.ReadUInt16(&serialized_type);
     frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
                                                serialized_type);
     DCHECK(frame_type == HEADERS || frame_type == SYN_STREAM) << frame_type;
   } else {
     uint8_t serialized_type;
     reader.ReadUInt8(&serialized_type);
     frame_type = SpdyConstants::ParseFrameType(framer.protocol_version(),
                                                serialized_type);
     DCHECK_EQ(HEADERS, frame_type);
     uint8_t flags;
     reader.ReadUInt8(&flags);
     if (flags & HEADERS_FLAG_PRIORITY) {
       frame_type = SYN_STREAM;
     }
   }
 
   if (frame_type == SYN_STREAM) {
-    return StringPiece(frame->data() + framer.GetSynStreamMinimumSize(),
-                       frame->size() - framer.GetSynStreamMinimumSize());
+    return StringPiece(frame.data() + framer.GetSynStreamMinimumSize(),
+                       frame.size() - framer.GetSynStreamMinimumSize());
   } else {
-    return StringPiece(frame->data() + framer.GetHeadersMinimumSize(),
-                       frame->size() - framer.GetHeadersMinimumSize());
+    return StringPiece(frame.data() + framer.GetHeadersMinimumSize(),
+                       frame.size() - framer.GetHeadersMinimumSize());
   }
 }
 
 class SpdyFramerTest : public ::testing::TestWithParam<SpdyMajorVersion> {
  protected:
   void SetUp() override {
     spdy_version_ = GetParam();
   }
 
   void CompareFrame(const string& description,
-                    const SpdyFrame& actual_frame,
+                    const SpdySerializedFrame& actual_frame,
                     const unsigned char* expected,
                     const int expected_len) {
     const unsigned char* actual =
         reinterpret_cast<const unsigned char*>(actual_frame.data());
     CompareCharArraysWithHexError(
         description, actual, actual_frame.size(), expected, expected_len);
   }
 
   void CompareFrames(const string& description,
-                     const SpdyFrame& expected_frame,
-                     const SpdyFrame& actual_frame) {
+                     const SpdySerializedFrame& expected_frame,
+                     const SpdySerializedFrame& actual_frame) {
     CompareCharArraysWithHexError(
         description,
         reinterpret_cast<const unsigned char*>(expected_frame.data()),
         expected_frame.size(),
         reinterpret_cast<const unsigned char*>(actual_frame.data()),
         actual_frame.size());
   }
 
   bool IsSpdy3() { return spdy_version_ == SPDY3; }
   bool IsHttp2() { return spdy_version_ == HTTP2; }
@@ skipping 13 matching lines @@
     // Not implemented for hpack.
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.SetHeader("cookie",
                     "=; key=value; ;  = ; foo; bar=;  ;  =   ; k2=v2 ; =");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
-  EXPECT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
-  visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(frame->data()),
-      frame->size());
+  visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
+                           frame.size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_NE(headers.header_block(), visitor.headers_);
   EXPECT_EQ(1u, visitor.headers_.size());
   EXPECT_EQ("key=value; foo; bar=; k2=v2 ", visitor.headers_["cookie"]);
 }
 
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
 TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
-  EXPECT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
-  visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(frame->data()),
-      frame->size());
+  visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
+                           frame.size());
 
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(headers.header_block(), visitor.headers_);
 }
 
 // Test that if there's not a full frame, we fail to parse it.
 TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
-  scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
-  EXPECT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
-  visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(frame->data()),
-      frame->size() - 2);
+  visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
+                           frame.size() - 2);
 
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0u, visitor.headers_.size());
 }
 
 // Test that we can encode and decode stream dependency values in a header
 // frame.
 TEST_P(SpdyFramerTest, HeaderStreamDependencyValues) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   const SpdyStreamId parent_stream_id_test_array[] = {0, 3};
   for (SpdyStreamId parent_stream_id : parent_stream_id_test_array) {
     const bool exclusive_test_array[] = {true, false};
     for (bool exclusive : exclusive_test_array) {
       SpdyHeadersIR headers(1);
       headers.set_has_priority(true);
       headers.set_parent_stream_id(parent_stream_id);
       headers.set_exclusive(exclusive);
-      scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers));
-      EXPECT_TRUE(frame.get() != NULL);
+      SpdySerializedFrame frame(framer.SerializeHeaders(headers));
 
       TestSpdyVisitor visitor(spdy_version_);
       visitor.use_compression_ = false;
-      visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame->data()),
-                               frame->size());
+      visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
+                               frame.size());
 
       EXPECT_TRUE(visitor.header_has_priority_);
       EXPECT_EQ(parent_stream_id, visitor.header_parent_stream_id_);
       EXPECT_EQ(exclusive, visitor.header_exclusive_);
     }
   }
 }
 
 // Test that if we receive a SYN_REPLY with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, SynReplyWithStreamIdZero) {
   if (!IsSpdy3()) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdySynReplyIR syn_reply(0);
   syn_reply.SetHeader("alpha", "beta");
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeSynReply(syn_reply));
-  ASSERT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
-  EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
+  EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyHeadersIR headers_ir(0);
   headers_ir.SetHeader("alpha", "beta");
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeHeaders(headers_ir));
-  ASSERT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
-  EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
+  EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
 // error (but don't crash).
 TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
   if (!IsHttp2()) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
-  scoped_ptr<SpdySerializedFrame> frame(
-      framer.SerializePushPromise(push_promise));
-  ASSERT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
-  EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
+  EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
 // signal an error (but don't crash).
 TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   if (!IsHttp2()) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
-  scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializePushPromise(push_promise));
-  ASSERT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
-  EXPECT_GT(frame->size(), framer.ProcessInput(frame->data(), frame->size()));
+  EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, DuplicateHeader) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): Punting on this because we haven't determined
     // whether duplicate HPACK headers other than Cookie are an error.
     // If they are, this will need to be updated to use HpackOutputStream.
@@ skipping 15 matching lines @@
   frame.WriteUInt32(2);  // Number of headers.
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value1");
   frame.WriteStringPiece32("name");
   frame.WriteStringPiece32("value2");
   // write the length
   frame.RewriteLength(framer);
 
   SpdyHeaderBlock new_headers;
   framer.set_enable_compression(false);
-  scoped_ptr<SpdyFrame> control_frame(frame.take());
-  StringPiece serialized_headers =
-      GetSerializedHeaders(control_frame.get(), framer);
+  SpdySerializedFrame control_frame(frame.take());
+  StringPiece serialized_headers = GetSerializedHeaders(control_frame, framer);
   // This should fail because duplicate headers are verboten by the spec.
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                serialized_headers.size(),
                                                &new_headers));
 }
 
 TEST_P(SpdyFramerTest, MultiValueHeader) {
   SpdyFramer framer(spdy_version_);
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024, spdy_version_);
@@ skipping 22 matching lines @@
     header_set["name"] = value;
     string buffer;
     HpackEncoder encoder(ObtainHpackHuffmanTable());
     encoder.EncodeHeaderSetWithoutCompression(header_set, &buffer);
     frame.WriteBytes(&buffer[0], buffer.size());
   }
   // write the length
   frame.RewriteLength(framer);
 
   framer.set_enable_compression(false);
-  scoped_ptr<SpdyFrame> control_frame(frame.take());
+  SpdySerializedFrame control_frame(frame.take());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(testing::Pair("name", StringPiece(value))));
 }
 
 TEST_P(SpdyFramerTest, BasicCompression) {
   if (!IsSpdy3()) {
     // Deflate compression doesn't apply to HPACK.
     return;
   }
 
   scoped_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor(spdy_version_));
   SpdyFramer framer(spdy_version_);
   framer.set_debug_visitor(visitor.get());
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("server", "SpdyServer 1.0");
   syn_stream.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
   syn_stream.SetHeader("status", "200");
   syn_stream.SetHeader("version", "HTTP/1.1");
   syn_stream.SetHeader("content-type", "text/html");
   syn_stream.SetHeader("content-length", "12");
-  scoped_ptr<SpdyFrame> frame1(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame frame1(framer.SerializeSynStream(syn_stream));
   size_t uncompressed_size1 = visitor->last_payload_len_;
   size_t compressed_size1 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
   EXPECT_EQ(165u, uncompressed_size1);
 #if defined(USE_SYSTEM_ZLIB)
   EXPECT_EQ(181u, compressed_size1);
 #else  // !defined(USE_SYSTEM_ZLIB)
   EXPECT_EQ(117u, compressed_size1);
 #endif  // !defined(USE_SYSTEM_ZLIB)
-  scoped_ptr<SpdyFrame> frame2(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame frame2(framer.SerializeSynStream(syn_stream));
   size_t uncompressed_size2 = visitor->last_payload_len_;
   size_t compressed_size2 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
 
   // Expect the second frame to be more compact than the first.
-  EXPECT_LE(frame2->size(), frame1->size());
+  EXPECT_LE(frame2.size(), frame1.size());
 
   // Decompress the first frame
-  scoped_ptr<SpdyFrame> frame3(
-      SpdyFramerTestUtil::DecompressFrame(&framer, *frame1));
+  SpdySerializedFrame frame3(
+      SpdyFramerTestUtil::DecompressFrame(&framer, frame1));
 
   // Decompress the second frame
   visitor.reset(new TestSpdyVisitor(spdy_version_));
   framer.set_debug_visitor(visitor.get());
-  scoped_ptr<SpdyFrame> frame4(
-      SpdyFramerTestUtil::DecompressFrame(&framer, *frame2));
-  size_t uncompressed_size4 =
-      frame4->size() - framer.GetSynStreamMinimumSize();
+  SpdySerializedFrame frame4(
+      SpdyFramerTestUtil::DecompressFrame(&framer, frame2));
+  size_t uncompressed_size4 = frame4.size() - framer.GetSynStreamMinimumSize();
   size_t compressed_size4 =
       visitor->last_frame_len_ - framer.GetSynStreamMinimumSize();
   EXPECT_EQ(165u, uncompressed_size4);
 #if defined(USE_SYSTEM_ZLIB)
   EXPECT_EQ(175u, compressed_size4);
 #else  // !defined(USE_SYSTEM_ZLIB)
   EXPECT_EQ(99u, compressed_size4);
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
   EXPECT_EQ(uncompressed_size1, uncompressed_size2);
   EXPECT_EQ(uncompressed_size1, uncompressed_size4);
   EXPECT_EQ(compressed_size2, compressed_size4);
 
   // Expect frames 3 & 4 to be the same.
-  CompareFrames("Uncompressed SYN_STREAM", *frame3, *frame4);
+  CompareFrames("Uncompressed SYN_STREAM", frame3, frame4);
 
   // Expect frames 3 to be the same as a uncompressed frame created
   // from scratch.
   framer.set_enable_compression(false);
-  scoped_ptr<SpdyFrame> uncompressed_frame(
-      framer.SerializeSynStream(syn_stream));
-  CompareFrames("Uncompressed SYN_STREAM", *frame3, *uncompressed_frame);
+  SpdySerializedFrame uncompressed_frame(framer.SerializeSynStream(syn_stream));
+  CompareFrames("Uncompressed SYN_STREAM", frame3, uncompressed_frame);
 }
 
 TEST_P(SpdyFramerTest, CompressEmptyHeaders) {
   // See crbug.com/172383
   SpdyHeadersIR headers(1);
   headers.SetHeader("server", "SpdyServer 1.0");
   headers.SetHeader("date", "Mon 12 Jan 2009 12:12:12 PST");
   headers.SetHeader("status", "200");
   headers.SetHeader("version", "HTTP/1.1");
   headers.SetHeader("content-type", "text/html");
   headers.SetHeader("content-length", "12");
   headers.SetHeader("x-empty-header", "");
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
-  scoped_ptr<SpdyFrame> frame1(framer.SerializeHeaders(headers));
+  SpdySerializedFrame frame1(framer.SerializeHeaders(headers));
 }
 
 TEST_P(SpdyFramerTest, Basic) {
   const unsigned char kV3Input[] = {
     0x80, 0x03, 0x00, 0x01,  // SYN Stream #1
     0x00, 0x00, 0x00, 0x1a,
     0x00, 0x00, 0x00, 0x01,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00,
     0x00, 0x01, 0x00, 0x00,
@@ skipping 288 matching lines @@
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
   const char kValue3[] = "value3";
 
   // SYN_STREAM #1
   SpdyHeaderBlock block;
   block[kHeader1] = kValue1;
   block[kHeader2] = kValue2;
   SpdySynStreamIR syn_ir_1(1);
   syn_ir_1.set_header_block(block);
-  scoped_ptr<SpdyFrame> syn_frame_1(send_framer.SerializeFrame(syn_ir_1));
-  EXPECT_TRUE(syn_frame_1.get() != NULL);
+  SpdySerializedFrame syn_frame_1(send_framer.SerializeFrame(syn_ir_1));
 
   // SYN_STREAM #2
   block[kHeader3] = kValue3;
   SpdySynStreamIR syn_stream(3);
   syn_stream.set_header_block(block);
-  scoped_ptr<SpdyFrame> syn_frame_2(send_framer.SerializeSynStream(syn_stream));
-  EXPECT_TRUE(syn_frame_2.get() != NULL);
-
-  // Now start decompressing
-  scoped_ptr<SpdyFrame> decompressed;
-  scoped_ptr<SpdyFrame> uncompressed;
-  StringPiece serialized_headers;
-  SpdyHeaderBlock decompressed_headers;
+  SpdySerializedFrame syn_frame_2(send_framer.SerializeSynStream(syn_stream));
 
   // Decompress SYN_STREAM #1
-  decompressed.reset(
-      SpdyFramerTestUtil::DecompressFrame(&recv_framer, *syn_frame_1));
-  EXPECT_TRUE(decompressed.get() != NULL);
-  serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
+  SpdySerializedFrame decompressed(
+      SpdyFramerTestUtil::DecompressFrame(&recv_framer, syn_frame_1));
+  StringPiece serialized_headers =
+      GetSerializedHeaders(decompressed, send_framer);
+  SpdyHeaderBlock decompressed_headers;
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                    serialized_headers.size(),
                                                    &decompressed_headers));
   EXPECT_EQ(2u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
 
   // Decompress SYN_STREAM #2
-  decompressed.reset(
-      SpdyFramerTestUtil::DecompressFrame(&recv_framer, *syn_frame_2));
-  EXPECT_TRUE(decompressed.get() != NULL);
-  serialized_headers = GetSerializedHeaders(decompressed.get(), send_framer);
+  decompressed = SpdyFramerTestUtil::DecompressFrame(&recv_framer, syn_frame_2);
+  serialized_headers = GetSerializedHeaders(decompressed, send_framer);
   decompressed_headers.clear();
   EXPECT_TRUE(recv_framer.ParseHeaderBlockInBuffer(serialized_headers.data(),
                                                    serialized_headers.size(),
                                                    &decompressed_headers));
   EXPECT_EQ(3u, decompressed_headers.size());
   EXPECT_EQ(kValue1, decompressed_headers[kHeader1]);
   EXPECT_EQ(kValue2, decompressed_headers[kHeader2]);
   EXPECT_EQ(kValue3, decompressed_headers[kHeader3]);
 }
 
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
 TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
   SpdyFramer send_framer(spdy_version_);
 
   send_framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeadersIR headers(1);
   headers.SetHeader(kHeader1, kValue1);
   headers.SetHeader(kHeader2, kValue2);
-  scoped_ptr<SpdyFrame> headers_frame(send_framer.SerializeHeaders(headers));
-  EXPECT_TRUE(headers_frame.get() != NULL);
+  SpdySerializedFrame headers_frame(send_framer.SerializeHeaders(headers));
 
   const char bytes[] = "this is a test test test test test!";
   SpdyDataIR data_ir(1, StringPiece(bytes, arraysize(bytes)));
   data_ir.set_fin(true);
-  scoped_ptr<SpdyFrame> send_frame(send_framer.SerializeData(data_ir));
-  EXPECT_TRUE(send_frame.get() != NULL);
+  SpdySerializedFrame send_frame(send_framer.SerializeData(data_ir));
 
   // Run the inputs through the framer.
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   const unsigned char* data;
-  data = reinterpret_cast<const unsigned char*>(headers_frame->data());
-  for (size_t idx = 0; idx < headers_frame->size(); ++idx) {
+  data = reinterpret_cast<const unsigned char*>(headers_frame.data());
+  for (size_t idx = 0; idx < headers_frame.size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
-  data = reinterpret_cast<const unsigned char*>(send_frame->data());
-  for (size_t idx = 0; idx < send_frame->size(); ++idx) {
+  data = reinterpret_cast<const unsigned char*>(send_frame.data());
+  for (size_t idx = 0; idx < send_frame.size(); ++idx) {
     visitor.SimulateInFramer(data + idx, 1);
     ASSERT_EQ(0, visitor.error_count_);
   }
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.syn_frame_count_);
   EXPECT_EQ(0, visitor.syn_reply_frame_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(arraysize(bytes), static_cast<unsigned>(visitor.data_bytes_));
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(1, visitor.data_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer(spdy_version_);
-  scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-      SpdyWindowUpdateIR(1, 0x12345678)));
+  SpdySerializedFrame frame(
+      framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kV3FrameData[] = {
     0x80, 0x03, 0x00, 0x09,
     0x00, 0x00, 0x00, 0x08,
     0x00, 0x00, 0x00, 0x01,
     0x12, 0x34, 0x56, 0x78
   };
   const unsigned char kH2FrameData[] = {
     0x00, 0x00, 0x04, 0x08,
     0x00, 0x00, 0x00, 0x00,
     0x01, 0x12, 0x34, 0x56,
     0x78
   };
 
   if (IsSpdy3()) {
-    CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+    CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
   } else {
-    CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+    CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateDataFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
@@ skipping 11 matching lines @@
                                           0x00,
                                           0x01,
                                           'h',
                                           'e',
                                           'l',
                                           'l',
                                           'o'};
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, bytes);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
 
     SpdyDataIR data_header_ir(1);
     data_header_ir.SetDataShallow(bytes);
-    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(
-        data_header_ir));
+    frame =
+        framer.SerializeDataFrameHeaderWithPaddingLengthField(data_header_ir);
     CompareCharArraysWithHexError(
-        kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
+        kDescription, reinterpret_cast<const unsigned char*>(frame.data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy3() ? kV3FrameData : kH2FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "'hello' data frame with more padding, no FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
@@ skipping 29 matching lines @@
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, bytes);
     // 247 zeros and the pad length field make the overall padding to be 248
     // bytes.
     data_ir.set_padding_len(248);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
 
-    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    frame = framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir);
     CompareCharArraysWithHexError(
-        kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
+        kDescription, reinterpret_cast<const unsigned char*>(frame.data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy3() ? kV3FrameData : kH2FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "'hello' data frame with few padding, no FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0d, 0x00,  // Length = 13.  PADDED set.
       0x08, 0x00, 0x00, 0x00,
       0x01, 0x07,              // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
       0x00,  0x00,  0x00,  0x00,   // Padding
       0x00,  0x00,  0x00
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, bytes);
     // 7 zeros and the pad length field make the overall padding to be 8 bytes.
     data_ir.set_padding_len(8);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "'hello' data frame with 1 byte padding, no FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
 
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06, 0x00,  // Length = 6.  PADDED set.
       0x08, 0x00, 0x00, 0x00,
       0x01, 0x00,              // Pad length field.
       'h',  'e',  'l',  'l',       // Data
       'o',
     };
     const char bytes[] = "hello";
 
     SpdyDataIR data_ir(1, bytes);
     // The pad length field itself is used for the 1-byte padding and no padding
     // payload is needed.
     data_ir.set_padding_len(1);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
 
-    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    frame = framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir);
     CompareCharArraysWithHexError(
-        kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
+        kDescription, reinterpret_cast<const unsigned char*>(frame.data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy3() ? kV3FrameData : kH2FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with negative data byte, no FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
       0xff
     };
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xff};
     SpdyDataIR data_ir(1, "\xff");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "'hello' data frame, with FIN";
     const unsigned char kV3FrameData[] = {
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x00, 0x00, 0x05,
       'h', 'e', 'l', 'l',
       'o'
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05, 0x00,
       0x01, 0x00, 0x00, 0x00,
       0x01, 'h',  'e',  'l',
       'l',  'o'
     };
     SpdyDataIR data_ir(1, "hello");
     data_ir.set_fin(true);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty data frame";
     const unsigned char kV3FrameData[] = {
         0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,
       0x01,
     };
     SpdyDataIR data_ir(1, "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
 
-    frame.reset(framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir));
+    frame = framer.SerializeDataFrameHeaderWithPaddingLengthField(data_ir);
     CompareCharArraysWithHexError(
-        kDescription, reinterpret_cast<const unsigned char*>(frame->data()),
+        kDescription, reinterpret_cast<const unsigned char*>(frame.data()),
         framer.GetDataFrameMinimumSize(),
         IsSpdy3() ? kV3FrameData : kH2FrameData,
         framer.GetDataFrameMinimumSize());
   }
 
   {
     const char kDescription[] = "Data frame with max stream ID";
     const unsigned char kV3FrameData[] = {
       0x7f, 0xff, 0xff, 0xff,
       0x01, 0x00, 0x00, 0x05,
       'h',  'e',  'l',  'l',
       'o'
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05, 0x00,
       0x01, 0x7f, 0xff, 0xff,
       0xff, 'h',  'e',  'l',
       'l',  'o'
     };
     SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   if (!IsHttp2()) {
     // This test does not apply to HTTP/2 because the max frame size is smaller
     // than 4MB.
     const char kDescription[] = "Large data frame";
     const int kDataSize = 4 * 1024 * 1024;  // 4 MB
     const string kData(kDataSize, 'A');
     const unsigned char kFrameHeader[] = {
       0x00, 0x00, 0x00, 0x01,
       0x01, 0x40, 0x00, 0x00,
     };
 
     const int kFrameSize = arraysize(kFrameHeader) + kDataSize;
     scoped_ptr<unsigned char[]> expected_frame_data(
         new unsigned char[kFrameSize]);
     memcpy(expected_frame_data.get(), kFrameHeader, arraysize(kFrameHeader));
     memset(expected_frame_data.get() + arraysize(kFrameHeader), 'A', kDataSize);
 
     SpdyDataIR data_ir(1, kData);
     data_ir.set_fin(true);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-    CompareFrame(kDescription, *frame, expected_frame_data.get(), kFrameSize);
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
+    CompareFrame(kDescription, frame, expected_frame_data.get(), kFrameSize);
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) {
   if (!IsSpdy3()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
@@ skipping 13 matching lines @@
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'b',
       'a',  'r'
     };
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(framer.GetLowestPriority());
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header name, highest pri, FIN, "
         "max stream ID";
 
@@ skipping 10 matching lines @@
       0x03, 'f',  'o',  'o',
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r'
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(framer.GetHighestPriority());
     syn_stream.set_fin(true);
     syn_stream.SetHeader("", "foo");
     syn_stream.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_STREAM frame with a 0-length header val, high pri, FIN, "
         "max stream ID";
 
@@ skipping 10 matching lines @@
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x00
     };
     SpdySynStreamIR syn_stream(0x7fffffff);
     syn_stream.set_associated_to_stream_id(0x7fffffff);
     syn_stream.set_priority(1);
     syn_stream.set_fin(true);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynStreamCompressed) {
@@ skipping 41 matching lines @@
       0x0a, 0x20, 0x80, 0x92,
       0x12, 0x8b, 0x00, 0x02,
       0x08, 0x00, 0x00, 0x00,
       0xff, 0xff,
     };
 
     SpdySynStreamIR syn_stream(1);
     syn_stream.set_priority(4);
     syn_stream.SetHeader("bar", "foo");
     syn_stream.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
     const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
+        reinterpret_cast<const unsigned char*>(frame.data());
     if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
+      if (memcmp(frame_data, kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame.size())) != 0) {
+        CompareCharArraysWithHexError(kDescription, frame_data, frame.size(),
+                                      kV3FrameData, arraysize(kV3FrameData));
       }
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) {
   if (!IsSpdy3()) {
@@ skipping 15 matching lines @@
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x03, 'b',  'a',  'r'
     };
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header name, FIN, max stream ID";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x03,
       'f',  'o',  'o',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'b',  'a',
       'r'
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("", "foo");
     syn_reply.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 
   {
     const char kDescription[] =
         "SYN_REPLY frame with a 0-length header val, FIN, max stream ID";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x02,
       0x01, 0x00, 0x00, 0x21,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x02,
       0x00, 0x00, 0x00, 0x03,
       'b',  'a',  'r',  0x00,
       0x00, 0x00, 0x03, 'f',
       'o',  'o',  0x00, 0x00,
       0x00, 0x03, 'f',  'o',
       'o',  0x00, 0x00, 0x00,
       0x00
     };
     SpdySynReplyIR syn_reply(0x7fffffff);
     syn_reply.set_fin(true);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateSynReplyCompressed) {
@@ skipping 36 matching lines @@
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x24, 0x0a, 0x20,
       0x80, 0x92, 0x12, 0x8b,
       0x00, 0x02, 0x08, 0x00,
       0x00, 0x00, 0xff, 0xff,
     };
 
     SpdySynReplyIR syn_reply(1);
     syn_reply.SetHeader("bar", "foo");
     syn_reply.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
     const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
+        reinterpret_cast<const unsigned char*>(frame.data());
     if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
+      if (memcmp(frame_data, kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame.size())) != 0) {
+        CompareCharArraysWithHexError(kDescription, frame_data, frame.size(),
+                                      kV3FrameData, arraysize(kV3FrameData));
       }
     } else {
       LOG(FATAL) << "Unsupported version in test.";
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04, 0x03, 0x00, 0x00, 0x00,
         0x00, 0x01, 0x00, 0x00, 0x00, 0x01,
     };
     SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
+    SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x03,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x01,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_PROTOCOL_ERROR);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
+    SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max status code";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x03,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x06,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x03,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x02,
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
+    SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
 
@@ skipping 14 matching lines @@
     uint32_t kValue = 0x0a0b0c0d;
     SpdySettingsIR settings_ir;
 
     SpdySettingsFlags kFlags = static_cast<SpdySettingsFlags>(0x01);
     SpdySettingsIds kId = SETTINGS_INITIAL_WINDOW_SIZE;
     settings_ir.AddSetting(kId,
                            kFlags & SETTINGS_FLAG_PLEASE_PERSIST,
                            kFlags & SETTINGS_FLAG_PERSISTED,
                            kValue);
 
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
+    SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "Basic SETTINGS frame";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x24,
       0x00, 0x00, 0x00, 0x04,
@@ skipping 32 matching lines @@
                            false,  // persisted
                            6);
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
                            false,  // persist
                            false,  // persisted
                            7);
     settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 4),
                            false,  // persist
                            false,  // persisted
                            8);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
+    SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
 
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "Empty SETTINGS frame";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x00, 0x04,
       0x00, 0x00, 0x00, 0x00,
       0x00,
     };
     SpdySettingsIR settings_ir;
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
+    SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreatePingFrame) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x06,
       0x00, 0x00, 0x00, 0x04,
       0x12, 0x34, 0x56, 0x78,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08, 0x06,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x12, 0x34, 0x56,
       0x78, 0x9a, 0xbc, 0xde,
       0xff,
     };
     const unsigned char kH2FrameDataWithAck[] = {
       0x00, 0x00, 0x08, 0x06,
       0x01, 0x00, 0x00, 0x00,
       0x00, 0x12, 0x34, 0x56,
       0x78, 0x9a, 0xbc, 0xde,
       0xff,
     };
-    scoped_ptr<SpdyFrame> frame;
+    SpdySerializedFrame frame;
     if (IsSpdy3()) {
-      frame.reset(framer.SerializePing(SpdyPingIR(0x12345678ull)));
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      frame = framer.SerializePing(SpdyPingIR(0x12345678ull));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
       const SpdyPingId kPingId = 0x123456789abcdeffULL;
       SpdyPingIR ping_ir(kPingId);
       // Tests SpdyPingIR when the ping is not an ack.
       ASSERT_FALSE(ping_ir.is_ack());
-      frame.reset(framer.SerializePing(ping_ir));
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      frame = framer.SerializePing(ping_ir);
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 
       // Tests SpdyPingIR when the ping is an ack.
       ping_ir.set_is_ack(true);
-      frame.reset(framer.SerializePing(ping_ir));
-      CompareFrame(kDescription, *frame, kH2FrameDataWithAck,
+      frame = framer.SerializePing(ping_ir);
+      CompareFrame(kDescription, frame, kH2FrameDataWithAck,
                    arraysize(kH2FrameDataWithAck));
-
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateGoAway) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x00,  // Stream Id
       0x00, 0x00, 0x00, 0x00,  // Status
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00,  // Stream id
       0x00, 0x00, 0x00, 0x00,  // Status
       0x00, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0, GOAWAY_OK, "GA");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
+    SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID, status";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x07,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,  // Stream Id
       0x00, 0x00, 0x00, 0x01,  // Status: PROTOCOL_ERROR.
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a, 0x07,
       0x00, 0x00, 0x00, 0x00,
       0x00, 0x7f, 0xff, 0xff,  // Stream Id
       0xff, 0x00, 0x00, 0x00,  // Status: INTERNAL_ERROR.
       0x02, 0x47, 0x41,        // Opaque Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
+    SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
@@ skipping 16 matching lines @@
        0x04, 0x00, 0x00, 0x00,  // Stream 1
        0x01, 0x00, 0x03, 0x62,  // @.ba
        0x61, 0x72, 0x03, 0x66,  // r.fo
        0x6f, 0x6f, 0x00, 0x03,  // o@.f
        0x66, 0x6f, 0x6f, 0x03,  // oo.b
        0x62, 0x61, 0x72,        // ar
     };
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x08,
       0x01, 0x00, 0x00, 0x21,
@@ skipping 12 matching lines @@
       0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
       0xff, 0x00, 0x00, 0x03,  // @..
       0x66, 0x6f, 0x6f, 0x00,  // foo@
       0x03, 0x66, 0x6f, 0x6f,  // .foo
       0x03, 0x62, 0x61, 0x72,  // .bar
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID";
 
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x08,
       0x01, 0x00, 0x00, 0x21,
@@ skipping 12 matching lines @@
       0x05, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
       0xff, 0x00, 0x03, 0x62,  // @.b
       0x61, 0x72, 0x03, 0x66,  // ar.f
       0x6f, 0x6f, 0x00, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x00,  // foo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
      headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
         0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
         0xff, 0x00, 0x00, 0x00,  // exclusive, parent stream
         0x00, 0xdb,              // weight
         0x00, 0x03, 0x62, 0x61,  // @.ba
         0x72, 0x03, 0x66, 0x6f,  // r.fo
         0x6f, 0x00, 0x03, 0x66,  // o@.f
         0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, "
         "exclusive=true, parent_stream=0";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
         0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
         0xff, 0x80, 0x00, 0x00,  // exclusive, parent stream
         0x00, 0xdb,              // weight
         0x00, 0x03, 0x62, 0x61,  // @.ba
         0x72, 0x03, 0x66, 0x6f,  // r.fo
         0x6f, 0x00, 0x03, 0x66,  // o@.f
         0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.set_exclusive(true);
     headers_ir.set_parent_stream_id(0);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header val, FIN, max stream ID, pri, "
         "exclusive=false, parent_stream=max stream ID";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x14, 0x01,  // Headers: FIN | END_HEADERS | PRIORITY
         0x25, 0x7f, 0xff, 0xff,  // Stream 0x7fffffff
         0xff, 0x7f, 0xff, 0xff,  // exclusive, parent stream
         0xff, 0xdb,              // weight
         0x00, 0x03, 0x62, 0x61,  // @.ba
         0x72, 0x03, 0x66, 0x6f,  // r.fo
         0x6f, 0x00, 0x03, 0x66,  // o@.f
         0x6f, 0x6f, 0x00,        // oo.
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.set_priority(1);
     headers_ir.set_has_priority(true);
     headers_ir.set_exclusive(false);
     headers_ir.set_parent_stream_id(0x7fffffff);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
       // HEADERS with priority not supported.
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] =
         "HEADERS frame with a 0-length header name, FIN, max stream ID, padded";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x15, 0x01,  // Headers
         0x0d, 0x7f, 0xff, 0xff,  // FIN | END_HEADERS | PADDED, Stream
                                  // 0x7fffffff
         0xff, 0x05, 0x00, 0x00,  // Pad length field
         0x03, 0x66, 0x6f, 0x6f,  // .foo
         0x00, 0x03, 0x66, 0x6f,  // @.fo
         0x6f, 0x03, 0x62, 0x61,  // o.ba
         0x72,                    // r
         // Padding payload
         0x00, 0x00, 0x00, 0x00, 0x00,
     };
     SpdyHeadersIR headers_ir(0x7fffffff);
     headers_ir.set_fin(true);
     headers_ir.SetHeader("", "foo");
     headers_ir.SetHeader("foo", "bar");
     headers_ir.set_padding_len(6);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     if (IsSpdy3()) {
       // Padding is not supported.
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 // TODO(phajdan.jr): Clean up after we no longer need
 // to workaround http://crbug.com/139744.
 #if !defined(USE_SYSTEM_ZLIB)
 TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(true);
@@ skipping 30 matching lines @@
       0xcb, 0xcf, 0x07, 0x08,
       0x20, 0x24, 0x0a, 0x20,
       0x80, 0x92, 0x12, 0x8b,
       0x00, 0x02, 0x08, 0x00,
       0x00, 0x00, 0xff, 0xff,
     };
 
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
+        reinterpret_cast<const unsigned char*>(frame.data());
     if (IsSpdy3()) {
-      if (memcmp(frame_data,
-                 kV3SIMDFrameData,
-                 std::min(arraysize(kV3SIMDFrameData), frame->size())) != 0) {
-        CompareCharArraysWithHexError(kDescription,
-                                      frame_data,
-                                      frame->size(),
-                                      kV3FrameData,
-                                      arraysize(kV3FrameData));
+      if (memcmp(frame_data, kV3SIMDFrameData,
+                 std::min(arraysize(kV3SIMDFrameData), frame.size())) != 0) {
+        CompareCharArraysWithHexError(kDescription, frame_data, frame.size(),
+                                      kV3FrameData, arraysize(kV3FrameData));
       }
     } else {
       // Deflate compression doesn't apply to HPACK.
     }
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
 TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer(spdy_version_);
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x00, 0x00, 0x00,
       0x01, 0x00, 0x00, 0x00,
       0x01,
     };
-    scoped_ptr<SpdyFrame> frame(
+    SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 1)));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max stream ID";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x7f, 0xff, 0xff, 0xff,
       0x00, 0x00, 0x00, 0x01,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x7f, 0xff, 0xff,
       0xff, 0x00, 0x00, 0x00,
       0x01,
     };
-    scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
+    SpdySerializedFrame frame(
+        framer.SerializeWindowUpdate(SpdyWindowUpdateIR(0x7FFFFFFF, 1)));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame with max window delta";
     const unsigned char kV3FrameData[] = {
       0x80, 0x03, 0x00, 0x09,
       0x00, 0x00, 0x00, 0x08,
       0x00, 0x00, 0x00, 0x01,
       0x7f, 0xff, 0xff, 0xff,
     };
     const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04, 0x08,
       0x00, 0x00, 0x00, 0x00,
       0x01, 0x7f, 0xff, 0xff,
       0xff,
     };
-    scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
+    SpdySerializedFrame frame(
+        framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     if (IsSpdy3()) {
-      CompareFrame(kDescription, *frame, kV3FrameData, arraysize(kV3FrameData));
+      CompareFrame(kDescription, frame, kV3FrameData, arraysize(kV3FrameData));
     } else {
-      CompareFrame(kDescription, *frame, kH2FrameData, arraysize(kH2FrameData));
+      CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
     }
   }
 }
 
 TEST_P(SpdyFramerTest, SerializeBlocked) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, BLOCKED));
   const unsigned char kFrameData[] = {
     0x00, 0x00, 0x00, kType, 0x00,
     0x00, 0x00, 0x00,  0x00,
   };
   SpdyBlockedIR blocked_ir(0);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+  SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
+  CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreateBlocked) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "BLOCKED frame";
   const SpdyStreamId kStreamId = 3;
 
-  scoped_ptr<SpdySerializedFrame> frame_serialized(
+  SpdySerializedFrame frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
-  scoped_ptr<SpdySerializedFrame> frame_created(
-      framer.SerializeFrame(blocked_ir));
+  SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir));
 
-  CompareFrames(kDescription, *frame_serialized, *frame_created);
+  CompareFrames(kDescription, frame_serialized, frame_created);
 }
 
 TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   if (!IsHttp2()) {
     return;
   }
 
   {
     // Test framing PUSH_PROMISE without padding.
     SpdyFramer framer(spdy_version_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame without padding";
 
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x16, 0x05,  // PUSH_PROMISE
         0x04, 0x00, 0x00, 0x00,  // END_HEADERS
         0x2a, 0x00, 0x00, 0x00,  // Stream 42
         0x39, 0x00, 0x03, 0x62,  // Promised stream 57, @.b
         0x61, 0x72, 0x03, 0x66,  // ar.f
         0x6f, 0x6f, 0x00, 0x03,  // oo@.
         0x66, 0x6f, 0x6f, 0x03,  // foo.
         0x62, 0x61, 0x72,        // bar
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
-    scoped_ptr<SpdySerializedFrame> frame(
-        framer.SerializePushPromise(push_promise));
-    CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+    SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
+    CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with one byte of padding.
     SpdyFramer framer(spdy_version_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with one byte of padding";
 
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x17, 0x05,  // PUSH_PROMISE
         0x0c, 0x00, 0x00, 0x00,  // END_HEADERS | PADDED
         0x2a, 0x00, 0x00, 0x00,  // Stream 42, Pad length field
         0x00, 0x39, 0x00, 0x03,  // Promised stream 57
         0x62, 0x61, 0x72, 0x03,  // bar.
         0x66, 0x6f, 0x6f, 0x00,  // foo@
         0x03, 0x66, 0x6f, 0x6f,  // .foo
         0x03, 0x62, 0x61, 0x72,  // .bar
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(1);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
-    scoped_ptr<SpdySerializedFrame> frame(
-        framer.SerializePushPromise(push_promise));
-    CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+    SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
+    CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 
   {
     // Test framing PUSH_PROMISE with 177 bytes of padding.
     SpdyFramer framer(spdy_version_);
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame with 177 bytes of padding";
 
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0xc7, 0x05,  // PUSH_PROMISE
@@ skipping 19 matching lines @@
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(177);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
-    scoped_ptr<SpdySerializedFrame> frame(
-        framer.SerializePushPromise(push_promise));
-    CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+    SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
+    CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 }
 
 // Regression test for https://crbug.com/464748.
 TEST_P(SpdyFramerTest, GetNumberRequiredContinuationFrames) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
@@ skipping 23 matching lines @@
       0x61, 0x72, 0x03, 0x66,  // ar.f
       0x6f, 0x6f, 0x00, 0x03,  // oo@.
       0x66, 0x6f, 0x6f, 0x03,  // foo.
       0x62, 0x61, 0x72,        // bar
   };
 
   SpdyContinuationIR continuation(42);
   continuation.SetHeader("bar", "foo");
   continuation.SetHeader("foo", "bar");
   continuation.set_end_headers(true);
-  scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializeContinuation(continuation));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+  SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
+  CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) {
   if (!IsHttp2()) {
     return;
   }
 
   {
     // Test framing in a case such that a PUSH_PROMISE frame, with one byte of
     // padding, cannot hold all the data payload, which is overflowed to the
@@ skipping 41 matching lines @@
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78, 0x78, 0x78,  // xxxx
         0x78, 0x78,
     };
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(1);
     string big_value(TestSpdyVisitor::sent_control_frame_max_size(), 'x');
     push_promise.SetHeader("xxx", big_value);
-    scoped_ptr<SpdySerializedFrame> frame(
-        framer.SerializePushPromise(push_promise));
+    SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
 
     // The entire frame should look like below:
     // Name                     Length in Byte
     // ------------------------------------------- Begin of PUSH_PROMISE frame
     // PUSH_PROMISE header      9
     // Pad length field         1
     // Promised stream          4
     // Length field of key      2
     // Content of key           3
     // Length field of value    3
     // Part of big_value        16361
     // ------------------------------------------- Begin of CONTINUATION frame
     // CONTINUATION header      9
     // Remaining of big_value   22
     // ------------------------------------------- End
 
     // Length of everything listed above except big_value.
     int len_non_data_payload = 31;
     EXPECT_EQ(
         TestSpdyVisitor::sent_control_frame_max_size() + len_non_data_payload,
-        frame->size());
+        frame.size());
 
     // Partially compare the PUSH_PROMISE frame against the template.
     const unsigned char* frame_data =
-        reinterpret_cast<const unsigned char*>(frame->data());
+        reinterpret_cast<const unsigned char*>(frame.data());
     CompareCharArraysWithHexError(kDescription,
                                   frame_data,
                                   arraysize(kPartialPushPromiseFrameData),
                                   kPartialPushPromiseFrameData,
                                   arraysize(kPartialPushPromiseFrameData));
 
     // Compare the CONTINUATION frame against the template.
     frame_data += TestSpdyVisitor::sent_control_frame_max_size();
     CompareCharArraysWithHexError(kDescription,
                                   frame_data,
@@ skipping 22 matching lines @@
       's',  't',  ':',  '1',   '2',  '3',  '"',  ';',  ' ',  'm',  'a',  '=',
       '4',  '2',  ';',  ' ',   'p',  '=',  '"',  '0',  '.',  '2',  '0',  '"',
       ';',  ' ',  'v',  '=',   '"',  '2',  '4',  '"'};
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_origin("origin");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, 1.0, SpdyAltSvcWireFormat::VersionVector{}));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "p\"=i:d", "h_\\o\"st", 123, 42, 0.2,
       SpdyAltSvcWireFormat::VersionVector{24}));
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+  SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
+  CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, CreatePriority) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
 
   const char kDescription[] = "PRIORITY frame";
   const unsigned char kType = static_cast<unsigned char>(
       SpdyConstants::SerializeFrameType(spdy_version_, PRIORITY));
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x05, kType, 0x00,
       0x00, 0x00, 0x00, 0x02,  // Stream ID = 2
       0x80, 0x00, 0x00, 0x01,  // Exclusive dependency, parent stream ID = 1
       0x10,                    // Weight = 16
   };
   SpdyPriorityIR priority_ir(2, 1, 16, true);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(priority_ir));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+  SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
+  CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   SpdyPriorityIR priority2(2);
   priority2.set_parent_stream_id(1);
   priority2.set_weight(16);
   priority2.set_exclusive(true);
-  frame.reset(framer.SerializeFrame(priority2));
-  CompareFrame(kDescription, *frame, kFrameData, arraysize(kFrameData));
+  frame = framer.SerializeFrame(priority2);
+  CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynStreamHeaderBlock) {
   if (!IsSpdy3()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "vv");
   syn_stream.SetHeader("bb", "ww");
   SpdyHeaderBlock headers = syn_stream.header_block();
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  SpdySerializedFrame control_frame(framer.SerializeSynStream(syn_stream));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedSynReplyHeaderBlock) {
   if (!IsSpdy3()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdySynReplyIR syn_reply(1);
   syn_reply.SetHeader("alpha", "beta");
   syn_reply.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = syn_reply.header_block();
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynReply(syn_reply));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  SpdySerializedFrame control_frame(framer.SerializeSynReply(syn_reply));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1, visitor.syn_reply_frame_count_);
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = headers_ir.header_block();
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   // control_frame_header_data_count_ depends on the random sequence
   // produced by rand(), so adding, removing or running single tests
   // alters this value.  The best we can do is assert that it happens
   // at least twice.
   EXPECT_LE(2, visitor.control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdyHeaderBlock headers = headers_ir.header_block();
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers_ir));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  SpdySerializedFrame control_frame(framer.SerializeHeaders(headers_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   // control_frame_header_data_count_ depends on the random sequence
   // produced by rand(), so adding, removing or running single tests
   // alters this value.  The best we can do is assert that it happens
   // at least twice.
   EXPECT_LE(2, visitor.control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameAtMaxSizeLimit) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
 
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "");
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame control_frame(framer.SerializeSynStream(syn_stream));
   const size_t kBigValueSize =
-      TestSpdyVisitor::sent_control_frame_max_size() - control_frame->size();
+      TestSpdyVisitor::sent_control_frame_max_size() - control_frame.size();
 
   // Create a frame at exactly that size.
   string big_value(kBigValueSize, 'x');
   syn_stream.SetHeader("aa", big_value);
-  control_frame.reset(framer.SerializeSynStream(syn_stream));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  control_frame = framer.SerializeSynStream(syn_stream);
   EXPECT_EQ(TestSpdyVisitor::sent_control_frame_max_size(),
-            control_frame->size());
+            control_frame.size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_LT(kBigValueSize, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameMaximumSize) {
   if (!IsSpdy3()) {
     // TODO(jgraettinger): This test setup doesn't work with HPACK.
     return;
   }
 
   // First find the size of the header value in order to just reach the control
   // frame max size.
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdySynStreamIR syn_stream(1);
   syn_stream.SetHeader("aa", "");
   syn_stream.set_priority(1);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame control_frame(framer.SerializeSynStream(syn_stream));
   const size_t kBigValueSize =
-      SpdyConstants::GetFrameMaximumSize(spdy_version_) - control_frame->size();
+      SpdyConstants::GetFrameMaximumSize(spdy_version_) - control_frame.size();
 
   // Create a frame at exatly that size.
   string big_value(kBigValueSize, 'x');
   syn_stream.SetHeader("aa", big_value);
   // Upstream branches here and wraps HTTP/2 with EXPECT_DEBUG_DFATAL. We
   // neither support that in Chromium, nor do we use the same DFATAL (see
   // SpdyFrameBuilder::WriteFramePrefix()).
-  control_frame.reset(framer.SerializeSynStream(syn_stream));
+  control_frame = framer.SerializeSynStream(syn_stream);
 
-  EXPECT_TRUE(control_frame.get() != NULL);
   EXPECT_EQ(SpdyConstants::GetFrameMaximumSize(spdy_version_),
-            control_frame->size());
+            control_frame.size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.syn_frame_count_);
 }
 
 TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdyHeadersIR headers(1);
   headers.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   headers.SetHeader("aa", big_value);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
-  EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_GT(control_frame->size(),
+  SpdySerializedFrame control_frame(framer.SerializeHeaders(headers));
+  EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 }
 
 TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   SpdyPushPromiseIR push_promise(1, 2);
   push_promise.set_padding_len(256);
 
   // Exact payload length will change with HPACK, but this should be long
   // enough to cause an overflow.
   const size_t kBigValueSize = TestSpdyVisitor::sent_control_frame_max_size();
   string big_value(kBigValueSize, 'x');
   push_promise.SetHeader("aa", big_value);
-  scoped_ptr<SpdyFrame> control_frame(
-      framer.SerializePushPromise(push_promise));
-  EXPECT_TRUE(control_frame.get() != NULL);
-  EXPECT_GT(control_frame->size(),
+  SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
+  EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(1, visitor.continuation_count_);
   EXPECT_EQ(1, visitor.zero_length_control_frame_header_data_count_);
 }
 
 // Check that the framer stops delivering header data chunks once the visitor
 // declares it doesn't want any more. This is important to guard against
 // "zip bomb" types of attacks.
 TEST_P(SpdyFramerTest, ControlFrameMuchTooLarge) {
   const size_t kHeaderBufferChunks = 4;
   const size_t kHeaderBufferSize =
       TestSpdyVisitor::header_data_chunk_max_size() * kHeaderBufferChunks;
   const size_t kBigValueSize = kHeaderBufferSize * 2;
   string big_value(kBigValueSize, 'x');
   SpdyFramer framer(spdy_version_);
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeHeaders(headers));
-  EXPECT_TRUE(control_frame.get() != NULL);
+  SpdySerializedFrame control_frame(framer.SerializeHeaders(headers));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_FALSE(visitor.header_buffer_valid_);
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 
   // The framer should have stoped delivering chunks after the visitor
   // signaled "stop" by returning false from OnControlFrameHeaderData().
   //
   // control_frame_header_data_count_ depends on the random sequence
@@ skipping 15 matching lines @@
   }
 
   SpdyFramer framer(spdy_version_);
   framer.set_enable_compression(false);
   // Construct a SYN_STREAM control frame without compressing the header block,
   // and have the framer try to decompress it. This will cause the framer to
   // deal with a decompression error.
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
   syn_stream.SetHeader("aa", "alpha beta gamma delta");
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame control_frame(framer.SerializeSynStream(syn_stream));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_DECOMPRESS_FAILURE, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
 TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   SpdyFramer framer(spdy_version_);
   // Create a GoAway frame that has a few extra bytes at the end.
   // We create enough overhead to overflow the framer's control frame buffer.
@@ skipping 37 matching lines @@
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   EXPECT_EQ(0, visitor.goaway_count_);  // Frame not parsed.
 }
 
 TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
-  SetFrameLength(control_frame.get(), 0, spdy_version_);
+  SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
+  SetFrameLength(&control_frame, 0, spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
+      reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetControlFrameHeaderSize());
   if (IsSpdy3()) {
     // Should generate an error, since zero-len settings frames are unsupported.
     EXPECT_EQ(1, visitor.error_count_);
   } else {
     // Zero-len settings frames are permitted as of HTTP/2.
     EXPECT_EQ(0, visitor.error_count_);
   }
 }
 
 // Tests handling of SETTINGS frames with invalid length.
 TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
 
   // Add a setting to pad the frame so that we don't get a buffer overflow when
   // calling SimulateInFramer() below.
   settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE,
                          false,
                          false,
                          0x00000002);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
+  SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   const size_t kNewLength = 14;
-  SetFrameLength(control_frame.get(), kNewLength, spdy_version_);
+  SetFrameLength(&control_frame, kNewLength, spdy_version_);
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
+      reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetControlFrameHeaderSize() + kNewLength);
   // Should generate an error, since its not possible to have a
   // settings frame of length kNewLength.
   EXPECT_EQ(1, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
 TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
   SpdyFramer framer(spdy_version_);
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
                          false,  // persist
                          false,  // persisted
                          5);
   settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 2),
                          false,  // persist
                          false,  // persisted
                          6);
   settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 3),
                          false,  // persist
                          false,  // persisted
                          7);
 
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
-  EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame->size());
+  SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
+  EXPECT_LT(SpdyFramerPeer::ControlFrameBufferSize(), control_frame.size());
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
 
   // Read all at once.
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3, visitor.setting_count_);
   if (IsHttp2()) {
     EXPECT_EQ(1, visitor.settings_ack_sent_);
   }
 
   // Read data in small chunks.
   size_t framed_data = 0;
-  size_t unframed_data = control_frame->size();
+  size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
-        reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
+        reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3 * 2, visitor.setting_count_);
   if (IsHttp2()) {
     EXPECT_EQ(2, visitor.settings_ack_sent_);
   }
 }
@@ skipping 152 matching lines @@
 
   const int kPaddingLen = 119;
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyDataIR data_ir(1, data_payload);
   data_ir.set_padding_len(kPaddingLen);
-  scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-  ASSERT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializeData(data_ir));
 
   int bytes_consumed = 0;
 
   // Send the frame header.
   EXPECT_CALL(visitor, OnDataFrameHeader(1,
                                          kPaddingLen + strlen(data_payload),
                                          false));
   CHECK_EQ(framer.GetDataFrameMinimumSize(),
-           framer.ProcessInput(frame->data(),
-                               framer.GetDataFrameMinimumSize()));
+           framer.ProcessInput(frame.data(), framer.GetDataFrameMinimumSize()));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READ_DATA_FRAME_PADDING_LENGTH);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += framer.GetDataFrameMinimumSize();
 
   // Send the padding length field.
   EXPECT_CALL(visitor, OnStreamPadding(1, 1));
-  CHECK_EQ(1u, framer.ProcessInput(frame->data() + bytes_consumed, 1));
+  CHECK_EQ(1u, framer.ProcessInput(frame.data() + bytes_consumed, 1));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 1;
 
   // Send the first two bytes of the data payload, i.e., "he".
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 2, false));
-  CHECK_EQ(2u, framer.ProcessInput(frame->data() + bytes_consumed, 2));
+  CHECK_EQ(2u, framer.ProcessInput(frame.data() + bytes_consumed, 2));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_FORWARD_STREAM_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 2;
 
   // Send the rest three bytes of the data payload, i.e., "llo".
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 3, false));
-  CHECK_EQ(3u, framer.ProcessInput(frame->data() + bytes_consumed, 3));
+  CHECK_EQ(3u, framer.ProcessInput(frame.data() + bytes_consumed, 3));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 3;
 
   // Send the first 100 bytes of the padding payload.
   EXPECT_CALL(visitor, OnStreamPadding(1, 100));
-  CHECK_EQ(100u, framer.ProcessInput(frame->data() + bytes_consumed, 100));
+  CHECK_EQ(100u, framer.ProcessInput(frame.data() + bytes_consumed, 100));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_CONSUME_PADDING);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
   bytes_consumed += 100;
 
   // Send rest of the padding payload.
   EXPECT_CALL(visitor, OnStreamPadding(1, 18));
-  CHECK_EQ(18u, framer.ProcessInput(frame->data() + bytes_consumed, 18));
+  CHECK_EQ(18u, framer.ProcessInput(frame.data() + bytes_consumed, 18));
   CHECK_EQ(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
 }
 
 TEST_P(SpdyFramerTest, ReadWindowUpdate) {
   SpdyFramer framer(spdy_version_);
-  scoped_ptr<SpdyFrame> control_frame(
+  SpdySerializedFrame control_frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(1u, visitor.last_window_update_stream_);
   EXPECT_EQ(2, visitor.last_window_update_delta_);
 }
 
 TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdyHeaderBlock headers = push_promise.header_block();
-  scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializePushPromise(push_promise));
-  EXPECT_TRUE(frame.get() != NULL);
+  SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = true;
-  visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(frame->data()),
-      frame->size());
+  visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
+                           frame.size());
   EXPECT_EQ(42u, visitor.last_push_promise_stream_);
   EXPECT_EQ(57u, visitor.last_push_promise_promised_stream_);
   EXPECT_EQ(headers, visitor.headers_);
 }
 
 TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   if (!IsHttp2()) {
     return;
   }
 
@@ skipping 303 matching lines @@
   visitor.SimulateInFramer(unknown_frame, arraysize(unknown_frame));
   EXPECT_EQ(0, visitor.error_count_);
 
   // Follow it up with a valid control frame to make sure we handle
   // subsequent frames correctly.
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SpdyConstants::ParseSettingId(spdy_version_, 1),
                          false,  // persist
                          false,  // persisted
                          10);
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeSettings(settings_ir));
+  SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
-      reinterpret_cast<unsigned char*>(control_frame->data()),
-      control_frame->size());
+      reinterpret_cast<unsigned char*>(control_frame.data()),
+      control_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.setting_count_));
   EXPECT_EQ(1u, static_cast<unsigned>(visitor.settings_ack_sent_));
 }
 
 TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
   if (!IsHttp2()) {
     return;
   }
 
@@ skipping 236 matching lines @@
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, DataFrameFlagsV2V3disabled) {
   FLAGS_spdy_on_stream_end = false;
 
   if (!IsSpdy3()) {
     return;
   }
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~DATA_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 12 matching lines @@
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~valid_data_flags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       if (flags & DATA_FLAG_PADDED) {
         // The first byte of payload is parsed as padding length.
         EXPECT_CALL(visitor, OnStreamPadding(_, 1));
         // Expect Error since the frame ends prematurely.
         EXPECT_CALL(visitor, OnError(_));
       } else {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
         if (flags & DATA_FLAG_FIN) {
           EXPECT_CALL(visitor, OnStreamEnd(_));
         }
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if ((flags & ~valid_data_flags) || (flags & DATA_FLAG_PADDED)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
@@ skipping 11 matching lines @@
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyDataIR data_ir(1, "hello");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeData(data_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeData(data_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~valid_data_flags) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnDataFrameHeader(1, 5, flags & DATA_FLAG_FIN));
       if (flags & DATA_FLAG_PADDED) {
         // The first byte of payload is parsed as padding length.
         EXPECT_CALL(visitor, OnStreamPadding(_, 1));
         // Expect Error since the frame ends prematurely.
         EXPECT_CALL(visitor, OnError(_));
       } else {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 5, false));
         if (flags & DATA_FLAG_FIN) {
           EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
         }
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if ((flags & ~valid_data_flags) || (flags & DATA_FLAG_PADDED)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
@@ skipping 15 matching lines @@
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
 
     SpdySynStreamIR syn_stream(8);
     syn_stream.set_associated_to_stream_id(3);
     syn_stream.set_priority(1);
     syn_stream.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
       EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
                                        flags & CONTROL_FLAG_UNIDIRECTIONAL));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 16 matching lines @@
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(8, SYN_STREAM, _, _));
 
     SpdySynStreamIR syn_stream(8);
     syn_stream.set_associated_to_stream_id(3);
     syn_stream.set_priority(1);
     syn_stream.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(8, SYN_STREAM, _));
       EXPECT_CALL(visitor, OnSynStream(8, 3, 1, flags & CONTROL_FLAG_FIN,
                                        flags & CONTROL_FLAG_UNIDIRECTIONAL));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(8, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~(CONTROL_FLAG_FIN | CONTROL_FLAG_UNIDIRECTIONAL)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 10 matching lines @@
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySynReplyIR syn_reply(37);
     syn_reply.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSynReply(37, flags & CONTROL_FLAG_FIN));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(37, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 10 matching lines @@
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySynReplyIR syn_reply(37);
     syn_reply.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSynReply(syn_reply));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSynReply(syn_reply));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSynReply(37, flags & CONTROL_FLAG_FIN));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(37, _, _))
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeRstStream(rst_stream));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags != 0) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 11 matching lines @@
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_UPLOAD_BANDWIDTH,
                            false,
                            false,
                            54321);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSettings(
           flags & SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS));
       EXPECT_CALL(visitor, OnSetting(SETTINGS_UPLOAD_BANDWIDTH,
                                      SETTINGS_FLAG_NONE, 54321));
       EXPECT_CALL(visitor, OnSettingsEnd());
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
   if (!IsHttp2()) {
     return;
   }
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
     settings_ir.AddSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 0, 16);
-    scoped_ptr<SpdyFrame> frame(framer.SerializeSettings(settings_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnSettings(flags & SETTINGS_FLAG_ACK));
       EXPECT_CALL(visitor, OnSetting(SETTINGS_INITIAL_WINDOW_SIZE, 0, 16));
       EXPECT_CALL(visitor, OnSettingsEnd());
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~SETTINGS_FLAG_ACK) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else if (flags & SETTINGS_FLAG_ACK) {
       // The frame is invalid because ACK frames should have no payload.
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, GoawayFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
     SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeGoAway(goaway_ir));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_OK));
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags != 0) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 12 matching lines @@
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
     if (IsHttp2() && (flags & HEADERS_FLAG_PRIORITY)) {
       headers_ir.set_priority(3);
       headers_ir.set_has_priority(true);
       headers_ir.set_parent_stream_id(5);
       headers_ir.set_exclusive(true);
     }
     headers_ir.SetHeader("foo", "bar");
-    std::unique_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     uint8_t set_flags = flags;
     if (IsHttp2()) {
       // TODO(jgraettinger): Add padding to SpdyHeadersIR,
       // and implement framing.
       set_flags &= ~HEADERS_FLAG_PADDED;
     }
-    SetFrameFlags(frame.get(), set_flags, spdy_version_);
+    SetFrameFlags(&frame, set_flags, spdy_version_);
 
     if (!IsHttp2() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else if (IsHttp2() &&
                flags &
                    ~(CONTROL_FLAG_FIN | HEADERS_FLAG_END_HEADERS |
                      HEADERS_FLAG_END_SEGMENT | HEADERS_FLAG_PADDED |
                      HEADERS_FLAG_PRIORITY)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
@@ skipping 17 matching lines @@
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN &&
           (IsSpdy3() || flags & HEADERS_FLAG_END_HEADERS)) {
         EXPECT_CALL(visitor, OnStreamEnd(_));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (IsSpdy3() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else if (IsHttp2() &&
                flags &
                    ~(CONTROL_FLAG_FIN | HEADERS_FLAG_END_HEADERS |
                      HEADERS_FLAG_END_SEGMENT | HEADERS_FLAG_PADDED |
                      HEADERS_FLAG_PRIORITY)) {
@@ skipping 25 matching lines @@
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
     if (IsHttp2() && (flags & HEADERS_FLAG_PRIORITY)) {
       headers_ir.set_priority(3);
       headers_ir.set_has_priority(true);
       headers_ir.set_parent_stream_id(5);
       headers_ir.set_exclusive(true);
     }
     headers_ir.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame(framer.SerializeHeaders(headers_ir));
+    SpdySerializedFrame frame(framer.SerializeHeaders(headers_ir));
     uint8_t set_flags = flags;
     if (IsHttp2()) {
       // TODO(jgraettinger): Add padding to SpdyHeadersIR,
       // and implement framing.
       set_flags &= ~HEADERS_FLAG_PADDED;
     }
-    SetFrameFlags(frame.get(), set_flags, spdy_version_);
+    SetFrameFlags(&frame, set_flags, spdy_version_);
 
     if (!IsHttp2() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_CALL(visitor, OnError(_));
     } else if (IsHttp2() &&
                flags &
                    ~(CONTROL_FLAG_FIN | HEADERS_FLAG_END_HEADERS |
                      HEADERS_FLAG_END_SEGMENT | HEADERS_FLAG_PADDED |
                      HEADERS_FLAG_PRIORITY)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
@@ skipping 17 matching lines @@
           .WillRepeatedly(testing::Return(true));
       if (flags & DATA_FLAG_FIN &&
           (IsSpdy3() || flags & HEADERS_FLAG_END_HEADERS)) {
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true));
       } else {
         // Do not close the stream if we are expecting a CONTINUATION frame.
         EXPECT_CALL(visitor, OnStreamFrameData(_, _, 0, true)).Times(0);
       }
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (IsSpdy3() && flags & ~CONTROL_FLAG_FIN) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else if (IsHttp2() && flags & ~(CONTROL_FLAG_FIN |
                                       HEADERS_FLAG_END_HEADERS |
                                       HEADERS_FLAG_END_SEGMENT |
                                       HEADERS_FLAG_PADDED |
                                       HEADERS_FLAG_PRIORITY)) {
@@ skipping 15 matching lines @@
 
 TEST_P(SpdyFramerTest, PingFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
-    scoped_ptr<SpdyFrame> frame(framer.SerializePing(SpdyPingIR(42)));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializePing(SpdyPingIR(42)));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (IsHttp2() && flags == PING_FLAG_ACK) {
       EXPECT_CALL(visitor, OnPing(42, true));
     } else if (flags == 0) {
       EXPECT_CALL(visitor, OnPing(42, false));
     } else {
       EXPECT_CALL(visitor, OnError(_));
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if ((IsHttp2() && flags == PING_FLAG_ACK) || flags == 0) {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags);
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
 
-    scoped_ptr<SpdyFrame> frame(framer.SerializeWindowUpdate(
-        SpdyWindowUpdateIR(4, 1024)));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(
+        framer.SerializeWindowUpdate(SpdyWindowUpdateIR(4, 1024)));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags != 0) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags != 0) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 12 matching lines @@
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer(spdy_version_);
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, PUSH_PROMISE, _, _));
 
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.SetHeader("foo", "bar");
-    scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializePushPromise(push_promise));
+    SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     // TODO(jgraettinger): Add padding to SpdyPushPromiseIR,
     // and implement framing.
-    SetFrameFlags(frame.get(), flags & ~HEADERS_FLAG_PADDED, spdy_version_);
+    SetFrameFlags(&frame, flags & ~HEADERS_FLAG_PADDED, spdy_version_);
 
     if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, PUSH_PROMISE, _));
       EXPECT_CALL(visitor, OnPushPromise(42, 57,
           flags & PUSH_PROMISE_FLAG_END_PUSH_PROMISE));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
           .WillRepeatedly(testing::Return(true));
     }
 
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~(PUSH_PROMISE_FLAG_END_PUSH_PROMISE | HEADERS_FLAG_PADDED)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 16 matching lines @@
     framer.set_debug_visitor(&debug_visitor);
 
     EXPECT_CALL(debug_visitor, OnSendCompressedFrame(42, HEADERS, _, _));
     EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, HEADERS, _));
     EXPECT_CALL(visitor, OnHeaders(42, false, 0, 0, false, false, false));
     EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
           .WillRepeatedly(testing::Return(true));
 
     SpdyHeadersIR headers_ir(42);
     headers_ir.SetHeader("foo", "bar");
-    scoped_ptr<SpdyFrame> frame0(framer.SerializeHeaders(headers_ir));
-    SetFrameFlags(frame0.get(), 0, spdy_version_);
+    SpdySerializedFrame frame0(framer.SerializeHeaders(headers_ir));
+    SetFrameFlags(&frame0, 0, spdy_version_);
 
     SpdyContinuationIR continuation(42);
     continuation.SetHeader("foo", "bar");
-    scoped_ptr<SpdySerializedFrame> frame(
-    framer.SerializeContinuation(continuation));
-    SetFrameFlags(frame.get(), flags, spdy_version_);
+    SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
+    SetFrameFlags(&frame, flags, spdy_version_);
 
     if (flags & ~(HEADERS_FLAG_END_HEADERS)) {
       EXPECT_CALL(visitor, OnError(_));
     } else {
       EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(42, CONTINUATION, _));
       EXPECT_CALL(visitor, OnContinuation(42,
                                           flags & HEADERS_FLAG_END_HEADERS));
       EXPECT_CALL(visitor, OnControlFrameHeaderData(42, _, _))
           .WillRepeatedly(testing::Return(true));
     }
 
-    framer.ProcessInput(frame0->data(), frame0->size());
-    framer.ProcessInput(frame->data(), frame->size());
+    framer.ProcessInput(frame0.data(), frame0.size());
+    framer.ProcessInput(frame.data(), frame.size());
     if (flags & ~(HEADERS_FLAG_END_HEADERS)) {
       EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS,
                 framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     } else {
       EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
       EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
           << SpdyFramer::ErrorCodeToString(framer.error_code());
     }
@@ skipping 12 matching lines @@
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   testing::StrictMock<test::MockDebugVisitor> debug_visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
   framer.set_debug_visitor(&debug_visitor);
 
   EXPECT_CALL(debug_visitor, OnSendCompressedFrame(1, SYN_STREAM, _, _));
 
   SpdySynStreamIR syn_stream(1);
   syn_stream.set_priority(1);
-  scoped_ptr<SpdyFrame> frame(framer.SerializeSynStream(syn_stream));
+  SpdySerializedFrame frame(framer.SerializeSynStream(syn_stream));
   // Adjust size to remove the header block.
-  SetFrameLength(
-      frame.get(),
-      framer.GetSynStreamMinimumSize() - framer.GetControlFrameHeaderSize(),
-      spdy_version_);
+  SetFrameLength(&frame, framer.GetSynStreamMinimumSize() -
+                             framer.GetControlFrameHeaderSize(),
+                 spdy_version_);
 
   EXPECT_CALL(debug_visitor, OnReceiveCompressedFrame(1, SYN_STREAM, _));
   EXPECT_CALL(visitor, OnSynStream(1, 0, 1, false, false));
   EXPECT_CALL(visitor, OnControlFrameHeaderData(1, NULL, 0));
 
-  framer.ProcessInput(frame->data(), framer.GetSynStreamMinimumSize());
+  framer.ProcessInput(frame.data(), framer.GetSynStreamMinimumSize());
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32_t kId = 0x020304;
   const uint32_t kFlags = 0x01;
   const uint32_t kWireFormat = base::HostToNet32(0x01020304);
 
@@ skipping 144 matching lines @@
 
   const SpdyStreamId kStreamId = 0;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnBlocked(kStreamId));
 
   SpdyBlockedIR blocked_ir(0);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(blocked_ir));
-  framer.ProcessInput(frame->data(), framer.GetBlockedSize());
+  SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
+  framer.ProcessInput(frame.data(), framer.GetBlockedSize());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvc) {
   if (!IsHttp2()) {
     return;
   }
@@ skipping 12 matching lines @@
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor,
               OnAltSvc(kStreamId, StringPiece("o_r|g!n"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o_r|g!n");
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), frame->size());
+  SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
   if (!IsHttp2()) {
     return;
   }
@@ skipping 10 matching lines @@
       "p\"=i:d", "h_\\o\"st", 123, 42, 0.2,
       SpdyAltSvcWireFormat::VersionVector{24});
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc1);
   altsvc_vector.push_back(altsvc2);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece(""), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), frame->size());
+  SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
   if (!IsHttp2()) {
     return;
   }
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, 1.0, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "", "h1", 443, 10, 1.0, SpdyAltSvcWireFormat::VersionVector()));
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), frame->size());
+  SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
   if (!IsHttp2()) {
     return;
   }
 
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(spdy_version_);
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc(
       "pid", "h1", 443, 10, 1.0, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector;
   altsvc_vector.push_back(altsvc);
   EXPECT_CALL(visitor, OnAltSvc(kStreamId, StringPiece("o1"), altsvc_vector));
 
   SpdyAltSvcIR altsvc_ir(1);
   altsvc_ir.set_origin("o1");
   altsvc_ir.add_altsvc(altsvc);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializeFrame(altsvc_ir));
-  framer.ProcessInput(frame->data(), frame->size());
+  SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
+  framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Tests handling of ALTSVC frames delivered in small chunks.
 TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyAltSvcIR altsvc_ir(1);
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, 1.0, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, 0.2,
       SpdyAltSvcWireFormat::VersionVector{24});
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
 
-  scoped_ptr<SpdyFrame> control_frame(framer.SerializeAltSvc(altsvc_ir));
+  SpdySerializedFrame control_frame(framer.SerializeAltSvc(altsvc_ir));
   TestSpdyVisitor visitor(spdy_version_);
   visitor.use_compression_ = false;
 
   // Read data in small chunks.
   size_t framed_data = 0;
-  size_t unframed_data = control_frame->size();
+  size_t unframed_data = control_frame.size();
   size_t kReadChunkSize = 5;  // Read five bytes at a time.
   while (unframed_data > 0) {
     size_t to_read = std::min(kReadChunkSize, unframed_data);
     visitor.SimulateInFramer(
-        reinterpret_cast<unsigned char*>(control_frame->data() + framed_data),
+        reinterpret_cast<unsigned char*>(control_frame.data() + framed_data),
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   ASSERT_EQ(2u, visitor.test_altsvc_ir_.altsvc_vector().size());
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[0] == altsvc1);
   EXPECT_TRUE(visitor.test_altsvc_ir_.altsvc_vector()[1] == altsvc2);
 }
 
 // Tests handling of PRIORITY frames.
 TEST_P(SpdyFramerTest, ReadPriority) {
   if (!IsHttp2()) {
     return;
   }
 
   SpdyFramer framer(spdy_version_);
   SpdyPriorityIR priority(3, 1, 255, false);
-  scoped_ptr<SpdySerializedFrame> frame(framer.SerializePriority(priority));
+  SpdySerializedFrame frame(framer.SerializePriority(priority));
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
   EXPECT_CALL(visitor, OnPriority(3, 1, 255, false));
-  framer.ProcessInput(frame->data(), frame->size());
+  framer.ProcessInput(frame.data(), frame.size());
 
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
   // TODO(mlavan): once we actually maintain a priority tree,
   // check that state is adjusted correctly.
 }
 
 TEST_P(SpdyFramerTest, PriorityWeightMapping) {
   if (!IsHttp2()) {
@@ skipping 56 matching lines @@
   SpdyFramer framer(spdy_version_);
   scoped_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor(spdy_version_));
   framer.set_visitor(visitor.get());
 
   // Create two input frames.
   SpdyHeadersIR headers(1);
   headers.set_priority(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
-  scoped_ptr<SpdyFrame> headers_frame(framer.SerializeHeaders(headers));
+  SpdySerializedFrame headers_frame(framer.SerializeHeaders(headers));
 
   const char four_score[] = "Four score and seven years ago";
   SpdyDataIR four_score_ir(1, four_score);
-  scoped_ptr<SpdyFrame> four_score_frame(framer.SerializeData(four_score_ir));
+  SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   // Put them in a single buffer (new variables here to make it easy to
   // change the order and type of frames).
-  SpdyFrame* frame1 = headers_frame.get();
-  SpdyFrame* frame2 = four_score_frame.get();
+  SpdySerializedFrame frame1 = std::move(headers_frame);
+  SpdySerializedFrame frame2 = std::move(four_score_frame);
 
-  const size_t frame1_size = frame1->size();
-  const size_t frame2_size = frame2->size();
+  const size_t frame1_size = frame1.size();
+  const size_t frame2_size = frame2.size();
 
   LOG(INFO) << "frame1_size = " << frame1_size;
   LOG(INFO) << "frame2_size = " << frame2_size;
 
   string input_buffer;
-  input_buffer.append(frame1->data(), frame1_size);
-  input_buffer.append(frame2->data(), frame2_size);
+  input_buffer.append(frame1.data(), frame1_size);
+  input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   LOG(INFO) << "buf_size = " << buf_size;
 
   size_t processed = framer.ProcessInput(buf, buf_size);
   EXPECT_EQ(buf_size, processed);
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(1, visitor->headers_frame_count_);
   EXPECT_EQ(1, visitor->data_frame_count_);
   EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
 }
 
 // Test that SpdyFramer stops after processing a full frame if
 // process_single_input_frame is set. Input to ProcessInput has two frames, but
 // only processes the first when we give it the first frame split at any point,
 // or give it more than one frame in the input buffer.
 TEST_P(SpdyFramerTest, ProcessAtMostOneFrame) {
   SpdyFramer framer(spdy_version_);
   framer.set_process_single_input_frame(true);
   scoped_ptr<TestSpdyVisitor> visitor;
 
   // Create two input frames.
   const char four_score[] = "Four score and ...";
   SpdyDataIR four_score_ir(1, four_score);
-  scoped_ptr<SpdyFrame> four_score_frame(framer.SerializeData(four_score_ir));
+  SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   SpdyHeadersIR headers(2);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
-  scoped_ptr<SpdyFrame> headers_frame(framer.SerializeHeaders(headers));
+  SpdySerializedFrame headers_frame(framer.SerializeHeaders(headers));
 
   // Put them in a single buffer (new variables here to make it easy to
   // change the order and type of frames).
-  SpdyFrame* frame1 = four_score_frame.get();
-  SpdyFrame* frame2 = headers_frame.get();
+  SpdySerializedFrame frame1 = std::move(four_score_frame);
+  SpdySerializedFrame frame2 = std::move(headers_frame);
 
-  const size_t frame1_size = frame1->size();
-  const size_t frame2_size = frame2->size();
+  const size_t frame1_size = frame1.size();
+  const size_t frame2_size = frame2.size();
 
   LOG(INFO) << "frame1_size = " << frame1_size;
   LOG(INFO) << "frame2_size = " << frame2_size;
 
   string input_buffer;
-  input_buffer.append(frame1->data(), frame1_size);
-  input_buffer.append(frame2->data(), frame2_size);
+  input_buffer.append(frame1.data(), frame1_size);
+  input_buffer.append(frame2.data(), frame2_size);
 
   const char* buf = input_buffer.data();
   const size_t buf_size = input_buffer.size();
 
   LOG(INFO) << "buf_size = " << buf_size;
 
   for (size_t first_size = 0; first_size <= buf_size; ++first_size) {
     LOG(INFO) << "first_size = " << first_size;
     visitor.reset(new TestSpdyVisitor(spdy_version_));
     framer.set_visitor(visitor.get());
@@ skipping 31 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net