QUIC Crypto - Code to mock out the QuicCryptoClientStream.

Use the mock class during crypto handshake in
quic_network_transaction, quic_http_stream and quic_stream_factory
classes. Deleted sending of shlo and chlo messages from
the unit tests of these classes.

This code deletes the following methods from quic_test_utils.cc.
We will share the cryto testing code with the server.

CreateChloMessage
ConstructClientHelloPacket
CreateShloMessage
ConstructServerHelloPacket

R=rch
TEST=net unittests
Review URL: https://codereview.chromium.org/12729017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@189904 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 241 insertions, 259 deletions

diff --git a/net/quic/quic_client_session.cc b/net/quic/quic_client_session.cc
index 8a3b0eb..7bd4078 100644
--- a/net/quic/quic_client_session.cc
+++ b/net/quic/quic_client_session.cc
@@ -11,19 +11,26 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/quic/quic_connection_helper.h"
+#include "net/quic/quic_crypto_client_stream_factory.h"
 #include "net/quic/quic_stream_factory.h"
 #include "net/udp/datagram_client_socket.h"
 
 namespace net {
 
-QuicClientSession::QuicClientSession(QuicConnection* connection,
-                                     DatagramClientSocket* socket,
-                                     QuicStreamFactory* stream_factory,
-                                     const string& server_hostname,
-                                     NetLog* net_log)
+QuicClientSession::QuicClientSession(
+    QuicConnection* connection,
+    DatagramClientSocket* socket,
+    QuicStreamFactory* stream_factory,
+    QuicCryptoClientStreamFactory* crypto_client_stream_factory,
+    const string& server_hostname,
+    NetLog* net_log)
     : QuicSession(connection, false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(crypto_stream_(this, server_hostname)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(crypto_stream_(
+          crypto_client_stream_factory ?
+              crypto_client_stream_factory->CreateQuicCryptoClientStream(
+                  this, server_hostname) :
+              new QuicCryptoClientStream(this, server_hostname))),
       stream_factory_(stream_factory),
       socket_(socket),
       read_buffer_(new IOBufferWithSize(kMaxPacketSize)),
@@ -44,7 +51,7 @@ QuicClientSession::~QuicClientSession() {
 }
 
 QuicReliableClientStream* QuicClientSession::CreateOutgoingReliableStream() {
-  if (!crypto_stream_.handshake_complete()) {
+  if (!crypto_stream_->handshake_complete()) {
     DLOG(INFO) << "Crypto handshake not complete, no outgoing stream created.";
     return NULL;
   }
@@ -66,11 +73,11 @@ QuicReliableClientStream* QuicClientSession::CreateOutgoingReliableStream() {
 }
 
 QuicCryptoClientStream* QuicClientSession::GetCryptoStream() {
-  return &crypto_stream_;
+  return crypto_stream_.get();
 };
 
 int QuicClientSession::CryptoConnect(const CompletionCallback& callback) {
-  if (!crypto_stream_.CryptoConnect()) {
+  if (!crypto_stream_->CryptoConnect()) {
     // TODO(wtc): change crypto_stream_.CryptoConnect() to return a
     // QuicErrorCode and map it to a net error code.
     return ERR_CONNECTION_FAILED;
diff --git a/net/quic/quic_client_session.h b/net/quic/quic_client_session.h
index cdb2e90..cdda311 100644
--- a/net/quic/quic_client_session.h
+++ b/net/quic/quic_client_session.h
@@ -23,6 +23,7 @@ namespace net {
 
 class DatagramClientSocket;
 class QuicConnectionHelper;
+class QuicCryptoClientStreamFactory;
 class QuicStreamFactory;
 
 class NET_EXPORT_PRIVATE QuicClientSession : public QuicSession {
@@ -33,6 +34,7 @@ class NET_EXPORT_PRIVATE QuicClientSession : public QuicSession {
   QuicClientSession(QuicConnection* connection,
                     DatagramClientSocket* socket,
                     QuicStreamFactory* stream_factory,
+                    QuicCryptoClientStreamFactory* crypto_client_stream_factory,
                     const std::string& server_hostname,
                     NetLog* net_log);
 
@@ -68,7 +70,7 @@ class NET_EXPORT_PRIVATE QuicClientSession : public QuicSession {
   void OnReadComplete(int result);
 
   base::WeakPtrFactory<QuicClientSession> weak_factory_;
-  QuicCryptoClientStream crypto_stream_;
+  scoped_ptr<QuicCryptoClientStream> crypto_stream_;
   QuicStreamFactory* stream_factory_;
   scoped_ptr<DatagramClientSocket> socket_;
   scoped_refptr<IOBufferWithSize> read_buffer_;
diff --git a/net/quic/quic_client_session_test.cc b/net/quic/quic_client_session_test.cc
index 6d2c368..5847b1e 100644
--- a/net/quic/quic_client_session_test.cc
+++ b/net/quic/quic_client_session_test.cc
@@ -29,16 +29,15 @@ class QuicClientSessionTest : public ::testing::Test {
   QuicClientSessionTest()
       : guid_(1),
         connection_(new PacketSavingConnection(guid_, IPEndPoint(), false)),
-        session_(connection_, NULL, NULL, kServerHostname, &net_log_) {
+        session_(connection_, NULL, NULL, NULL, kServerHostname, &net_log_) {
   }
 
   void CompleteCryptoHandshake() {
     ASSERT_EQ(ERR_IO_PENDING,
               session_.CryptoConnect(callback_.callback()));
-    session_.GetCryptoStream()->OnHandshakeMessage(
-        CreateShloMessage(&clock_, &random_, "www.google.com"));
+    CryptoTestUtils::HandshakeWithFakeServer(
+        connection_, session_.GetCryptoStream());
     ASSERT_EQ(OK, callback_.WaitForResult());
-
   }
 
   QuicGuid guid_;
diff --git a/net/quic/quic_crypto_client_stream.h b/net/quic/quic_crypto_client_stream.h
index 33cf6c4..3b0c97d 100644
--- a/net/quic/quic_crypto_client_stream.h
+++ b/net/quic/quic_crypto_client_stream.h
@@ -30,7 +30,7 @@ class NET_EXPORT_PRIVATE QuicCryptoClientStream : public QuicCryptoStream {
 
   // Performs a crypto handshake with the server. Returns true if the crypto
   // handshake is started successfully.
-  bool CryptoConnect();
+  virtual bool CryptoConnect();
 
  private:
   friend class test::CryptoTestUtils;
diff --git a/net/quic/quic_crypto_client_stream_factory.h b/net/quic/quic_crypto_client_stream_factory.h
new file mode 100644
index 0000000..abfcbb4
--- /dev/null
+++ b/net/quic/quic_crypto_client_stream_factory.h
@@ -0,0 +1,29 @@
+// Copyright (c) 2013 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.
+
+#ifndef NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_FACTORY_H_
+#define NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_FACTORY_H_
+
+#include <string>
+
+#include "net/base/net_export.h"
+
+namespace net {
+
+class QuicCryptoClientStream;
+class QuicSession;
+
+// An interface used to instantiate QuicCryptoClientStream objects. Used to
+// facilitate testing code with mock implementations.
+class NET_EXPORT QuicCryptoClientStreamFactory {
+ public:
+  virtual ~QuicCryptoClientStreamFactory() {}
+
+  virtual QuicCryptoClientStream* CreateQuicCryptoClientStream(
+      QuicSession* session, const std::string& server_hostname) = 0;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_QUIC_CRYPTO_CLIENT_STREAM_FACTORY_H_
diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc
index b5a342c..7f4fef7 100644
--- a/net/quic/quic_http_stream_test.cc
+++ b/net/quic/quic_http_stream_test.cc
@@ -13,12 +13,14 @@
 #include "net/http/http_response_headers.h"
 #include "net/quic/congestion_control/receive_algorithm_interface.h"
 #include "net/quic/congestion_control/send_algorithm_interface.h"
+#include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_client_session.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
 #include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
@@ -178,13 +180,9 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     session_.reset(new QuicClientSession(connection_, socket, NULL,
+                                         &crypto_client_stream_factory_,
                                          "www.google.com", NULL));
-    scoped_ptr<QuicPacket> shlo(ConstructServerHelloPacket(
-        guid_, &clock_, &random_generator_, "www.google.com"));
-    scoped_ptr<QuicEncryptedPacket> shlo_packet(
-        framer_.EncryptPacket(1, *shlo));
     session_->GetCryptoStream()->CryptoConnect();
-    ProcessPacket(*shlo_packet);
     EXPECT_TRUE(session_->IsCryptoHandshakeComplete());
     QuicReliableClientStream* stream =
         session_->CreateOutgoingReliableStream();
@@ -219,20 +217,14 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
     return std::string(frame->data(), len);
   }
 
-  QuicEncryptedPacket* ConstructChloPacket() {
-    scoped_ptr<QuicPacket> chlo(
-        ConstructClientHelloPacket(guid_, &clock_, &random_generator_,
-                                   "www.google.com", true));
-    return framer_.EncryptPacket(1, *chlo);
-  }
-
   // Returns a newly created packet to send kData on stream 1.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
+      bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
-    InitializeHeader(sequence_number);
+    InitializeHeader(sequence_number, should_include_version);
     QuicStreamFrame frame(3, fin, offset, data);
     return ConstructPacket(header_, QuicFrame(&frame));
   }
@@ -242,7 +234,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
       QuicPacketSequenceNumber sequence_number,
       QuicPacketSequenceNumber largest_received,
       QuicPacketSequenceNumber least_unacked) {
-    InitializeHeader(sequence_number);
+    InitializeHeader(sequence_number, false);
 
     QuicAckFrame ack(largest_received, QuicTime::Zero(), least_unacked);
     ack.sent_info.entropy_hash = 0;
@@ -255,7 +247,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
   QuicEncryptedPacket* ConstructRstPacket(
       QuicPacketSequenceNumber sequence_number,
       QuicStreamId stream_id) {
-    InitializeHeader(sequence_number);
+    InitializeHeader(sequence_number, false);
 
     QuicRstStreamFrame rst(stream_id, QUIC_NO_ERROR);
     return ConstructPacket(header_, QuicFrame(&rst));
@@ -283,10 +275,11 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
   std::string response_data_;
 
  private:
-  void InitializeHeader(QuicPacketSequenceNumber sequence_number) {
+  void InitializeHeader(QuicPacketSequenceNumber sequence_number,
+                        bool should_include_version) {
     header_.public_header.guid = guid_;
     header_.public_header.reset_flag = false;
-    header_.public_header.version_flag = false;
+    header_.public_header.version_flag = should_include_version;
     header_.packet_sequence_number = sequence_number;
     header_.fec_group = 0;
     header_.fec_entropy_flag = false;
@@ -308,6 +301,7 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
   IPEndPoint self_addr_;
   IPEndPoint peer_addr_;
   MockRandom random_;
+  MockCryptoClientStreamFactory crypto_client_stream_factory_;
   QuicPacketCreator creator_;
   QuicPacketHeader header_;
   scoped_ptr<StaticSocketDataProvider> socket_data_;
@@ -315,29 +309,25 @@ class QuicHttpStreamTest : public ::testing::TestWithParam<bool> {
 };
 
 TEST_F(QuicHttpStreamTest, RenewStreamForAuth) {
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
   Initialize();
   EXPECT_EQ(NULL, stream_->RenewStreamForAuth());
 }
 
 TEST_F(QuicHttpStreamTest, CanFindEndOfResponse) {
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
   Initialize();
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
 TEST_F(QuicHttpStreamTest, IsConnectionReusable) {
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
 }
 
 TEST_F(QuicHttpStreamTest, GetRequest) {
   SetRequestString("GET", "/");
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0,
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0,
                                             request_data_));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 1));
   Initialize();
 
   request_.method = "GET";
@@ -350,7 +340,7 @@ TEST_F(QuicHttpStreamTest, GetRequest) {
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack the request.
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 1, 1));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
 
   EXPECT_EQ(ERR_IO_PENDING,
@@ -359,7 +349,7 @@ TEST_F(QuicHttpStreamTest, GetRequest) {
   // Send the response without a body.
   SetResponseString("404 Not Found", "");
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, kFin, 0, response_data_));
+      ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
@@ -378,9 +368,8 @@ TEST_F(QuicHttpStreamTest, GetRequest) {
 
 TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
   SetRequestString("GET", "/");
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(2, 2, 1));
   Initialize();
 
   request_.method = "GET";
@@ -393,7 +382,7 @@ TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack the request.
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 1, 1));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
 
   EXPECT_EQ(ERR_IO_PENDING,
@@ -402,7 +391,7 @@ TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
   // Send the response with a body.
   SetResponseString("200 OK", "hello world!");
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, kFin, 0, response_data_));
+      ConstructDataPacket(2, false, kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Now that the headers have been processed, the callback will return.
@@ -422,11 +411,11 @@ TEST_F(QuicHttpStreamTest, GetRequestFullResponseInSinglePacket) {
 
 TEST_F(QuicHttpStreamTest, SendPostRequest) {
   SetRequestString("POST", "/");
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, !kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(3, kFin, request_data_.length(),
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, !kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, true, kFin,
+                                            request_data_.length(),
                                             kUploadData));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
 
   Initialize();
 
@@ -446,13 +435,13 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) {
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack both packets in the request.
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 2, 1));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", "");
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, !kFin, 0, response_data_));
+      ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
@@ -464,7 +453,8 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) {
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
-      ConstructDataPacket(3, kFin, response_data_.length(), kResponseBody));
+      ConstructDataPacket(3, false, kFin, response_data_.length(),
+                          kResponseBody));
   ProcessPacket(*resp_body);
 
   // Since the body has already arrived, this should return immediately.
@@ -479,14 +469,14 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) {
 TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
   SetRequestString("POST", "/");
   size_t chunk_size = strlen(kUploadData);
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, !kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(3, !kFin, request_data_.length(),
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, !kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, true, !kFin,
+                                            request_data_.length(),
                                             kUploadData));
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(4, kFin,
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(3, true, kFin,
                                             request_data_.length() + chunk_size,
                                             kUploadData));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(5, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 1));
 
   Initialize();
 
@@ -507,13 +497,13 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
   upload_data_stream.AppendChunk(kUploadData, chunk_size, true);
 
   // Ack both packets in the request.
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 2, 1));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
 
   // Send the response headers (but not the body).
   SetResponseString("200 OK", "");
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, !kFin, 0, response_data_));
+      ConstructDataPacket(2, false, !kFin, 0, response_data_));
   ProcessPacket(*resp);
 
   // Since the headers have already arrived, this should return immediately.
@@ -525,7 +515,8 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
   // Send the response body.
   const char kResponseBody[] = "Hello world!";
   scoped_ptr<QuicEncryptedPacket> resp_body(
-      ConstructDataPacket(3, kFin, response_data_.length(), kResponseBody));
+      ConstructDataPacket(3, false, kFin, response_data_.length(),
+                          kResponseBody));
   ProcessPacket(*resp_body);
 
   // Since the body has already arrived, this should return immediately.
