1 files changed, 24 insertions, 16 deletions

diff --git a/chromium/net/quic/quic_client_session_test.cc b/chromium/net/quic/quic_client_session_test.cc
index f0b4dd4ecab..264fbfa5270 100644
--- a/chromium/net/quic/quic_client_session_test.cc
+++ b/chromium/net/quic/quic_client_session_test.cc
@@ -13,10 +13,12 @@
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
+#include "net/quic/crypto/quic_server_info.h"
 #include "net/quic/quic_default_packet_writer.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/quic_client_session_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
+#include "net/quic/test_tools/simple_quic_framer.h"
 #include "net/socket/socket_test_util.h"
 #include "net/udp/datagram_client_socket.h"
 
@@ -27,24 +29,21 @@ namespace test {
 namespace {
 
 const char kServerHostname[] = "www.example.com";
+const uint16 kServerPort = 80;
 
 class TestPacketWriter : public QuicDefaultPacketWriter {
  public:
-  TestPacketWriter() {
-  }
+  TestPacketWriter(QuicVersion version) : version_(version) {}
 
   // QuicPacketWriter
   virtual WriteResult WritePacket(
       const char* buffer, size_t buf_len,
       const IPAddressNumber& self_address,
-      const IPEndPoint& peer_address,
-      QuicBlockedWriterInterface* blocked_writer) OVERRIDE {
-    QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), true);
-    FramerVisitorCapturingFrames visitor;
-    framer.set_visitor(&visitor);
+      const IPEndPoint& peer_address) OVERRIDE {
+    SimpleQuicFramer framer(SupportedVersions(version_));
     QuicEncryptedPacket packet(buffer, buf_len);
     EXPECT_TRUE(framer.ProcessPacket(packet));
-    header_ = *visitor.header();
+    header_ = framer.header();
     return WriteResult(WRITE_STATUS_OK, packet.length());
   }
 
@@ -58,16 +57,22 @@ class TestPacketWriter : public QuicDefaultPacketWriter {
   const QuicPacketHeader& header() { return header_; }
 
  private:
+  QuicVersion version_;
   QuicPacketHeader header_;
 };
 
-class QuicClientSessionTest : public ::testing::Test {
+class QuicClientSessionTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicClientSessionTest()
-      : writer_(new TestPacketWriter()),
-        connection_(new PacketSavingConnection(false)),
+      : writer_(new TestPacketWriter(GetParam())),
+        connection_(
+            new PacketSavingConnection(false, SupportedVersions(GetParam()))),
         session_(connection_, GetSocket().Pass(), writer_.Pass(), NULL, NULL,
-                 kServerHostname, DefaultQuicConfig(), &crypto_config_,
+                 make_scoped_ptr((QuicServerInfo*)NULL),
+                 QuicServerId(kServerHostname, kServerPort, false,
+                              PRIVACY_MODE_DISABLED),
+                 DefaultQuicConfig(), &crypto_config_,
+                 base::MessageLoop::current()->message_loop_proxy().get(),
                  &net_log_) {
     session_.config()->SetDefaults();
     crypto_config_.SetDefaults();
@@ -105,11 +110,14 @@ class QuicClientSessionTest : public ::testing::Test {
   QuicCryptoClientConfig crypto_config_;
 };
 
-TEST_F(QuicClientSessionTest, CryptoConnect) {
+INSTANTIATE_TEST_CASE_P(Tests, QuicClientSessionTest,
+                        ::testing::ValuesIn(QuicSupportedVersions()));
+
+TEST_P(QuicClientSessionTest, CryptoConnect) {
   CompleteCryptoHandshake();
 }
 
-TEST_F(QuicClientSessionTest, MaxNumStreams) {
+TEST_P(QuicClientSessionTest, MaxNumStreams) {
   CompleteCryptoHandshake();
 
   std::vector<QuicReliableClientStream*> streams;
@@ -125,7 +133,7 @@ TEST_F(QuicClientSessionTest, MaxNumStreams) {
   EXPECT_TRUE(session_.CreateOutgoingDataStream());
 }
 
-TEST_F(QuicClientSessionTest, MaxNumStreamsViaRequest) {
+TEST_P(QuicClientSessionTest, MaxNumStreamsViaRequest) {
   CompleteCryptoHandshake();
 
   std::vector<QuicReliableClientStream*> streams;
@@ -149,7 +157,7 @@ TEST_F(QuicClientSessionTest, MaxNumStreamsViaRequest) {
   EXPECT_TRUE(stream != NULL);
 }
 
-TEST_F(QuicClientSessionTest, GoAwayReceived) {
+TEST_P(QuicClientSessionTest, GoAwayReceived) {
   CompleteCryptoHandshake();
 
   // After receiving a GoAway, I should no longer be able to create outgoing