Land Recent QUIC Changes.

net/tools/quic/quic_dispatcher_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/tools/quic/quic_dispatcher.h"
 
 #include <string>
 
 #include "base/strings/string_piece.h"
 #include "net/quic/crypto/crypto_handshake.h"
@@ skipping 29 matching lines @@
 
 class TestDispatcher : public QuicDispatcher {
  public:
   explicit TestDispatcher(const QuicConfig& config,
                           const QuicCryptoServerConfig& crypto_config,
                           EpollServer* eps)
       : QuicDispatcher(config, crypto_config, QuicSupportedVersions(), eps) {
   }
 
   MOCK_METHOD3(CreateQuicSession, QuicSession*(
-      QuicGuid guid,
+      QuicConnectionId connection_id,
       const IPEndPoint& server_address,
       const IPEndPoint& client_address));
   using QuicDispatcher::write_blocked_list;
 };
 
 // A Connection class which unregisters the session from the dispatcher
 // when sending connection close.
 // It'd be slightly more realistic to do this from the Session but it would
 // involve a lot more mocking.
 class MockServerConnection : public MockConnection {
  public:
-  MockServerConnection(QuicGuid guid,
+  MockServerConnection(QuicConnectionId connection_id,
                        QuicDispatcher* dispatcher)
-      : MockConnection(guid, true),
+      : MockConnection(connection_id, true),
         dispatcher_(dispatcher) {}
 
   void UnregisterOnConnectionClosed() {
-    LOG(ERROR) << "Unregistering " << guid();
-    dispatcher_->OnConnectionClosed(guid(), QUIC_NO_ERROR);
+    LOG(ERROR) << "Unregistering " << connection_id();
+    dispatcher_->OnConnectionClosed(connection_id(), QUIC_NO_ERROR);
   }
  private:
   QuicDispatcher* dispatcher_;
 };
 
 QuicSession* CreateSession(QuicDispatcher* dispatcher,
-                           QuicGuid guid,
+                           QuicConnectionId connection_id,
                            const IPEndPoint& addr,
                            MockSession** session) {
-  MockServerConnection* connection = new MockServerConnection(guid, dispatcher);
+  MockServerConnection* connection =
+      new MockServerConnection(connection_id, dispatcher);
   *session = new MockSession(connection);
   ON_CALL(*connection, SendConnectionClose(_)).WillByDefault(
       WithoutArgs(Invoke(
           connection, &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>((*session)->connection()),
               ProcessUdpPacket(_, addr, _));
 
   return *session;
 }
 
@@ skipping 12 matching lines @@
 
   MockConnection* connection1() {
     return reinterpret_cast<MockConnection*>(session1_->connection());
   }
 
   MockConnection* connection2() {
     return reinterpret_cast<MockConnection*>(session2_->connection());
   }
 
   QuicEncryptedPacket* ConstructEncryptedPacket(
-      QuicGuid guid,
+      QuicConnectionId connection_id,
       bool version_flag,
       bool reset_flag,
       QuicPacketSequenceNumber sequence_number,
       const string& data) {
     QuicPacketHeader header;
-    header.public_header.guid = guid;
-    header.public_header.guid_length = PACKET_8BYTE_GUID;
+    header.public_header.connection_id = connection_id;
+    header.public_header.connection_id_length = PACKET_8BYTE_CONNECTION_ID;
     header.public_header.version_flag = version_flag;
     header.public_header.reset_flag = reset_flag;
     header.public_header.sequence_number_length = PACKET_6BYTE_SEQUENCE_NUMBER;
     header.packet_sequence_number = sequence_number;
     header.entropy_flag = false;
     header.entropy_hash = 0;
     header.fec_flag = false;
     header.is_in_fec_group = NOT_IN_FEC_GROUP;
     header.fec_group = 0;
     QuicStreamFrame stream_frame(1, false, 0, MakeIOVector(data));
     QuicFrame frame(&stream_frame);
     QuicFrames frames;
     frames.push_back(frame);
     QuicFramer framer(QuicSupportedVersions(), QuicTime::Zero(), false);
     scoped_ptr<QuicPacket> packet(
         framer.BuildUnsizedDataPacket(header, frames).packet);
     EXPECT_TRUE(packet != NULL);
     QuicEncryptedPacket* encrypted = framer.EncryptPacket(ENCRYPTION_NONE,
                                                           sequence_number,
                                                           *packet);
     EXPECT_TRUE(encrypted != NULL);
     data_ = string(encrypted->data(), encrypted->length());
     return encrypted;
   }
 
   void ProcessPacket(IPEndPoint addr,
-                     QuicGuid guid,
+                     QuicConnectionId connection_id,
                      bool has_version_flag,
                      const string& data) {
-    scoped_ptr<QuicEncryptedPacket> packet(
-        ConstructEncryptedPacket(guid, has_version_flag, false, 1, data));
+    scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
+        connection_id, has_version_flag, false, 1, data));
     dispatcher_.ProcessPacket(IPEndPoint(), addr, *packet.get());
   }
 
   void ValidatePacket(const QuicEncryptedPacket& packet) {
     EXPECT_EQ(data_.length(), packet.AsStringPiece().length());
     EXPECT_EQ(data_, packet.AsStringPiece());
   }
 
   EpollServer eps_;
   QuicConfig config_;
@@ skipping 42 matching lines @@
 class MockTimeWaitListManager : public QuicTimeWaitListManager {
  public:
   MockTimeWaitListManager(QuicPacketWriter* writer,
                           QuicServerSessionVisitor* visitor,
                           EpollServer* eps)
       : QuicTimeWaitListManager(writer, visitor, eps, QuicSupportedVersions()) {
   }
 
   MOCK_METHOD4(ProcessPacket, void(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
-                                   QuicGuid guid,
+                                   QuicConnectionId connection_id,
                                    QuicPacketSequenceNumber sequence_number));
 };
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
           QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
   // Create a new session.
   IPEndPoint addr(net::test::Loopback4(), 1);
-  QuicGuid guid = 1;
-  EXPECT_CALL(dispatcher_, CreateQuicSession(guid, _, addr))
+  QuicConnectionId connection_id = 1;
+  EXPECT_CALL(dispatcher_, CreateQuicSession(connection_id, _, addr))
       .WillOnce(testing::Return(CreateSession(
-                    &dispatcher_, guid, addr, &session1_)));
-  ProcessPacket(addr, guid, true, "foo");
+                    &dispatcher_, connection_id, addr, &session1_)));
+  ProcessPacket(addr, connection_id, true, "foo");
 
   // Close the connection by sending public reset packet.
   QuicPublicResetPacket packet;