@@ -539,10 +530,9 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) {
 
 TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   SetRequestString("GET", "/");
-  AddWrite(SYNCHRONOUS, ConstructChloPacket());
-  AddWrite(SYNCHRONOUS, ConstructDataPacket(2, kFin, 0, request_data_));
-  AddWrite(SYNCHRONOUS, ConstructRstPacket(3, 3));
-  AddWrite(SYNCHRONOUS, ConstructAckPacket(4, 2, 1));
+  AddWrite(SYNCHRONOUS, ConstructDataPacket(1, true, kFin, 0, request_data_));
+  AddWrite(SYNCHRONOUS, ConstructRstPacket(2, 3));
+  AddWrite(SYNCHRONOUS, ConstructAckPacket(3, 2, 1));
   use_closing_stream_ = true;
   Initialize();
 
@@ -556,7 +546,7 @@ TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   EXPECT_EQ(&response_, stream_->GetResponseInfo());
 
   // Ack the request.
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 1, 1));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0, 0));
   ProcessPacket(*ack);
   EXPECT_EQ(ERR_IO_PENDING,
             stream_->ReadResponseHeaders(callback_.callback()));
@@ -565,7 +555,7 @@ TEST_F(QuicHttpStreamTest, DestroyedEarly) {
   const char kResponseHeaders[] = "HTTP/1.1 404 OK\r\n"
       "Content-Type: text/plain\r\n\r\nhello world!";
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, kFin, 0, kResponseHeaders));
+      ConstructDataPacket(2, false, kFin, 0, kResponseHeaders));
 
   // In the course of processing this packet, the QuicHttpStream close itself.
   ProcessPacket(*resp);
