Add HpackDecoder2.

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>
 #include <limits>
 #include <memory>
 #include <string>
+#include <tuple>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "net/quic/core/quic_flags.h"
 #include "net/spdy/hpack/hpack_constants.h"
 #include "net/spdy/mock_spdy_framer_visitor.h"
 #include "net/spdy/spdy_flags.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_frame_reader.h"
 #include "net/spdy/spdy_protocol.h"
 #include "net/spdy/spdy_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::StringPiece;
 using std::string;
 using testing::_;
 
 namespace net {
 
 namespace test {
 
@@ skipping 564 matching lines @@
   reader.ReadUInt8(&serialized_type);
   SpdyFrameType type = SpdyConstants::ParseFrameType(serialized_type);
   DCHECK_EQ(HEADERS, type);
   uint8_t flags;
   reader.ReadUInt8(&flags);
 
   return StringPiece(frame.data() + framer.GetHeadersMinimumSize(),
                      frame.size() - framer.GetHeadersMinimumSize());
 }
 
-class SpdyFramerTest : public ::testing::Test {
+enum DecoderChoice { DECODER_SELF, DECODER_NESTED };
+enum HpackChoice { HPACK_DECODER_1, HPACK_DECODER_2 };
+
+class SpdyFramerTest
+    : public ::testing::TestWithParam<std::tuple<DecoderChoice, HpackChoice>> {
  protected:
+  void SetUp() override {
+    auto param = GetParam();
+    switch (std::get<0>(param)) {
+      case DECODER_SELF:
+        FLAGS_use_nested_spdy_framer_decoder = false;
+        break;
+      case DECODER_NESTED:
+        FLAGS_use_nested_spdy_framer_decoder = true;
+        break;
+    }
+    switch (std::get<1>(param)) {
+      case HPACK_DECODER_1:
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = false;
+        break;
+      case HPACK_DECODER_2:
+        FLAGS_chromium_http2_flag_spdy_use_hpack_decoder2 = true;
+        break;
+    }
+  }
+
   void CompareFrame(const string& description,
                     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 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());
   }
 };
 
+INSTANTIATE_TEST_CASE_P(
+    SpdyFramerTests,
+    SpdyFramerTest,
+    ::testing::Combine(::testing::Values(DECODER_SELF, DECODER_NESTED),
+                       ::testing::Values(HPACK_DECODER_1, HPACK_DECODER_2)));
+
 // Test that we can encode and decode a SpdyHeaderBlock in serialized form.
-TEST_F(SpdyFramerTest, HeaderBlockInBuffer) {
+TEST_P(SpdyFramerTest, HeaderBlockInBuffer) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(reinterpret_cast<unsigned char*>(frame.data()),
                            frame.size());
 
   EXPECT_EQ(0, 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_F(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
+TEST_P(SpdyFramerTest, UndersizedHeaderBlockInBuffer) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
 
   // Encode the header block into a Headers frame.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   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 treat incoming upper-case or mixed-case header values as
 // malformed.
-TEST_F(SpdyFramerTest, RejectUpperCaseHeaderBlockValue) {
+TEST_P(SpdyFramerTest, RejectUpperCaseHeaderBlockValue) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
 
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 1);
   frame.WriteUInt32(1);
   frame.WriteStringPiece32("Name1");
   frame.WriteStringPiece32("value1");
   frame.RewriteLength(framer);
 
@@ skipping 14 matching lines @@
 
   SpdyHeaderBlock new_headers;
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers.data(), serialized_headers.size(), &new_headers));
   EXPECT_FALSE(framer.ParseHeaderBlockInBuffer(
       serialized_headers2.data(), serialized_headers2.size(), &new_headers));
 }
 
 // Test that we can encode and decode stream dependency values in a header
 // frame.
-TEST_F(SpdyFramerTest, HeaderStreamDependencyValues) {
+TEST_P(SpdyFramerTest, HeaderStreamDependencyValues) {
   SpdyFramer framer;
   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);
       SpdySerializedFrame frame(
           SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
       TestSpdyVisitor visitor;
       visitor.use_compression_ = false;
       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 frame with payload length field at the
 // advertised max size, we do not set an error in ProcessInput.
-TEST_F(SpdyFramerTest, AcceptMaxFrameSizeSetting) {
+TEST_P(SpdyFramerTest, AcceptMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with maximum allowed payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x00,        // Length: 2^14
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnDataFrameHeader(1, 1 << 14, false));
   EXPECT_CALL(visitor, OnStreamFrameData(1, _, 4));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_FALSE(framer.HasError());
 }
 
 // Test that if we receive a frame with payload length larger than the
 // advertised max size, we set an error of SPDY_INVALID_CONTROL_FRAME_SIZE.
-TEST_F(SpdyFramerTest, ExceedMaxFrameSizeSetting) {
+TEST_P(SpdyFramerTest, ExceedMaxFrameSizeSetting) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with too large payload length.
   unsigned char kH2FrameData[] = {
       0x00, 0x40, 0x01,        // Length: 2^14 + 1
       0x00,                    //   Type: HEADERS
       0x00,                    //  Flags: None
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Junk payload
   };
 
   SpdySerializedFrame frame(reinterpret_cast<char*>(kH2FrameData),
                             sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   framer.ProcessInput(frame.data(), frame.size());
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_OVERSIZED_PAYLOAD, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
-TEST_F(SpdyFramerTest, OversizedDataPaddingError) {
+TEST_P(SpdyFramerTest, OversizedDataPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
@@ skipping 14 matching lines @@
     EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   }
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA frame with padding length not larger than the
 // payload length, we do not set an error of SPDY_INVALID_PADDING
-TEST_F(SpdyFramerTest, CorrectlySizedDataPaddingNoError) {
+TEST_P(SpdyFramerTest, CorrectlySizedDataPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // DATA frame with valid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x00,                    //   Type: DATA
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
@@ skipping 14 matching lines @@
   }
 
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length larger than the
 // payload length, we set an error of SPDY_INVALID_PADDING
-TEST_F(SpdyFramerTest, OversizedHeadersPaddingError) {
+TEST_P(SpdyFramerTest, OversizedHeadersPaddingError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid padding length.
   // |kH2FrameData| has to be |unsigned char|, because Chromium on Windows uses
   // MSVC, where |char| is signed by default, which would not compile because of
   // the element exceeding 127.
   unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
@@ skipping 11 matching lines @@
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a HEADERS frame with padding length not larger
 // than the payload length, we do not set an error of SPDY_INVALID_PADDING
-TEST_F(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
+TEST_P(SpdyFramerTest, CorrectlySizedHeadersPaddingNoError) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // HEADERS frame with invalid Padding length
   char kH2FrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x08,                    //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x04,                    // PadLen: 4 trailing bytes
       0x00, 0x00, 0x00, 0x00,  // Padding
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   EXPECT_CALL(visitor, OnHeaders(1, false, 0, 0, false, false, false));
   EXPECT_CALL(visitor, OnHeaderFrameStart(1)).Times(1);
   EXPECT_EQ(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_FALSE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a DATA with stream ID zero, we signal an error
 // (but don't crash).
-TEST_F(SpdyFramerTest, DataWithStreamIdZero) {
+TEST_P(SpdyFramerTest, DataWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   const char bytes[] = "hello";
   SpdyDataIR data_ir(0, bytes);
   SpdySerializedFrame frame(framer.SerializeData(data_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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, 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_F(SpdyFramerTest, HeadersWithStreamIdZero) {
+TEST_P(SpdyFramerTest, HeadersWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyHeadersIR headers(0);
   headers.SetHeader("alpha", "beta");
   SpdySerializedFrame frame(SpdyFramerPeer::SerializeHeaders(&framer, headers));
 
   // 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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PRIORITY with stream ID zero, we signal an error
 // (but don't crash).
-TEST_F(SpdyFramerTest, PriorityWithStreamIdZero) {
+TEST_P(SpdyFramerTest, PriorityWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPriorityIR priority_ir(0, 1, 16, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error
 // (but don't crash).
-TEST_F(SpdyFramerTest, RstStreamWithStreamIdZero) {
+TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyRstStreamIR rst_stream_ir(0, RST_STREAM_PROTOCOL_ERROR);
   SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a SETTINGS with stream ID other than zero,
 // we signal an error (but don't crash).
-TEST_F(SpdyFramerTest, SettingsWithStreamIdNotZero) {
+TEST_P(SpdyFramerTest, SettingsWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // Settings frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x04,              //  Param: INITIAL_WINDOW_SIZE
       0x0a, 0x0b, 0x0c, 0x0d,  //  Value: 168496141
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // 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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a GOAWAY with stream ID other than zero,
 // we signal an error (but don't crash).
-TEST_F(SpdyFramerTest, GoawayWithStreamIdNotZero) {
+TEST_P(SpdyFramerTest, GoawayWithStreamIdNotZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // GOAWAY frame with invalid StreamID of 0x01
   char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //   Last: 0
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
       0x47, 0x41,              // Description
   };
 
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // 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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a CONTINUATION with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
-TEST_F(SpdyFramerTest, ContinuationWithStreamIdZero) {
+TEST_P(SpdyFramerTest, ContinuationWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyContinuationIR continuation(0);
   auto some_nonsense_encoding =
       base::MakeUnique<string>("some nonsense encoding");
   continuation.take_encoding(std::move(some_nonsense_encoding));
   continuation.set_end_headers(true);
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
 
   // 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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with stream ID zero, we signal an
 // SPDY_INVALID_STREAM_ID.
-TEST_F(SpdyFramerTest, PushPromiseWithStreamIdZero) {
+TEST_P(SpdyFramerTest, PushPromiseWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(0, 4);
   push_promise.SetHeader("alpha", "beta");
   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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test that if we receive a PUSH_PROMISE with promised stream ID zero, we
 // signal SPDY_INVALID_STREAM_ID.
-TEST_F(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
+TEST_P(SpdyFramerTest, PushPromiseWithPromisedStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyPushPromiseIR push_promise(3, 0);
   push_promise.SetHeader("alpha", "beta");
   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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
-TEST_F(SpdyFramerTest, DuplicateHeader) {
+TEST_P(SpdyFramerTest, DuplicateHeader) {
   SpdyFramer framer;
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS, 0, 3);
 
   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);
   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_F(SpdyFramerTest, MultiValueHeader) {
+TEST_P(SpdyFramerTest, MultiValueHeader) {
   SpdyFramer framer;
   // Frame builder with plentiful buffer size.
   SpdyFrameBuilder frame(1024);
   frame.BeginNewFrame(framer, HEADERS,
                       HEADERS_FLAG_PRIORITY | HEADERS_FLAG_END_HEADERS, 3);
   frame.WriteUInt32(0);   // Priority exclusivity and dependent stream.
   frame.WriteUInt8(255);  // Priority weight.
 
   string value("value1\0value2", 13);
   // TODO(jgraettinger): If this pattern appears again, move to test class.
@@ skipping 12 matching lines @@
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
 
   EXPECT_THAT(visitor.headers_,
               testing::ElementsAre(testing::Pair("name", StringPiece(value))));
 }
 
-TEST_F(SpdyFramerTest, CompressEmptyHeaders) {
+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;
   framer.set_enable_compression(true);
   SpdySerializedFrame frame1(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
 }
 
-TEST_F(SpdyFramerTest, Basic) {
+TEST_P(SpdyFramerTest, Basic) {
   // Send HEADERS frames with PRIORITY and END_HEADERS set.
   // frame-format off
   const unsigned char kH2Input[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x24,                    //  Flags: END_HEADERS|PRIORITY
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Parent: 0
       0x82,                    // Weight: 131
 
@@ skipping 60 matching lines @@
   EXPECT_EQ(3, visitor.headers_frame_count_);
   EXPECT_TRUE(visitor.fin_opaque_data_.empty());
 
   EXPECT_EQ(0, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(4, visitor.data_frame_count_);
   visitor.fin_opaque_data_.clear();
 }
 
 // Test that the FIN flag on a data frame signifies EOF.
-TEST_F(SpdyFramerTest, FinOnDataFrame) {
+TEST_P(SpdyFramerTest, FinOnDataFrame) {
   // Send HEADERS frames with END_HEADERS set.
   // frame-format off
   const unsigned char kH2Input[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x24,                    //  Flags: END_HEADERS|PRIORITY
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Parent: 0
       0x82,                    // Weight: 131
 
@@ skipping 24 matching lines @@
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(2, visitor.headers_frame_count_);
   EXPECT_EQ(16, 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(2, visitor.data_frame_count_);
 }
 
-TEST_F(SpdyFramerTest, FinOnHeadersFrame) {
+TEST_P(SpdyFramerTest, FinOnHeadersFrame) {
   // Send HEADERS frames with END_HEADERS set.
   // frame-format off
   const unsigned char kH2Input[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x01,                    //   Type: HEADERS
       0x24,                    //  Flags: END_HEADERS|PRIORITY
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  // Parent: 0
       0x82,                    // Weight: 131
 
@@ skipping 12 matching lines @@
   EXPECT_EQ(2, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.data_bytes_);
   EXPECT_EQ(0, visitor.fin_frame_count_);
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
 // Verify we can decompress the stream even if handed over to the
 // framer 1 byte at a time.
-TEST_F(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
+TEST_P(SpdyFramerTest, UnclosedStreamDataCompressorsOneByteAtATime) {
   SpdyFramer framer;
 
   framer.set_enable_compression(true);
 
   const char kHeader1[] = "header1";
   const char kHeader2[] = "header2";
   const char kValue1[] = "value1";
   const char kValue2[] = "value2";
 
   SpdyHeadersIR headers(1);
@@ skipping 24 matching lines @@
 
   EXPECT_EQ(0, visitor.error_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_F(SpdyFramerTest, WindowUpdateFrame) {
+TEST_P(SpdyFramerTest, WindowUpdateFrame) {
   SpdyFramer framer;
   SpdySerializedFrame frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x12345678)));
 
   const char kDescription[] = "WINDOW_UPDATE frame, stream 1, delta 0x12345678";
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x12, 0x34, 0x56, 0x78,  // Increment: 305419896
   };
 
   CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 }
 
-TEST_F(SpdyFramerTest, CreateDataFrame) {
+TEST_P(SpdyFramerTest, CreateDataFrame) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "'hello' data frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x05,        // Length: 5
         0x00,                    //   Type: DATA
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
@@ skipping 181 matching lines @@
         0x68, 0x65, 0x6c, 0x6c,  // Payload
         0x6f,                    //
     };
     SpdyDataIR data_ir(0x7fffffff, "hello");
     data_ir.set_fin(true);
     SpdySerializedFrame frame(framer.SerializeData(data_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, CreateRstStream) {
+TEST_P(SpdyFramerTest, CreateRstStream) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
@@ skipping 25 matching lines @@
         0x00,                    //  Flags: none
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
     };
     SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, CreateSettings) {
+TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
 
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x06,        // Length: 6
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
@@ skipping 63 matching lines @@
         0x04,                    //   Type: SETTINGS
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
     };
     SpdySettingsIR settings_ir;
     SpdySerializedFrame frame(framer.SerializeSettings(settings_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, CreatePingFrame) {
+TEST_P(SpdyFramerTest, CreatePingFrame) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "PING frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x08,        // Length: 8
         0x06,                    //   Type: PING
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x12, 0x34, 0x56, 0x78,  // Opaque
@@ skipping 16 matching lines @@
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
 
     // Tests SpdyPingIR when the ping is an ack.
     ping_ir.set_is_ack(true);
     frame = framer.SerializePing(ping_ir);
     CompareFrame(kDescription, frame, kH2FrameDataWithAck,
                  arraysize(kH2FrameDataWithAck));
   }
 }
 
-TEST_F(SpdyFramerTest, CreateGoAway) {
+TEST_P(SpdyFramerTest, CreateGoAway) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x0a,        // Length: 10
         0x07,                    //   Type: GOAWAY
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x00, 0x00, 0x00,  //   Last: 0
@@ skipping 15 matching lines @@
         0x7f, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
         0x47, 0x41,              // Description
     };
     SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, CreateHeadersUncompressed) {
+TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
     // frame-format off
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x12,        // Length: 18
         0x01,                    //   Type: HEADERS
         0x04,                    //  Flags: END_HEADERS
@@ skipping 231 matching lines @@
     headers_ir.set_padding_len(6);
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     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_F(SpdyFramerTest, CreateHeadersCompressed) {
+TEST_P(SpdyFramerTest, CreateHeadersCompressed) {
   SpdyFramer framer;
   framer.set_enable_compression(true);
 
   {
     SpdyHeadersIR headers_ir(1);
     headers_ir.SetHeader("bar", "foo");
     headers_ir.SetHeader("foo", "bar");
     SpdySerializedFrame frame(
         SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
     // Deflate compression doesn't apply to HPACK.
   }
 }
 #endif  // !defined(USE_SYSTEM_ZLIB)
 
-TEST_F(SpdyFramerTest, CreateWindowUpdate) {
+TEST_P(SpdyFramerTest, CreateWindowUpdate) {
   SpdyFramer framer;
 
   {
     const char kDescription[] = "WINDOW_UPDATE frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x08,                    //   Type: WINDOW_UPDATE
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  // Increment: 1
@@ skipping 25 matching lines @@
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x7f, 0xff, 0xff, 0xff,  // Increment: 0x7fffffff
     };
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 0x7FFFFFFF)));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, SerializeBlocked) {
+TEST_P(SpdyFramerTest, SerializeBlocked) {
   SpdyFramer framer;
 
   const char kDescription[] = "BLOCKED frame";
   const unsigned char kType =
       static_cast<unsigned char>(SpdyConstants::SerializeFrameType(BLOCKED));
   const unsigned char kFrameData[] = {
       0x00,  0x00, 0x00,        // Length: 0
       kType,                    //   Type: BLOCKED
       0x00,                     //  Flags: none
       0x00,  0x00, 0x00, 0x00,  // Stream: 0
   };
   SpdyBlockedIR blocked_ir(0);
   SpdySerializedFrame frame(framer.SerializeFrame(blocked_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
-TEST_F(SpdyFramerTest, CreateBlocked) {
+TEST_P(SpdyFramerTest, CreateBlocked) {
   SpdyFramer framer;
 
   const char kDescription[] = "BLOCKED frame";
   const SpdyStreamId kStreamId = 3;
 
   SpdySerializedFrame frame_serialized(
       framer.SerializeBlocked(SpdyBlockedIR(kStreamId)));
   SpdyBlockedIR blocked_ir(kStreamId);
   SpdySerializedFrame frame_created(framer.SerializeFrame(blocked_ir));
 
   CompareFrames(kDescription, frame_serialized, frame_created);
 }
 
-TEST_F(SpdyFramerTest, CreatePushPromiseUncompressed) {
+TEST_P(SpdyFramerTest, CreatePushPromiseUncompressed) {
   {
     // Test framing PUSH_PROMISE without padding.
     SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] = "PUSH_PROMISE frame without padding";
 
     // frame-format off
     const unsigned char kFrameData[] = {
         0x00, 0x00, 0x16,        // Length: 22
         0x05,                    //   Type: PUSH_PROMISE
@@ skipping 111 matching lines @@
     SpdyPushPromiseIR push_promise(42, 57);
     push_promise.set_padding_len(177);
     push_promise.SetHeader("bar", "foo");
     push_promise.SetHeader("foo", "bar");
     SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
     CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   }
 }
 
 // Regression test for https://crbug.com/464748.
-TEST_F(SpdyFramerTest, GetNumberRequiredContinuationFrames) {
+TEST_P(SpdyFramerTest, GetNumberRequiredContinuationFrames) {
   SpdyFramer framer;
   EXPECT_EQ(1u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 16374 + 1));
   EXPECT_EQ(2u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374));
   EXPECT_EQ(3u, SpdyFramerPeer::GetNumberRequiredContinuationFrames(
                     &framer, 16383 + 2 * 16374 + 1));
 }
 
-TEST_F(SpdyFramerTest, CreateContinuationUncompressed) {
+TEST_P(SpdyFramerTest, CreateContinuationUncompressed) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
   const char kDescription[] = "CONTINUATION frame";
 
   // frame-format off
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
@@ skipping 22 matching lines @@
   SpdyContinuationIR continuation(42);
   continuation.take_encoding(std::move(buffer));
   continuation.set_end_headers(true);
 
   SpdySerializedFrame frame(framer.SerializeContinuation(continuation));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
 // Test that if we send an unexpected CONTINUATION
 // we signal an error (but don't crash).
-TEST_F(SpdyFramerTest, SendUnexpectedContinuation) {
+TEST_P(SpdyFramerTest, SendUnexpectedContinuation) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   // frame-format off
   char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x09,                    //   Type: CONTINUATION
       0x04,                    //  Flags: END_HEADERS
       0x00, 0x00, 0x00, 0x2a,  // Stream: 42
@@ skipping 15 matching lines @@
   SpdySerializedFrame frame(kH2FrameData, sizeof(kH2FrameData), false);
 
   // 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_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
-TEST_F(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) {
+TEST_P(SpdyFramerTest, CreatePushPromiseThenContinuationUncompressed) {
   {
     // 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
     // consecutive CONTINUATION frame.
     SpdyFramer framer;
     framer.set_enable_compression(false);
     const char kDescription[] =
         "PUSH_PROMISE and CONTINUATION frames with one byte of padding";
 
     // frame-format off
@@ skipping 80 matching lines @@
         kPartialPushPromiseFrameData, arraysize(kPartialPushPromiseFrameData));
 
     // Compare the CONTINUATION frame against the template.
     frame_data += TestSpdyVisitor::sent_control_frame_max_size();
     CompareCharArraysWithHexError(
         kDescription, frame_data, arraysize(kContinuationFrameData),
         kContinuationFrameData, arraysize(kContinuationFrameData));
   }
 }
 
-TEST_F(SpdyFramerTest, CreateAltSvc) {
+TEST_P(SpdyFramerTest, CreateAltSvc) {
   SpdyFramer framer;
 
   const char kDescription[] = "ALTSVC frame";
   const char kType =
       static_cast<unsigned char>(SpdyConstants::SerializeFrameType(ALTSVC));
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x49, kType, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x06, 'o',
       'r',  'i',  'g',  'i',   'n',  'p',  'i',  'd',  '1',  '=',  '"',  'h',
       'o',  's',  't',  ':',   '4',  '4',  '3',  '"',  ';',  ' ',  'm',  'a',
       '=',  '5',  ',',  'p',   '%',  '2',  '2',  '%',  '3',  'D',  'i',  '%',
       '3',  'A',  'd',  '=',   '"',  'h',  '_',  '\\', '\\', 'o',  '\\', '"',
       's',  't',  ':',  '1',   '2',  '3',  '"',  ';',  ' ',  'm',  'a',  '=',
       '4',  '2',  ';',  ' ',   'v',  '=',  '"',  '2',  '4',  '"'};
   SpdyAltSvcIR altsvc_ir(3);
   altsvc_ir.set_origin("origin");
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "p\"=i:d", "h_\\o\"st", 123, 42,
       SpdyAltSvcWireFormat::VersionVector{24}));
   SpdySerializedFrame frame(framer.SerializeFrame(altsvc_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
-TEST_F(SpdyFramerTest, CreatePriority) {
+TEST_P(SpdyFramerTest, CreatePriority) {
   SpdyFramer framer;
 
   const char kDescription[] = "PRIORITY frame";
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x05,        // Length: 5
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x02,  // Stream: 2
       0x80, 0x00, 0x00, 0x01,  // Parent: 1 (Exclusive)
       0x10,                    // Weight: 17
   };
   SpdyPriorityIR priority_ir(2, 1, 17, true);
   SpdySerializedFrame frame(framer.SerializeFrame(priority_ir));
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
   SpdyPriorityIR priority2(2);
   priority2.set_parent_stream_id(1);
   priority2.set_weight(17);
   priority2.set_exclusive(true);
   frame = framer.SerializeFrame(priority2);
   CompareFrame(kDescription, frame, kFrameData, arraysize(kFrameData));
 }
 
-TEST_F(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
+TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlock) {
   SpdyFramer framer;
   SpdyHeadersIR headers_ir(1);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
-TEST_F(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
+TEST_P(SpdyFramerTest, ReadCompressedHeadersHeaderBlockWithHalfClose) {
   SpdyFramer framer;
   SpdyHeadersIR headers_ir(1);
   headers_ir.set_fin(true);
   headers_ir.SetHeader("alpha", "beta");
   headers_ir.SetHeader("gamma", "delta");
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers_ir));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
   EXPECT_EQ(headers_ir.header_block(), visitor.headers_);
 }
 
-TEST_F(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
+TEST_P(SpdyFramerTest, TooLargeHeadersFrameUsesContinuation) {
   SpdyFramer framer;
   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);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       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(0, visitor.zero_length_control_frame_header_data_count_);
 }
 
-TEST_F(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
+TEST_P(SpdyFramerTest, MultipleContinuationFramesWithIterator) {
   SpdyFramer framer;
   framer.set_enable_compression(false);
   auto headers = base::MakeUnique<SpdyHeadersIR>(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_valuex(kBigValueSize, 'x');
   headers->SetHeader("aa", big_valuex);
@@ skipping 41 matching lines @@
       second_cont_frame.size());
   EXPECT_TRUE(visitor.header_buffer_valid_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
 
   EXPECT_FALSE(frame_it.HasNextFrame());
 }
 
-TEST_F(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
+TEST_P(SpdyFramerTest, TooLargePushPromiseFrameUsesContinuation) {
   SpdyFramer framer;
   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);
   SpdySerializedFrame control_frame(framer.SerializePushPromise(push_promise));
   EXPECT_GT(control_frame.size(),
             TestSpdyVisitor::sent_control_frame_max_size());
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       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(0, 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_F(SpdyFramerTest, ControlFrameMuchTooLarge) {
+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;
   SpdyHeadersIR headers(1);
   headers.set_fin(true);
   headers.SetHeader("aa", big_value);
   SpdySerializedFrame control_frame(
       SpdyFramerPeer::SerializeHeaders(&framer, headers));
   TestSpdyVisitor visitor;
   visitor.set_header_buffer_size(kHeaderBufferSize);
   visitor.use_compression_ = true;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       control_frame.size());
   // It's up to the visitor to ignore extraneous header data; the framer
   // won't throw an error.
   EXPECT_GT(visitor.header_bytes_received_, visitor.header_buffer_size_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 }
 
-TEST_F(SpdyFramerTest, ControlFrameSizesAreValidated) {
+TEST_P(SpdyFramerTest, ControlFrameSizesAreValidated) {
   SpdyFramer framer;
   // 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.
   ASSERT_LE(SpdyFramerPeer::ControlFrameBufferSize(), 250u);
   const size_t length = SpdyFramerPeer::ControlFrameBufferSize() + 1;
 
   // HTTP/2 GOAWAY frames are only bound by a minimal length, since they may
   // carry opaque data. Verify that minimal length is tested.
   ASSERT_GT(framer.GetGoAwayMinimumSize(), SpdyConstants::kFrameHeaderSize);
   const size_t less_than_min_length =
@@ skipping 17 matching lines @@
   visitor.SimulateInFramer(reinterpret_cast<const unsigned char*>(pad.c_str()),
                            pad.length());
 
   EXPECT_EQ(1, visitor.error_count_);  // This generated an error.
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.goaway_count_);  // Frame not parsed.
 }
 
-TEST_F(SpdyFramerTest, ReadZeroLenSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadZeroLenSettingsFrame) {
   SpdyFramer framer;
   SpdySettingsIR settings_ir;
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   SetFrameLength(&control_frame, 0);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize());
   // 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_F(SpdyFramerTest, ReadBogusLenSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadBogusLenSettingsFrame) {
   SpdyFramer framer;
   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);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   const size_t kNewLength = 14;
   SetFrameLength(&control_frame, kNewLength);
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(control_frame.data()),
       framer.GetFrameHeaderSize() + kNewLength);
   // Should generate an error, since its not possible to have a
   // settings frame of length kNewLength.
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of SETTINGS frames larger than the frame buffer size.
-TEST_F(SpdyFramerTest, ReadLargeSettingsFrame) {
+TEST_P(SpdyFramerTest, ReadLargeSettingsFrame) {
   SpdyFramer framer;
   SpdySettingsIR settings_ir;
   settings_ir.AddSetting(SETTINGS_HEADER_TABLE_SIZE,
                          false,  // persist
                          false,  // persisted
                          5);
   settings_ir.AddSetting(SETTINGS_ENABLE_PUSH,
                          false,  // persist
                          false,  // persisted
                          6);
@@ skipping 26 matching lines @@
         to_read);
     unframed_data -= to_read;
     framed_data += to_read;
   }
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(3 * 2, visitor.setting_count_);
   EXPECT_EQ(2, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with duplicate entries.
-TEST_F(SpdyFramerTest, ReadDuplicateSettings) {
+TEST_P(SpdyFramerTest, ReadDuplicateSettings) {
   SpdyFramer framer;
 
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, duplicate settings are allowed;
   // each setting replaces the previous value for that setting.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.settings_ack_sent_);
 }
 
 // Tests handling of SETTINGS frame with a setting we don't recognize.
-TEST_F(SpdyFramerTest, ReadUnknownSettingsId) {
+TEST_P(SpdyFramerTest, ReadUnknownSettingsId) {
   SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x06,        // Length: 6
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x10,              //  Param: 16
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
   };
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, we ignore unknown settings because of extensions.
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
 // Tests handling of SETTINGS frame with entries out of order.
-TEST_F(SpdyFramerTest, ReadOutOfOrderSettings) {
+TEST_P(SpdyFramerTest, ReadOutOfOrderSettings) {
   SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x12,        // Length: 18
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x02,              //  Param: ENABLE_PUSH
       0x00, 0x00, 0x00, 0x02,  //  Value: 2
       0x00, 0x01,              //  Param: HEADER_TABLE_SIZE
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
       0x00, 0x03,              //  Param: MAX_CONCURRENT_STREAMS
       0x00, 0x00, 0x00, 0x03,  //  Value: 3
   };
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kH2FrameData, sizeof(kH2FrameData));
 
   // In HTTP/2, settings are allowed in any order.
   EXPECT_EQ(3, visitor.setting_count_);
   EXPECT_EQ(0, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerTest, ProcessSettingsAckFrame) {
+TEST_P(SpdyFramerTest, ProcessSettingsAckFrame) {
   SpdyFramer framer;
 
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x00,        // Length: 0
       0x04,                    //   Type: SETTINGS
       0x01,                    //  Flags: ACK
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
   };
 
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(0, visitor.setting_count_);
   EXPECT_EQ(1, visitor.settings_ack_received_);
 }
 
-TEST_F(SpdyFramerTest, ProcessDataFrameWithPadding) {
+TEST_P(SpdyFramerTest, ProcessDataFrameWithPadding) {
   const int kPaddingLen = 119;
   const char data_payload[] = "hello";
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyDataIR data_ir(1, data_payload);
   data_ir.set_padding_len(kPaddingLen);
   SpdySerializedFrame frame(framer.SerializeData(data_ir));
@@ skipping 37 matching lines @@
   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(framer.state(), SpdyFramer::SPDY_READY_FOR_FRAME);
   CHECK_EQ(framer.error_code(), SpdyFramer::SPDY_NO_ERROR);
 }
 
-TEST_F(SpdyFramerTest, ReadWindowUpdate) {
+TEST_P(SpdyFramerTest, ReadWindowUpdate) {
   SpdyFramer framer;
   SpdySerializedFrame control_frame(
       framer.SerializeWindowUpdate(SpdyWindowUpdateIR(1, 2)));
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(
       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_F(SpdyFramerTest, ReadCompressedPushPromise) {
+TEST_P(SpdyFramerTest, ReadCompressedPushPromise) {
   SpdyFramer framer;
   SpdyPushPromiseIR push_promise(42, 57);
   push_promise.SetHeader("foo", "bar");
   push_promise.SetHeader("bar", "foofoo");
   SpdySerializedFrame frame(framer.SerializePushPromise(push_promise));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = true;
   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(push_promise.header_block(), visitor.headers_);
 }
 
-TEST_F(SpdyFramerTest, ReadHeadersWithContinuation) {
+TEST_P(SpdyFramerTest, ReadHeadersWithContinuation) {
   // frame-format off
   const unsigned char kInput[] = {
       0x00, 0x00, 0x14,                       // Length: 20
       0x01,                                   //   Type: HEADERS
       0x08,                                   //  Flags: PADDED
       0x00, 0x00, 0x00, 0x01,                 // Stream: 1
       0x03,                                   // PadLen: 3 trailing bytes
       0x00,                                   // Unindexed Entry
       0x06,                                   // Name Len: 6
       'c',  'o',  'o',  'k',  'i', 'e',       // Name
@@ skipping 37 matching lines @@
   EXPECT_EQ(2, visitor.continuation_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
       visitor.headers_,
       testing::ElementsAre(testing::Pair("cookie", "foo=bar; baz=bing; "),
                            testing::Pair("name", "value")));
 }
 
-TEST_F(SpdyFramerTest, ReadHeadersWithContinuationAndFin) {
+TEST_P(SpdyFramerTest, ReadHeadersWithContinuationAndFin) {
   // frame-format off
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,                       // Length: 20
       0x01,                                   //   Type: HEADERS
       0x01,                                   //  Flags: END_STREAM
       0x00, 0x00, 0x00, 0x01,                 // Stream: 1
       0x00,                                   // Unindexed Entry
       0x06,                                   // Name Len: 6
       'c',  'o',  'o',  'k',  'i', 'e',       // Name
       0x07,                                   // Value Len: 7
@@ skipping 36 matching lines @@
   EXPECT_EQ(1, visitor.fin_flag_count_);
   EXPECT_EQ(0, visitor.zero_length_control_frame_header_data_count_);
   EXPECT_EQ(1, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
       visitor.headers_,
       testing::ElementsAre(testing::Pair("cookie", "foo=bar; baz=bing; "),
                            testing::Pair("name", "value")));
 }
 
-TEST_F(SpdyFramerTest, ReadPushPromiseWithContinuation) {
+TEST_P(SpdyFramerTest, ReadPushPromiseWithContinuation) {
   // frame-format off
   const unsigned char kInput[] = {
     0x00, 0x00, 0x17, 0x05,  // PUSH_PROMISE
     0x08, 0x00, 0x00, 0x00,  // PADDED
     0x01, 0x02, 0x00, 0x00,  // Stream 1, Pad length field
     0x00, 0x2A, 0x00, 0x06,  // Promised stream 42
     'c',  'o',  'o',  'k',
     'i',  'e',  0x07, 'f',
     'o',  'o',  '=',  'b',
     'a',  'r',  0x00, 0x00,
@@ skipping 29 matching lines @@
   EXPECT_EQ(0, visitor.end_of_stream_count_);
 
   EXPECT_THAT(
       visitor.headers_,
       testing::ElementsAre(testing::Pair("cookie", "foo=bar; baz=bing; "),
                            testing::Pair("name", "value")));
 }
 
 // Receiving an unknown frame when a continuation is expected should
 // result in a SPDY_UNEXPECTED_FRAME error
-TEST_F(SpdyFramerTest, ReceiveUnknownMidContinuation) {
+TEST_P(SpdyFramerTest, ReceiveUnknownMidContinuation) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
@@ skipping 16 matching lines @@
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
-TEST_F(SpdyFramerTest, ReceiveContinuationOnWrongStream) {
+TEST_P(SpdyFramerTest, ReceiveContinuationOnWrongStream) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
@@ skipping 14 matching lines @@
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
-TEST_F(SpdyFramerTest, ReadContinuationOutOfOrder) {
+TEST_P(SpdyFramerTest, ReadContinuationOutOfOrder) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x18,        // Length: 24
       0x09,                    //   Type: CONTINUATION
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
   };
 
   SpdyFramer framer;
   TestSpdyVisitor visitor;
   framer.set_visitor(&visitor);
   visitor.SimulateInFramer(kInput, sizeof(kInput));
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
 }
 
-TEST_F(SpdyFramerTest, ExpectContinuationReceiveData) {
+TEST_P(SpdyFramerTest, ExpectContinuationReceiveData) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
@@ skipping 12 matching lines @@
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
-TEST_F(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
+TEST_P(SpdyFramerTest, ExpectContinuationReceiveControlFrame) {
   const unsigned char kInput[] = {
       0x00, 0x00, 0x10,        // Length: 16
       0x01,                    //   Type: HEADERS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x06, 0x63, 0x6f,  // HPACK
       0x6f, 0x6b, 0x69, 0x65,  //
       0x07, 0x66, 0x6f, 0x6f,  //
       0x3d, 0x62, 0x61, 0x72,  //
 
@@ skipping 14 matching lines @@
 
   EXPECT_EQ(1, visitor.error_count_);
   EXPECT_EQ(SpdyFramer::SPDY_UNEXPECTED_FRAME, visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
   EXPECT_EQ(1, visitor.headers_frame_count_);
   EXPECT_EQ(0, visitor.continuation_count_);
   EXPECT_EQ(0u, visitor.header_buffer_length_);
   EXPECT_EQ(0, visitor.data_frame_count_);
 }
 
-TEST_F(SpdyFramerTest, ReadGarbage) {
+TEST_P(SpdyFramerTest, ReadGarbage) {
   SpdyFramer framer;
   unsigned char garbage_frame[256];
   memset(garbage_frame, ~0, sizeof(garbage_frame));
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(garbage_frame, sizeof(garbage_frame));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerTest, ReadUnknownExtensionFrame) {
+TEST_P(SpdyFramerTest, ReadUnknownExtensionFrame) {
   SpdyFramer framer;
 
   // The unrecognized frame type should still have a valid length.
   const unsigned char unknown_frame[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
@@ skipping 15 matching lines @@
                          10);
   SpdySerializedFrame control_frame(framer.SerializeSettings(settings_ir));
   visitor.SimulateInFramer(
       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_F(SpdyFramerTest, ReadGarbageWithValidLength) {
+TEST_P(SpdyFramerTest, ReadGarbageWithValidLength) {
   SpdyFramer framer;
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0xff,                    //   Type: UnknownFrameType(255)
       0xff,                    //  Flags: 0xff
       0xff, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff (R-bit set)
       0xff, 0xff, 0xff, 0xff,  // Payload
       0xff, 0xff, 0xff, 0xff,  //
   };
   TestSpdyVisitor visitor;
   visitor.use_compression_ = false;
   visitor.SimulateInFramer(kFrameData, arraysize(kFrameData));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerTest, ReadGarbageHPACKEncoding) {
+TEST_P(SpdyFramerTest, ReadGarbageHPACKEncoding) {
   const unsigned char kInput[] = {
       0x00, 0x12, 0x01,        // Length: 4609
       0x04,                    //   Type: SETTINGS
       0x00,                    //  Flags: none
       0x00, 0x00, 0x01, 0xef,  // Stream: 495
       0xef, 0xff,              //  Param: 61439
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff,              //  Param: 0xffff
       0xff, 0xff, 0xff, 0xff,  //  Value: 4294967295
       0xff, 0xff, 0xff, 0xff,  // Settings (Truncated)
       0xff,                    //
   };
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kInput, arraysize(kInput));
   EXPECT_EQ(1, visitor.error_count_);
 }
 
-TEST_F(SpdyFramerTest, SizesTest) {
+TEST_P(SpdyFramerTest, SizesTest) {
   SpdyFramer framer;
   EXPECT_EQ(9u, framer.GetDataFrameMinimumSize());
   EXPECT_EQ(9u, framer.GetFrameHeaderSize());
   EXPECT_EQ(13u, framer.GetRstStreamMinimumSize());
   EXPECT_EQ(9u, framer.GetSettingsMinimumSize());
   EXPECT_EQ(17u, framer.GetPingSize());
   EXPECT_EQ(17u, framer.GetGoAwayMinimumSize());
   EXPECT_EQ(9u, framer.GetHeadersMinimumSize());
   EXPECT_EQ(13u, framer.GetWindowUpdateSize());
   EXPECT_EQ(9u, framer.GetBlockedSize());
   EXPECT_EQ(13u, framer.GetPushPromiseMinimumSize());
   EXPECT_EQ(11u, framer.GetAltSvcMinimumSize());
   EXPECT_EQ(9u, framer.GetFrameMinimumSize());
   EXPECT_EQ(16393u, framer.GetFrameMaximumSize());
   EXPECT_EQ(16384u, framer.GetDataFrameMaximumPayload());
 }
 
-TEST_F(SpdyFramerTest, StateToStringTest) {
+TEST_P(SpdyFramerTest, StateToStringTest) {
   EXPECT_STREQ("ERROR", SpdyFramer::StateToString(SpdyFramer::SPDY_ERROR));
   EXPECT_STREQ("FRAME_COMPLETE",
                SpdyFramer::StateToString(SpdyFramer::SPDY_FRAME_COMPLETE));
   EXPECT_STREQ("READY_FOR_FRAME",
                SpdyFramer::StateToString(SpdyFramer::SPDY_READY_FOR_FRAME));
   EXPECT_STREQ(
       "READING_COMMON_HEADER",
       SpdyFramer::StateToString(SpdyFramer::SPDY_READING_COMMON_HEADER));
   EXPECT_STREQ(
       "CONTROL_FRAME_PAYLOAD",
@@ skipping 13 matching lines @@
   EXPECT_STREQ(
       "SPDY_SETTINGS_FRAME_PAYLOAD",
       SpdyFramer::StateToString(SpdyFramer::SPDY_SETTINGS_FRAME_PAYLOAD));
   EXPECT_STREQ(
       "SPDY_ALTSVC_FRAME_PAYLOAD",
       SpdyFramer::StateToString(SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD));
   EXPECT_STREQ("UNKNOWN_STATE", SpdyFramer::StateToString(
                                     SpdyFramer::SPDY_ALTSVC_FRAME_PAYLOAD + 1));
 }
 
-TEST_F(SpdyFramerTest, ErrorCodeToStringTest) {
+TEST_P(SpdyFramerTest, ErrorCodeToStringTest) {
   EXPECT_STREQ("NO_ERROR",
                SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_NO_ERROR));
   EXPECT_STREQ("INVALID_STREAM_ID", SpdyFramer::ErrorCodeToString(
                                         SpdyFramer::SPDY_INVALID_STREAM_ID));
   EXPECT_STREQ(
       "INVALID_CONTROL_FRAME",
       SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
   EXPECT_STREQ("CONTROL_PAYLOAD_TOO_LARGE",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_CONTROL_PAYLOAD_TOO_LARGE));
@@ skipping 14 matching lines @@
   EXPECT_STREQ(
       "SPDY_INVALID_DATA_FRAME_FLAGS",
       SpdyFramer::ErrorCodeToString(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS));
   EXPECT_STREQ("SPDY_INVALID_CONTROL_FRAME_FLAGS",
                SpdyFramer::ErrorCodeToString(
                    SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS));
   EXPECT_STREQ("UNKNOWN_ERROR",
                SpdyFramer::ErrorCodeToString(SpdyFramer::LAST_ERROR));
 }
 
-TEST_F(SpdyFramerTest, StatusCodeToStringTest) {
+TEST_P(SpdyFramerTest, StatusCodeToStringTest) {
   EXPECT_STREQ("NO_ERROR", SpdyFramer::StatusCodeToString(RST_STREAM_NO_ERROR));
   EXPECT_STREQ("PROTOCOL_ERROR",
                SpdyFramer::StatusCodeToString(RST_STREAM_PROTOCOL_ERROR));
   EXPECT_STREQ("INVALID_STREAM",
                SpdyFramer::StatusCodeToString(RST_STREAM_INVALID_STREAM));
   EXPECT_STREQ("REFUSED_STREAM",
                SpdyFramer::StatusCodeToString(RST_STREAM_REFUSED_STREAM));
   EXPECT_STREQ("UNSUPPORTED_VERSION",
                SpdyFramer::StatusCodeToString(RST_STREAM_UNSUPPORTED_VERSION));
   EXPECT_STREQ("CANCEL", SpdyFramer::StatusCodeToString(RST_STREAM_CANCEL));
   EXPECT_STREQ("INTERNAL_ERROR",
                SpdyFramer::StatusCodeToString(RST_STREAM_INTERNAL_ERROR));
   EXPECT_STREQ("FLOW_CONTROL_ERROR",
                SpdyFramer::StatusCodeToString(RST_STREAM_FLOW_CONTROL_ERROR));
   EXPECT_STREQ("UNKNOWN_STATUS", SpdyFramer::StatusCodeToString(-1));
 }
 
-TEST_F(SpdyFramerTest, FrameTypeToStringTest) {
+TEST_P(SpdyFramerTest, FrameTypeToStringTest) {
   EXPECT_STREQ("DATA", SpdyFramer::FrameTypeToString(DATA));
   EXPECT_STREQ("RST_STREAM", SpdyFramer::FrameTypeToString(RST_STREAM));
   EXPECT_STREQ("SETTINGS", SpdyFramer::FrameTypeToString(SETTINGS));
   EXPECT_STREQ("PING", SpdyFramer::FrameTypeToString(PING));
   EXPECT_STREQ("GOAWAY", SpdyFramer::FrameTypeToString(GOAWAY));
   EXPECT_STREQ("HEADERS", SpdyFramer::FrameTypeToString(HEADERS));
   EXPECT_STREQ("WINDOW_UPDATE", SpdyFramer::FrameTypeToString(WINDOW_UPDATE));
   EXPECT_STREQ("PUSH_PROMISE", SpdyFramer::FrameTypeToString(PUSH_PROMISE));
   EXPECT_STREQ("CONTINUATION", SpdyFramer::FrameTypeToString(CONTINUATION));
 }
 
-TEST_F(SpdyFramerTest, DataFrameFlagsV4) {
+TEST_P(SpdyFramerTest, DataFrameFlagsV4) {
   uint8_t valid_data_flags = DATA_FLAG_FIN | DATA_FLAG_PADDED;
 
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
@@ skipping 30 matching lines @@
       EXPECT_EQ(SpdyFramer::SPDY_INVALID_PADDING, 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_F(SpdyFramerTest, RstStreamFrameFlags) {
+TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, SettingsFrameFlags) {
+TEST_P(SpdyFramerTest, SettingsFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySettingsIR settings_ir;
@@ skipping 17 matching lines @@
                 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_F(SpdyFramerTest, GoawayFrameFlags) {
+TEST_P(SpdyFramerTest, GoawayFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyGoAwayIR goaway_ir(97, GOAWAY_OK, "test");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_OK));
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, HeadersFrameFlags) {
+TEST_P(SpdyFramerTest, HeadersFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdyHeadersIR headers_ir(57);
@@ skipping 36 matching lines @@
       EXPECT_CALL(visitor, OnStreamEnd(_)).Times(0);
     }
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, PingFrameFlags) {
+TEST_P(SpdyFramerTest, PingFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(framer.SerializePing(SpdyPingIR(42)));
     SetFrameFlags(&frame, flags);
 
     if (flags & PING_FLAG_ACK) {
       EXPECT_CALL(visitor, OnPing(42, true));
     } else {
       EXPECT_CALL(visitor, OnPing(42, false));
     }
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, WindowUpdateFrameFlags) {
+TEST_P(SpdyFramerTest, WindowUpdateFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
 
     SpdySerializedFrame frame(
         framer.SerializeWindowUpdate(SpdyWindowUpdateIR(4, 1024)));
     SetFrameFlags(&frame, flags);
 
     EXPECT_CALL(visitor, OnWindowUpdate(4, 1024));
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, PushPromiseFrameFlags) {
+TEST_P(SpdyFramerTest, PushPromiseFrameFlags) {
   const SpdyStreamId client_id = 123;   // Must be odd.
   const SpdyStreamId promised_id = 22;  // Must be even.
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer;
@@ skipping 19 matching lines @@
       EXPECT_CALL(visitor, OnHeaderFrameEnd(client_id, _)).Times(1);
     }
 
     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());
   } while (++flags != 0);
 }
 
-TEST_F(SpdyFramerTest, ContinuationFrameFlags) {
+TEST_P(SpdyFramerTest, ContinuationFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     testing::StrictMock<test::MockDebugVisitor> debug_visitor;
     SpdyFramer framer;
     framer.set_visitor(&visitor);
     framer.set_debug_visitor(&debug_visitor);
@@ skipping 25 matching lines @@
     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);
 }
 
 // TODO(mlavan): Add TEST_F(SpdyFramerTest, AltSvcFrameFlags)
 
 // TODO(hkhalil): Add TEST_F(SpdyFramerTest, BlockedFrameFlags)
 
-TEST_F(SpdyFramerTest, SettingsFlagsAndId) {
+TEST_P(SpdyFramerTest, SettingsFlagsAndId) {
   const uint32_t kId = 0x020304;
   const uint32_t kFlags = 0x01;
   const uint32_t kWireFormat = base::HostToNet32(0x01020304);
 
   SettingsFlagsAndId id_and_flags =
       SettingsFlagsAndId::FromWireFormat(kWireFormat);
   EXPECT_EQ(kId, id_and_flags.id());
   EXPECT_EQ(kFlags, id_and_flags.flags());
   EXPECT_EQ(kWireFormat, id_and_flags.GetWireFormat());
 }
 
 // Test handling of a RST_STREAM with out-of-bounds status codes.
-TEST_F(SpdyFramerTest, RstStreamStatusBounds) {
+TEST_P(SpdyFramerTest, RstStreamStatusBounds) {
   const unsigned char kH2RstStreamInvalid[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
   const unsigned char kH2RstStreamNumStatusCodes[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x03,                    //   Type: RST_STREAM
@@ skipping 17 matching lines @@
 
   EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamNumStatusCodes),
                       arraysize(kH2RstStreamNumStatusCodes));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
 // Test handling of GOAWAY frames with out-of-bounds status code.
-TEST_F(SpdyFramerTest, GoAwayStatusBounds) {
+TEST_P(SpdyFramerTest, GoAwayStatusBounds) {
   SpdyFramer framer;
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  //   Last: 1
       0xff, 0xff, 0xff, 0xff,  //  Error: 0xffffffff
       0x47, 0x41,              // Description
   };
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(1, GOAWAY_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   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 a GOAWAY frame with out-of-bounds stream ID.
-TEST_F(SpdyFramerTest, GoAwayStreamIdBounds) {
+TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0xff, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff (R-bit set)
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_OK));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.error_code())
       << SpdyFramer::ErrorCodeToString(framer.error_code());
 }
 
-TEST_F(SpdyFramerTest, OnBlocked) {
+TEST_P(SpdyFramerTest, OnBlocked) {
   const SpdyStreamId kStreamId = 0;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   EXPECT_CALL(visitor, OnBlocked(kStreamId));
 
   SpdyBlockedIR blocked_ir(0);
   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_F(SpdyFramerTest, OnAltSvc) {
+TEST_P(SpdyFramerTest, OnAltSvc) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   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);
   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_F(SpdyFramerTest, OnAltSvcNoOrigin) {
+TEST_P(SpdyFramerTest, OnAltSvcNoOrigin) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, 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);
   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_F(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
+TEST_P(SpdyFramerTest, OnAltSvcEmptyProtocolId) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   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, SpdyAltSvcWireFormat::VersionVector()));
   altsvc_ir.add_altsvc(SpdyAltSvcWireFormat::AlternativeService(
       "", "h1", 443, 10, SpdyAltSvcWireFormat::VersionVector()));
   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_F(SpdyFramerTest, OnAltSvcBadLengths) {
+TEST_P(SpdyFramerTest, OnAltSvcBadLengths) {
   const SpdyStreamId kStreamId = 1;
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer;
   framer.set_visitor(&visitor);
 
   SpdyAltSvcWireFormat::AlternativeService altsvc(
       "pid", "h1", 443, 10, 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);
   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_F(SpdyFramerTest, ReadChunkedAltSvcFrame) {
+TEST_P(SpdyFramerTest, ReadChunkedAltSvcFrame) {
   SpdyFramer framer;
   SpdyAltSvcIR altsvc_ir(1);
   SpdyAltSvcWireFormat::AlternativeService altsvc1(
       "pid1", "host", 443, 5, SpdyAltSvcWireFormat::VersionVector());
   SpdyAltSvcWireFormat::AlternativeService altsvc2(
       "p\"=i:d", "h_\\o\"st", 123, 42, SpdyAltSvcWireFormat::VersionVector{24});
   altsvc_ir.add_altsvc(altsvc1);
   altsvc_ir.add_altsvc(altsvc2);
 
   SpdySerializedFrame control_frame(framer.SerializeAltSvc(altsvc_ir));
@@ skipping 13 matching lines @@
     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_F(SpdyFramerTest, ReadPriority) {
+TEST_P(SpdyFramerTest, ReadPriority) {
   SpdyFramer framer;
   SpdyPriorityIR priority(3, 1, 256, false);
   SpdySerializedFrame frame(framer.SerializePriority(priority));
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
   EXPECT_CALL(visitor, OnPriority(3, 1, 256, false));
   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.
 }
 
 // Tests handling of PRIORITY frame with incorrect size.
-TEST_F(SpdyFramerTest, ReadIncorrectlySizedPriority) {
+TEST_P(SpdyFramerTest, ReadIncorrectlySizedPriority) {
   // PRIORITY frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x02,                    //   Type: PRIORITY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x00, 0x01,  // Priority (Truncated)
   };
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of PING frame with incorrect size.
-TEST_F(SpdyFramerTest, ReadIncorrectlySizedPing) {
+TEST_P(SpdyFramerTest, ReadIncorrectlySizedPing) {
   // PING frame of size 4, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x04,        // Length: 4
       0x06,                    //   Type: PING
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  // Ping (Truncated)
   };
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of WINDOW_UPDATE frame with incorrect size.
-TEST_F(SpdyFramerTest, ReadIncorrectlySizedWindowUpdate) {
+TEST_P(SpdyFramerTest, ReadIncorrectlySizedWindowUpdate) {
   // WINDOW_UPDATE frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x08,                    //   Type: WINDOW_UPDATE
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // WindowUpdate (Truncated)
   };
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Tests handling of RST_STREAM frame with incorrect size.
-TEST_F(SpdyFramerTest, ReadIncorrectlySizedRstStream) {
+TEST_P(SpdyFramerTest, ReadIncorrectlySizedRstStream) {
   // RST_STREAM frame of size 3, which isn't correct.
   const unsigned char kFrameData[] = {
       0x00, 0x00, 0x03,        // Length: 3
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x03,  // Stream: 3
       0x00, 0x00, 0x01,        // RstStream (Truncated)
   };
 
   TestSpdyVisitor visitor;
   visitor.SimulateInFramer(kFrameData, sizeof(kFrameData));
 
   EXPECT_EQ(SpdyFramer::SPDY_ERROR, visitor.framer_.state());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_CONTROL_FRAME_SIZE,
             visitor.framer_.error_code())
       << SpdyFramer::ErrorCodeToString(visitor.framer_.error_code());
 }
 
 // Test that SpdyFramer processes, by default, all passed input in one call
 // to ProcessInput (i.e. will not be calling set_process_single_input_frame()).
-TEST_F(SpdyFramerTest, ProcessAllInput) {
+TEST_P(SpdyFramerTest, ProcessAllInput) {
   SpdyFramer framer;
   std::unique_ptr<TestSpdyVisitor> visitor(new TestSpdyVisitor);
   framer.set_visitor(visitor.get());
 
   // Create two input frames.
   SpdyHeadersIR headers(1);
   headers.SetHeader("alpha", "beta");
   headers.SetHeader("gamma", "charlie");
   headers.SetHeader("cookie", "key1=value1; key2=value2");
   SpdySerializedFrame headers_frame(
@@ skipping 28 matching lines @@
   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_F(SpdyFramerTest, ProcessAtMostOneFrame) {
+TEST_P(SpdyFramerTest, ProcessAtMostOneFrame) {
   SpdyFramer framer;
   framer.set_process_single_input_frame(true);
   std::unique_ptr<TestSpdyVisitor> visitor;
 
   // Create two input frames.
   const char four_score[] = "Four score and ...";
   SpdyDataIR four_score_ir(1, four_score);
   SpdySerializedFrame four_score_frame(framer.SerializeData(four_score_ir));
 
   SpdyHeadersIR headers(2);
@@ skipping 61 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