Move all the packet parsing logic into QuicDispatcher from the

net/quic/quic_framer.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_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "net/quic/crypto/quic_decrypter.h"
 #include "net/quic/crypto/quic_encrypter.h"
 #include "net/quic/quic_data_reader.h"
@@ skipping 464 matching lines @@
   visitor_->OnPacket();
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&public_header)) {
     DLOG(WARNING) << "Unable to process public header.";
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
+  if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
+    // The visitor suppresses further processing of the packet.
+    reader_.reset(NULL);
+    return true;
+  }
+
   if (is_server_ && public_header.version_flag &&
       public_header.versions[0] != quic_version_) {
     if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
       reader_.reset(NULL);
       return true;
     }
   }
 
   bool rv;
   if (!is_server_ && public_header.version_flag) {
@@ skipping 311 matching lines @@
     if (version == quic_version_ && public_flags > PACKET_PUBLIC_FLAGS_MAX) {
       set_detailed_error("Illegal public flags value.");
       return false;
     }
     public_header->versions.push_back(version);
   }
   return true;
 }
 
 // static
-bool QuicFramer::ReadGuidFromPacket(const QuicEncryptedPacket& packet,
-                                    QuicGuid* guid) {
-  QuicDataReader reader(packet.data(), packet.length());
-  uint8 public_flags;
-  if (!reader.ReadBytes(&public_flags, 1)) {
-    return false;
-  }
-  // Ensure it's an 8 byte guid.
-  if ((public_flags & PACKET_PUBLIC_FLAGS_8BYTE_GUID) !=
-          PACKET_PUBLIC_FLAGS_8BYTE_GUID) {
-    return false;
-  }
-
-  return reader.ReadUInt64(guid);
-}
-
-// static
 QuicSequenceNumberLength QuicFramer::GetMinSequenceNumberLength(
     QuicPacketSequenceNumber sequence_number) {
   if (sequence_number < 1 << (PACKET_1BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_1BYTE_SEQUENCE_NUMBER;
   } else if (sequence_number < 1 << (PACKET_2BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_2BYTE_SEQUENCE_NUMBER;
   } else if (sequence_number <
              GG_UINT64_C(1) << (PACKET_4BYTE_SEQUENCE_NUMBER * 8)) {
     return PACKET_4BYTE_SEQUENCE_NUMBER;
   } else {
@@ skipping 918 matching lines @@
     }
   }
 
   if (!writer->WriteIOVector(frame.data)) {
     return false;
   }
   return true;
 }
 
 // static
-bool QuicFramer::HasVersionFlag(const QuicEncryptedPacket& packet) {
-  return packet.length() > 0 &&
-      (packet.data()[0] & PACKET_PUBLIC_FLAGS_VERSION) != 0;
-}
-
 void QuicFramer::set_version(const QuicVersion version) {
   DCHECK(IsSupportedVersion(version));
   quic_version_ = version;
 }
 
 bool QuicFramer::AppendAckFramePayloadAndTypeByte(
     const QuicPacketHeader& header,
     const QuicAckFrame& frame,
     QuicDataWriter* writer) {
   AckFrameInfo ack_info = GetAckFrameInfo(frame);
@@ skipping 266 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net