Send the ClientHello handshake message. Fix a bug in

net/quic/quic_client_session_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_client_session.h"
 
 #include <vector>
 
 #include "base/stl_util.h"
 #include "net/base/test_completion_callback.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 
+using base::StringPiece;
+using std::vector;
 using testing::_;
 
 namespace net {
 namespace test {
 namespace {
 
+class TestEncrypter : public QuicEncrypter {
+ public:
+  virtual QuicData* Encrypt(StringPiece associated_data,
+                            StringPiece plaintext) {
+    return new QuicData(plaintext.data(), plaintext.length());
+  }
+  virtual size_t GetMaxPlaintextSize(size_t ciphertext_size) {
+    return ciphertext_size;
+  }
+  virtual size_t GetCiphertextSize(size_t plaintext_size) {
+    return plaintext_size;
+  }
+};
+
+class TestDecrypter : public QuicDecrypter {
+ public:
+  virtual QuicData* Decrypt(StringPiece associated_data,
+                            StringPiece ciphertext) {
+    return new QuicData(ciphertext.data(), ciphertext.length());
+  }
+};
+
+class TestQuicVisitor : public NoOpFramerVisitor {
+ public:
+  TestQuicVisitor() {}
+
+  // NoOpFramerVisitor
+  virtual void OnStreamFrame(const QuicStreamFrame& frame) {
+    frame_ = frame;
+  }
+
+  QuicStreamFrame* frame() { return &frame_; }
+
+ private:
+  QuicStreamFrame frame_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestQuicVisitor);
+};
+
+class TestCryptoVisitor : public CryptoFramerVisitorInterface {
+ public:
+  TestCryptoVisitor()
+      : error_count_(0) {
+  }
+
+  virtual void OnError(CryptoFramer* framer) {
+    DLOG(ERROR) << "CryptoFramer Error: " << framer->error();
+    ++error_count_;
+  }
+
+  virtual void OnHandshakeMessage(const CryptoHandshakeMessage& message) {
+    messages_.push_back(message);
+  }
+
+  // Counters from the visitor callbacks.
+  int error_count_;
+
+  vector<CryptoHandshakeMessage> messages_;
+};
+
 class QuicClientSessionTest : public ::testing::Test {
  protected:
   QuicClientSessionTest()
       : guid_(1),
         connection_(new PacketSavingConnection(guid_, IPEndPoint())),
         session_(connection_, NULL, NULL) {
   }
 
- protected:
+  // Checks whether |packet| is the default ClientHello packet.
+  void CheckClientHelloPacket(QuicPacket* packet);
+
   QuicGuid guid_;
   PacketSavingConnection* connection_;
   QuicClientSession session_;
   QuicConnectionVisitorInterface* visitor_;
   TestCompletionCallback callback_;
 };
 
+void QuicClientSessionTest::CheckClientHelloPacket(QuicPacket* packet) {

[Ryan Hamilton, 2012/12/22 22:31:32]

Instead of parsing all the fields of the the CHLO message in
QuicClientSessionTest, I think I would move this logic to a new test in
quic_crypto_client_stream_test.cc

Then in this test, I would probably simply call ConstructClientHelloPacket() to
create a CHLO packet and strcmp the results with packets[0].  

Make sense?  basically, the test that inspects the innards of the CHLO packet
belongs in a test of the code the generates it.  Everywhere else, we can simply
generate a CHLO with the same inputs and be confident that it is valid. 

[wtc, 2013/01/15 03:57:59]

Thank you for the suggestion. I did the latter, but not
the former.

I will think about the former and ask you if I have questions,
then implement it (possibly in a separate CL).

+  QuicFramer quic_framer(new TestDecrypter, new TestEncrypter);
+  TestQuicVisitor quic_visitor;
+  quic_framer.set_visitor(&quic_visitor);
+  QuicEncryptedPacket encrypted(packet->data(), packet->length());
+  ASSERT_TRUE(quic_framer.ProcessPacket(IPEndPoint(), IPEndPoint(),
+                                        encrypted));
+  EXPECT_EQ(kCryptoStreamId, quic_visitor.frame()->stream_id);
+  EXPECT_FALSE(quic_visitor.frame()->fin);
+  EXPECT_EQ(0u, quic_visitor.frame()->offset);
+
+  // Check quic_visitor.frame()->data.
+  test::TestCryptoVisitor crypto_visitor;
+  CryptoFramer crypto_framer;
+  crypto_framer.set_visitor(&crypto_visitor);
+  ASSERT_TRUE(crypto_framer.ProcessInput(quic_visitor.frame()->data));
+  ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
+  ASSERT_EQ(1u, crypto_visitor.messages_.size());
+  EXPECT_EQ(kCHLO, crypto_visitor.messages_[0].tag);
+
+  CryptoTagValueMap& tag_value_map =
+      crypto_visitor.messages_[0].tag_value_map;
+  ASSERT_EQ(7u, tag_value_map.size());
+
+  // kNONC
+  // TODO(wtc): check the nonce.
+  ASSERT_EQ(32u, tag_value_map[kNONC].size());
+
+  // kAEAD
+  ASSERT_EQ(8u, tag_value_map[kAEAD].size());
+  CryptoTag cipher[2];
+  memcpy(&cipher[0], &tag_value_map[kAEAD][0], 4);
+  memcpy(&cipher[1], &tag_value_map[kAEAD][4], 4);
+  EXPECT_EQ(kAESG, cipher[0]);
+  EXPECT_EQ(kAESH, cipher[1]);
+
+  // kICSL
+  ASSERT_EQ(4u, tag_value_map[kICSL].size());
+  uint32 idle_lifetime;
+  memcpy(&idle_lifetime, tag_value_map[kICSL].data(), 4);
+  EXPECT_EQ(300u, idle_lifetime);
+
+  // kKATO
+  ASSERT_EQ(4u, tag_value_map[kKATO].size());
+  uint32 keepalive_timeout;
+  memcpy(&keepalive_timeout, tag_value_map[kKATO].data(), 4);
+  EXPECT_EQ(0u, keepalive_timeout);
+
+  // kVERS
+  ASSERT_EQ(2u, tag_value_map[kVERS].size());
+  uint16 version;
+  memcpy(&version, tag_value_map[kVERS].data(), 2);
+  EXPECT_EQ(0u, version);
+
+  // kKEXS
+  ASSERT_EQ(8u, tag_value_map[kKEXS].size());
+  CryptoTag key_exchange[2];
+  memcpy(&key_exchange[0], &tag_value_map[kKEXS][0], 4);
+  memcpy(&key_exchange[1], &tag_value_map[kKEXS][4], 4);
+  EXPECT_EQ(kC255, key_exchange[0]);
+  EXPECT_EQ(kP256, key_exchange[1]);
+
+  // kCGST
+  ASSERT_EQ(4u, tag_value_map[kCGST].size());
+  CryptoTag congestion[1];
+  memcpy(&congestion[0], &tag_value_map[kCGST][0], 4);
+  EXPECT_EQ(kQBIC, congestion[0]);
+}
+
 TEST_F(QuicClientSessionTest, CryptoConnectSendsCorrectData) {
   EXPECT_EQ(ERR_IO_PENDING, session_.CryptoConnect(callback_.callback()));
   ASSERT_EQ(1u, connection_->packets_.size());
-  scoped_ptr<QuicPacket> chlo(ConstructHandshakePacket(guid_, kCHLO));
-  CompareQuicDataWithHexError("CHLO", connection_->packets_[0], chlo.get());
+  CheckClientHelloPacket(connection_->packets_[0]);
 }
 
 TEST_F(QuicClientSessionTest, CryptoConnectSendsCompletesAfterSHLO) {
   ASSERT_EQ(ERR_IO_PENDING, session_.CryptoConnect(callback_.callback()));
   // Send the SHLO message.
   CryptoHandshakeMessage server_message;
   server_message.tag = kSHLO;
   session_.GetCryptoStream()->OnHandshakeMessage(server_message);
   EXPECT_EQ(OK, callback_.WaitForResult());
 }
 
 TEST_F(QuicClientSessionTest, MaxNumConnections) {
   // Initialize crypto before the client session will create a stream.
   ASSERT_EQ(ERR_IO_PENDING, session_.CryptoConnect(callback_.callback()));
+  // Simulate the server crypto handshake.
   CryptoHandshakeMessage server_message;
   server_message.tag = kSHLO;
   session_.GetCryptoStream()->OnHandshakeMessage(server_message);
   callback_.WaitForResult();
 
   std::vector<QuicReliableClientStream*> streams;
   for (size_t i = 0; i < kDefaultMaxStreamsPerConnection; i++) {
     QuicReliableClientStream* stream = session_.CreateOutgoingReliableStream();
     EXPECT_TRUE(stream);
     streams.push_back(stream);
   }
   EXPECT_FALSE(session_.CreateOutgoingReliableStream());
 
   // Close a stream and ensure I can now open a new one.
   session_.CloseStream(streams[0]->id());
   EXPECT_TRUE(session_.CreateOutgoingReliableStream());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net