diff --git a/net/quic/quic_network_transaction_unittest.cc b/net/quic/quic_network_transaction_unittest.cc
index 293beec..fecd7d9 100644
--- a/net/quic/quic_network_transaction_unittest.cc
+++ b/net/quic/quic_network_transaction_unittest.cc
@@ -23,6 +23,7 @@
 #include "net/quic/quic_framer.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/socket/client_socket_factory.h"
@@ -82,34 +83,6 @@ class QuicNetworkTransactionTest : public PlatformTest {
     HttpStreamFactory::SetNextProtos(std::vector<std::string>());
   }
 
-  // TODO(rch): factor these Construct* methods out into a test helper class.
-  scoped_ptr<QuicEncryptedPacket> ConstructChlo() {
-    const std::string host = "www.google.com";
-    scoped_ptr<QuicPacket> chlo(ConstructClientHelloPacket(0xDEADBEEF,
-                                                           clock_,
-                                                           &random_generator_,
-                                                           host,
-                                                           true));
-    QuicFramer framer(kQuicVersion1,
-                      QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL),
-                      false);
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *chlo));
-  }
-
-  scoped_ptr<QuicEncryptedPacket> ConstructShlo() {
-    const std::string host = "www.google.com";
-    scoped_ptr<QuicPacket> shlo(ConstructServerHelloPacket(0xDEADBEEF,
-                                                           clock_,
-                                                           &random_generator_,
-                                                           host));
-    QuicFramer framer(kQuicVersion1,
-                      QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL),
-                      false);
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *shlo));
-  }
-
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
@@ -135,7 +108,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
     header.public_header.version_flag = false;
