Land Recent QUIC changes.

net/quic/quic_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_session.h"
-#include "net/quic/quic_connection.h"
 
 #include <set>
 
 #include "base/hash_tables.h"
 #include "net/quic/crypto/crypto_handshake.h"
+#include "net/quic/quic_connection.h"
+#include "net/quic/quic_protocol.h"
+#include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::hash_map;
 using std::set;
 using testing::_;
 using testing::InSequence;
 
 namespace net {
 namespace test {
 namespace {
 
 class TestCryptoStream : public QuicCryptoStream {
  public:
   explicit TestCryptoStream(QuicSession* session)
       : QuicCryptoStream(session) {
   }
 
   virtual void OnHandshakeMessage(
       const CryptoHandshakeMessage& message) OVERRIDE {
     encryption_established_ = true;
     handshake_confirmed_ = true;
+    CryptoHandshakeMessage msg;
+    string error_details;
+    session()->config()->ToHandshakeMessage(&msg);
+    const QuicErrorCode error = session()->config()->ProcessClientHello(
+        msg, &error_details);
+    EXPECT_EQ(QUIC_NO_ERROR, error);
     session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
   }
 };
 
 class TestStream : public ReliableQuicStream {
  public:
   TestStream(QuicStreamId id, QuicSession* session)
       : ReliableQuicStream(id, session) {
   }
 
   virtual uint32 ProcessData(const char* data, uint32 data_len) {
     return data_len;
   }
 
   MOCK_METHOD0(OnCanWrite, void());
 };
 
 class TestSession : public QuicSession {
  public:
   TestSession(QuicConnection* connection, bool is_server)
-      : QuicSession(connection, is_server),
+      : QuicSession(connection, QuicConfig(), is_server),
         crypto_stream_(this) {
+    config()->SetDefaults();
   }
 
   virtual QuicCryptoStream* GetCryptoStream() OVERRIDE {
     return &crypto_stream_;
   }
 
   virtual TestStream* CreateOutgoingReliableStream() OVERRIDE {
     TestStream* stream = new TestStream(GetNextStreamId(), this);
     ActivateStream(stream);
     return stream;
@@ skipping 10 matching lines @@
   ReliableQuicStream* GetIncomingReliableStream(QuicStreamId stream_id) {
     return QuicSession::GetIncomingReliableStream(stream_id);
   }
 
   // Helper method for gmock
   void MarkTwoWriteBlocked() {
     this->MarkWriteBlocked(2);
   }
 
   TestCryptoStream crypto_stream_;
+  QuicConfig config_;
 };
 
 class QuicSessionTest : public ::testing::Test {
  protected:
   QuicSessionTest()
       : guid_(1),
         connection_(new MockConnection(guid_, IPEndPoint(), false)),
         session_(connection_, true) {
   }
 
@@ skipping 62 matching lines @@
   CloseStream(9);
   CheckClosedStreams();
 }
 
 TEST_F(QuicSessionTest, StreamIdTooLarge) {
   session_.GetIncomingReliableStream(3);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   session_.GetIncomingReliableStream(105);
 }
 
+TEST_F(QuicSessionTest, DecompressionError) {
+  ReliableQuicStream* stream = session_.GetIncomingReliableStream(3);
+  EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
+  const char data[] =
+      "\1\0\0\0"   // headers id
+      "\0\0\0\4"   // length
+      "abcd";      // invalid compressed data
+  stream->ProcessRawData(data, arraysize(data));
+}
+
 TEST_F(QuicSessionTest, OnCanWrite) {
   TestStream* stream2 = session_.CreateOutgoingReliableStream();
   TestStream* stream4 = session_.CreateOutgoingReliableStream();
   TestStream* stream6 = session_.CreateOutgoingReliableStream();
 
   session_.MarkWriteBlocked(2);
   session_.MarkWriteBlocked(6);
   session_.MarkWriteBlocked(4);
 
   InSequence s;
@@ skipping 27 matching lines @@
   // result in a RST being sent.
   EXPECT_CALL(*connection_,
               SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away."));
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
 
   EXPECT_CALL(*connection_, SendRstStream(3u, QUIC_STREAM_PEER_GOING_AWAY));
   EXPECT_FALSE(session_.GetIncomingReliableStream(3u));
 }
 
+TEST_F(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
+  EXPECT_EQ(kDefaultInitialTimeoutSecs,
+            QuicConnectionPeer::GetTimeout(connection_).ToSeconds());
+  CryptoHandshakeMessage msg;
+  session_.crypto_stream_.OnHandshakeMessage(msg);
+  EXPECT_EQ(kDefaultTimeoutSecs,
+            QuicConnectionPeer::GetTimeout(connection_).ToSeconds());
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace net