Move all the packet parsing logic into QuicDispatcher from the

net/quic/quic_framer_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 <algorithm>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
@@ skipping 170 matching lines @@
 class TestQuicVisitor : public ::net::QuicFramerVisitorInterface {
  public:
   TestQuicVisitor()
       : error_count_(0),
         version_mismatch_(0),
         packet_count_(0),
         frame_count_(0),
         fec_count_(0),
         complete_packets_(0),
         revived_packets_(0),
-        accept_packet_(true) {
+        accept_packet_(true),
+        accept_public_header_(true) {
   }
 
   virtual ~TestQuicVisitor() {
     STLDeleteElements(&stream_frames_);
     STLDeleteElements(&ack_frames_);
     STLDeleteElements(&congestion_feedback_frames_);
     STLDeleteElements(&fec_data_);
   }
 
   virtual void OnError(QuicFramer* f) OVERRIDE {
@@ skipping 23 matching lines @@
     version_mismatch_++;
     return true;
   }
 
   virtual bool OnPacketHeader(const QuicPacketHeader& header) OVERRIDE {
     packet_count_++;
     header_.reset(new QuicPacketHeader(header));
     return accept_packet_;
   }
 
+  virtual bool OnUnauthenticatedPublicHeader(
+      const QuicPacketPublicHeader& header) OVERRIDE {
+    public_header_.reset(new QuicPacketPublicHeader(header));
+    return accept_public_header_;
+  }
+
   virtual bool OnUnauthenticatedHeader(
       const QuicPacketHeader& header) OVERRIDE {
     return true;
   }
 
   virtual bool OnStreamFrame(const QuicStreamFrame& frame) OVERRIDE {
     frame_count_++;
     stream_frames_.push_back(new QuicStreamFrame(frame));
     return true;
   }
@@ skipping 43 matching lines @@
 
   // Counters from the visitor_ callbacks.
   int error_count_;
   int version_mismatch_;
   int packet_count_;
   int frame_count_;
   int fec_count_;
   int complete_packets_;
   int revived_packets_;
   bool accept_packet_;
+  bool accept_public_header_;
 
   scoped_ptr<QuicPacketHeader> header_;
+  scoped_ptr<QuicPacketPublicHeader> public_header_;
   scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
   vector<QuicStreamFrame*> stream_frames_;
   vector<QuicAckFrame*> ack_frames_;
   vector<QuicCongestionFeedbackFrame*> congestion_feedback_frames_;
   vector<QuicFecData*> fec_data_;
   string fec_protected_payload_;
   QuicRstStreamFrame rst_stream_frame_;
   QuicConnectionCloseFrame connection_close_frame_;
   QuicGoAwayFrame goaway_frame_;
@@ skipping 1174 matching lines @@
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
 
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
   ASSERT_TRUE(visitor_.header_.get());
   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
 
   ASSERT_EQ(0u, visitor_.stream_frames_.size());
   EXPECT_EQ(0u, visitor_.ack_frames_.size());
 }
 
+TEST_P(QuicFramerTest, RejectPublicHeader) {
+  visitor_.accept_public_header_ = false;
+
+  unsigned char packet[] = {
+    // public flags (8 byte guid)
+    0x3C,
+    // guid
+    0x10, 0x32, 0x54, 0x76,
+    0x98, 0xBA, 0xDC, 0xFE,
+  };
+
+  QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
+  EXPECT_TRUE(framer_.ProcessPacket(encrypted));
+
+  EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
+  ASSERT_TRUE(visitor_.public_header_.get());
+  ASSERT_FALSE(visitor_.header_.get());
+}
+
 TEST_P(QuicFramerTest, RevivedStreamFrame) {
   unsigned char payload[] = {
     // frame type (stream frame with fin)
     0xFF,
     // stream id
     0x04, 0x03, 0x02, 0x01,
     // offset
     0x54, 0x76, 0x10, 0x32,
     0xDC, 0xFE, 0x98, 0xBA,
     // data length
@@ skipping 1974 matching lines @@
   EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
   EXPECT_CALL(visitor, OnPacketComplete());
 
   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
 }
 
 }  // namespace test
 }  // namespace net