-    header.packet_sequence_number = 3;
+    header.packet_sequence_number = 2;
     header.entropy_flag = false;
     header.fec_flag = false;
     header.fec_entropy_flag = false;
@@ -192,10 +165,11 @@ class QuicNetworkTransactionTest : public PlatformTest {
   // Returns a newly created packet to send kData on stream 1.
   QuicEncryptedPacket* ConstructDataPacket(
       QuicPacketSequenceNumber sequence_number,
+      bool should_include_version,
       bool fin,
       QuicStreamOffset offset,
       base::StringPiece data) {
-    InitializeHeader(sequence_number);
+    InitializeHeader(sequence_number, should_include_version);
     QuicStreamFrame frame(3, fin, offset, data);
     return ConstructPacket(header_, QuicFrame(&frame)).release();
   }
@@ -215,10 +189,11 @@ class QuicNetworkTransactionTest : public PlatformTest {
         framer.EncryptPacket(header.packet_sequence_number, *packet));
   }
 
-  void InitializeHeader(QuicPacketSequenceNumber sequence_number) {
+  void InitializeHeader(QuicPacketSequenceNumber sequence_number,
+                        bool should_include_version) {
     header_.public_header.guid = random_generator_.RandUint64();
     header_.public_header.reset_flag = false;
-    header_.public_header.version_flag = false;
+    header_.public_header.version_flag = should_include_version;
     header_.packet_sequence_number = sequence_number;
     header_.fec_group = 0;
     header_.entropy_flag = false;
@@ -231,6 +206,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
     params_.quic_clock = clock_;
     params_.quic_random = &random_generator_;
     params_.client_socket_factory = &socket_factory_;
+    params_.quic_crypto_client_stream_factory = &crypto_client_stream_factory_;
     params_.host_resolver = &host_resolver_;
     params_.cert_verifier = &cert_verifier_;
     params_.proxy_service = proxy_service_.get();
@@ -244,6 +220,7 @@ class QuicNetworkTransactionTest : public PlatformTest {
   QuicPacketHeader header_;
   scoped_refptr<HttpNetworkSession> session_;
   MockClientSocketFactory socket_factory_;
+  MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockClock* clock_;  // Owned by QuicStreamFactory after CreateSession.
   MockHostResolver host_resolver_;
   MockCertVerifier cert_verifier_;
@@ -263,22 +240,19 @@ TEST_F(QuicNetworkTransactionTest, ForceQuic) {
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
-  scoped_ptr<QuicEncryptedPacket> chlo(ConstructChlo());
   scoped_ptr<QuicEncryptedPacket> data(
-      ConstructDataPacket(2, true, 0, GetRequestString("GET", "/")));
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(2, 1));
+      ConstructDataPacket(1, true, true, 0, GetRequestString("GET", "/")));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
     MockWrite(SYNCHRONOUS, data->data(), data->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
 
-  scoped_ptr<QuicEncryptedPacket> shlo(ConstructShlo());
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, true, 0, GetResponseString("200 OK", "hello!")));
+      ConstructDataPacket(
+          1, false, true, 0, GetResponseString("200 OK", "hello!")));
   MockRead quic_reads[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(SYNCHRONOUS, resp->data(), resp->length()),
     MockRead(ASYNC, OK),  // EOF
   };
