Landing Recent QUIC changes until 10:38 AM, Oct 17, 2016 UTC-4

net/quic/core/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/core/quic_framer.h"
 
 #include <cstdint>
 #include <memory>
 #include <vector>
 
@@ skipping 790 matching lines @@
   return QuicTime::Delta::FromMicroseconds(time);
 }
 
 bool QuicFramer::IsValidPath(QuicPathId path_id,
                              QuicPacketNumber* base_packet_number) {
   if (ContainsKey(closed_paths_, path_id)) {
     // Path is closed.
     return false;
   }
 
-  if (FLAGS_quic_packet_numbers_largest_received) {
-    if (path_id == last_path_id_) {
-      *base_packet_number = largest_packet_number_;
-      return true;
-    }
+  if (path_id == last_path_id_) {
+    *base_packet_number = largest_packet_number_;
+    return true;
+  }
 
-    if (ContainsKey(largest_packet_numbers_, path_id)) {
-      *base_packet_number = largest_packet_numbers_[path_id];
-    } else {
-      *base_packet_number = 0;
-    }
+  if (ContainsKey(largest_packet_numbers_, path_id)) {
+    *base_packet_number = largest_packet_numbers_[path_id];
   } else {
-    if (path_id == last_path_id_) {
-      *base_packet_number = last_packet_number_;
-      return true;
-    }
-
-    if (ContainsKey(last_packet_numbers_, path_id)) {
-      *base_packet_number = last_packet_numbers_[path_id];
-    } else {
-      *base_packet_number = 0;
-    }
+    *base_packet_number = 0;
   }
 
   return true;
 }
 
 void QuicFramer::SetLastPacketNumber(const QuicPacketHeader& header) {
   if (header.public_header.multipath_flag && header.path_id != last_path_id_) {
     if (last_path_id_ != kInvalidPathId) {
       // Save current last packet number before changing path.
-      last_packet_numbers_[last_path_id_] = last_packet_number_;
-      if (FLAGS_quic_packet_numbers_largest_received) {
-        largest_packet_numbers_[last_path_id_] = largest_packet_number_;
-      }
+      largest_packet_numbers_[last_path_id_] = largest_packet_number_;
     }
     // Change path.
     last_path_id_ = header.path_id;
   }
   last_packet_number_ = header.packet_number;
-  if (FLAGS_quic_packet_numbers_largest_received) {
-    largest_packet_number_ = max(header.packet_number, largest_packet_number_);
-  }
+  largest_packet_number_ = max(header.packet_number, largest_packet_number_);
 }
 
 void QuicFramer::OnPathClosed(QuicPathId path_id) {
   closed_paths_.insert(path_id);
-  last_packet_numbers_.erase(path_id);
+  largest_packet_numbers_.erase(path_id);
 }
 
 QuicPacketNumber QuicFramer::CalculatePacketNumberFromWire(
     QuicPacketNumberLength packet_number_length,
     QuicPacketNumber base_packet_number,
     QuicPacketNumber packet_number) const {
   // The new packet number might have wrapped to the next epoch, or
   // it might have reverse wrapped to the previous epoch, or it might
   // remain in the same epoch.  Select the packet number closest to the
   // next expected packet number, the previous packet number plus 1.
@@ skipping 197 matching lines @@
 
 bool QuicFramer::ProcessUnauthenticatedHeader(QuicDataReader* encrypted_reader,
                                               QuicPacketHeader* header) {
   header->path_id = kDefaultPathId;
   if (header->public_header.multipath_flag &&
       !ProcessPathId(encrypted_reader, &header->path_id)) {
     set_detailed_error("Unable to read path id.");
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
-  QuicPacketNumber base_packet_number =
-      FLAGS_quic_packet_numbers_largest_received ? largest_packet_number_
-                                                 : last_packet_number_;
+  QuicPacketNumber base_packet_number = largest_packet_number_;
   if (header->public_header.multipath_flag &&
       !IsValidPath(header->path_id, &base_packet_number)) {
     // Stop processing because path is closed.
     return false;
   }
 
   if (!ProcessPacketSequenceNumber(
           encrypted_reader, header->public_header.packet_number_length,
           base_packet_number, &header->packet_number)) {
     set_detailed_error("Unable to read packet number.");
@@ skipping 1491 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net