-  packet.public_header.guid = guid;
+  packet.public_header.connection_id = connection_id;
   packet.public_header.reset_flag = true;
   packet.public_header.version_flag = false;
   packet.rejected_sequence_number = 19191;
   packet.nonce_proof = 132232;
   scoped_ptr<QuicEncryptedPacket> encrypted(
       QuicFramer::BuildPublicResetPacket(packet));
   EXPECT_CALL(*session1_, OnConnectionClosed(QUIC_PUBLIC_RESET, true)).Times(1)
       .WillOnce(WithoutArgs(Invoke(
           reinterpret_cast<MockServerConnection*>(session1_->connection()),
           &MockServerConnection::UnregisterOnConnectionClosed)));
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _))
       .WillOnce(Invoke(
           reinterpret_cast<MockConnection*>(session1_->connection()),
           &MockConnection::ReallyProcessUdpPacket));
   dispatcher_.ProcessPacket(IPEndPoint(), addr, *encrypted);
-  EXPECT_TRUE(time_wait_list_manager->IsGuidInTimeWait(guid));
+  EXPECT_TRUE(time_wait_list_manager->IsConnectionIdInTimeWait(connection_id));
 
-  // Dispatcher forwards subsequent packets for this guid to the time wait list
-  // manager.
-  EXPECT_CALL(*time_wait_list_manager, ProcessPacket(_, _, guid, _)).Times(1);
-  ProcessPacket(addr, guid, true, "foo");
+  // Dispatcher forwards subsequent packets for this connection_id to the time
+  // wait list manager.
+  EXPECT_CALL(*time_wait_list_manager,
+              ProcessPacket(_, _, connection_id, _)).Times(1);
+  ProcessPacket(addr, connection_id, true, "foo");
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
           QuicDispatcherPeer::GetWriter(&dispatcher_), &dispatcher_, &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
 
   IPEndPoint addr(net::test::Loopback4(), 1);
-  QuicGuid guid = 1;
-  // Dispatcher forwards all packets for this guid to the time wait list
-  // manager.
+  QuicConnectionId connection_id = 1;
+  // Dispatcher forwards all packets for this connection_id to the time wait
+  // list manager.
   EXPECT_CALL(dispatcher_, CreateQuicSession(_, _, _)).Times(0);
-  EXPECT_CALL(*time_wait_list_manager, ProcessPacket(_, _, guid, _)).Times(1);
+  EXPECT_CALL(*time_wait_list_manager,
+              ProcessPacket(_, _, connection_id, _)).Times(1);
   string data = "foo";
-  ProcessPacket(addr, guid, false, "foo");
+  ProcessPacket(addr, connection_id, false, "foo");
 }
 
 class BlockingWriter : public QuicPacketWriterWrapper {
  public:
   BlockingWriter() : write_blocked_(false) {}
 
   virtual bool IsWriteBlocked() const OVERRIDE { return write_blocked_; }
   virtual void SetWritable() OVERRIDE { write_blocked_ = false; }
 
   virtual WriteResult WritePacket(
@@ skipping 180 matching lines @@
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
   EXPECT_FALSE(dispatcher_.HasPendingWrites());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net