@@ -387,22 +361,19 @@ TEST_F(QuicNetworkTransactionTest, UseAlternateProtocolForQuic) {
   socket_factory_.AddSocketDataProvider(&first_transaction);
 
 
-  scoped_ptr<QuicEncryptedPacket> chlo(ConstructChlo());
   scoped_ptr<QuicEncryptedPacket> data(
-      ConstructDataPacket(2, true, 0, GetRequestString("GET", "/")));
-  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(2, 1));
+      ConstructDataPacket(1, true, true, 0, GetRequestString("GET", "/")));
+  scoped_ptr<QuicEncryptedPacket> ack(ConstructAckPacket(1, 0));
 
   MockWrite quic_writes[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
     MockWrite(SYNCHRONOUS, data->data(), data->length()),
     MockWrite(SYNCHRONOUS, ack->data(), ack->length()),
   };
 
-  scoped_ptr<QuicEncryptedPacket> shlo(ConstructShlo());
   scoped_ptr<QuicEncryptedPacket> resp(
-      ConstructDataPacket(2, true, 0, GetResponseString("200 OK", "hello!")));
+      ConstructDataPacket(
+          1, false, true, 0, GetResponseString("200 OK", "hello!")));
   MockRead quic_reads[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(SYNCHRONOUS, resp->data(), resp->length()),
     MockRead(ASYNC, OK),  // EOF
   };
diff --git a/net/quic/quic_stream_factory.cc b/net/quic/quic_stream_factory.cc
index e33306a..4bb6449 100644
--- a/net/quic/quic_stream_factory.cc
+++ b/net/quic/quic_stream_factory.cc
@@ -19,6 +19,7 @@
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_connection_helper.h"
+#include "net/quic/quic_crypto_client_stream_factory.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/quic_protocol.h"
 #include "net/socket/client_socket_factory.h"
@@ -219,10 +220,12 @@ int QuicStreamFactory::Job::DoConnectComplete(int rv) {
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
+    QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
     QuicRandom* random_generator,
     QuicClock* clock)
     : host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
+      quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
@@ -375,7 +378,9 @@ QuicClientSession* QuicStreamFactory::CreateSession(
 
   QuicConnection* connection = new QuicConnection(guid, addr, helper, false);
   QuicClientSession* session =
-      new QuicClientSession(connection, socket, this, host, net_log.net_log());
+      new QuicClientSession(connection, socket, this,
+                            quic_crypto_client_stream_factory_, host,
+                            net_log.net_log());
   all_sessions_.insert(session);  // owning pointer
   return session;
 }
diff --git a/net/quic/quic_stream_factory.h b/net/quic/quic_stream_factory.h
index 3620bc3..48f4da0 100644
--- a/net/quic/quic_stream_factory.h
+++ b/net/quic/quic_stream_factory.h
@@ -23,6 +23,7 @@ class HostResolver;
 class ClientSocketFactory;
 class QuicClock;
 class QuicClientSession;
+class QuicCryptoClientStreamFactory;
 class QuicRandom;
 class QuicStreamFactory;
 
