Land Recent QUIC changes

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/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 27 matching lines @@
 }
 
 QuicPacketSequenceNumber ClosestTo(QuicPacketSequenceNumber target,
                                    QuicPacketSequenceNumber a,
                                    QuicPacketSequenceNumber b) {
   return (Delta(target, a) < Delta(target, b)) ? a : b;
 }
 
 }  // namespace
 
-QuicFramer::QuicFramer(QuicVersionTag version,
+QuicFramer::QuicFramer(QuicTag version,
                        QuicTime creation_time,
                        bool is_server)
     : visitor_(NULL),
       fec_builder_(NULL),
       error_(QUIC_NO_ERROR),
       last_sequence_number_(0),
       quic_version_(version),
       decrypter_(QuicDecrypter::Create(kNULL)),
+      alternative_decrypter_latch_(false),
       is_server_(is_server),
       creation_time_(creation_time) {
   DCHECK(IsSupportedVersion(version));
   encrypter_[ENCRYPTION_NONE].reset(QuicEncrypter::Create(kNULL));
 }
 
 QuicFramer::~QuicFramer() {}
 
 bool CanTruncate(const QuicFrame& frame) {
   if (frame.type == ACK_FRAME ||
@@ skipping 27 matching lines @@
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       GetMinAckFrameSize();
 }
 
 // static
 size_t QuicFramer::GetMinGoAwayFrameSize() {
   return kQuicFrameTypeSize + kQuicErrorCodeSize + kQuicErrorDetailsLengthSize +
       kQuicStreamIdSize;
 }
 
-bool QuicFramer::IsSupportedVersion(QuicVersionTag version) {
+bool QuicFramer::IsSupportedVersion(QuicTag version) {
   return version == kQuicVersion1;
 }
 
 size_t QuicFramer::GetVersionNegotiationPacketSize(size_t number_versions) {
   return kQuicGuidSize + kPublicFlagsSize +
       number_versions * kQuicVersionSize;
 }
 
 size_t QuicFramer::GetSerializedFrameLength(
     const QuicFrame& frame, size_t free_bytes, bool first_frame) {
@@ skipping 166 matching lines @@
   if (!AppendPacketSequenceNumber(packet.rejected_sequence_number,
                                   &writer)) {
     return NULL;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 QuicEncryptedPacket* QuicFramer::ConstructVersionNegotiationPacket(
     const QuicPacketPublicHeader& header,
-    const QuicVersionTagList& supported_versions) {
+    const QuicTagVector& supported_versions) {
   DCHECK(header.version_flag);
   size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
   QuicDataWriter writer(len);
 
   if (!writer.WriteUInt64(header.guid)) {
     return NULL;
   }
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION);
   if (!writer.WriteUInt8(flags)) {
@@ skipping 41 matching lines @@
 
   reader_.reset(NULL);
   return rv;
 }
 
 bool QuicFramer::ProcessVersionNegotiationPacket(
     QuicPacketPublicHeader* public_header) {
   DCHECK(!is_server_);
   // Try reading at least once to raise error if the packet is invalid.
   do {
-    QuicVersionTag version;
+    QuicTag version;
     if (!reader_->ReadBytes(&version, kQuicVersionSize)) {
       set_detailed_error("Unable to read supported version in negotiation.");
       return RaiseError(QUIC_INVALID_VERSION_NEGOTIATION_PACKET);
     }
     public_header->versions.push_back(version);
   } while (!reader_->IsDoneReading());
 
   visitor_->OnVersionNegotiationPacket(*public_header);
   return true;
 }
@@ skipping 182 matching lines @@
   public_header->reset_flag = (public_flags & PACKET_PUBLIC_FLAGS_RST) != 0;
   public_header->version_flag =
       (public_flags & PACKET_PUBLIC_FLAGS_VERSION) != 0;
 
   if (public_header->reset_flag && public_header->version_flag) {
     set_detailed_error("Got version flag in reset packet");
     return false;
   }
 
   if (public_header->version_flag && is_server_) {
-    QuicVersionTag version;
+    QuicTag version;
     if (!reader_->ReadUInt32(&version)) {
       // Read the version only if the packet is from the client.
       // version flag from the server means version negotiation packet.
       set_detailed_error("Unable to read protocol version.");
       return false;
     }
     public_header->versions.push_back(version);
   }
   return true;
 }
@@ skipping 494 matching lines @@
   encrypter_[level].reset(encrypter);
 }
 
 const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
   DCHECK(encrypter_[level].get() != NULL);
   return encrypter_[level].get();
 }
 
+void QuicFramer::SwapCryptersForTest(QuicFramer* other) {
+  for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; i++) {
+    encrypter_[i].swap(other->encrypter_[i]);
+  }
+  decrypter_.swap(other->decrypter_);
+  alternative_decrypter_.swap(other->alternative_decrypter_);
+
+  const bool other_latch = other->alternative_decrypter_latch_;
+  other->alternative_decrypter_latch_ = alternative_decrypter_latch_;
+  alternative_decrypter_latch_ = other_latch;
+}
+
 QuicEncryptedPacket* QuicFramer::EncryptPacket(
     EncryptionLevel level,
     QuicPacketSequenceNumber packet_sequence_number,
     const QuicPacket& packet) {
   DCHECK(encrypter_[level].get() != NULL);
 
   scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket(
       packet_sequence_number, packet.AssociatedData(), packet.Plaintext()));
   if (out.get() == NULL) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
@@ skipping 28 matching lines @@
 }
 
 bool QuicFramer::DecryptPayload(QuicPacketSequenceNumber sequence_number,
                                 bool version_flag,
                                 const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
     return false;
   }
   DCHECK(decrypter_.get() != NULL);
-  LOG(INFO) << "Decrypting packet";
   decrypted_.reset(decrypter_->DecryptPacket(
       sequence_number,
       GetAssociatedDataFromEncryptedPacket(packet, version_flag),
       encrypted));
   if  (decrypted_.get() == NULL && alternative_decrypter_.get() != NULL) {
-    LOG(INFO) << "Trying alternative";
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
         sequence_number,
         GetAssociatedDataFromEncryptedPacket(packet, version_flag),
         encrypted));
     if (decrypted_.get() != NULL) {
-      LOG(INFO) << "alternative ok";
       if (alternative_decrypter_latch_) {
-        LOG(INFO) << "  latching";
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
       } else {
-        LOG(INFO) << "  swapping";
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
       }
     }
   }
 
   if  (decrypted_.get() == NULL) {
     return false;
   }
 
@@ skipping 328 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DLOG(INFO) << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   reader_.reset(NULL);
   return false;
 }
 
 }  // namespace net