Landing Recent QUIC changes until: Fri Oct 30 22:23:58 2015 +0000

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"
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 #include "net/tools/quic/quic_per_connection_packet_writer.h"
 #include "net/tools/quic/quic_time_wait_list_manager.h"
 
 namespace net {
 
 namespace tools {
 
 using std::make_pair;
 using base::StringPiece;
 
-// The threshold size for the session map, over which the dispatcher will start
-// sending stateless rejects (SREJ), rather than stateful rejects (REJ) to
-// clients who support them.  If -1, stateless rejects will not be sent.  If 0,
-// the server will only send stateless rejects to clients who support them.
-int32 FLAGS_quic_session_map_threshold_for_stateless_rejects = -1;
-
 namespace {
 
 // An alarm that informs the QuicDispatcher to delete old sessions.
 class DeleteSessionsAlarm : public QuicAlarm::Delegate {
  public:
   explicit DeleteSessionsAlarm(QuicDispatcher* dispatcher)
       : dispatcher_(dispatcher) {
   }
 
   QuicTime OnAlarm() override {
@@ skipping 162 matching lines @@
 }
 
 void QuicDispatcher::ProcessPacket(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
                                    const QuicEncryptedPacket& packet) {
   current_server_address_ = server_address;
   current_client_address_ = client_address;
   current_packet_ = &packet;
   // ProcessPacket will cause the packet to be dispatched in
   // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
-  // in OnAuthenticatedHeader.
+  // in OnUnauthenticatedHeader.
   framer_.ProcessPacket(packet);
   // TODO(rjshade): Return a status describing if/why a packet was dropped,
   //                and log somehow.  Maybe expose as a varz.
 }
 
 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
   // Port zero is only allowed for unidirectional UDP, so is disallowed by QUIC.
   // Given that we can't even send a reply rejecting the packet, just drop the
   // packet.
@@ skipping 129 matching lines @@
       header.packet_number > kMaxReasonableInitialPacketNumber) {
     return kFateTimeWait;
   }
 
   return kFateProcess;
 }
 
 void QuicDispatcher::CleanUpSession(SessionMap::iterator it,
                                     bool should_close_statelessly) {
   QuicConnection* connection = it->second->connection();
-  QuicEncryptedPacket* connection_close_packet =
-      connection->ReleaseConnectionClosePacket();
+
   write_blocked_list_.erase(connection);
-  DCHECK(!should_close_statelessly || !connection_close_packet);
+  if (should_close_statelessly) {
+    DCHECK(connection->termination_packets() != nullptr &&
+           !connection->termination_packets()->empty());
+  }
   time_wait_list_manager_->AddConnectionIdToTimeWait(
       it->first, connection->version(), should_close_statelessly,
-      connection_close_packet);
+      connection->termination_packets());
   session_map_.erase(it);
 }
 
 void QuicDispatcher::DeleteSessions() {
   STLDeleteElements(&closed_session_list_);
 }
 
 void QuicDispatcher::OnCanWrite() {
   // The socket is now writable.
   writer_->SetWritable();
@@ skipping 74 matching lines @@
     QuicConnectionId connection_id,
     const IPEndPoint& client_address) {
   // The QuicServerSession takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), connection_writer_factory_,
       /* owns_writer= */ true, Perspective::IS_SERVER, supported_versions_);
 
   QuicServerSession* session =
       new QuicServerSession(config_, connection, this, crypto_config_);
   session->Initialize();
-  if (FLAGS_quic_session_map_threshold_for_stateless_rejects != -1 &&
-      session_map_.size() >=
-          static_cast<size_t>(
-              FLAGS_quic_session_map_threshold_for_stateless_rejects)) {
-    session->set_use_stateless_rejects_if_peer_supported(true);
-  }
   return session;
 }
 
 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
   // TODO(rjshade): The QuicTimeWaitListManager should take ownership of the
   // per-connection packet writer.
   time_wait_list_writer_.reset(
       packet_writer_factory_->Create(writer_.get(), nullptr));
   return new QuicTimeWaitListManager(time_wait_list_writer_.get(), this,
                                      helper_.get());
@@ skipping 15 matching lines @@
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 void QuicDispatcher::SetLastError(QuicErrorCode error) {
   last_error_ = error;
 }
 
 }  // namespace tools
 }  // namespace net