@@ -62,10 +63,12 @@ class NET_EXPORT_PRIVATE QuicStreamRequest {
 // QuicClientSessions.
 class NET_EXPORT_PRIVATE QuicStreamFactory {
  public:
-  QuicStreamFactory(HostResolver* host_resolver,
-                    ClientSocketFactory* client_socket_factory,
-                    QuicRandom* random_generator,
-                    QuicClock* clock);
+  QuicStreamFactory(
+      HostResolver* host_resolver,
+      ClientSocketFactory* client_socket_factory,
+      QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory,
+      QuicRandom* random_generator,
+      QuicClock* clock);
   virtual ~QuicStreamFactory();
 
   // Creates a new QuicHttpStream to |host_port_proxy_pair| which will be
@@ -119,6 +122,7 @@ class NET_EXPORT_PRIVATE QuicStreamFactory {
 
   HostResolver* host_resolver_;
   ClientSocketFactory* client_socket_factory_;
+  QuicCryptoClientStreamFactory* quic_crypto_client_stream_factory_;
   QuicRandom* random_generator_;
   scoped_ptr<QuicClock> clock_;
 
diff --git a/net/quic/quic_stream_factory_test.cc b/net/quic/quic_stream_factory_test.cc
index a34f80a..e5f74b6 100644
--- a/net/quic/quic_stream_factory_test.cc
+++ b/net/quic/quic_stream_factory_test.cc
@@ -14,6 +14,7 @@
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/test_tools/mock_clock.h"
+#include "net/quic/test_tools/mock_crypto_client_stream_factory.h"
 #include "net/quic/test_tools/mock_random.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/socket/socket_test_util.h"
@@ -27,45 +28,19 @@ class QuicStreamFactoryTest : public ::testing::Test {
   QuicStreamFactoryTest()
       : clock_(new MockClock()),
         factory_(&host_resolver_, &socket_factory_,
+                 &crypto_client_stream_factory_,
                  &random_generator_, clock_),
         host_port_proxy_pair_(HostPortPair("www.google.com", 443),
                               ProxyServer::Direct()) {
   }
 
-  scoped_ptr<QuicEncryptedPacket> ConstructChlo() {
-    const std::string& host = host_port_proxy_pair_.first.host();
-    scoped_ptr<QuicPacket> chlo(ConstructClientHelloPacket(0xDEADBEEF,
-                                                           clock_,
-                                                           &random_generator_,
-                                                           host,
-                                                           true));
-    QuicFramer framer(kQuicVersion1,
-                      QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL),
-                      false);
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *chlo));
-  }
-
-  scoped_ptr<QuicEncryptedPacket> ConstructShlo() {
-    const std::string host = "www.google.com";
-    scoped_ptr<QuicPacket> shlo(ConstructServerHelloPacket(0xDEADBEEF,
-                                                           clock_,
-                                                           &random_generator_,
-                                                           host));
-    QuicFramer framer(kQuicVersion1,
-                      QuicDecrypter::Create(kNULL),
-                      QuicEncrypter::Create(kNULL),
-                      false);
-    return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(1, *shlo));
-  }
-
   scoped_ptr<QuicEncryptedPacket> ConstructRstPacket(
       QuicPacketSequenceNumber num,
       QuicStreamId stream_id) {
     QuicPacketHeader header;
     header.public_header.guid = 0xDEADBEEF;
     header.public_header.reset_flag = false;
-    header.public_header.version_flag = false;
+    header.public_header.version_flag = true;
     header.packet_sequence_number = num;
     header.entropy_flag = false;
     header.fec_entropy_flag = false;
@@ -148,6 +123,7 @@ class QuicStreamFactoryTest : public ::testing::Test {
 
   MockHostResolver host_resolver_;
   MockClientSocketFactory socket_factory_;
+  MockCryptoClientStreamFactory crypto_client_stream_factory_;
   MockRandom random_generator_;
   MockClock* clock_;  // Owned by factory_.
   QuicStreamFactory factory_;
@@ -162,19 +138,15 @@ TEST_F(QuicStreamFactoryTest, CreateIfSessionExists) {
 }
 
 TEST_F(QuicStreamFactoryTest, Create) {
-  scoped_ptr<QuicEncryptedPacket> chlo(ConstructChlo());
-  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(2, 3));
-  scoped_ptr<QuicEncryptedPacket> rst5(ConstructRstPacket(3, 5));
-  scoped_ptr<QuicEncryptedPacket> rst7(ConstructRstPacket(4, 7));
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
+  scoped_ptr<QuicEncryptedPacket> rst5(ConstructRstPacket(2, 5));
+  scoped_ptr<QuicEncryptedPacket> rst7(ConstructRstPacket(3, 7));
   MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
     MockWrite(SYNCHRONOUS, rst3->data(), rst3->length()),
     MockWrite(SYNCHRONOUS, rst5->data(), rst5->length()),
     MockWrite(SYNCHRONOUS, rst7->data(), rst7->length()),
   };
-  scoped_ptr<QuicEncryptedPacket> shlo(ConstructShlo());
   MockRead reads[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(ASYNC, OK),  // EOF
   };
   StaticSocketDataProvider socket_data(reads, arraysize(reads),
@@ -219,16 +191,12 @@ TEST_F(QuicStreamFactoryTest, CreateError) {
 }
 
 TEST_F(QuicStreamFactoryTest, CancelCreate) {
-  scoped_ptr<QuicEncryptedPacket> chlo(ConstructChlo());
-  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(2, 3));
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
 
   MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
     MockWrite(SYNCHRONOUS, rst3->data(), rst3->length()),
   };
-  scoped_ptr<QuicEncryptedPacket> shlo(ConstructShlo());
   MockRead reads[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(ASYNC, OK),  // EOF
   };
   StaticSocketDataProvider socket_data(reads, arraysize(reads),
@@ -253,26 +221,18 @@ TEST_F(QuicStreamFactoryTest, CancelCreate) {
 }
 
 TEST_F(QuicStreamFactoryTest, CloseAllSessions) {
-  scoped_ptr<QuicEncryptedPacket> chlo(ConstructChlo());
-  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(2, 3));
-  MockWrite writes[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
-  };
-  scoped_ptr<QuicEncryptedPacket> shlo(ConstructShlo());
+  scoped_ptr<QuicEncryptedPacket> rst3(ConstructRstPacket(1, 3));
   MockRead reads[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(ASYNC, OK),  // EOF
   };
   StaticSocketDataProvider socket_data(reads, arraysize(reads),
-                                       writes, arraysize(writes));
+                                       NULL, 0);
   socket_factory_.AddSocketDataProvider(&socket_data);
 
   MockWrite writes2[] = {
-    MockWrite(SYNCHRONOUS, chlo->data(), chlo->length()),
     MockWrite(SYNCHRONOUS, rst3->data(), rst3->length()),
   };
   MockRead reads2[] = {
-    MockRead(SYNCHRONOUS, shlo->data(), shlo->length()),
     MockRead(ASYNC, OK),  // EOF
   };
   StaticSocketDataProvider socket_data2(reads2, arraysize(reads2),
diff --git a/net/quic/test_tools/mock_crypto_client_stream.cc b/net/quic/test_tools/mock_crypto_client_stream.cc
new file mode 100644
index 0000000..5f2d06b
--- /dev/null
+++ b/net/quic/test_tools/mock_crypto_client_stream.cc
@@ -0,0 +1,27 @@
+// Copyright (c) 2013 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/quic/test_tools/mock_crypto_client_stream.h"
+
+namespace net {
+
+MockCryptoClientStream::MockCryptoClientStream(QuicSession* session,
+                                               const string& server_hostname)
+    : QuicCryptoClientStream(session, server_hostname) {
+}
+
+MockCryptoClientStream::~MockCryptoClientStream() {
+}
+
+void MockCryptoClientStream::OnHandshakeMessage(
+    const CryptoHandshakeMessage& message) {
+  CloseConnection(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE);
+}
+
+bool MockCryptoClientStream::CryptoConnect() {
+  SetHandshakeComplete(QUIC_NO_ERROR);
+  return true;
+}
+
+}  // namespace net
diff --git a/net/quic/test_tools/mock_crypto_client_stream.h b/net/quic/test_tools/mock_crypto_client_stream.h
new file mode 100644
index 0000000..a115e15
--- /dev/null
+++ b/net/quic/test_tools/mock_crypto_client_stream.h
@@ -0,0 +1,32 @@
+// Copyright (c) 2013 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.
+
+#ifndef NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_H_
+#define NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_H_
+
+#include <string>
+
+#include "net/quic/crypto/crypto_handshake.h"
+#include "net/quic/quic_crypto_client_stream.h"
+#include "net/quic/quic_session.h"
+
+namespace net {
+
+class MockCryptoClientStream : public QuicCryptoClientStream {
+ public:
+  MockCryptoClientStream(QuicSession* session,
+                         const std::string& server_hostname);
+  virtual ~MockCryptoClientStream();
+
+  // CryptoFramerVisitorInterface implementation.
+  virtual void OnHandshakeMessage(
+      const CryptoHandshakeMessage& message) OVERRIDE;
+
+  // QuicCryptoClientStream implementation.
+  virtual bool CryptoConnect() OVERRIDE;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_H_
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.cc b/net/quic/test_tools/mock_crypto_client_stream_factory.cc
new file mode 100644
index 0000000..153ddd4
--- /dev/null
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.cc
@@ -0,0 +1,22 @@
+// Copyright (c) 2013 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/quic/test_tools/mock_crypto_client_stream_factory.h"
+
+#include "base/lazy_instance.h"
+#include "net/quic/quic_crypto_client_stream.h"
+#include "net/quic/test_tools/mock_crypto_client_stream.h"
+
+using std::string;
+
+namespace net {
+
+QuicCryptoClientStream*
+MockCryptoClientStreamFactory::CreateQuicCryptoClientStream(
+    QuicSession* session,
+    const string& server_hostname) {
+  return new MockCryptoClientStream(session, server_hostname);
+}
+
+}  // namespace net
diff --git a/net/quic/test_tools/mock_crypto_client_stream_factory.h b/net/quic/test_tools/mock_crypto_client_stream_factory.h
new file mode 100644
index 0000000..1ed81f5
--- /dev/null
+++ b/net/quic/test_tools/mock_crypto_client_stream_factory.h
@@ -0,0 +1,26 @@
+// Copyright (c) 2013 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.
+
+#ifndef NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_FACTORY_H_
+#define NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_FACTORY_H_
+
+#include <string>
+
+#include "net/quic/quic_crypto_client_stream.h"
+#include "net/quic/quic_crypto_client_stream_factory.h"
+#include "net/quic/quic_session.h"
+
+namespace net {
+
+class MockCryptoClientStreamFactory : public QuicCryptoClientStreamFactory  {
+ public:
+  virtual ~MockCryptoClientStreamFactory() {}
+
+  virtual QuicCryptoClientStream* CreateQuicCryptoClientStream(
+      QuicSession* session, const std::string& server_hostname) OVERRIDE;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_TEST_TOOLS_MOCK_CRYPTO_CLIENT_STREAM_FACTORY_H_
diff --git a/net/quic/test_tools/quic_test_utils.cc b/net/quic/test_tools/quic_test_utils.cc
index a43a9b2..1e02ead 100644
--- a/net/quic/test_tools/quic_test_utils.cc
+++ b/net/quic/test_tools/quic_test_utils.cc
@@ -296,77 +296,6 @@ QuicPacket* ConstructHandshakePacket(QuicGuid guid, CryptoTag tag) {
   return ConstructPacketFromHandshakeMessage(guid, message, false);
 }
 
-CryptoHandshakeMessage CreateChloMessage(const QuicClock* clock,
-                                         QuicRandom* random_generator,
-                                         const string& server_hostname) {
-  QuicCryptoClientConfig client_config;
-  client_config.SetDefaults(random_generator);
-  string nonce;
-  CryptoUtils::GenerateNonce(clock, random_generator, &nonce);
-
-  QuicConfig config;
-  config.SetDefaults();
-
-  CryptoHandshakeMessage message;
-  client_config.FillClientHello(nonce, server_hostname, &message);
-  config.ToHandshakeMessage(&message);
-  return message;
-}
-
-QuicPacket* ConstructClientHelloPacket(QuicGuid guid,
-                                       const QuicClock* clock,
-                                       QuicRandom* random_generator,
-                                       const string& server_hostname,
-                                       bool should_include_version) {
-  CryptoHandshakeMessage chlo = CreateChloMessage(clock, random_generator,
-                                                  server_hostname);
-  return ConstructPacketFromHandshakeMessage(
-      guid, chlo, should_include_version);
-}
-
-CryptoHandshakeMessage CreateShloMessage(const QuicClock* clock,
-                                         QuicRandom* random_generator,
-                                         const string& server_hostname) {
-  // Expected CHLO
-  CryptoHandshakeMessage chlo = CreateChloMessage(clock, random_generator,
-                                                  server_hostname);
-
-  QuicConfig config;
-  config.SetDefaults();
-  QuicNegotiatedParameters negotiated_params;
-  string error_details;
-  QuicErrorCode error = config.ProcessPeerHandshake(
-      chlo, CryptoUtils::LOCAL_PRIORITY, &negotiated_params, &error_details);
-  DCHECK_EQ(QUIC_NO_ERROR, error);
-
-  std::string nonce;
-  CryptoUtils::GenerateNonce(clock, random_generator, &nonce);
-  QuicCryptoNegotiatedParams params;
-  QuicCryptoServerConfig server_config;
-  // Use hardcoded crypto parameters for now.
-  CryptoHandshakeMessage extra_tags;
-  config.ToHandshakeMessage(&extra_tags);
-  scoped_ptr<CryptoTagValueMap> config_tags(
-      server_config.AddTestingConfig(random_generator, clock, extra_tags));
-
-  CryptoHandshakeMessage shlo;
-  server_config.ProcessClientHello(chlo, nonce, &shlo, &params,
-                                   &error_details);
-  DCHECK(error_details.empty()) << error_details;
-  config.ToHandshakeMessage(&shlo);
-
-  return shlo;
-}
-
-QuicPacket* ConstructServerHelloPacket(QuicGuid guid,
-                                       const QuicClock* clock,
-                                       QuicRandom* random_generator,
-                                       const string& server_hostname) {
-  CryptoHandshakeMessage shlo =
-      CreateShloMessage(clock, random_generator, server_hostname);
-  return ConstructPacketFromHandshakeMessage(guid, shlo, false);
-}
-
 size_t GetPacketLengthForOneStream(bool include_version, size_t payload) {
   // TODO(wtc): the hardcoded use of NullEncrypter here seems wrong.
   return NullEncrypter().GetCiphertextSize(payload) +
diff --git a/net/quic/test_tools/quic_test_utils.h b/net/quic/test_tools/quic_test_utils.h
index 4cf5ac9..9a012ac 100644
--- a/net/quic/test_tools/quic_test_utils.h
+++ b/net/quic/test_tools/quic_test_utils.h
@@ -31,27 +31,6 @@ void CompareQuicDataWithHexError(const std::string& description,
                                  QuicData* actual,
                                  QuicData* expected);
 
-CryptoHandshakeMessage CreateChloMessage(const QuicClock* clock,
-                                         QuicRandom* random_generator,
-                                         const string& server_hostname);
-
-// Constructs a ClientHello crypto handshake message
-QuicPacket* ConstructClientHelloPacket(QuicGuid guid,
-                                       const QuicClock* clock,
-                                       QuicRandom* random_generator,
-                                       const std::string& server_hostname,
-                                       bool should_include_version);
-
-CryptoHandshakeMessage CreateShloMessage(const QuicClock* clock,
-                                         QuicRandom* random_generator,
-                                         const string& server_hostname);
-
-// Constructs a ClientHello crypto handshake message
-QuicPacket* ConstructServerHelloPacket(QuicGuid guid,
-                                       const QuicClock* clock,
-                                       QuicRandom* random_generator,
-                                       const std::string& server_hostname);
-
 // Returns the length of the QuicPacket that will be created if it contains
 // a stream frame that has |payload| bytes.
 size_t GetPacketLengthForOneStream(bool include_version, size_t payload);