BASELINE: Update Chromium to 51.0.2704.41

Also adds in all smaller components by reversing logic for exclusion.

Change-Id: Ibf90b506e7da088ea2f65dcf23f2b0992c504422
Reviewed-by: Joerg Bornemann <joerg.bornemann@theqtcompany.com>

1 files changed, 119 insertions, 155 deletions

diff --git a/chromium/net/quic/quic_headers_stream_test.cc b/chromium/net/quic/quic_headers_stream_test.cc
index 2425683a5b4..e02f5307708 100644
--- a/chromium/net/quic/quic_headers_stream_test.cc
+++ b/chromium/net/quic/quic_headers_stream_test.cc
@@ -42,6 +42,7 @@ class MockVisitor : public SpdyFramerVisitorInterface {
   MOCK_METHOD4(
       OnStreamFrameData,
       void(SpdyStreamId stream_id, const char* data, size_t len, bool fin));
+  MOCK_METHOD1(OnStreamEnd, void(SpdyStreamId stream_id));
   MOCK_METHOD2(OnStreamPadding, void(SpdyStreamId stream_id, size_t len));
   MOCK_METHOD1(OnHeaderFrameStart,
                SpdyHeadersHandlerInterface*(SpdyStreamId stream_id));
@@ -92,19 +93,26 @@ class MockVisitor : public SpdyFramerVisitorInterface {
   MOCK_METHOD2(OnUnknownFrame, bool(SpdyStreamId stream_id, int frame_type));
 };
 
-// Run all tests with each version, and client or server
+// Run all tests with each version, perspective (client or server),
+// and relevant flag options (false or true)
 struct TestParams {
-  TestParams(QuicVersion version, Perspective perspective)
-      : version(version), perspective(perspective) {}
+  TestParams(QuicVersion version,
+             Perspective perspective,
+             bool spdy_on_stream_end)
+      : version(version),
+        perspective(perspective),
+        spdy_on_stream_end(spdy_on_stream_end) {}
 
   friend ostream& operator<<(ostream& os, const TestParams& p) {
     os << "{ version: " << QuicVersionToString(p.version);
-    os << ", perspective: " << p.perspective << " }";
+    os << ", perspective: " << p.perspective;
+    os << ", spdy_on_stream_end: " << p.spdy_on_stream_end << " }";
     return os;
   }
 
   QuicVersion version;
   Perspective perspective;
+  bool spdy_on_stream_end;
 };
 
 // Constructs various test permutations.
@@ -112,8 +120,10 @@ vector<TestParams> GetTestParams() {
   vector<TestParams> params;
   QuicVersionVector all_supported_versions = QuicSupportedVersions();
   for (const QuicVersion version : all_supported_versions) {
-    params.push_back(TestParams(version, Perspective::IS_CLIENT));
-    params.push_back(TestParams(version, Perspective::IS_SERVER));
+    params.push_back(TestParams(version, Perspective::IS_CLIENT, true));
+    params.push_back(TestParams(version, Perspective::IS_SERVER, true));
+    params.push_back(TestParams(version, Perspective::IS_CLIENT, false));
+    params.push_back(TestParams(version, Perspective::IS_SERVER, false));
   }
   FLAGS_quic_supports_push_promise = true;
   return params;
@@ -128,14 +138,15 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
         session_(connection_),
         headers_stream_(QuicSpdySessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
-        framer_(HTTP2),
         stream_frame_(kHeadersStreamId, /*fin=*/false, /*offset=*/0, ""),
         next_promised_stream_id_(2) {
     FLAGS_quic_always_log_bugs_for_tests = true;
     headers_[":version"] = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
-    framer_.set_visitor(&visitor_);
+    FLAGS_spdy_on_stream_end = GetParam().spdy_on_stream_end;
+    framer_ = std::unique_ptr<SpdyFramer>(new SpdyFramer(HTTP2));
+    framer_->set_visitor(&visitor_);
     EXPECT_EQ(version(), session_.connection()->version());
     EXPECT_TRUE(headers_stream_ != nullptr);
     VLOG(1) << GetParam();
@@ -175,7 +186,7 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
                                 SpdyPriority priority,
                                 SpdyFrameType type) {
     // Write the headers and capture the outgoing data
-    EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, _, nullptr))
+    EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, nullptr))
         .WillOnce(WithArgs<1>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
     headers_stream_->WriteHeaders(stream_id, headers_, fin, priority, nullptr);
 
@@ -196,11 +207,15 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
         .WillRepeatedly(WithArgs<1, 2>(
             Invoke(this, &QuicHeadersStreamTest::SaveHeaderData)));
     if (fin) {
-      EXPECT_CALL(visitor_, OnStreamFrameData(stream_id, nullptr, 0, true));
+      if (FLAGS_spdy_on_stream_end) {
+        EXPECT_CALL(visitor_, OnStreamEnd(stream_id));
+      } else {
+        EXPECT_CALL(visitor_, OnStreamFrameData(stream_id, nullptr, 0, true));
+      }
     }
-    framer_.ProcessInput(saved_data_.data(), saved_data_.length());
-    EXPECT_FALSE(framer_.HasError())
-        << SpdyFramer::ErrorCodeToString(framer_.error_code());
+    framer_->ProcessInput(saved_data_.data(), saved_data_.length());
+    EXPECT_FALSE(framer_->HasError())
+        << SpdyFramer::ErrorCodeToString(framer_->error_code());
 
     CheckHeaders();
     saved_data_.clear();
@@ -208,7 +223,7 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
 
   void CheckHeaders() {
     SpdyHeaderBlock headers;
-    EXPECT_TRUE(framer_.ParseHeaderBlockInBuffer(
+    EXPECT_TRUE(framer_->ParseHeaderBlockInBuffer(
         saved_header_data_.data(), saved_header_data_.length(), &headers));
     EXPECT_EQ(headers_, headers);
     saved_header_data_.clear();
@@ -224,7 +239,9 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
     return versions;
   }
 
-  void CloseConnection() { QuicConnectionPeer::CloseConnection(connection_); }
+  void TearDownLocalConnectionState() {
+    QuicConnectionPeer::TearDownLocalConnectionState(connection_);
+  }
 
   QuicStreamId NextPromisedStreamId() { return next_promised_stream_id_ += 2; }
 
@@ -239,7 +256,7 @@ class QuicHeadersStreamTest : public ::testing::TestWithParam<TestParams> {
   string body_;
   string saved_data_;
   string saved_header_data_;
-  SpdyFramer framer_;
+  std::unique_ptr<SpdyFramer> framer_;
   StrictMock<MockVisitor> visitor_;
   QuicStreamFrame stream_frame_;
   QuicStreamId next_promised_stream_id_;
@@ -253,10 +270,6 @@ TEST_P(QuicHeadersStreamTest, StreamId) {
   EXPECT_EQ(3u, headers_stream_->id());
 }
 
-TEST_P(QuicHeadersStreamTest, Priority) {
-  EXPECT_EQ(0u, headers_stream_->Priority());
-}
-
 TEST_P(QuicHeadersStreamTest, WriteHeaders) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
@@ -279,8 +292,7 @@ TEST_P(QuicHeadersStreamTest, WritePushPromises) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
     if (perspective() == Perspective::IS_SERVER) {
       // Write the headers and capture the outgoing data
-      EXPECT_CALL(session_,
-                  WritevData(kHeadersStreamId, _, _, false, _, nullptr))
+      EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, nullptr))
           .WillOnce(WithArgs<1>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
       headers_stream_->WritePushPromise(stream_id, promised_stream_id, headers_,
                                         nullptr);
@@ -291,9 +303,9 @@ TEST_P(QuicHeadersStreamTest, WritePushPromises) {
       EXPECT_CALL(visitor_, OnControlFrameHeaderData(stream_id, _, _))
           .WillRepeatedly(WithArgs<1, 2>(
               Invoke(this, &QuicHeadersStreamTest::SaveHeaderData)));
-      framer_.ProcessInput(saved_data_.data(), saved_data_.length());
-      EXPECT_FALSE(framer_.HasError())
-          << SpdyFramer::ErrorCodeToString(framer_.error_code());
+      framer_->ProcessInput(saved_data_.data(), saved_data_.length());
+      EXPECT_FALSE(framer_->HasError())
+          << SpdyFramer::ErrorCodeToString(framer_->error_code());
       CheckHeaders();
       saved_data_.clear();
     } else {
@@ -310,29 +322,29 @@ TEST_P(QuicHeadersStreamTest, ProcessRawData) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
-        scoped_ptr<SpdySerializedFrame> frame;
+        SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
-          frame.reset(framer_.SerializeFrame(headers_frame));
+          frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
-          frame.reset(framer_.SerializeFrame(headers_frame));
+          frame = framer_->SerializeFrame(headers_frame);
         }
         EXPECT_CALL(session_, OnStreamHeaders(stream_id, _))
             .WillRepeatedly(WithArgs<1>(Invoke(
                 this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
         EXPECT_CALL(session_,
-                    OnStreamHeadersComplete(stream_id, fin, frame->size()));
-        stream_frame_.frame_buffer = frame->data();
-        stream_frame_.frame_length = frame->size();
+                    OnStreamHeadersComplete(stream_id, fin, frame.size()));
+        stream_frame_.frame_buffer = frame.data();
+        stream_frame_.frame_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
-        stream_frame_.offset += frame->size();
+        stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
@@ -345,76 +357,32 @@ TEST_P(QuicHeadersStreamTest, ProcessPushPromise) {
   for (QuicStreamId stream_id = kClientDataStreamId1;
        stream_id < kClientDataStreamId3; stream_id += 2) {
     QuicStreamId promised_stream_id = NextPromisedStreamId();
-    scoped_ptr<SpdySerializedFrame> frame;
     SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
     push_promise.set_header_block(headers_);
-    frame.reset(framer_.SerializeFrame(push_promise));
+    SpdySerializedFrame frame(framer_->SerializeFrame(push_promise));
     if (perspective() == Perspective::IS_SERVER) {
-      EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
-                                    QUIC_INVALID_HEADERS_STREAM_DATA,
-                                    "PUSH_PROMISE not supported."))
-          .WillRepeatedly(
-              InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
+      EXPECT_CALL(*connection_,
+                  CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                  "PUSH_PROMISE not supported.", _))
+          .WillRepeatedly(InvokeWithoutArgs(
+              this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
     } else {
       EXPECT_CALL(session_, OnPromiseHeaders(stream_id, _))
           .WillRepeatedly(WithArgs<1>(
               Invoke(this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
       EXPECT_CALL(session_, OnPromiseHeadersComplete(
-                                stream_id, promised_stream_id, frame->size()));
+                                stream_id, promised_stream_id, frame.size()));
     }
-    stream_frame_.frame_buffer = frame->data();
-    stream_frame_.frame_length = frame->size();
+    stream_frame_.frame_buffer = frame.data();
+    stream_frame_.frame_length = frame.size();
     headers_stream_->OnStreamFrame(stream_frame_);
     if (perspective() == Perspective::IS_CLIENT) {
-      stream_frame_.offset += frame->size();
+      stream_frame_.offset += frame.size();
       CheckHeaders();
     }
   }
 }
 
-TEST_P(QuicHeadersStreamTest, PushPromiseOutOfOrder) {
-  if (perspective() == Perspective::IS_SERVER)
-    return;
-
-  QuicStreamId promised_stream_id = NextPromisedStreamId();
-  QuicStreamId stream_id = kClientDataStreamId1;
-
-  scoped_ptr<SpdySerializedFrame> frame;
-  SpdyPushPromiseIR push_promise(stream_id, promised_stream_id);
-  push_promise.set_header_block(headers_);
-  frame.reset(framer_.SerializeFrame(push_promise));
-  EXPECT_CALL(session_, OnPromiseHeaders(stream_id, _))
-      .WillRepeatedly(WithArgs<1>(
-          Invoke(this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
-  EXPECT_CALL(session_, OnPromiseHeadersComplete(stream_id, promised_stream_id,
-                                                 frame->size()));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
-  headers_stream_->OnStreamFrame(stream_frame_);
-  if (perspective() == Perspective::IS_CLIENT) {
-    stream_frame_.offset += frame->size();
-    CheckHeaders();
-  }
-
-  stream_id += 2;
-  push_promise.set_stream_id(stream_id);
-  frame.reset(framer_.SerializeFrame(push_promise));
-  EXPECT_CALL(session_, OnPromiseHeaders(stream_id, _))
-      .WillRepeatedly(WithArgs<1>(
-          Invoke(this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
-  EXPECT_CALL(session_, OnPromiseHeadersComplete(stream_id, promised_stream_id,
-                                                 frame->size()));
-  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
-                                QUIC_INVALID_STREAM_ID,
-                                "Received push stream id lesser or equal to the"
-                                " last accepted before"))
-      .WillRepeatedly(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
-  headers_stream_->OnStreamFrame(stream_frame_);
-}
-
 TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) {
   EXPECT_CALL(session_, OnHeadersHeadOfLineBlocking(_)).Times(0);
   testing::InSequence seq;
@@ -422,28 +390,28 @@ TEST_P(QuicHeadersStreamTest, EmptyHeaderHOLBlockedTime) {
   for (int stream_num = 0; stream_num < 10; stream_num++) {
     QuicStreamId stream_id = QuicClientDataStreamId(stream_num);
     // Replace with "WriteHeadersAndSaveData"
-    scoped_ptr<SpdySerializedFrame> frame;
+    SpdySerializedFrame frame;
     if (perspective() == Perspective::IS_SERVER) {
       SpdyHeadersIR headers_frame(stream_id);
       headers_frame.set_header_block(headers_);
       headers_frame.set_fin(fin);
       headers_frame.set_has_priority(true);
-      frame.reset(framer_.SerializeFrame(headers_frame));
+      frame = framer_->SerializeFrame(headers_frame);
       EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
     } else {
       SpdyHeadersIR headers_frame(stream_id);
       headers_frame.set_header_block(headers_);
       headers_frame.set_fin(fin);
-      frame.reset(framer_.SerializeFrame(headers_frame));
+      frame = framer_->SerializeFrame(headers_frame);
     }
     EXPECT_CALL(session_, OnStreamHeaders(stream_id, _));
     EXPECT_CALL(session_,
-                OnStreamHeadersComplete(stream_id, fin, frame->size()));
-    stream_frame_.frame_buffer = frame->data();
-    stream_frame_.frame_length = frame->size();
+                OnStreamHeadersComplete(stream_id, fin, frame.size()));
+    stream_frame_.frame_buffer = frame.data();
+    stream_frame_.frame_length = frame.size();
     headers_stream_->OnStreamFrame(stream_frame_);
     connection_->AdvanceTime(QuicTime::Delta::FromMilliseconds(1));
-    stream_frame_.offset += frame->size();
+    stream_frame_.offset += frame.size();
   }
 }
 
@@ -451,7 +419,7 @@ TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) {
   QuicStreamId stream_id;
   bool fin = true;
   QuicStreamFrame stream_frames[10];
-  scoped_ptr<SpdySerializedFrame> frames[10];
+  SpdySerializedFrame frames[10];
   // First create all the frames in order
   {
     InSequence seq;
@@ -462,21 +430,21 @@ TEST_P(QuicHeadersStreamTest, NonEmptyHeaderHOLBlockedTime) {
         headers_frame.set_header_block(headers_);
         headers_frame.set_fin(fin);
         headers_frame.set_has_priority(true);
-        frames[stream_num].reset(framer_.SerializeFrame(headers_frame));
+        frames[stream_num] = framer_->SerializeFrame(headers_frame);
         EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0)).Times(1);
       } else {
         SpdyHeadersIR headers_frame(stream_id);
         headers_frame.set_header_block(headers_);
         headers_frame.set_fin(fin);
-        frames[stream_num].reset(framer_.SerializeFrame(headers_frame));
+        frames[stream_num] = framer_->SerializeFrame(headers_frame);
       }
       stream_frames[stream_num].stream_id = stream_frame_.stream_id;
       stream_frames[stream_num].offset = stream_frame_.offset;
-      stream_frames[stream_num].frame_buffer = frames[stream_num]->data();
-      stream_frames[stream_num].frame_length = frames[stream_num]->size();
+      stream_frames[stream_num].frame_buffer = frames[stream_num].data();
+      stream_frames[stream_num].frame_length = frames[stream_num].size();
       DVLOG(1) << "make frame for stream " << stream_num << " offset "
                << stream_frames[stream_num].offset;
-      stream_frame_.offset += frames[stream_num]->size();
+      stream_frame_.offset += frames[stream_num].size();
       EXPECT_CALL(session_, OnStreamHeaders(stream_id, _)).Times(1);
       EXPECT_CALL(session_, OnStreamHeadersComplete(stream_id, fin, _))
           .Times(1);
@@ -506,29 +474,29 @@ TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
     for (bool fin : {false, true}) {
       for (SpdyPriority priority = 0; priority < 7; ++priority) {
         // Replace with "WriteHeadersAndSaveData"
-        scoped_ptr<SpdySerializedFrame> frame;
+        SpdySerializedFrame frame;
         if (perspective() == Perspective::IS_SERVER) {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
           headers_frame.set_has_priority(true);
-          frame.reset(framer_.SerializeFrame(headers_frame));
+          frame = framer_->SerializeFrame(headers_frame);
           EXPECT_CALL(session_, OnStreamHeadersPriority(stream_id, 0));
         } else {
           SpdyHeadersIR headers_frame(stream_id);
           headers_frame.set_header_block(headers_);
           headers_frame.set_fin(fin);
-          frame.reset(framer_.SerializeFrame(headers_frame));
+          frame = framer_->SerializeFrame(headers_frame);
         }
         EXPECT_CALL(session_, OnStreamHeaders(stream_id, _))
             .WillRepeatedly(WithArgs<1>(Invoke(
                 this, &QuicHeadersStreamTest::SaveHeaderDataStringPiece)));
         EXPECT_CALL(session_,
-                    OnStreamHeadersComplete(stream_id, fin, frame->size()));
-        stream_frame_.frame_buffer = frame->data();
-        stream_frame_.frame_length = frame->size();
+                    OnStreamHeadersComplete(stream_id, fin, frame.size()));
+        stream_frame_.frame_buffer = frame.data();
+        stream_frame_.frame_length = frame.size();
         headers_stream_->OnStreamFrame(stream_frame_);
-        stream_frame_.offset += frame->size();
+        stream_frame_.offset += frame.size();
         CheckHeaders();
       }
     }
@@ -537,8 +505,8 @@ TEST_P(QuicHeadersStreamTest, ProcessLargeRawData) {
 
 TEST_P(QuicHeadersStreamTest, ProcessBadData) {
   const char kBadData[] = "blah blah blah";
-  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
-                                QUIC_INVALID_HEADERS_STREAM_DATA, _))
+  EXPECT_CALL(*connection_,
+              CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA, _, _))
       .Times(::testing::AnyNumber());
   stream_frame_.frame_buffer = kBadData;
   stream_frame_.frame_length = strlen(kBadData);
@@ -547,80 +515,76 @@ TEST_P(QuicHeadersStreamTest, ProcessBadData) {
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdyDataFrame) {
   SpdyDataIR data(2, "");
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
-  EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                             "SPDY DATA frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "SPDY DATA frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdyRstStreamFrame) {
   SpdyRstStreamIR data(2, RST_STREAM_PROTOCOL_ERROR);
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
   EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                             "SPDY RST_STREAM frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+              CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                              "SPDY RST_STREAM frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdySettingsFrame) {
   SpdySettingsIR data;
   data.AddSetting(SETTINGS_HEADER_TABLE_SIZE, true, true, 0);
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
-  EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                             "SPDY SETTINGS frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "SPDY SETTINGS frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdyPingFrame) {
   SpdyPingIR data(1);
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
-  EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                             "SPDY PING frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "SPDY PING frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdyGoAwayFrame) {
   SpdyGoAwayIR data(1, GOAWAY_PROTOCOL_ERROR, "go away");
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
-  EXPECT_CALL(*connection_,
-              SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
-                                             "SPDY GOAWAY frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                                            "SPDY GOAWAY frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }
 
 TEST_P(QuicHeadersStreamTest, ProcessSpdyWindowUpdateFrame) {
   SpdyWindowUpdateIR data(1, 1);
-  scoped_ptr<SpdySerializedFrame> frame(framer_.SerializeFrame(data));
-  EXPECT_CALL(*connection_, SendConnectionCloseWithDetails(
-                                QUIC_INVALID_HEADERS_STREAM_DATA,
-                                "SPDY WINDOW_UPDATE frame received."))
-      .WillOnce(
-          InvokeWithoutArgs(this, &QuicHeadersStreamTest::CloseConnection));
-  stream_frame_.frame_buffer = frame->data();
-  stream_frame_.frame_length = frame->size();
+  SpdySerializedFrame frame(framer_->SerializeFrame(data));
+  EXPECT_CALL(*connection_,
+              CloseConnection(QUIC_INVALID_HEADERS_STREAM_DATA,
+                              "SPDY WINDOW_UPDATE frame received.", _))
+      .WillOnce(InvokeWithoutArgs(
+          this, &QuicHeadersStreamTest::TearDownLocalConnectionState));
+  stream_frame_.frame_buffer = frame.data();
+  stream_frame_.frame_length = frame.size();
   headers_stream_->OnStreamFrame(stream_frame_);
 }