Port QuicServer to Chrome network stack

net/quic/quic_dispatcher.cc

 // Copyright 2014 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_dispatcher.h"
 
 #include <errno.h>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 159 matching lines @@
       framer_(supported_versions, /*unused*/ QuicTime::Zero(), true),
       framer_visitor_(new QuicFramerVisitor(this)) {
   framer_.set_visitor(framer_visitor_.get());
 }
 
 QuicDispatcher::~QuicDispatcher() {
   STLDeleteValues(&session_map_);
   STLDeleteElements(&closed_session_list_);
 }
 
-void QuicDispatcher::Initialize(QuicPacketWriter* writer) {
+void QuicDispatcher::Initialize(QuicServerPacketWriter* writer) {
   DCHECK(writer_ == NULL);
   writer_.reset(writer);
   time_wait_list_manager_.reset(CreateQuicTimeWaitListManager());
 
   // Remove all versions > QUIC_VERSION_16 from the
   // supported_versions_no_flow_control_ vector.
   QuicVersionVector::iterator it =
       find(supported_versions_no_flow_control_.begin(),
            supported_versions_no_flow_control_.end(), QUIC_VERSION_17);
   if (it != supported_versions_no_flow_control_.end()) {
@@ skipping 168 matching lines @@
 
 void QuicDispatcher::OnWriteBlocked(QuicBlockedWriterInterface* writer) {
   DCHECK(writer_->IsWriteBlocked());
   write_blocked_list_.insert(make_pair(writer, true));
 }
 
 QuicSession* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& server_address,
     const IPEndPoint& client_address) {
+  QuicPerConnectionPacketWriter* connection_packet_writer =

[wtc, 2014/06/23 23:12:15]

Nit: rename this variable "per_connection_packet_writer"?

[dmziegler, 2014/06/24 00:08:52]

Done.

+      new QuicPerConnectionPacketWriter(writer_.get());
+  QuicConnection* connection =
+      CreateQuicConnection(connection_id,
+                           server_address,
+                           client_address,
+                           connection_packet_writer);
+  connection_packet_writer->set_connection(connection);

[wtc, 2014/06/23 23:12:15]

1. Nit: the two-way links between |connection| and |connection_packet_writer|
are a little confusing. Why are they necessary?

2. Can we hide the creation and setup of the QuicPerConnectionPacketWriter
inside the CreateQuicConnection() method?

[dmziegler, 2014/06/24 00:08:52]

The connection needs to write on the writer, and the writer needs to tell the
connection that its writes finished. It would be possible to create the
QuicPerConnectionPacketWriter inside CreateQuicConnection, but it would have to
be passed out as an out parameter, since it's passed to the QuicServerSession
constructor. I will change that once the QuicServerSession no longer owns it.
However, I have moved the set_connection call to CreateQuicConnection.

   QuicServerSession* session = new QuicServerSession(
       config_,
-      CreateQuicConnection(connection_id, server_address, client_address),
+      connection,
+      connection_packet_writer,
       this);
   session->InitializeSession(crypto_config_);
   return session;
 }
 
 QuicConnection* QuicDispatcher::CreateQuicConnection(
     QuicConnectionId connection_id,
     const IPEndPoint& server_address,
-    const IPEndPoint& client_address) {
+    const IPEndPoint& client_address,
+    QuicPerConnectionPacketWriter* writer) {
   if (FLAGS_enable_quic_stream_flow_control_2 &&
       FLAGS_enable_quic_connection_flow_control_2) {
     DVLOG(1) << "Creating QuicDispatcher with all versions.";
     return new QuicConnection(connection_id, client_address, helper_,
-                              writer_.get(), true, supported_versions_);
+                              writer, true, supported_versions_);
   }
 
   if (FLAGS_enable_quic_stream_flow_control_2 &&
       !FLAGS_enable_quic_connection_flow_control_2) {
     DVLOG(1) << "Connection flow control disabled, creating QuicDispatcher "
              << "WITHOUT version 19 or higher.";
     return new QuicConnection(connection_id, client_address, helper_,
-                              writer_.get(), true,
+                              writer, true,
                               supported_versions_no_connection_flow_control_);
   }
 
   DVLOG(1) << "Flow control disabled, creating QuicDispatcher WITHOUT "
            << "version 17 or higher.";
   return new QuicConnection(connection_id, client_address, helper_,
-                            writer_.get(), true,
+                            writer, true,
                             supported_versions_no_flow_control_);
 }
 
 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
   return new QuicTimeWaitListManager(
       writer_.get(), this, helper_, supported_versions());
 }
 
 bool QuicDispatcher::HandlePacketForTimeWait(
     const QuicPacketPublicHeader& header) {
   if (header.reset_flag) {
     // Public reset packets do not have sequence numbers, so ignore the packet.
     return false;
   }
 
   // Switch the framer to the correct version, so that the sequence number can
   // be parsed correctly.
   framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
       header.connection_id));
 
   // Continue parsing the packet to extract the sequence number.  Then
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 }  // namespace net