Send the ClientHello handshake message. Fix a bug in

net/quic/test_tools/quic_test_utils.h

 // 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.
 //
 // Common utilities for Quic tests
 
 #ifndef NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 #define NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_
 
 #include "net/quic/congestion_control/quic_send_scheduler.h"
@@ skipping 14 matching lines @@
                                    const char* expected,
                                    const int expected_len);
 
 void CompareQuicDataWithHexError(const std::string& description,
                                  QuicData* actual,
                                  QuicData* expected);
 
 // Constructs a basic crypto handshake message
 QuicPacket* ConstructHandshakePacket(QuicGuid guid, CryptoTag tag);
 
+// Constructs a ClientHello crypto handshake message
+QuicPacket* ConstructClientHelloPacket(QuicGuid guid,
+                                       const QuicClock* clock,
+                                       QuicRandom* random_generator);
+
 class MockFramerVisitor : public QuicFramerVisitorInterface {
  public:
   MockFramerVisitor();
   ~MockFramerVisitor();
 
   MOCK_METHOD1(OnError, void(QuicFramer* framer));
   MOCK_METHOD2(OnPacket, void(const IPEndPoint& self_address,
                               const IPEndPoint& peer_address));
   MOCK_METHOD0(OnRevivedPacket, void());
   // The constructor set this up to return true by default.
@@ skipping 96 matching lines @@
   MOCK_METHOD0(IsSendAlarmSet, bool());
   MOCK_METHOD0(UnregisterSendAlarmIfRegistered, void());
  private:
   const MockClock clock_;
   MockRandom random_generator_;
 };
 
 class MockConnection : public QuicConnection {
  public:
   MockConnection(QuicGuid guid, IPEndPoint address);
+  MockConnection(QuicGuid guid,
+                 IPEndPoint address,
+                 QuicConnectionHelperInterface* helper);
   virtual ~MockConnection();
 
   MOCK_METHOD3(ProcessUdpPacket, void(const IPEndPoint& self_address,
                                       const IPEndPoint& peer_address,
                                       const QuicEncryptedPacket& packet));
   MOCK_METHOD1(SendConnectionClose, void(QuicErrorCode error));
 
   MOCK_METHOD3(SendRstStream, void(QuicStreamId id,
                                    QuicErrorCode error,
                                    QuicStreamOffset offset));
@@ skipping 29 matching lines @@
 
   MOCK_METHOD4(OnPacket, bool(const IPEndPoint& self_address,
                               const IPEndPoint& peer_address,
                               const QuicPacketHeader& header,
                               const std::vector<QuicStreamFrame>& frame));
   MOCK_METHOD2(ConnectionClose, void(QuicErrorCode error, bool from_peer));
   MOCK_METHOD1(CreateIncomingReliableStream,
                ReliableQuicStream*(QuicStreamId id));
   MOCK_METHOD0(GetCryptoStream, QuicCryptoStream*());
   MOCK_METHOD0(CreateOutgoingReliableStream, ReliableQuicStream*());
-  MOCK_METHOD3(WriteData,
-               void(QuicStreamId id, base::StringPiece data, bool fin));
   MOCK_METHOD4(WriteData, QuicConsumedData(QuicStreamId id,
                                            base::StringPiece data,
                                            QuicStreamOffset offset, bool fin));
   MOCK_METHOD0(IsHandshakeComplete, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockSession);
 };
 
 class MockScheduler : public QuicSendScheduler {
  public:
   MockScheduler();
   virtual ~MockScheduler();
 
   MOCK_METHOD1(TimeUntilSend, QuicTime::Delta(bool));
   MOCK_METHOD1(OnIncomingAckFrame, void(const QuicAckFrame&));
   MOCK_METHOD3(SentPacket, void(QuicPacketSequenceNumber, size_t, bool));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockScheduler);
 };
 
 }  // namespace test
 
 }  // namespace net
 
 #endif  // NET_QUIC_TEST_TOOLS_QUIC_TEST_UTILS_H_