Landing Recent QUIC changes until 12:43 PM, Nov 5, 2016 UTC+8

net/tools/quic/quic_dispatcher.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 <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 696 matching lines @@
       connection_id, *current_packet_, current_server_address_,
       current_client_address_, /*is_chlo=*/false);
   if (rs != EnqueuePacketResult::SUCCESS) {
     OnBufferPacketFailure(rs, connection_id);
   } else if (!FLAGS_quic_create_session_after_insertion && is_new_connection) {
     ShouldCreateOrBufferPacketForConnection(connection_id);
   }
 }
 
 void QuicDispatcher::ProcessChlo() {
-  QUIC_BUG_IF(!FLAGS_quic_buffer_packet_till_chlo &&
-              FLAGS_quic_limit_num_new_sessions_per_epoll_loop)
-      << "Try to limit connection creation per epoll event while not "
-         "supporting packet buffer. "
-         "--quic_limit_num_new_sessions_per_epoll_loop = true "
-         "--quic_buffer_packet_till_chlo = false";
-
   if (FLAGS_quic_create_session_after_insertion &&
       !buffered_packets_.HasBufferedPackets(current_connection_id_) &&
       !ShouldCreateOrBufferPacketForConnection(current_connection_id_)) {
     return;
   }
 
   if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
-      FLAGS_quic_buffer_packet_till_chlo &&
       new_sessions_allowed_per_event_loop_ <= 0) {
     // Can't create new session any more. Wait till next event loop.
     if (!buffered_packets_.HasChloForConnection(current_connection_id_)) {
       // Only buffer one CHLO per connection. Remove this condition check when
       // --gfe2_reloadable_flag_quic_buffer_packets_after_chlo
       // is deprecated because after that retransmitted CHLO should be buffered
       // earlier in OnUnauthenticatedPublicHeader().
       bool is_new_connection =
           !buffered_packets_.HasBufferedPackets(current_connection_id_);
       EnqueuePacketResult rs = buffered_packets_.EnqueuePacket(
@@ skipping 10 matching lines @@
   }
   // Creates a new session and process all buffered packets for this connection.
   QuicSession* session =
       CreateQuicSession(current_connection_id_, current_client_address_);
   DVLOG(1) << "Created new session for " << current_connection_id_;
   session_map_.insert(
       std::make_pair(current_connection_id_, base::WrapUnique(session)));
   std::list<BufferedPacket> packets =
       buffered_packets_.DeliverPackets(current_connection_id_);
   // Check if CHLO is the first packet arrived on this connection.
-  if (!FLAGS_quic_create_session_after_insertion &&
-      FLAGS_quic_buffer_packet_till_chlo && packets.empty()) {
+  if (!FLAGS_quic_create_session_after_insertion && packets.empty()) {
     ShouldCreateOrBufferPacketForConnection(current_connection_id_);
   }
   // Process CHLO at first.
   session->ProcessUdpPacket(current_server_address_, current_client_address_,
                             *current_packet_);
   // Deliver queued-up packets in the same order as they arrived.
   // Do this even when flag is off because there might be still some packets
   // buffered in the store before flag is turned off.
   DeliverPacketsToSession(packets, session);
-  if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop &&
-      FLAGS_quic_buffer_packet_till_chlo) {
+  if (FLAGS_quic_limit_num_new_sessions_per_epoll_loop) {
     --new_sessions_allowed_per_event_loop_;
   }
 }
 
 bool QuicDispatcher::HandlePacketForTimeWait(
     const QuicPacketPublicHeader& header) {
   if (header.reset_flag) {
     // Public reset packets do not have packet numbers, so ignore the packet.
     return false;
   }
@@ skipping 51 matching lines @@
 };
 
 void QuicDispatcher::MaybeRejectStatelessly(QuicConnectionId connection_id,
                                             const QuicPacketHeader& header) {
   // TODO(rch): This logic should probably live completely inside the rejector.
   if (!FLAGS_quic_use_cheap_stateless_rejects ||
       !FLAGS_enable_quic_stateless_reject_support ||
       header.public_header.versions.front() <= QUIC_VERSION_32 ||
       !ShouldAttemptCheapStatelessRejection()) {
     // Not use cheap stateless reject.
-    if (FLAGS_quic_buffer_packet_till_chlo &&
-        !ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
+    if (!ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                                 nullptr)) {
       // Buffer non-CHLO packets.
       ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id,
                                        header.packet_number);
       return;
     }
     ProcessUnauthenticatedHeaderFate(kFateProcess, connection_id,
                                      header.packet_number);
     return;
   }
 
   std::unique_ptr<StatelessRejector> rejector(new StatelessRejector(
       header.public_header.versions.front(), GetSupportedVersions(),
       crypto_config_, &compressed_certs_cache_, helper()->GetClock(),
       helper()->GetRandomGenerator(), current_packet_->length(),
       current_client_address_, current_server_address_));
   ChloValidator validator(session_helper_.get(), current_server_address_,
                           rejector.get());
   if (!ChloExtractor::Extract(*current_packet_, GetSupportedVersions(),
                               &validator)) {
-    if (!FLAGS_quic_buffer_packet_till_chlo) {
-      QUIC_BUG
-          << "Have to drop packet because buffering non-chlo packet is "
-             "not supported while trying to do stateless reject. "
-             "--gfe2_reloadable_flag_quic_buffer_packet_till_chlo false"
-             " --gfe2_reloadable_flag_quic_use_cheap_stateless_rejects true";
-      ProcessUnauthenticatedHeaderFate(kFateDrop, connection_id,
-                                       header.packet_number);
-      return;
-    }
     ProcessUnauthenticatedHeaderFate(kFateBuffer, connection_id,
                                      header.packet_number);
     return;
   }
 
   if (!validator.can_accept()) {
     // This CHLO is prohibited by policy.
     StatelessConnectionTerminator terminator(connection_id, &framer_, helper(),
                                              time_wait_list_manager_.get());
     terminator.CloseConnection(QUIC_HANDSHAKE_FAILED,
@@ skipping 119 matching lines @@
 void QuicDispatcher::DeliverPacketsToSession(
     const std::list<BufferedPacket>& packets,
     QuicSession* session) {
   for (const BufferedPacket& packet : packets) {
     session->ProcessUdpPacket(packet.server_address, packet.client_address,
                               *(packet.packet));
   }
 }
 
 }  // namespace net