Move all the packet parsing logic into QuicDispatcher from the

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 87 matching lines @@
   virtual ~QuicDispatcherTest() {}
 
   MockConnection* connection1() {
     return reinterpret_cast<MockConnection*>(session1_->connection());
   }
 
   MockConnection* connection2() {
     return reinterpret_cast<MockConnection*>(session2_->connection());
   }
 
+  QuicEncryptedPacket* ConstructEncryptedPacket(
+      QuicGuid guid,
+      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.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,
                      bool has_version_flag,
                      const string& data) {
-    dispatcher_.ProcessPacket(
-        IPEndPoint(), addr, guid, has_version_flag,
-        QuicEncryptedPacket(data.data(), data.length()));
+    scoped_ptr<QuicEncryptedPacket> packet(
+        ConstructEncryptedPacket(guid, has_version_flag, false, 1, data));
+    dispatcher_.ProcessPacket(IPEndPoint(), addr, *packet.get());
   }
 
   void ValidatePacket(const QuicEncryptedPacket& packet) {
-    EXPECT_TRUE(packet.AsStringPiece().find(data_) != StringPiece::npos);
+    EXPECT_EQ(data_.length(), packet.AsStringPiece().length());
+    EXPECT_EQ(data_, packet.AsStringPiece());
   }
 
   EpollServer eps_;
   QuicConfig config_;
   QuicCryptoServerConfig crypto_config_;
   TestDispatcher dispatcher_;
   MockSession* session1_;
   MockSession* session2_;
   string data_;
 };
 
 TEST_F(QuicDispatcherTest, ProcessPackets) {
   IPEndPoint addr(net::test::Loopback4(), 1);
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(1, _, addr))
       .WillOnce(testing::Return(CreateSession(
           &dispatcher_, 1, addr, &session1_)));
   ProcessPacket(addr, 1, true, "foo");
 
   EXPECT_CALL(dispatcher_, CreateQuicSession(2, _, addr))
       .WillOnce(testing::Return(CreateSession(
                     &dispatcher_, 2, addr, &session2_)));
   ProcessPacket(addr, 2, true, "bar");
 
-  data_ = "eep";
   EXPECT_CALL(*reinterpret_cast<MockConnection*>(session1_->connection()),
               ProcessUdpPacket(_, _, _)).Times(1).
       WillOnce(testing::WithArgs<2>(Invoke(
           this, &QuicDispatcherTest::ValidatePacket)));
   ProcessPacket(addr, 1, false, "eep");
 }
 
 TEST_F(QuicDispatcherTest, Shutdown) {
   IPEndPoint addr(net::test::Loopback4(), 1);
 
@@ skipping 12 matching lines @@
 class MockTimeWaitListManager : public QuicTimeWaitListManager {
  public:
   MockTimeWaitListManager(QuicPacketWriter* writer,
                           EpollServer* eps)
       : QuicTimeWaitListManager(writer, eps, QuicSupportedVersions()) {
   }
 
   MOCK_METHOD4(ProcessPacket, void(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
                                    QuicGuid guid,
-                                   const QuicEncryptedPacket& packet));
+                                   QuicPacketSequenceNumber sequence_number));
 };
 
 TEST_F(QuicDispatcherTest, TimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
       new MockTimeWaitListManager(
           QuicDispatcherPeer::GetWriter(&dispatcher_), &eps_);
   // dispatcher takes the ownership of time_wait_list_manager.
   QuicDispatcherPeer::SetTimeWaitListManager(&dispatcher_,
                                              time_wait_list_manager);
   // Create a new session.
@@ skipping 15 matching lines @@
       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, guid, true, *encrypted);
+  dispatcher_.ProcessPacket(IPEndPoint(), addr, *encrypted);
   EXPECT_TRUE(time_wait_list_manager->IsGuidInTimeWait(guid));
 
   // 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");
 }
 
 TEST_F(QuicDispatcherTest, StrayPacketToTimeWaitListManager) {
   MockTimeWaitListManager* time_wait_list_manager =
@@ skipping 156 matching lines @@
 
   // And we'll resume where we left off when we get another call.
   EXPECT_CALL(*connection2(), OnCanWrite());
   dispatcher_.OnCanWrite();
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net