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 103 matching lines @@
                                                      connection->version(),
                                                      connection_close_packet);
   session_map_.erase(it);
 }
 
 void QuicDispatcher::DeleteSessions() {
   STLDeleteElements(&closed_session_list_);
 }
 
 void QuicDispatcher::OnCanWrite() {
-  // We got an EPOLLOUT: the socket should not be blocked.
+  // We finished a write: the socket should not be blocked.
   writer_->SetWritable();
 
-  // Give each writer one attempt to write.
-  int num_writers = write_blocked_list_.size();
-  for (int i = 0; i < num_writers; ++i) {
-    if (write_blocked_list_.empty()) {
-      return;
-    }
+  // Let all the blocked writers try to write, until we're blocked again or
+  // there's no work left.
+  while (!write_blocked_list_.empty() && !writer_->IsWriteBlocked()) {
     QuicBlockedWriterInterface* blocked_writer =
         write_blocked_list_.begin()->first;
     write_blocked_list_.erase(write_blocked_list_.begin());
     blocked_writer->OnCanWrite();
-    if (writer_->IsWriteBlocked()) {
-      // We were unable to write.  Wait for the next EPOLLOUT. The writer is
-      // responsible for adding itself to the blocked list via OnWriteBlocked().
-      return;
-    }
   }
 }
 
 bool QuicDispatcher::HasPendingWrites() const {
   return !write_blocked_list_.empty();
 }
 
 void QuicDispatcher::Shutdown() {
   while (!session_map_.empty()) {
     QuicSession* session = session_map_.begin()->second;
@@ skipping 27 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* per_connection_packet_writer =
+      new QuicPerConnectionPacketWriter(writer_.get());
+  QuicConnection* connection =
+      CreateQuicConnection(connection_id,
+                           server_address,
+                           client_address,
+                           per_connection_packet_writer);
   QuicServerSession* session = new QuicServerSession(
       config_,
-      CreateQuicConnection(connection_id, server_address, client_address),
+      connection,
+      per_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) {
+  QuicConnection* connection;
   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_);
-  }
-
-  if (FLAGS_enable_quic_stream_flow_control_2 &&
+    connection = new QuicConnection(connection_id, client_address, helper_,
+                                    writer, true, supported_versions_);
+  } else 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,
-                              supported_versions_no_connection_flow_control_);
+    connection = new QuicConnection(
+        connection_id, client_address, helper_,
+        writer, true,
+        supported_versions_no_connection_flow_control_);
+  } else {
+    DVLOG(1) << "Flow control disabled, creating QuicDispatcher WITHOUT "
+             << "version 17 or higher.";
+    connection = new QuicConnection(connection_id, client_address, helper_,
+                                    writer, true,
+                                    supported_versions_no_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,
-                            supported_versions_no_flow_control_);
+  writer->set_connection(connection);
+  return connection;
 }
 
 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