Send the ClientHello handshake message. Fix a bug in

net/quic/quic_stream_factory_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/quic/quic_stream_factory.h"
 
 #include "base/run_loop.h"
 #include "base/string_util.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
 #include "net/quic/quic_http_stream.h"
 #include "net/quic/test_tools/mock_clock.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"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
 class QuicStreamFactoryTest : public ::testing::Test {
  protected:
   QuicStreamFactoryTest()
-      : factory_(&host_resolver_, &socket_factory_,
-                 &random_generator_,
-                 new MockClock()),
+      : clock_(new MockClock()),
+        factory_(&host_resolver_, &socket_factory_,
+                 &random_generator_, clock_),
         host_port_proxy_pair_(HostPortPair("www.google.com", 443),
                               ProxyServer::Direct()) {
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructChlo() {
-    scoped_ptr<QuicPacket> chlo(ConstructHandshakePacket(0xDEADBEEF, kCHLO));
+    scoped_ptr<QuicPacket> chlo(ConstructClientHelloPacket(0xDEADBEEF,
+                                                           clock_,
+                                                           &random_generator_));
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*chlo));
   }
 
   scoped_ptr<QuicEncryptedPacket> ConstructShlo() {
     scoped_ptr<QuicPacket> shlo(ConstructHandshakePacket(0xDEADBEEF, kSHLO));
     QuicFramer framer(QuicDecrypter::Create(kNULL),
                       QuicEncrypter::Create(kNULL));
     return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*shlo));
@@ skipping 54 matching lines @@
     QuicFrames frames;
     frames.push_back(frame);
     scoped_ptr<QuicPacket> packet(
         framer.ConstructFrameDataPacket(header, frames));
     return scoped_ptr<QuicEncryptedPacket>(framer.EncryptPacket(*packet));
   }
 
   MockHostResolver host_resolver_;
   MockClientSocketFactory socket_factory_;
   MockRandom random_generator_;
+  MockClock* clock_;  // Owned by factory_.
   QuicStreamFactory factory_;
   HostPortProxyPair host_port_proxy_pair_;
   BoundNetLog net_log_;
   TestCompletionCallback callback_;
 };
 
 TEST_F(QuicStreamFactoryTest, CreateIfSessionExists) {
   EXPECT_EQ(NULL, factory_.CreateIfSessionExists(host_port_proxy_pair_,
                                                  net_log_).get());
 }
@@ skipping 96 matching lines @@
       factory_.CreateIfSessionExists(host_port_proxy_pair_, net_log_));
   EXPECT_TRUE(stream.get());
   stream.reset();
 
   EXPECT_TRUE(socket_data.at_read_eof());
   EXPECT_TRUE(socket_data.at_write_eof());
 }
 
 }  // namespace test
 }  // namespace net